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