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 *mei_flow_control;
297 mei_hdr = (struct mei_msg_hdr *) &dev->wr_msg_buf[0];
298 mei_hdr->host_addr = 0;
299 mei_hdr->me_addr = 0;
300 mei_hdr->length = sizeof(struct hbm_flow_control);
301 mei_hdr->msg_complete = 1;
302 mei_hdr->reserved = 0;
304 mei_flow_control = (struct hbm_flow_control *) &dev->wr_msg_buf[1];
305 memset(mei_flow_control, 0, sizeof(*mei_flow_control));
306 mei_flow_control->host_addr = cl->host_client_id;
307 mei_flow_control->me_addr = cl->me_client_id;
308 mei_flow_control->hbm_cmd = MEI_FLOW_CONTROL_CMD;
309 memset(mei_flow_control->reserved, 0,
310 sizeof(mei_flow_control->reserved));
311 dev_dbg(&dev->pdev->dev, "sending flow control host client = %d, ME client = %d\n",
312 cl->host_client_id, cl->me_client_id);
314 return mei_write_message(dev, mei_hdr,
315 (unsigned char *) mei_flow_control,
316 sizeof(struct hbm_flow_control));
320 * mei_other_client_is_connecting - checks if other
321 * client with the same client id is connected.
323 * @dev: the device structure
324 * @cl: private data of the file object
326 * returns 1 if other client is connected, 0 - otherwise.
328 int mei_other_client_is_connecting(struct mei_device *dev,
331 struct mei_cl *cl_pos = NULL;
332 struct mei_cl *cl_next = NULL;
334 list_for_each_entry_safe(cl_pos, cl_next, &dev->file_list, link) {
335 if ((cl_pos->state == MEI_FILE_CONNECTING) &&
337 cl->me_client_id == cl_pos->me_client_id)
345 * mei_disconnect - sends disconnect message to fw.
347 * @dev: the device structure
348 * @cl: private data of the file object
350 * This function returns -EIO on write failure
352 int mei_disconnect(struct mei_device *dev, struct mei_cl *cl)
354 struct mei_msg_hdr *mei_hdr;
355 struct hbm_client_disconnect_request *mei_cli_disconnect;
357 mei_hdr = (struct mei_msg_hdr *) &dev->wr_msg_buf[0];
358 mei_hdr->host_addr = 0;
359 mei_hdr->me_addr = 0;
360 mei_hdr->length = sizeof(struct hbm_client_disconnect_request);
361 mei_hdr->msg_complete = 1;
362 mei_hdr->reserved = 0;
365 (struct hbm_client_disconnect_request *) &dev->wr_msg_buf[1];
366 memset(mei_cli_disconnect, 0, sizeof(*mei_cli_disconnect));
367 mei_cli_disconnect->host_addr = cl->host_client_id;
368 mei_cli_disconnect->me_addr = cl->me_client_id;
369 mei_cli_disconnect->hbm_cmd = CLIENT_DISCONNECT_REQ_CMD;
370 mei_cli_disconnect->reserved[0] = 0;
372 return mei_write_message(dev, mei_hdr,
373 (unsigned char *) mei_cli_disconnect,
374 sizeof(struct hbm_client_disconnect_request));
378 * mei_connect - sends connect message to fw.
380 * @dev: the device structure
381 * @cl: private data of the file object
383 * This function returns -EIO on write failure
385 int mei_connect(struct mei_device *dev, struct mei_cl *cl)
387 struct mei_msg_hdr *mei_hdr;
388 struct hbm_client_connect_request *mei_cli_connect;
390 mei_hdr = (struct mei_msg_hdr *) &dev->wr_msg_buf[0];
391 mei_hdr->host_addr = 0;
392 mei_hdr->me_addr = 0;
393 mei_hdr->length = sizeof(struct hbm_client_connect_request);
394 mei_hdr->msg_complete = 1;
395 mei_hdr->reserved = 0;
398 (struct hbm_client_connect_request *) &dev->wr_msg_buf[1];
399 mei_cli_connect->host_addr = cl->host_client_id;
400 mei_cli_connect->me_addr = cl->me_client_id;
401 mei_cli_connect->hbm_cmd = CLIENT_CONNECT_REQ_CMD;
402 mei_cli_connect->reserved = 0;
404 return mei_write_message(dev, mei_hdr,
405 (unsigned char *) mei_cli_connect,
406 sizeof(struct hbm_client_connect_request));