projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'char-misc-3.6' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh...
[deliverable/linux.git] / drivers / misc / mei / interrupt.c
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
18 #include <linux/pci.h>
19 #include <linux/kthread.h>
20 #include <linux/interrupt.h>
21 #include <linux/fs.h>
22 #include <linux/jiffies.h>
23
24 #include "mei_dev.h"
25 #include <linux/mei.h>
26 #include "hw.h"
27 #include "interface.h"
28
29
30 /**
31 * mei_interrupt_quick_handler - The ISR of the MEI device
32 *
33 * @irq: The irq number
34 * @dev_id: pointer to the device structure
35 *
36 * returns irqreturn_t
37 */
38 irqreturn_t mei_interrupt_quick_handler(int irq, void *dev_id)
39 {
40 struct mei_device *dev = (struct mei_device *) dev_id;
41 u32 csr_reg = mei_hcsr_read(dev);
42
43 if ((csr_reg & H_IS) != H_IS)
44 return IRQ_NONE;
45
46 /* clear H_IS bit in H_CSR */
47 mei_reg_write(dev, H_CSR, csr_reg);
48
49 return IRQ_WAKE_THREAD;
50 }
51
52 /**
53 * _mei_cmpl - processes completed operation.
54 *
55 * @cl: private data of the file object.
56 * @cb_pos: callback block.
57 */
58 static void _mei_cmpl(struct mei_cl *cl, struct mei_cl_cb *cb_pos)
59 {
60 if (cb_pos->major_file_operations == MEI_WRITE) {
61 mei_free_cb_private(cb_pos);
62 cb_pos = NULL;
63 cl->writing_state = MEI_WRITE_COMPLETE;
64 if (waitqueue_active(&cl->tx_wait))
65 wake_up_interruptible(&cl->tx_wait);
66
67 } else if (cb_pos->major_file_operations == MEI_READ &&
68 MEI_READING == cl->reading_state) {
69 cl->reading_state = MEI_READ_COMPLETE;
70 if (waitqueue_active(&cl->rx_wait))
71 wake_up_interruptible(&cl->rx_wait);
72
73 }
74 }
75
76 /**
77 * _mei_cmpl_iamthif - processes completed iamthif operation.
78 *
79 * @dev: the device structure.
80 * @cb_pos: callback block.
81 */
82 static void _mei_cmpl_iamthif(struct mei_device *dev, struct mei_cl_cb *cb_pos)
83 {
84 if (dev->iamthif_canceled != 1) {
85 dev->iamthif_state = MEI_IAMTHIF_READ_COMPLETE;
86 dev->iamthif_stall_timer = 0;
87 memcpy(cb_pos->response_buffer.data,
88 dev->iamthif_msg_buf,
89 dev->iamthif_msg_buf_index);
90 list_add_tail(&cb_pos->cb_list,
91 &dev->amthi_read_complete_list.mei_cb.cb_list);
92 dev_dbg(&dev->pdev->dev, "amthi read completed.\n");
93 dev->iamthif_timer = jiffies;
94 dev_dbg(&dev->pdev->dev, "dev->iamthif_timer = %ld\n",
95 dev->iamthif_timer);
96 } else {
97 mei_run_next_iamthif_cmd(dev);
98 }
99
100 dev_dbg(&dev->pdev->dev, "completing amthi call back.\n");
101 wake_up_interruptible(&dev->iamthif_cl.wait);
102 }
103
104
105 /**
106 * mei_irq_thread_read_amthi_message - bottom half read routine after ISR to
107 * handle the read amthi message data processing.
108 *
109 * @complete_list: An instance of our list structure
110 * @dev: the device structure
111 * @mei_hdr: header of amthi message
112 *
113 * returns 0 on success, <0 on failure.
114 */
115 static int mei_irq_thread_read_amthi_message(struct mei_io_list *complete_list,
116 struct mei_device *dev,
117 struct mei_msg_hdr *mei_hdr)
118 {
119 struct mei_cl *cl;
120 struct mei_cl_cb *cb;
121 unsigned char *buffer;
122
123 BUG_ON(mei_hdr->me_addr != dev->iamthif_cl.me_client_id);
124 BUG_ON(dev->iamthif_state != MEI_IAMTHIF_READING);
125
126 buffer = dev->iamthif_msg_buf + dev->iamthif_msg_buf_index;
127 BUG_ON(dev->iamthif_mtu < dev->iamthif_msg_buf_index + mei_hdr->length);
128
129 mei_read_slots(dev, buffer, mei_hdr->length);
130
131 dev->iamthif_msg_buf_index += mei_hdr->length;
132
133 if (!mei_hdr->msg_complete)
134 return 0;
135
136 dev_dbg(&dev->pdev->dev,
137 "amthi_message_buffer_index =%d\n",
138 mei_hdr->length);
139
140 dev_dbg(&dev->pdev->dev, "completed amthi read.\n ");
141 if (!dev->iamthif_current_cb)
142 return -ENODEV;
143
144 cb = dev->iamthif_current_cb;
145 dev->iamthif_current_cb = NULL;
146
147 cl = (struct mei_cl *)cb->file_private;
148 if (!cl)
149 return -ENODEV;
150
151 dev->iamthif_stall_timer = 0;
152 cb->information = dev->iamthif_msg_buf_index;
153 cb->read_time = jiffies;
154 if (dev->iamthif_ioctl && cl == &dev->iamthif_cl) {
155 /* found the iamthif cb */
156 dev_dbg(&dev->pdev->dev, "complete the amthi read cb.\n ");
157 dev_dbg(&dev->pdev->dev, "add the amthi read cb to complete.\n ");
158 list_add_tail(&cb->cb_list,
159 &complete_list->mei_cb.cb_list);
160 }
161 return 0;
162 }
163
164 /**
165 * _mei_irq_thread_state_ok - checks if mei header matches file private data
166 *
167 * @cl: private data of the file object
168 * @mei_hdr: header of mei client message
169 *
170 * returns !=0 if matches, 0 if no match.
171 */
172 static int _mei_irq_thread_state_ok(struct mei_cl *cl,
173 struct mei_msg_hdr *mei_hdr)
174 {
175 return (cl->host_client_id == mei_hdr->host_addr &&
176 cl->me_client_id == mei_hdr->me_addr &&
177 cl->state == MEI_FILE_CONNECTED &&
178 MEI_READ_COMPLETE != cl->reading_state);
179 }
180
181 /**
182 * mei_irq_thread_read_client_message - bottom half read routine after ISR to
183 * handle the read mei client message data processing.
184 *
185 * @complete_list: An instance of our list structure
186 * @dev: the device structure
187 * @mei_hdr: header of mei client message
188 *
189 * returns 0 on success, <0 on failure.
190 */
191 static int mei_irq_thread_read_client_message(struct mei_io_list *complete_list,
192 struct mei_device *dev,
193 struct mei_msg_hdr *mei_hdr)
194 {
195 struct mei_cl *cl;
196 struct mei_cl_cb *cb_pos = NULL, *cb_next = NULL;
197 unsigned char *buffer = NULL;
198
199 dev_dbg(&dev->pdev->dev, "start client msg\n");
200 if (list_empty(&dev->read_list.mei_cb.cb_list))
201 goto quit;
202
203 list_for_each_entry_safe(cb_pos, cb_next,
204 &dev->read_list.mei_cb.cb_list, cb_list) {
205 cl = (struct mei_cl *)cb_pos->file_private;
206 if (cl && _mei_irq_thread_state_ok(cl, mei_hdr)) {
207 cl->reading_state = MEI_READING;
208 buffer = cb_pos->response_buffer.data + cb_pos->information;
209
210 if (cb_pos->response_buffer.size <
211 mei_hdr->length + cb_pos->information) {
212 dev_dbg(&dev->pdev->dev, "message overflow.\n");
213 list_del(&cb_pos->cb_list);
214 return -ENOMEM;
215 }
216 if (buffer)
217 mei_read_slots(dev, buffer, mei_hdr->length);
218
219 cb_pos->information += mei_hdr->length;
220 if (mei_hdr->msg_complete) {
221 cl->status = 0;
222 list_del(&cb_pos->cb_list);
223 dev_dbg(&dev->pdev->dev,
224 "completed read H cl = %d, ME cl = %d, length = %lu\n",
225 cl->host_client_id,
226 cl->me_client_id,
227 cb_pos->information);
228 list_add_tail(&cb_pos->cb_list,
229 &complete_list->mei_cb.cb_list);
230 }
231
232 break;
233 }
234
235 }
236
237 quit:
238 dev_dbg(&dev->pdev->dev, "message read\n");
239 if (!buffer) {
240 mei_read_slots(dev, dev->rd_msg_buf, mei_hdr->length);
241 dev_dbg(&dev->pdev->dev, "discarding message, header =%08x.\n",
242 *(u32 *) dev->rd_msg_buf);
243 }
244
245 return 0;
246 }
247
248 /**
249 * _mei_irq_thread_iamthif_read - prepares to read iamthif data.
250 *
251 * @dev: the device structure.
252 * @slots: free slots.
253 *
254 * returns 0, OK; otherwise, error.
255 */
256 static int _mei_irq_thread_iamthif_read(struct mei_device *dev, s32 *slots)
257 {
258
259 if (((*slots) * sizeof(u32)) < (sizeof(struct mei_msg_hdr)
260 + sizeof(struct hbm_flow_control))) {
261 return -EMSGSIZE;
262 }
263 *slots -= mei_data2slots(sizeof(struct hbm_flow_control));
264 if (mei_send_flow_control(dev, &dev->iamthif_cl)) {
265 dev_dbg(&dev->pdev->dev, "iamthif flow control failed\n");
266 return -EIO;
267 }
268
269 dev_dbg(&dev->pdev->dev, "iamthif flow control success\n");
270 dev->iamthif_state = MEI_IAMTHIF_READING;
271 dev->iamthif_flow_control_pending = false;
272 dev->iamthif_msg_buf_index = 0;
273 dev->iamthif_msg_buf_size = 0;
274 dev->iamthif_stall_timer = IAMTHIF_STALL_TIMER;
275 dev->mei_host_buffer_is_empty = mei_hbuf_is_empty(dev);
276 return 0;
277 }
278
279 /**
280 * _mei_irq_thread_close - processes close related operation.
281 *
282 * @dev: the device structure.
283 * @slots: free slots.
284 * @cb_pos: callback block.
285 * @cl: private data of the file object.
286 * @cmpl_list: complete list.
287 *
288 * returns 0, OK; otherwise, error.
289 */
290 static int _mei_irq_thread_close(struct mei_device *dev, s32 *slots,
291 struct mei_cl_cb *cb_pos,
292 struct mei_cl *cl,
293 struct mei_io_list *cmpl_list)
294 {
295 if ((*slots * sizeof(u32)) < (sizeof(struct mei_msg_hdr) +
296 sizeof(struct hbm_client_disconnect_request)))
297 return -EBADMSG;
298
299 *slots -= mei_data2slots(sizeof(struct hbm_client_disconnect_request));
300
301 if (mei_disconnect(dev, cl)) {
302 cl->status = 0;
303 cb_pos->information = 0;
304 list_move_tail(&cb_pos->cb_list,
305 &cmpl_list->mei_cb.cb_list);
306 return -EMSGSIZE;
307 } else {
308 cl->state = MEI_FILE_DISCONNECTING;
309 cl->status = 0;
310 cb_pos->information = 0;
311 list_move_tail(&cb_pos->cb_list,
312 &dev->ctrl_rd_list.mei_cb.cb_list);
313 cl->timer_count = MEI_CONNECT_TIMEOUT;
314 }
315
316 return 0;
317 }
318
319 /**
320 * is_treat_specially_client - checks if the message belongs
321 * to the file private data.
322 *
323 * @cl: private data of the file object
324 * @rs: connect response bus message
325 *
326 */
327 static bool is_treat_specially_client(struct mei_cl *cl,
328 struct hbm_client_connect_response *rs)
329 {
330
331 if (cl->host_client_id == rs->host_addr &&
332 cl->me_client_id == rs->me_addr) {
333 if (!rs->status) {
334 cl->state = MEI_FILE_CONNECTED;
335 cl->status = 0;
336
337 } else {
338 cl->state = MEI_FILE_DISCONNECTED;
339 cl->status = -ENODEV;
340 }
341 cl->timer_count = 0;
342
343 return true;
344 }
345 return false;
346 }
347
348 /**
349 * mei_client_connect_response - connects to response irq routine
350 *
351 * @dev: the device structure
352 * @rs: connect response bus message
353 */
354 static void mei_client_connect_response(struct mei_device *dev,
355 struct hbm_client_connect_response *rs)
356 {
357
358 struct mei_cl *cl;
359 struct mei_cl_cb *cb_pos = NULL, *cb_next = NULL;
360
361 dev_dbg(&dev->pdev->dev,
362 "connect_response:\n"
363 "ME Client = %d\n"
364 "Host Client = %d\n"
365 "Status = %d\n",
366 rs->me_addr,
367 rs->host_addr,
368 rs->status);
369
370 /* if WD or iamthif client treat specially */
371
372 if (is_treat_specially_client(&(dev->wd_cl), rs)) {
373 dev_dbg(&dev->pdev->dev, "successfully connected to WD client.\n");
374 mei_watchdog_register(dev);
375
376 /* next step in the state maching */
377 mei_host_init_iamthif(dev);
378 return;
379 }
380
381 if (is_treat_specially_client(&(dev->iamthif_cl), rs)) {
382 dev->iamthif_state = MEI_IAMTHIF_IDLE;
383 return;
384 }
385 list_for_each_entry_safe(cb_pos, cb_next,
386 &dev->ctrl_rd_list.mei_cb.cb_list, cb_list) {
387
388 cl = (struct mei_cl *)cb_pos->file_private;
389 if (!cl) {
390 list_del(&cb_pos->cb_list);
391 return;
392 }
393 if (MEI_IOCTL == cb_pos->major_file_operations) {
394 if (is_treat_specially_client(cl, rs)) {
395 list_del(&cb_pos->cb_list);
396 cl->status = 0;
397 cl->timer_count = 0;
398 break;
399 }
400 }
401 }
402 }
403
404 /**
405 * mei_client_disconnect_response - disconnects from response irq routine
406 *
407 * @dev: the device structure
408 * @rs: disconnect response bus message
409 */
410 static void mei_client_disconnect_response(struct mei_device *dev,
411 struct hbm_client_connect_response *rs)
412 {
413 struct mei_cl *cl;
414 struct mei_cl_cb *cb_pos = NULL, *cb_next = NULL;
415
416 dev_dbg(&dev->pdev->dev,
417 "disconnect_response:\n"
418 "ME Client = %d\n"
419 "Host Client = %d\n"
420 "Status = %d\n",
421 rs->me_addr,
422 rs->host_addr,
423 rs->status);
424
425 list_for_each_entry_safe(cb_pos, cb_next,
426 &dev->ctrl_rd_list.mei_cb.cb_list, cb_list) {
427 cl = (struct mei_cl *)cb_pos->file_private;
428
429 if (!cl) {
430 list_del(&cb_pos->cb_list);
431 return;
432 }
433
434 dev_dbg(&dev->pdev->dev, "list_for_each_entry_safe in ctrl_rd_list.\n");
435 if (cl->host_client_id == rs->host_addr &&
436 cl->me_client_id == rs->me_addr) {
437
438 list_del(&cb_pos->cb_list);
439 if (!rs->status)
440 cl->state = MEI_FILE_DISCONNECTED;
441
442 cl->status = 0;
443 cl->timer_count = 0;
444 break;
445 }
446 }
447 }
448
449 /**
450 * same_flow_addr - tells if they have the same address.
451 *
452 * @file: private data of the file object.
453 * @flow: flow control.
454 *
455 * returns !=0, same; 0,not.
456 */
457 static int same_flow_addr(struct mei_cl *cl, struct hbm_flow_control *flow)
458 {
459 return (cl->host_client_id == flow->host_addr &&
460 cl->me_client_id == flow->me_addr);
461 }
462
463 /**
464 * add_single_flow_creds - adds single buffer credentials.
465 *
466 * @file: private data ot the file object.
467 * @flow: flow control.
468 */
469 static void add_single_flow_creds(struct mei_device *dev,
470 struct hbm_flow_control *flow)
471 {
472 struct mei_me_client *client;
473 int i;
474
475 for (i = 0; i < dev->me_clients_num; i++) {
476 client = &dev->me_clients[i];
477 if (client && flow->me_addr == client->client_id) {
478 if (client->props.single_recv_buf) {
479 client->mei_flow_ctrl_creds++;
480 dev_dbg(&dev->pdev->dev, "recv flow ctrl msg ME %d (single).\n",
481 flow->me_addr);
482 dev_dbg(&dev->pdev->dev, "flow control credentials =%d.\n",
483 client->mei_flow_ctrl_creds);
484 } else {
485 BUG(); /* error in flow control */
486 }
487 }
488 }
489 }
490
491 /**
492 * mei_client_flow_control_response - flow control response irq routine
493 *
494 * @dev: the device structure
495 * @flow_control: flow control response bus message
496 */
497 static void mei_client_flow_control_response(struct mei_device *dev,
498 struct hbm_flow_control *flow_control)
499 {
500 struct mei_cl *cl_pos = NULL;
501 struct mei_cl *cl_next = NULL;
502
503 if (!flow_control->host_addr) {
504 /* single receive buffer */
505 add_single_flow_creds(dev, flow_control);
506 } else {
507 /* normal connection */
508 list_for_each_entry_safe(cl_pos, cl_next,
509 &dev->file_list, link) {
510 dev_dbg(&dev->pdev->dev, "list_for_each_entry_safe in file_list\n");
511
512 dev_dbg(&dev->pdev->dev, "cl of host client %d ME client %d.\n",
513 cl_pos->host_client_id,
514 cl_pos->me_client_id);
515 dev_dbg(&dev->pdev->dev, "flow ctrl msg for host %d ME %d.\n",
516 flow_control->host_addr,
517 flow_control->me_addr);
518 if (same_flow_addr(cl_pos, flow_control)) {
519 dev_dbg(&dev->pdev->dev, "recv ctrl msg for host %d ME %d.\n",
520 flow_control->host_addr,
521 flow_control->me_addr);
522 cl_pos->mei_flow_ctrl_creds++;
523 dev_dbg(&dev->pdev->dev, "flow control credentials = %d.\n",
524 cl_pos->mei_flow_ctrl_creds);
525 break;
526 }
527 }
528 }
529 }
530
531 /**
532 * same_disconn_addr - tells if they have the same address
533 *
534 * @file: private data of the file object.
535 * @disconn: disconnection request.
536 *
537 * returns !=0, same; 0,not.
538 */
539 static int same_disconn_addr(struct mei_cl *cl,
540 struct hbm_client_disconnect_request *disconn)
541 {
542 return (cl->host_client_id == disconn->host_addr &&
543 cl->me_client_id == disconn->me_addr);
544 }
545
546 /**
547 * mei_client_disconnect_request - disconnects from request irq routine
548 *
549 * @dev: the device structure.
550 * @disconnect_req: disconnect request bus message.
551 */
552 static void mei_client_disconnect_request(struct mei_device *dev,
553 struct hbm_client_disconnect_request *disconnect_req)
554 {
555 struct mei_msg_hdr *mei_hdr;
556 struct hbm_client_connect_response *disconnect_res;
557 struct mei_cl *cl_pos = NULL;
558 struct mei_cl *cl_next = NULL;
559
560 list_for_each_entry_safe(cl_pos, cl_next, &dev->file_list, link) {
561 if (same_disconn_addr(cl_pos, disconnect_req)) {
562 dev_dbg(&dev->pdev->dev, "disconnect request host client %d ME client %d.\n",
563 disconnect_req->host_addr,
564 disconnect_req->me_addr);
565 cl_pos->state = MEI_FILE_DISCONNECTED;
566 cl_pos->timer_count = 0;
567 if (cl_pos == &dev->wd_cl)
568 dev->wd_pending = false;
569 else if (cl_pos == &dev->iamthif_cl)
570 dev->iamthif_timer = 0;
571
572 /* prepare disconnect response */
573 mei_hdr =
574 (struct mei_msg_hdr *) &dev->ext_msg_buf[0];
575 mei_hdr->host_addr = 0;
576 mei_hdr->me_addr = 0;
577 mei_hdr->length =
578 sizeof(struct hbm_client_connect_response);
579 mei_hdr->msg_complete = 1;
580 mei_hdr->reserved = 0;
581
582 disconnect_res =
583 (struct hbm_client_connect_response *)
584 &dev->ext_msg_buf[1];
585 disconnect_res->host_addr = cl_pos->host_client_id;
586 disconnect_res->me_addr = cl_pos->me_client_id;
587 disconnect_res->hbm_cmd = CLIENT_DISCONNECT_RES_CMD;
588 disconnect_res->status = 0;
589 dev->extra_write_index = 2;
590 break;
591 }
592 }
593 }
594
595
596 /**
597 * mei_irq_thread_read_bus_message - bottom half read routine after ISR to
598 * handle the read bus message cmd processing.
599 *
600 * @dev: the device structure
601 * @mei_hdr: header of bus message
602 */
603 static void mei_irq_thread_read_bus_message(struct mei_device *dev,
604 struct mei_msg_hdr *mei_hdr)
605 {
606 struct mei_bus_message *mei_msg;
607 struct hbm_host_version_response *version_res;
608 struct hbm_client_connect_response *connect_res;
609 struct hbm_client_connect_response *disconnect_res;
610 struct hbm_flow_control *flow_control;
611 struct hbm_props_response *props_res;
612 struct hbm_host_enum_response *enum_res;
613 struct hbm_client_disconnect_request *disconnect_req;
614 struct hbm_host_stop_request *host_stop_req;
615 int res;
616
617
618 /* read the message to our buffer */
619 BUG_ON(mei_hdr->length >= sizeof(dev->rd_msg_buf));
620 mei_read_slots(dev, dev->rd_msg_buf, mei_hdr->length);
621 mei_msg = (struct mei_bus_message *)dev->rd_msg_buf;
622
623 switch (mei_msg->hbm_cmd) {
624 case HOST_START_RES_CMD:
625 version_res = (struct hbm_host_version_response *) mei_msg;
626 if (version_res->host_version_supported) {
627 dev->version.major_version = HBM_MAJOR_VERSION;
628 dev->version.minor_version = HBM_MINOR_VERSION;
629 if (dev->dev_state == MEI_DEV_INIT_CLIENTS &&
630 dev->init_clients_state == MEI_START_MESSAGE) {
631 dev->init_clients_timer = 0;
632 mei_host_enum_clients_message(dev);
633 } else {
634 dev->recvd_msg = false;
635 dev_dbg(&dev->pdev->dev, "IMEI reset due to received host start response bus message.\n");
636 mei_reset(dev, 1);
637 return;
638 }
639 } else {
640 dev->version = version_res->me_max_version;
641 /* send stop message */
642 mei_hdr = (struct mei_msg_hdr *)&dev->wr_msg_buf[0];
643 mei_hdr->host_addr = 0;
644 mei_hdr->me_addr = 0;
645 mei_hdr->length = sizeof(struct hbm_host_stop_request);
646 mei_hdr->msg_complete = 1;
647 mei_hdr->reserved = 0;
648
649 host_stop_req = (struct hbm_host_stop_request *)
650 &dev->wr_msg_buf[1];
651
652 memset(host_stop_req,
653 0,
654 sizeof(struct hbm_host_stop_request));
655 host_stop_req->hbm_cmd = HOST_STOP_REQ_CMD;
656 host_stop_req->reason = DRIVER_STOP_REQUEST;
657 mei_write_message(dev, mei_hdr,
658 (unsigned char *) (host_stop_req),
659 mei_hdr->length);
660 dev_dbg(&dev->pdev->dev, "version mismatch.\n");
661 return;
662 }
663
664 dev->recvd_msg = true;
665 dev_dbg(&dev->pdev->dev, "host start response message received.\n");
666 break;
667
668 case CLIENT_CONNECT_RES_CMD:
669 connect_res =
670 (struct hbm_client_connect_response *) mei_msg;
671 mei_client_connect_response(dev, connect_res);
672 dev_dbg(&dev->pdev->dev, "client connect response message received.\n");
673 wake_up(&dev->wait_recvd_msg);
674 break;
675
676 case CLIENT_DISCONNECT_RES_CMD:
677 disconnect_res =
678 (struct hbm_client_connect_response *) mei_msg;
679 mei_client_disconnect_response(dev, disconnect_res);
680 dev_dbg(&dev->pdev->dev, "client disconnect response message received.\n");
681 wake_up(&dev->wait_recvd_msg);
682 break;
683
684 case MEI_FLOW_CONTROL_CMD:
685 flow_control = (struct hbm_flow_control *) mei_msg;
686 mei_client_flow_control_response(dev, flow_control);
687 dev_dbg(&dev->pdev->dev, "client flow control response message received.\n");
688 break;
689
690 case HOST_CLIENT_PROPERTIES_RES_CMD:
691 props_res = (struct hbm_props_response *)mei_msg;
692 if (props_res->status || !dev->me_clients) {
693 dev_dbg(&dev->pdev->dev, "reset due to received host client properties response bus message wrong status.\n");
694 mei_reset(dev, 1);
695 return;
696 }
697 if (dev->me_clients[dev->me_client_presentation_num]
698 .client_id == props_res->address) {
699
700 dev->me_clients[dev->me_client_presentation_num].props
701 = props_res->client_properties;
702
703 if (dev->dev_state == MEI_DEV_INIT_CLIENTS &&
704 dev->init_clients_state ==
705 MEI_CLIENT_PROPERTIES_MESSAGE) {
706 dev->me_client_index++;
707 dev->me_client_presentation_num++;
708
709 /** Send Client Properties request **/
710 res = mei_host_client_properties(dev);
711 if (res < 0) {
712 dev_dbg(&dev->pdev->dev, "mei_host_client_properties() failed");
713 return;
714 } else if (!res) {
715 /*
716 * No more clients to send to.
717 * Clear Map for indicating now ME clients
718 * with associated host client
719 */
720 bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX);
721 dev->open_handle_count = 0;
722
723 /*
724 * Reserving the first three client IDs
725 * Client Id 0 - Reserved for MEI Bus Message communications
726 * Client Id 1 - Reserved for Watchdog
727 * Client ID 2 - Reserved for AMTHI
728 */
729 bitmap_set(dev->host_clients_map, 0, 3);
730 dev->dev_state = MEI_DEV_ENABLED;
731
732 /* if wd initialization fails, initialization the AMTHI client,
733 * otherwise the AMTHI client will be initialized after the WD client connect response
734 * will be received
735 */
736 if (mei_wd_host_init(dev))
737 mei_host_init_iamthif(dev);
738 }
739
740 } else {
741 dev_dbg(&dev->pdev->dev, "reset due to received host client properties response bus message");
742 mei_reset(dev, 1);
743 return;
744 }
745 } else {
746 dev_dbg(&dev->pdev->dev, "reset due to received host client properties response bus message for wrong client ID\n");
747 mei_reset(dev, 1);
748 return;
749 }
750 break;
751
752 case HOST_ENUM_RES_CMD:
753 enum_res = (struct hbm_host_enum_response *) mei_msg;
754 memcpy(dev->me_clients_map, enum_res->valid_addresses, 32);
755 if (dev->dev_state == MEI_DEV_INIT_CLIENTS &&
756 dev->init_clients_state == MEI_ENUM_CLIENTS_MESSAGE) {
757 dev->init_clients_timer = 0;
758 dev->me_client_presentation_num = 0;
759 dev->me_client_index = 0;
760 mei_allocate_me_clients_storage(dev);
761 dev->init_clients_state =
762 MEI_CLIENT_PROPERTIES_MESSAGE;
763 mei_host_client_properties(dev);
764 } else {
765 dev_dbg(&dev->pdev->dev, "reset due to received host enumeration clients response bus message.\n");
766 mei_reset(dev, 1);
767 return;
768 }
769 break;
770
771 case HOST_STOP_RES_CMD:
772 dev->dev_state = MEI_DEV_DISABLED;
773 dev_dbg(&dev->pdev->dev, "resetting because of FW stop response.\n");
774 mei_reset(dev, 1);
775 break;
776
777 case CLIENT_DISCONNECT_REQ_CMD:
778 /* search for client */
779 disconnect_req =
780 (struct hbm_client_disconnect_request *) mei_msg;
781 mei_client_disconnect_request(dev, disconnect_req);
782 break;
783
784 case ME_STOP_REQ_CMD:
785 /* prepare stop request */
786 mei_hdr = (struct mei_msg_hdr *) &dev->ext_msg_buf[0];
787 mei_hdr->host_addr = 0;
788 mei_hdr->me_addr = 0;
789 mei_hdr->length = sizeof(struct hbm_host_stop_request);
790 mei_hdr->msg_complete = 1;
791 mei_hdr->reserved = 0;
792 host_stop_req =
793 (struct hbm_host_stop_request *) &dev->ext_msg_buf[1];
794 memset(host_stop_req, 0, sizeof(struct hbm_host_stop_request));
795 host_stop_req->hbm_cmd = HOST_STOP_REQ_CMD;
796 host_stop_req->reason = DRIVER_STOP_REQUEST;
797 host_stop_req->reserved[0] = 0;
798 host_stop_req->reserved[1] = 0;
799 dev->extra_write_index = 2;
800 break;
801
802 default:
803 BUG();
804 break;
805
806 }
807 }
808
809
810 /**
811 * _mei_hb_read - processes read related operation.
812 *
813 * @dev: the device structure.
814 * @slots: free slots.
815 * @cb_pos: callback block.
816 * @cl: private data of the file object.
817 * @cmpl_list: complete list.
818 *
819 * returns 0, OK; otherwise, error.
820 */
821 static int _mei_irq_thread_read(struct mei_device *dev, s32 *slots,
822 struct mei_cl_cb *cb_pos,
823 struct mei_cl *cl,
824 struct mei_io_list *cmpl_list)
825 {
826 if ((*slots * sizeof(u32)) < (sizeof(struct mei_msg_hdr) +
827 sizeof(struct hbm_flow_control))) {
828 /* return the cancel routine */
829 list_del(&cb_pos->cb_list);
830 return -EBADMSG;
831 }
832
833 *slots -= mei_data2slots(sizeof(struct hbm_flow_control));
834
835 if (mei_send_flow_control(dev, cl)) {
836 cl->status = -ENODEV;
837 cb_pos->information = 0;
838 list_move_tail(&cb_pos->cb_list, &cmpl_list->mei_cb.cb_list);
839 return -ENODEV;
840 }
841 list_move_tail(&cb_pos->cb_list, &dev->read_list.mei_cb.cb_list);
842
843 return 0;
844 }
845
846
847 /**
848 * _mei_irq_thread_ioctl - processes ioctl related operation.
849 *
850 * @dev: the device structure.
851 * @slots: free slots.
852 * @cb_pos: callback block.
853 * @cl: private data of the file object.
854 * @cmpl_list: complete list.
855 *
856 * returns 0, OK; otherwise, error.
857 */
858 static int _mei_irq_thread_ioctl(struct mei_device *dev, s32 *slots,
859 struct mei_cl_cb *cb_pos,
860 struct mei_cl *cl,
861 struct mei_io_list *cmpl_list)
862 {
863 if ((*slots * sizeof(u32)) < (sizeof(struct mei_msg_hdr) +
864 sizeof(struct hbm_client_connect_request))) {
865 /* return the cancel routine */
866 list_del(&cb_pos->cb_list);
867 return -EBADMSG;
868 }
869
870 cl->state = MEI_FILE_CONNECTING;
871 *slots -= mei_data2slots(sizeof(struct hbm_client_connect_request));
872 if (mei_connect(dev, cl)) {
873 cl->status = -ENODEV;
874 cb_pos->information = 0;
875 list_del(&cb_pos->cb_list);
876 return -ENODEV;
877 } else {
878 list_move_tail(&cb_pos->cb_list,
879 &dev->ctrl_rd_list.mei_cb.cb_list);
880 cl->timer_count = MEI_CONNECT_TIMEOUT;
881 }
882 return 0;
883 }
884
885 /**
886 * _mei_irq_thread_cmpl - processes completed and no-iamthif operation.
887 *
888 * @dev: the device structure.
889 * @slots: free slots.
890 * @cb_pos: callback block.
891 * @cl: private data of the file object.
892 * @cmpl_list: complete list.
893 *
894 * returns 0, OK; otherwise, error.
895 */
896 static int _mei_irq_thread_cmpl(struct mei_device *dev, s32 *slots,
897 struct mei_cl_cb *cb_pos,
898 struct mei_cl *cl,
899 struct mei_io_list *cmpl_list)
900 {
901 struct mei_msg_hdr *mei_hdr;
902
903 if ((*slots * sizeof(u32)) >= (sizeof(struct mei_msg_hdr) +
904 (cb_pos->request_buffer.size -
905 cb_pos->information))) {
906 mei_hdr = (struct mei_msg_hdr *) &dev->wr_msg_buf[0];
907 mei_hdr->host_addr = cl->host_client_id;
908 mei_hdr->me_addr = cl->me_client_id;
909 mei_hdr->length = cb_pos->request_buffer.size -
910 cb_pos->information;
911 mei_hdr->msg_complete = 1;
912 mei_hdr->reserved = 0;
913 dev_dbg(&dev->pdev->dev, "cb_pos->request_buffer.size =%d"
914 "mei_hdr->msg_complete = %d\n",
915 cb_pos->request_buffer.size,
916 mei_hdr->msg_complete);
917 dev_dbg(&dev->pdev->dev, "cb_pos->information =%lu\n",
918 cb_pos->information);
919 dev_dbg(&dev->pdev->dev, "mei_hdr->length =%d\n",
920 mei_hdr->length);
921 *slots -= mei_data2slots(mei_hdr->length);
922 if (mei_write_message(dev, mei_hdr,
923 (unsigned char *)
924 (cb_pos->request_buffer.data +
925 cb_pos->information),
926 mei_hdr->length)) {
927 cl->status = -ENODEV;
928 list_move_tail(&cb_pos->cb_list,
929 &cmpl_list->mei_cb.cb_list);
930 return -ENODEV;
931 } else {
932 if (mei_flow_ctrl_reduce(dev, cl))
933 return -ENODEV;
934 cl->status = 0;
935 cb_pos->information += mei_hdr->length;
936 list_move_tail(&cb_pos->cb_list,
937 &dev->write_waiting_list.mei_cb.cb_list);
938 }
939 } else if (*slots == dev->hbuf_depth) {
940 /* buffer is still empty */
941 mei_hdr = (struct mei_msg_hdr *) &dev->wr_msg_buf[0];
942 mei_hdr->host_addr = cl->host_client_id;
943 mei_hdr->me_addr = cl->me_client_id;
944 mei_hdr->length =
945 (*slots * sizeof(u32)) - sizeof(struct mei_msg_hdr);
946 mei_hdr->msg_complete = 0;
947 mei_hdr->reserved = 0;
948 *slots -= mei_data2slots(mei_hdr->length);
949 if (mei_write_message(dev, mei_hdr,
950 (unsigned char *)
951 (cb_pos->request_buffer.data +
952 cb_pos->information),
953 mei_hdr->length)) {
954 cl->status = -ENODEV;
955 list_move_tail(&cb_pos->cb_list,
956 &cmpl_list->mei_cb.cb_list);
957 return -ENODEV;
958 } else {
959 cb_pos->information += mei_hdr->length;
960 dev_dbg(&dev->pdev->dev,
961 "cb_pos->request_buffer.size =%d"
962 " mei_hdr->msg_complete = %d\n",
963 cb_pos->request_buffer.size,
964 mei_hdr->msg_complete);
965 dev_dbg(&dev->pdev->dev, "cb_pos->information =%lu\n",
966 cb_pos->information);
967 dev_dbg(&dev->pdev->dev, "mei_hdr->length =%d\n",
968 mei_hdr->length);
969 }
970 return -EMSGSIZE;
971 } else {
972 return -EBADMSG;
973 }
974
975 return 0;
976 }
977
978 /**
979 * _mei_irq_thread_cmpl_iamthif - processes completed iamthif operation.
980 *
981 * @dev: the device structure.
982 * @slots: free slots.
983 * @cb_pos: callback block.
984 * @cl: private data of the file object.
985 * @cmpl_list: complete list.
986 *
987 * returns 0, OK; otherwise, error.
988 */
989 static int _mei_irq_thread_cmpl_iamthif(struct mei_device *dev, s32 *slots,
990 struct mei_cl_cb *cb_pos,
991 struct mei_cl *cl,
992 struct mei_io_list *cmpl_list)
993 {
994 struct mei_msg_hdr *mei_hdr;
995
996 if ((*slots * sizeof(u32)) >= (sizeof(struct mei_msg_hdr) +
997 dev->iamthif_msg_buf_size -
998 dev->iamthif_msg_buf_index)) {
999 mei_hdr = (struct mei_msg_hdr *) &dev->wr_msg_buf[0];
1000 mei_hdr->host_addr = cl->host_client_id;
1001 mei_hdr->me_addr = cl->me_client_id;
1002 mei_hdr->length = dev->iamthif_msg_buf_size -
1003 dev->iamthif_msg_buf_index;
1004 mei_hdr->msg_complete = 1;
1005 mei_hdr->reserved = 0;
1006
1007 *slots -= mei_data2slots(mei_hdr->length);
1008
1009 if (mei_write_message(dev, mei_hdr,
1010 (dev->iamthif_msg_buf +
1011 dev->iamthif_msg_buf_index),
1012 mei_hdr->length)) {
1013 dev->iamthif_state = MEI_IAMTHIF_IDLE;
1014 cl->status = -ENODEV;
1015 list_del(&cb_pos->cb_list);
1016 return -ENODEV;
1017 } else {
1018 if (mei_flow_ctrl_reduce(dev, cl))
1019 return -ENODEV;
1020 dev->iamthif_msg_buf_index += mei_hdr->length;
1021 cb_pos->information = dev->iamthif_msg_buf_index;
1022 cl->status = 0;
1023 dev->iamthif_state = MEI_IAMTHIF_FLOW_CONTROL;
1024 dev->iamthif_flow_control_pending = true;
1025 /* save iamthif cb sent to amthi client */
1026 dev->iamthif_current_cb = cb_pos;
1027 list_move_tail(&cb_pos->cb_list,
1028 &dev->write_waiting_list.mei_cb.cb_list);
1029
1030 }
1031 } else if (*slots == dev->hbuf_depth) {
1032 /* buffer is still empty */
1033 mei_hdr = (struct mei_msg_hdr *) &dev->wr_msg_buf[0];
1034 mei_hdr->host_addr = cl->host_client_id;
1035 mei_hdr->me_addr = cl->me_client_id;
1036 mei_hdr->length =
1037 (*slots * sizeof(u32)) - sizeof(struct mei_msg_hdr);
1038 mei_hdr->msg_complete = 0;
1039 mei_hdr->reserved = 0;
1040
1041 *slots -= mei_data2slots(mei_hdr->length);
1042
1043 if (mei_write_message(dev, mei_hdr,
1044 (dev->iamthif_msg_buf +
1045 dev->iamthif_msg_buf_index),
1046 mei_hdr->length)) {
1047 cl->status = -ENODEV;
1048 list_del(&cb_pos->cb_list);
1049 } else {
1050 dev->iamthif_msg_buf_index += mei_hdr->length;
1051 }
1052 return -EMSGSIZE;
1053 } else {
1054 return -EBADMSG;
1055 }
1056
1057 return 0;
1058 }
1059
1060 /**
1061 * mei_irq_thread_read_handler - bottom half read routine after ISR to
1062 * handle the read processing.
1063 *
1064 * @cmpl_list: An instance of our list structure
1065 * @dev: the device structure
1066 * @slots: slots to read.
1067 *
1068 * returns 0 on success, <0 on failure.
1069 */
1070 static int mei_irq_thread_read_handler(struct mei_io_list *cmpl_list,
1071 struct mei_device *dev,
1072 s32 *slots)
1073 {
1074 struct mei_msg_hdr *mei_hdr;
1075 struct mei_cl *cl_pos = NULL;
1076 struct mei_cl *cl_next = NULL;
1077 int ret = 0;
1078
1079 if (!dev->rd_msg_hdr) {
1080 dev->rd_msg_hdr = mei_mecbrw_read(dev);
1081 dev_dbg(&dev->pdev->dev, "slots =%08x.\n", *slots);
1082 (*slots)--;
1083 dev_dbg(&dev->pdev->dev, "slots =%08x.\n", *slots);
1084 }
1085 mei_hdr = (struct mei_msg_hdr *) &dev->rd_msg_hdr;
1086 dev_dbg(&dev->pdev->dev, "mei_hdr->length =%d\n", mei_hdr->length);
1087
1088 if (mei_hdr->reserved || !dev->rd_msg_hdr) {
1089 dev_dbg(&dev->pdev->dev, "corrupted message header.\n");
1090 ret = -EBADMSG;
1091 goto end;
1092 }
1093
1094 if (mei_hdr->host_addr || mei_hdr->me_addr) {
1095 list_for_each_entry_safe(cl_pos, cl_next,
1096 &dev->file_list, link) {
1097 dev_dbg(&dev->pdev->dev,
1098 "list_for_each_entry_safe read host"
1099 " client = %d, ME client = %d\n",
1100 cl_pos->host_client_id,
1101 cl_pos->me_client_id);
1102 if (cl_pos->host_client_id == mei_hdr->host_addr &&
1103 cl_pos->me_client_id == mei_hdr->me_addr)
1104 break;
1105 }
1106
1107 if (&cl_pos->link == &dev->file_list) {
1108 dev_dbg(&dev->pdev->dev, "corrupted message header\n");
1109 ret = -EBADMSG;
1110 goto end;
1111 }
1112 }
1113 if (((*slots) * sizeof(u32)) < mei_hdr->length) {
1114 dev_dbg(&dev->pdev->dev,
1115 "we can't read the message slots =%08x.\n",
1116 *slots);
1117 /* we can't read the message */
1118 ret = -ERANGE;
1119 goto end;
1120 }
1121
1122 /* decide where to read the message too */
1123 if (!mei_hdr->host_addr) {
1124 dev_dbg(&dev->pdev->dev, "call mei_irq_thread_read_bus_message.\n");
1125 mei_irq_thread_read_bus_message(dev, mei_hdr);
1126 dev_dbg(&dev->pdev->dev, "end mei_irq_thread_read_bus_message.\n");
1127 } else if (mei_hdr->host_addr == dev->iamthif_cl.host_client_id &&
1128 (MEI_FILE_CONNECTED == dev->iamthif_cl.state) &&
1129 (dev->iamthif_state == MEI_IAMTHIF_READING)) {
1130 dev_dbg(&dev->pdev->dev, "call mei_irq_thread_read_iamthif_message.\n");
1131 dev_dbg(&dev->pdev->dev, "mei_hdr->length =%d\n",
1132 mei_hdr->length);
1133 ret = mei_irq_thread_read_amthi_message(cmpl_list,
1134 dev, mei_hdr);
1135 if (ret)
1136 goto end;
1137
1138 } else {
1139 dev_dbg(&dev->pdev->dev, "call mei_irq_thread_read_client_message.\n");
1140 ret = mei_irq_thread_read_client_message(cmpl_list,
1141 dev, mei_hdr);
1142 if (ret)
1143 goto end;
1144
1145 }
1146
1147 /* reset the number of slots and header */
1148 *slots = mei_count_full_read_slots(dev);
1149 dev->rd_msg_hdr = 0;
1150
1151 if (*slots == -EOVERFLOW) {
1152 /* overflow - reset */
1153 dev_dbg(&dev->pdev->dev, "resetting due to slots overflow.\n");
1154 /* set the event since message has been read */
1155 ret = -ERANGE;
1156 goto end;
1157 }
1158 end:
1159 return ret;
1160 }
1161
1162
1163 /**
1164 * mei_irq_thread_write_handler - bottom half write routine after
1165 * ISR to handle the write processing.
1166 *
1167 * @cmpl_list: An instance of our list structure
1168 * @dev: the device structure
1169 * @slots: slots to write.
1170 *
1171 * returns 0 on success, <0 on failure.
1172 */
1173 static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
1174 struct mei_device *dev,
1175 s32 *slots)
1176 {
1177
1178 struct mei_cl *cl;
1179 struct mei_cl_cb *pos = NULL, *next = NULL;
1180 struct mei_io_list *list;
1181 int ret;
1182
1183 if (!mei_hbuf_is_empty(dev)) {
1184 dev_dbg(&dev->pdev->dev, "host buffer is not empty.\n");
1185 return 0;
1186 }
1187 *slots = mei_hbuf_empty_slots(dev);
1188 if (*slots <= 0)
1189 return -EMSGSIZE;
1190
1191 /* complete all waiting for write CB */
1192 dev_dbg(&dev->pdev->dev, "complete all waiting for write cb.\n");
1193
1194 list = &dev->write_waiting_list;
1195 list_for_each_entry_safe(pos, next, &list->mei_cb.cb_list, cb_list) {
1196 cl = (struct mei_cl *)pos->file_private;
1197 if (cl == NULL)
1198 continue;
1199
1200 cl->status = 0;
1201 list_del(&pos->cb_list);
1202 if (MEI_WRITING == cl->writing_state &&
1203 (pos->major_file_operations == MEI_WRITE) &&
1204 (cl != &dev->iamthif_cl)) {
1205 dev_dbg(&dev->pdev->dev, "MEI WRITE COMPLETE\n");
1206 cl->writing_state = MEI_WRITE_COMPLETE;
1207 list_add_tail(&pos->cb_list,
1208 &cmpl_list->mei_cb.cb_list);
1209 }
1210 if (cl == &dev->iamthif_cl) {
1211 dev_dbg(&dev->pdev->dev, "check iamthif flow control.\n");
1212 if (dev->iamthif_flow_control_pending) {
1213 ret = _mei_irq_thread_iamthif_read(dev, slots);
1214 if (ret)
1215 return ret;
1216 }
1217 }
1218 }
1219
1220 if (dev->wd_state == MEI_WD_STOPPING) {
1221 dev->wd_state = MEI_WD_IDLE;
1222 wake_up_interruptible(&dev->wait_stop_wd);
1223 }
1224
1225 if (dev->extra_write_index) {
1226 dev_dbg(&dev->pdev->dev, "extra_write_index =%d.\n",
1227 dev->extra_write_index);
1228 mei_write_message(dev,
1229 (struct mei_msg_hdr *) &dev->ext_msg_buf[0],
1230 (unsigned char *) &dev->ext_msg_buf[1],
1231 (dev->extra_write_index - 1) * sizeof(u32));
1232 *slots -= dev->extra_write_index;
1233 dev->extra_write_index = 0;
1234 }
1235 if (dev->dev_state == MEI_DEV_ENABLED) {
1236 if (dev->wd_pending &&
1237 mei_flow_ctrl_creds(dev, &dev->wd_cl) > 0) {
1238 if (mei_wd_send(dev))
1239 dev_dbg(&dev->pdev->dev, "wd send failed.\n");
1240 else if (mei_flow_ctrl_reduce(dev, &dev->wd_cl))
1241 return -ENODEV;
1242
1243 dev->wd_pending = false;
1244
1245 if (dev->wd_state == MEI_WD_RUNNING)
1246 *slots -= mei_data2slots(MEI_WD_START_MSG_SIZE);
1247 else
1248 *slots -= mei_data2slots(MEI_WD_STOP_MSG_SIZE);
1249 }
1250 }
1251
1252 /* complete control write list CB */
1253 dev_dbg(&dev->pdev->dev, "complete control write list cb.\n");
1254 list_for_each_entry_safe(pos, next,
1255 &dev->ctrl_wr_list.mei_cb.cb_list, cb_list) {
1256 cl = (struct mei_cl *) pos->file_private;
1257 if (!cl) {
1258 list_del(&pos->cb_list);
1259 return -ENODEV;
1260 }
1261 switch (pos->major_file_operations) {
1262 case MEI_CLOSE:
1263 /* send disconnect message */
1264 ret = _mei_irq_thread_close(dev, slots, pos, cl, cmpl_list);
1265 if (ret)
1266 return ret;
1267
1268 break;
1269 case MEI_READ:
1270 /* send flow control message */
1271 ret = _mei_irq_thread_read(dev, slots, pos, cl, cmpl_list);
1272 if (ret)
1273 return ret;
1274
1275 break;
1276 case MEI_IOCTL:
1277 /* connect message */
1278 if (mei_other_client_is_connecting(dev, cl))
1279 continue;
1280 ret = _mei_irq_thread_ioctl(dev, slots, pos, cl, cmpl_list);
1281 if (ret)
1282 return ret;
1283
1284 break;
1285
1286 default:
1287 BUG();
1288 }
1289
1290 }
1291 /* complete write list CB */
1292 dev_dbg(&dev->pdev->dev, "complete write list cb.\n");
1293 list_for_each_entry_safe(pos, next,
1294 &dev->write_list.mei_cb.cb_list, cb_list) {
1295 cl = (struct mei_cl *)pos->file_private;
1296 if (cl == NULL)
1297 continue;
1298
1299 if (cl != &dev->iamthif_cl) {
1300 if (mei_flow_ctrl_creds(dev, cl) <= 0) {
1301 dev_dbg(&dev->pdev->dev,
1302 "No flow control credentials for client %d, not sending.\n",
1303 cl->host_client_id);
1304 continue;
1305 }
1306 ret = _mei_irq_thread_cmpl(dev, slots, pos,
1307 cl, cmpl_list);
1308 if (ret)
1309 return ret;
1310
1311 } else if (cl == &dev->iamthif_cl) {
1312 /* IAMTHIF IOCTL */
1313 dev_dbg(&dev->pdev->dev, "complete amthi write cb.\n");
1314 if (mei_flow_ctrl_creds(dev, cl) <= 0) {
1315 dev_dbg(&dev->pdev->dev,
1316 "No flow control credentials for amthi client %d.\n",
1317 cl->host_client_id);
1318 continue;
1319 }
1320 ret = _mei_irq_thread_cmpl_iamthif(dev, slots, pos,
1321 cl, cmpl_list);
1322 if (ret)
1323 return ret;
1324
1325 }
1326
1327 }
1328 return 0;
1329 }
1330
1331
1332
1333 /**
1334 * mei_timer - timer function.
1335 *
1336 * @work: pointer to the work_struct structure
1337 *
1338 * NOTE: This function is called by timer interrupt work
1339 */
1340 void mei_timer(struct work_struct *work)
1341 {
1342 unsigned long timeout;
1343 struct mei_cl *cl_pos = NULL;
1344 struct mei_cl *cl_next = NULL;
1345 struct list_head *amthi_complete_list = NULL;
1346 struct mei_cl_cb *cb_pos = NULL;
1347 struct mei_cl_cb *cb_next = NULL;
1348
1349 struct mei_device *dev = container_of(work,
1350 struct mei_device, timer_work.work);
1351
1352
1353 mutex_lock(&dev->device_lock);
1354 if (dev->dev_state != MEI_DEV_ENABLED) {
1355 if (dev->dev_state == MEI_DEV_INIT_CLIENTS) {
1356 if (dev->init_clients_timer) {
1357 if (--dev->init_clients_timer == 0) {
1358 dev_dbg(&dev->pdev->dev, "IMEI reset due to init clients timeout ,init clients state = %d.\n",
1359 dev->init_clients_state);
1360 mei_reset(dev, 1);
1361 }
1362 }
1363 }
1364 goto out;
1365 }
1366 /*** connect/disconnect timeouts ***/
1367 list_for_each_entry_safe(cl_pos, cl_next, &dev->file_list, link) {
1368 if (cl_pos->timer_count) {
1369 if (--cl_pos->timer_count == 0) {
1370 dev_dbg(&dev->pdev->dev, "HECI reset due to connect/disconnect timeout.\n");
1371 mei_reset(dev, 1);
1372 goto out;
1373 }
1374 }
1375 }
1376
1377 if (dev->iamthif_stall_timer) {
1378 if (--dev->iamthif_stall_timer == 0) {
1379 dev_dbg(&dev->pdev->dev, "resetting because of hang to amthi.\n");
1380 mei_reset(dev, 1);
1381 dev->iamthif_msg_buf_size = 0;
1382 dev->iamthif_msg_buf_index = 0;
1383 dev->iamthif_canceled = false;
1384 dev->iamthif_ioctl = true;
1385 dev->iamthif_state = MEI_IAMTHIF_IDLE;
1386 dev->iamthif_timer = 0;
1387
1388 if (dev->iamthif_current_cb)
1389 mei_free_cb_private(dev->iamthif_current_cb);
1390
1391 dev->iamthif_file_object = NULL;
1392 dev->iamthif_current_cb = NULL;
1393 mei_run_next_iamthif_cmd(dev);
1394 }
1395 }
1396
1397 if (dev->iamthif_timer) {
1398
1399 timeout = dev->iamthif_timer +
1400 msecs_to_jiffies(IAMTHIF_READ_TIMER);
1401
1402 dev_dbg(&dev->pdev->dev, "dev->iamthif_timer = %ld\n",
1403 dev->iamthif_timer);
1404 dev_dbg(&dev->pdev->dev, "timeout = %ld\n", timeout);
1405 dev_dbg(&dev->pdev->dev, "jiffies = %ld\n", jiffies);
1406 if (time_after(jiffies, timeout)) {
1407 /*
1408 * User didn't read the AMTHI data on time (15sec)
1409 * freeing AMTHI for other requests
1410 */
1411
1412 dev_dbg(&dev->pdev->dev, "freeing AMTHI for other requests\n");
1413
1414 amthi_complete_list = &dev->amthi_read_complete_list.
1415 mei_cb.cb_list;
1416
1417 list_for_each_entry_safe(cb_pos, cb_next, amthi_complete_list, cb_list) {
1418
1419 cl_pos = cb_pos->file_object->private_data;
1420
1421 /* Finding the AMTHI entry. */
1422 if (cl_pos == &dev->iamthif_cl)
1423 list_del(&cb_pos->cb_list);
1424 }
1425 if (dev->iamthif_current_cb)
1426 mei_free_cb_private(dev->iamthif_current_cb);
1427
1428 dev->iamthif_file_object->private_data = NULL;
1429 dev->iamthif_file_object = NULL;
1430 dev->iamthif_current_cb = NULL;
1431 dev->iamthif_timer = 0;
1432 mei_run_next_iamthif_cmd(dev);
1433
1434 }
1435 }
1436 out:
1437 schedule_delayed_work(&dev->timer_work, 2 * HZ);
1438 mutex_unlock(&dev->device_lock);
1439 }
1440
1441 /**
1442 * mei_interrupt_thread_handler - function called after ISR to handle the interrupt
1443 * processing.
1444 *
1445 * @irq: The irq number
1446 * @dev_id: pointer to the device structure
1447 *
1448 * returns irqreturn_t
1449 *
1450 */
1451 irqreturn_t mei_interrupt_thread_handler(int irq, void *dev_id)
1452 {
1453 struct mei_device *dev = (struct mei_device *) dev_id;
1454 struct mei_io_list complete_list;
1455 struct mei_cl_cb *cb_pos = NULL, *cb_next = NULL;
1456 struct mei_cl *cl;
1457 s32 slots;
1458 int rets;
1459 bool bus_message_received;
1460
1461
1462 dev_dbg(&dev->pdev->dev, "function called after ISR to handle the interrupt processing.\n");
1463 /* initialize our complete list */
1464 mutex_lock(&dev->device_lock);
1465 mei_io_list_init(&complete_list);
1466 dev->host_hw_state = mei_hcsr_read(dev);
1467
1468 /* Ack the interrupt here
1469 * In case of MSI we don't go through the quick handler */
1470 if (pci_dev_msi_enabled(dev->pdev))
1471 mei_reg_write(dev, H_CSR, dev->host_hw_state);
1472
1473 dev->me_hw_state = mei_mecsr_read(dev);
1474
1475 /* check if ME wants a reset */
1476 if ((dev->me_hw_state & ME_RDY_HRA) == 0 &&
1477 dev->dev_state != MEI_DEV_RESETING &&
1478 dev->dev_state != MEI_DEV_INITIALIZING) {
1479 dev_dbg(&dev->pdev->dev, "FW not ready.\n");
1480 mei_reset(dev, 1);
1481 mutex_unlock(&dev->device_lock);
1482 return IRQ_HANDLED;
1483 }
1484
1485 /* check if we need to start the dev */
1486 if ((dev->host_hw_state & H_RDY) == 0) {
1487 if ((dev->me_hw_state & ME_RDY_HRA) == ME_RDY_HRA) {
1488 dev_dbg(&dev->pdev->dev, "we need to start the dev.\n");
1489 dev->host_hw_state |= (H_IE | H_IG | H_RDY);
1490 mei_hcsr_set(dev);
1491 dev->dev_state = MEI_DEV_INIT_CLIENTS;
1492 dev_dbg(&dev->pdev->dev, "link is established start sending messages.\n");
1493 /* link is established
1494 * start sending messages.
1495 */
1496 mei_host_start_message(dev);
1497 mutex_unlock(&dev->device_lock);
1498 return IRQ_HANDLED;
1499 } else {
1500 dev_dbg(&dev->pdev->dev, "FW not ready.\n");
1501 mutex_unlock(&dev->device_lock);
1502 return IRQ_HANDLED;
1503 }
1504 }
1505 /* check slots available for reading */
1506 slots = mei_count_full_read_slots(dev);
1507 dev_dbg(&dev->pdev->dev, "slots =%08x extra_write_index =%08x.\n",
1508 slots, dev->extra_write_index);
1509 while (slots > 0 && !dev->extra_write_index) {
1510 dev_dbg(&dev->pdev->dev, "slots =%08x extra_write_index =%08x.\n",
1511 slots, dev->extra_write_index);
1512 dev_dbg(&dev->pdev->dev, "call mei_irq_thread_read_handler.\n");
1513 rets = mei_irq_thread_read_handler(&complete_list, dev, &slots);
1514 if (rets)
1515 goto end;
1516 }
1517 rets = mei_irq_thread_write_handler(&complete_list, dev, &slots);
1518 end:
1519 dev_dbg(&dev->pdev->dev, "end of bottom half function.\n");
1520 dev->host_hw_state = mei_hcsr_read(dev);
1521 dev->mei_host_buffer_is_empty = mei_hbuf_is_empty(dev);
1522
1523 bus_message_received = false;
1524 if (dev->recvd_msg && waitqueue_active(&dev->wait_recvd_msg)) {
1525 dev_dbg(&dev->pdev->dev, "received waiting bus message\n");
1526 bus_message_received = true;
1527 }
1528 mutex_unlock(&dev->device_lock);
1529 if (bus_message_received) {
1530 dev_dbg(&dev->pdev->dev, "wake up dev->wait_recvd_msg\n");
1531 wake_up_interruptible(&dev->wait_recvd_msg);
1532 bus_message_received = false;
1533 }
1534 if (list_empty(&complete_list.mei_cb.cb_list))
1535 return IRQ_HANDLED;
1536
1537
1538 list_for_each_entry_safe(cb_pos, cb_next,
1539 &complete_list.mei_cb.cb_list, cb_list) {
1540 cl = (struct mei_cl *)cb_pos->file_private;
1541 list_del(&cb_pos->cb_list);
1542 if (cl) {
1543 if (cl != &dev->iamthif_cl) {
1544 dev_dbg(&dev->pdev->dev, "completing call back.\n");
1545 _mei_cmpl(cl, cb_pos);
1546 cb_pos = NULL;
1547 } else if (cl == &dev->iamthif_cl) {
1548 _mei_cmpl_iamthif(dev, cb_pos);
1549 }
1550 }
1551 }
1552 return IRQ_HANDLED;
1553 }
Linux kernel - Deliverables
This page took 0.084943 seconds and 5 git commands to generate.