3 * Intel Management Engine Interface (Intel MEI) Linux driver
4 * Copyright (c) 2003-2012, Intel Corporation.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
17 #include <linux/pci.h>
19 #include <linux/mei.h>
20 #include "interface.h"
25 * mei_set_csr_register - writes H_CSR register to the mei device,
26 * and ignores the H_IS bit for it is write-one-to-zero.
28 * @dev: the device structure
30 void mei_hcsr_set(struct mei_device *dev)
32 if ((dev->host_hw_state & H_IS) == H_IS)
33 dev->host_hw_state &= ~H_IS;
34 mei_reg_write(dev, H_CSR, dev->host_hw_state);
35 dev->host_hw_state = mei_hcsr_read(dev);
39 * mei_csr_enable_interrupts - enables mei device interrupts
41 * @dev: the device structure
43 void mei_enable_interrupts(struct mei_device *dev)
45 dev->host_hw_state |= H_IE;
50 * mei_csr_disable_interrupts - disables mei device interrupts
52 * @dev: the device structure
54 void mei_disable_interrupts(struct mei_device *dev)
56 dev->host_hw_state &= ~H_IE;
61 * mei_hbuf_filled_slots - gets number of device filled buffer slots
63 * @device: the device structure
65 * returns number of filled slots
67 static unsigned char mei_hbuf_filled_slots(struct mei_device *dev)
69 char read_ptr, write_ptr;
71 dev->host_hw_state = mei_hcsr_read(dev);
73 read_ptr = (char) ((dev->host_hw_state & H_CBRP) >> 8);
74 write_ptr = (char) ((dev->host_hw_state & H_CBWP) >> 16);
76 return (unsigned char) (write_ptr - read_ptr);
80 * mei_hbuf_is_empty - checks if host buffer is empty.
82 * @dev: the device structure
84 * returns true if empty, false - otherwise.
86 bool mei_hbuf_is_empty(struct mei_device *dev)
88 return mei_hbuf_filled_slots(dev) == 0;
92 * mei_hbuf_empty_slots - counts write empty slots.
94 * @dev: the device structure
96 * returns -1(ESLOTS_OVERFLOW) if overflow, otherwise empty slots count
98 int mei_hbuf_empty_slots(struct mei_device *dev)
100 unsigned char filled_slots, empty_slots;
102 filled_slots = mei_hbuf_filled_slots(dev);
103 empty_slots = dev->hbuf_depth - filled_slots;
105 /* check for overflow */
106 if (filled_slots > dev->hbuf_depth)
113 * mei_write_message - writes a message to mei device.
115 * @dev: the device structure
116 * @header: header of message
117 * @write_buffer: message buffer will be written
118 * @write_length: message size will be written
120 * This function returns -EIO if write has failed
122 int mei_write_message(struct mei_device *dev, struct mei_msg_hdr *header,
123 unsigned char *buf, unsigned long length)
125 unsigned long rem, dw_cnt;
126 u32 *reg_buf = (u32 *)buf;
131 dev_dbg(&dev->pdev->dev,
132 "mei_write_message header=%08x.\n",
135 empty_slots = mei_hbuf_empty_slots(dev);
136 dev_dbg(&dev->pdev->dev, "empty slots = %hu.\n", empty_slots);
138 dw_cnt = mei_data2slots(length);
139 if (empty_slots < 0 || dw_cnt > empty_slots)
142 mei_reg_write(dev, H_CB_WW, *((u32 *) header));
144 for (i = 0; i < length / 4; i++)
145 mei_reg_write(dev, H_CB_WW, reg_buf[i]);
150 memcpy(®, &buf[length - rem], rem);
151 mei_reg_write(dev, H_CB_WW, reg);
154 dev->host_hw_state = mei_hcsr_read(dev);
155 dev->host_hw_state |= H_IG;
157 dev->me_hw_state = mei_mecsr_read(dev);
158 if ((dev->me_hw_state & ME_RDY_HRA) != ME_RDY_HRA)
165 * mei_count_full_read_slots - counts read full slots.
167 * @dev: the device structure
169 * returns -1(ESLOTS_OVERFLOW) if overflow, otherwise filled slots count
171 int mei_count_full_read_slots(struct mei_device *dev)
173 char read_ptr, write_ptr;
174 unsigned char buffer_depth, filled_slots;
176 dev->me_hw_state = mei_mecsr_read(dev);
177 buffer_depth = (unsigned char)((dev->me_hw_state & ME_CBD_HRA) >> 24);
178 read_ptr = (char) ((dev->me_hw_state & ME_CBRP_HRA) >> 8);
179 write_ptr = (char) ((dev->me_hw_state & ME_CBWP_HRA) >> 16);
180 filled_slots = (unsigned char) (write_ptr - read_ptr);
182 /* check for overflow */
183 if (filled_slots > buffer_depth)
186 dev_dbg(&dev->pdev->dev, "filled_slots =%08x\n", filled_slots);
187 return (int)filled_slots;
191 * mei_read_slots - reads a message from mei device.
193 * @dev: the device structure
194 * @buffer: message buffer will be written
195 * @buffer_length: message size will be read
197 void mei_read_slots(struct mei_device *dev, unsigned char *buffer,
198 unsigned long buffer_length)
200 u32 *reg_buf = (u32 *)buffer;
202 for (; buffer_length >= sizeof(u32); buffer_length -= sizeof(u32))
203 *reg_buf++ = mei_mecbrw_read(dev);
205 if (buffer_length > 0) {
206 u32 reg = mei_mecbrw_read(dev);
207 memcpy(reg_buf, ®, buffer_length);
210 dev->host_hw_state |= H_IG;
215 * mei_flow_ctrl_creds - checks flow_control credentials.
217 * @dev: the device structure
218 * @cl: private data of the file object
220 * returns 1 if mei_flow_ctrl_creds >0, 0 - otherwise.
221 * -ENOENT if mei_cl is not present
222 * -EINVAL if single_recv_buf == 0
224 int mei_flow_ctrl_creds(struct mei_device *dev, struct mei_cl *cl)
228 if (!dev->me_clients_num)
231 if (cl->mei_flow_ctrl_creds > 0)
234 for (i = 0; i < dev->me_clients_num; i++) {
235 struct mei_me_client *me_cl = &dev->me_clients[i];
236 if (me_cl->client_id == cl->me_client_id) {
237 if (me_cl->mei_flow_ctrl_creds) {
238 if (WARN_ON(me_cl->props.single_recv_buf == 0))
250 * mei_flow_ctrl_reduce - reduces flow_control.
252 * @dev: the device structure
253 * @cl: private data of the file object
256 * -ENOENT when me client is not found
257 * -EINVAL when ctrl credits are <= 0
259 int mei_flow_ctrl_reduce(struct mei_device *dev, struct mei_cl *cl)
263 if (!dev->me_clients_num)
266 for (i = 0; i < dev->me_clients_num; i++) {
267 struct mei_me_client *me_cl = &dev->me_clients[i];
268 if (me_cl->client_id == cl->me_client_id) {
269 if (me_cl->props.single_recv_buf != 0) {
270 if (WARN_ON(me_cl->mei_flow_ctrl_creds <= 0))
272 dev->me_clients[i].mei_flow_ctrl_creds--;
274 if (WARN_ON(cl->mei_flow_ctrl_creds <= 0))
276 cl->mei_flow_ctrl_creds--;
285 * mei_send_flow_control - sends flow control to fw.
287 * @dev: the device structure
288 * @cl: private data of the file object
290 * This function returns -EIO on write failure
292 int mei_send_flow_control(struct mei_device *dev, struct mei_cl *cl)
294 struct mei_msg_hdr *mei_hdr;
295 struct hbm_flow_control *flow_ctrl;
296 const size_t len = sizeof(struct hbm_flow_control);
298 mei_hdr = mei_hbm_hdr(&dev->wr_msg_buf[0], len);
300 flow_ctrl = (struct hbm_flow_control *)&dev->wr_msg_buf[1];
301 memset(flow_ctrl, 0, len);
302 flow_ctrl->hbm_cmd = MEI_FLOW_CONTROL_CMD;
303 flow_ctrl->host_addr = cl->host_client_id;
304 flow_ctrl->me_addr = cl->me_client_id;
305 /* FIXME: reserved !? */
306 memset(flow_ctrl->reserved, 0, sizeof(flow_ctrl->reserved));
307 dev_dbg(&dev->pdev->dev, "sending flow control host client = %d, ME client = %d\n",
308 cl->host_client_id, cl->me_client_id);
310 return mei_write_message(dev, mei_hdr,
311 (unsigned char *) flow_ctrl, len);
315 * mei_other_client_is_connecting - checks if other
316 * client with the same client id is connected.
318 * @dev: the device structure
319 * @cl: private data of the file object
321 * returns 1 if other client is connected, 0 - otherwise.
323 int mei_other_client_is_connecting(struct mei_device *dev,
326 struct mei_cl *cl_pos = NULL;
327 struct mei_cl *cl_next = NULL;
329 list_for_each_entry_safe(cl_pos, cl_next, &dev->file_list, link) {
330 if ((cl_pos->state == MEI_FILE_CONNECTING) &&
332 cl->me_client_id == cl_pos->me_client_id)
340 * mei_disconnect - sends disconnect message to fw.
342 * @dev: the device structure
343 * @cl: private data of the file object
345 * This function returns -EIO on write failure
347 int mei_disconnect(struct mei_device *dev, struct mei_cl *cl)
349 struct mei_msg_hdr *mei_hdr;
350 struct hbm_client_connect_request *req;
351 const size_t len = sizeof(struct hbm_client_connect_request);
353 mei_hdr = mei_hbm_hdr(&dev->wr_msg_buf[0], len);
355 req = (struct hbm_client_connect_request *)&dev->wr_msg_buf[1];
357 req->hbm_cmd = CLIENT_DISCONNECT_REQ_CMD;
358 req->host_addr = cl->host_client_id;
359 req->me_addr = cl->me_client_id;
362 return mei_write_message(dev, mei_hdr, (unsigned char *)req, len);
366 * mei_connect - sends connect message to fw.
368 * @dev: the device structure
369 * @cl: private data of the file object
371 * This function returns -EIO on write failure
373 int mei_connect(struct mei_device *dev, struct mei_cl *cl)
375 struct mei_msg_hdr *mei_hdr;
376 struct hbm_client_connect_request *req;
377 const size_t len = sizeof(struct hbm_client_connect_request);
379 mei_hdr = mei_hbm_hdr(&dev->wr_msg_buf[0], len);
381 req = (struct hbm_client_connect_request *) &dev->wr_msg_buf[1];
382 req->hbm_cmd = CLIENT_CONNECT_REQ_CMD;
383 req->host_addr = cl->host_client_id;
384 req->me_addr = cl->me_client_id;
387 return mei_write_message(dev, mei_hdr, (unsigned char *) req, len);