1 /*
2 *
3 * Intel Management Engine Interface (Intel MEI) Linux driver
4 * Copyright (c) 2003-2012, Intel Corporation.
5 *
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.
9 *
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
13 * more details.
14 *
15 */
16
17 #include <linux/pci.h>
18 #include "mei_dev.h"
19 #include "mei.h"
20 #include "interface.h"
21
22
23
24 /**
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.
27 *
28 * @dev: the device structure
29 */
mei_hcsr_set(struct mei_device * dev)30 void mei_hcsr_set(struct mei_device *dev)
31 {
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);
36 }
37
38 /**
39 * mei_csr_enable_interrupts - enables mei device interrupts
40 *
41 * @dev: the device structure
42 */
mei_enable_interrupts(struct mei_device * dev)43 void mei_enable_interrupts(struct mei_device *dev)
44 {
45 dev->host_hw_state |= H_IE;
46 mei_hcsr_set(dev);
47 }
48
49 /**
50 * mei_csr_disable_interrupts - disables mei device interrupts
51 *
52 * @dev: the device structure
53 */
mei_disable_interrupts(struct mei_device * dev)54 void mei_disable_interrupts(struct mei_device *dev)
55 {
56 dev->host_hw_state &= ~H_IE;
57 mei_hcsr_set(dev);
58 }
59
60 /**
61 * _host_get_filled_slots - gets number of device filled buffer slots
62 *
63 * @device: the device structure
64 *
65 * returns number of filled slots
66 */
_host_get_filled_slots(const struct mei_device * dev)67 static unsigned char _host_get_filled_slots(const struct mei_device *dev)
68 {
69 char read_ptr, write_ptr;
70
71 read_ptr = (char) ((dev->host_hw_state & H_CBRP) >> 8);
72 write_ptr = (char) ((dev->host_hw_state & H_CBWP) >> 16);
73
74 return (unsigned char) (write_ptr - read_ptr);
75 }
76
77 /**
78 * mei_host_buffer_is_empty - checks if host buffer is empty.
79 *
80 * @dev: the device structure
81 *
82 * returns 1 if empty, 0 - otherwise.
83 */
mei_host_buffer_is_empty(struct mei_device * dev)84 int mei_host_buffer_is_empty(struct mei_device *dev)
85 {
86 unsigned char filled_slots;
87
88 dev->host_hw_state = mei_hcsr_read(dev);
89 filled_slots = _host_get_filled_slots(dev);
90
91 if (filled_slots == 0)
92 return 1;
93
94 return 0;
95 }
96
97 /**
98 * mei_count_empty_write_slots - counts write empty slots.
99 *
100 * @dev: the device structure
101 *
102 * returns -1(ESLOTS_OVERFLOW) if overflow, otherwise empty slots count
103 */
mei_count_empty_write_slots(struct mei_device * dev)104 int mei_count_empty_write_slots(struct mei_device *dev)
105 {
106 unsigned char buffer_depth, filled_slots, empty_slots;
107
108 dev->host_hw_state = mei_hcsr_read(dev);
109 buffer_depth = (unsigned char) ((dev->host_hw_state & H_CBD) >> 24);
110 filled_slots = _host_get_filled_slots(dev);
111 empty_slots = buffer_depth - filled_slots;
112
113 /* check for overflow */
114 if (filled_slots > buffer_depth)
115 return -EOVERFLOW;
116
117 return empty_slots;
118 }
119
120 /**
121 * mei_write_message - writes a message to mei device.
122 *
123 * @dev: the device structure
124 * @header: header of message
125 * @write_buffer: message buffer will be written
126 * @write_length: message size will be written
127 *
128 * This function returns -EIO if write has failed
129 */
mei_write_message(struct mei_device * dev,struct mei_msg_hdr * header,unsigned char * write_buffer,unsigned long write_length)130 int mei_write_message(struct mei_device *dev,
131 struct mei_msg_hdr *header,
132 unsigned char *write_buffer,
133 unsigned long write_length)
134 {
135 u32 temp_msg = 0;
136 unsigned long bytes_written = 0;
137 unsigned char buffer_depth, filled_slots, empty_slots;
138 unsigned long dw_to_write;
139
140 dev->host_hw_state = mei_hcsr_read(dev);
141
142 dev_dbg(&dev->pdev->dev,
143 "host_hw_state = 0x%08x.\n",
144 dev->host_hw_state);
145
146 dev_dbg(&dev->pdev->dev,
147 "mei_write_message header=%08x.\n",
148 *((u32 *) header));
149
150 buffer_depth = (unsigned char) ((dev->host_hw_state & H_CBD) >> 24);
151 filled_slots = _host_get_filled_slots(dev);
152 empty_slots = buffer_depth - filled_slots;
153 dev_dbg(&dev->pdev->dev,
154 "filled = %hu, empty = %hu.\n",
155 filled_slots, empty_slots);
156
157 dw_to_write = ((write_length + 3) / 4);
158
159 if (dw_to_write > empty_slots)
160 return -EIO;
161
162 mei_reg_write(dev, H_CB_WW, *((u32 *) header));
163
164 while (write_length >= 4) {
165 mei_reg_write(dev, H_CB_WW,
166 *(u32 *) (write_buffer + bytes_written));
167 bytes_written += 4;
168 write_length -= 4;
169 }
170
171 if (write_length > 0) {
172 memcpy(&temp_msg, &write_buffer[bytes_written], write_length);
173 mei_reg_write(dev, H_CB_WW, temp_msg);
174 }
175
176 dev->host_hw_state |= H_IG;
177 mei_hcsr_set(dev);
178 dev->me_hw_state = mei_mecsr_read(dev);
179 if ((dev->me_hw_state & ME_RDY_HRA) != ME_RDY_HRA)
180 return -EIO;
181
182 return 0;
183 }
184
185 /**
186 * mei_count_full_read_slots - counts read full slots.
187 *
188 * @dev: the device structure
189 *
190 * returns -1(ESLOTS_OVERFLOW) if overflow, otherwise filled slots count
191 */
mei_count_full_read_slots(struct mei_device * dev)192 int mei_count_full_read_slots(struct mei_device *dev)
193 {
194 char read_ptr, write_ptr;
195 unsigned char buffer_depth, filled_slots;
196
197 dev->me_hw_state = mei_mecsr_read(dev);
198 buffer_depth = (unsigned char)((dev->me_hw_state & ME_CBD_HRA) >> 24);
199 read_ptr = (char) ((dev->me_hw_state & ME_CBRP_HRA) >> 8);
200 write_ptr = (char) ((dev->me_hw_state & ME_CBWP_HRA) >> 16);
201 filled_slots = (unsigned char) (write_ptr - read_ptr);
202
203 /* check for overflow */
204 if (filled_slots > buffer_depth)
205 return -EOVERFLOW;
206
207 dev_dbg(&dev->pdev->dev, "filled_slots =%08x\n", filled_slots);
208 return (int)filled_slots;
209 }
210
211 /**
212 * mei_read_slots - reads a message from mei device.
213 *
214 * @dev: the device structure
215 * @buffer: message buffer will be written
216 * @buffer_length: message size will be read
217 */
mei_read_slots(struct mei_device * dev,unsigned char * buffer,unsigned long buffer_length)218 void mei_read_slots(struct mei_device *dev, unsigned char *buffer,
219 unsigned long buffer_length)
220 {
221 u32 *reg_buf = (u32 *)buffer;
222
223 for (; buffer_length >= sizeof(u32); buffer_length -= sizeof(u32))
224 *reg_buf++ = mei_mecbrw_read(dev);
225
226 if (buffer_length > 0) {
227 u32 reg = mei_mecbrw_read(dev);
228 memcpy(reg_buf, ®, buffer_length);
229 }
230
231 dev->host_hw_state |= H_IG;
232 mei_hcsr_set(dev);
233 }
234
235 /**
236 * mei_flow_ctrl_creds - checks flow_control credentials.
237 *
238 * @dev: the device structure
239 * @cl: private data of the file object
240 *
241 * returns 1 if mei_flow_ctrl_creds >0, 0 - otherwise.
242 * -ENOENT if mei_cl is not present
243 * -EINVAL if single_recv_buf == 0
244 */
mei_flow_ctrl_creds(struct mei_device * dev,struct mei_cl * cl)245 int mei_flow_ctrl_creds(struct mei_device *dev, struct mei_cl *cl)
246 {
247 int i;
248
249 if (!dev->me_clients_num)
250 return 0;
251
252 if (cl->mei_flow_ctrl_creds > 0)
253 return 1;
254
255 for (i = 0; i < dev->me_clients_num; i++) {
256 struct mei_me_client *me_cl = &dev->me_clients[i];
257 if (me_cl->client_id == cl->me_client_id) {
258 if (me_cl->mei_flow_ctrl_creds) {
259 if (WARN_ON(me_cl->props.single_recv_buf == 0))
260 return -EINVAL;
261 return 1;
262 } else {
263 return 0;
264 }
265 }
266 }
267 return -ENOENT;
268 }
269
270 /**
271 * mei_flow_ctrl_reduce - reduces flow_control.
272 *
273 * @dev: the device structure
274 * @cl: private data of the file object
275 * @returns
276 * 0 on success
277 * -ENOENT when me client is not found
278 * -EINVAL when ctrl credits are <= 0
279 */
mei_flow_ctrl_reduce(struct mei_device * dev,struct mei_cl * cl)280 int mei_flow_ctrl_reduce(struct mei_device *dev, struct mei_cl *cl)
281 {
282 int i;
283
284 if (!dev->me_clients_num)
285 return -ENOENT;
286
287 for (i = 0; i < dev->me_clients_num; i++) {
288 struct mei_me_client *me_cl = &dev->me_clients[i];
289 if (me_cl->client_id == cl->me_client_id) {
290 if (me_cl->props.single_recv_buf != 0) {
291 if (WARN_ON(me_cl->mei_flow_ctrl_creds <= 0))
292 return -EINVAL;
293 dev->me_clients[i].mei_flow_ctrl_creds--;
294 } else {
295 if (WARN_ON(cl->mei_flow_ctrl_creds <= 0))
296 return -EINVAL;
297 cl->mei_flow_ctrl_creds--;
298 }
299 return 0;
300 }
301 }
302 return -ENOENT;
303 }
304
305 /**
306 * mei_send_flow_control - sends flow control to fw.
307 *
308 * @dev: the device structure
309 * @cl: private data of the file object
310 *
311 * This function returns -EIO on write failure
312 */
mei_send_flow_control(struct mei_device * dev,struct mei_cl * cl)313 int mei_send_flow_control(struct mei_device *dev, struct mei_cl *cl)
314 {
315 struct mei_msg_hdr *mei_hdr;
316 struct hbm_flow_control *mei_flow_control;
317
318 mei_hdr = (struct mei_msg_hdr *) &dev->wr_msg_buf[0];
319 mei_hdr->host_addr = 0;
320 mei_hdr->me_addr = 0;
321 mei_hdr->length = sizeof(struct hbm_flow_control);
322 mei_hdr->msg_complete = 1;
323 mei_hdr->reserved = 0;
324
325 mei_flow_control = (struct hbm_flow_control *) &dev->wr_msg_buf[1];
326 memset(mei_flow_control, 0, sizeof(*mei_flow_control));
327 mei_flow_control->host_addr = cl->host_client_id;
328 mei_flow_control->me_addr = cl->me_client_id;
329 mei_flow_control->hbm_cmd = MEI_FLOW_CONTROL_CMD;
330 memset(mei_flow_control->reserved, 0,
331 sizeof(mei_flow_control->reserved));
332 dev_dbg(&dev->pdev->dev, "sending flow control host client = %d, ME client = %d\n",
333 cl->host_client_id, cl->me_client_id);
334
335 return mei_write_message(dev, mei_hdr,
336 (unsigned char *) mei_flow_control,
337 sizeof(struct hbm_flow_control));
338 }
339
340 /**
341 * mei_other_client_is_connecting - checks if other
342 * client with the same client id is connected.
343 *
344 * @dev: the device structure
345 * @cl: private data of the file object
346 *
347 * returns 1 if other client is connected, 0 - otherwise.
348 */
mei_other_client_is_connecting(struct mei_device * dev,struct mei_cl * cl)349 int mei_other_client_is_connecting(struct mei_device *dev,
350 struct mei_cl *cl)
351 {
352 struct mei_cl *cl_pos = NULL;
353 struct mei_cl *cl_next = NULL;
354
355 list_for_each_entry_safe(cl_pos, cl_next, &dev->file_list, link) {
356 if ((cl_pos->state == MEI_FILE_CONNECTING) &&
357 (cl_pos != cl) &&
358 cl->me_client_id == cl_pos->me_client_id)
359 return 1;
360
361 }
362 return 0;
363 }
364
365 /**
366 * mei_disconnect - sends disconnect message to fw.
367 *
368 * @dev: the device structure
369 * @cl: private data of the file object
370 *
371 * This function returns -EIO on write failure
372 */
mei_disconnect(struct mei_device * dev,struct mei_cl * cl)373 int mei_disconnect(struct mei_device *dev, struct mei_cl *cl)
374 {
375 struct mei_msg_hdr *mei_hdr;
376 struct hbm_client_disconnect_request *mei_cli_disconnect;
377
378 mei_hdr = (struct mei_msg_hdr *) &dev->wr_msg_buf[0];
379 mei_hdr->host_addr = 0;
380 mei_hdr->me_addr = 0;
381 mei_hdr->length = sizeof(struct hbm_client_disconnect_request);
382 mei_hdr->msg_complete = 1;
383 mei_hdr->reserved = 0;
384
385 mei_cli_disconnect =
386 (struct hbm_client_disconnect_request *) &dev->wr_msg_buf[1];
387 memset(mei_cli_disconnect, 0, sizeof(*mei_cli_disconnect));
388 mei_cli_disconnect->host_addr = cl->host_client_id;
389 mei_cli_disconnect->me_addr = cl->me_client_id;
390 mei_cli_disconnect->hbm_cmd = CLIENT_DISCONNECT_REQ_CMD;
391 mei_cli_disconnect->reserved[0] = 0;
392
393 return mei_write_message(dev, mei_hdr,
394 (unsigned char *) mei_cli_disconnect,
395 sizeof(struct hbm_client_disconnect_request));
396 }
397
398 /**
399 * mei_connect - sends connect message to fw.
400 *
401 * @dev: the device structure
402 * @cl: private data of the file object
403 *
404 * This function returns -EIO on write failure
405 */
mei_connect(struct mei_device * dev,struct mei_cl * cl)406 int mei_connect(struct mei_device *dev, struct mei_cl *cl)
407 {
408 struct mei_msg_hdr *mei_hdr;
409 struct hbm_client_connect_request *mei_cli_connect;
410
411 mei_hdr = (struct mei_msg_hdr *) &dev->wr_msg_buf[0];
412 mei_hdr->host_addr = 0;
413 mei_hdr->me_addr = 0;
414 mei_hdr->length = sizeof(struct hbm_client_connect_request);
415 mei_hdr->msg_complete = 1;
416 mei_hdr->reserved = 0;
417
418 mei_cli_connect =
419 (struct hbm_client_connect_request *) &dev->wr_msg_buf[1];
420 mei_cli_connect->host_addr = cl->host_client_id;
421 mei_cli_connect->me_addr = cl->me_client_id;
422 mei_cli_connect->hbm_cmd = CLIENT_CONNECT_REQ_CMD;
423 mei_cli_connect->reserved = 0;
424
425 return mei_write_message(dev, mei_hdr,
426 (unsigned char *) mei_cli_connect,
427 sizeof(struct hbm_client_connect_request));
428 }
429