Loading...
Note: File does not exist in v5.4.
1/*
2 *
3 * Intel Management Engine Interface (Intel MEI) Linux driver
4 * Copyright (c) 2003-2012, Intel Corporation.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 */
16
17#include <linux/kernel.h>
18#include <linux/fs.h>
19#include <linux/errno.h>
20#include <linux/types.h>
21#include <linux/fcntl.h>
22#include <linux/aio.h>
23#include <linux/pci.h>
24#include <linux/ioctl.h>
25#include <linux/cdev.h>
26#include <linux/list.h>
27#include <linux/delay.h>
28#include <linux/sched.h>
29#include <linux/uuid.h>
30#include <linux/jiffies.h>
31#include <linux/uaccess.h>
32
33#include <linux/mei.h>
34
35#include "mei_dev.h"
36#include "hbm.h"
37#include "client.h"
38
39const uuid_le mei_amthif_guid = UUID_LE(0x12f80028, 0xb4b7, 0x4b2d,
40 0xac, 0xa8, 0x46, 0xe0,
41 0xff, 0x65, 0x81, 0x4c);
42
43/**
44 * mei_amthif_reset_params - initializes mei device iamthif
45 *
46 * @dev: the device structure
47 */
48void mei_amthif_reset_params(struct mei_device *dev)
49{
50 /* reset iamthif parameters. */
51 dev->iamthif_current_cb = NULL;
52 dev->iamthif_msg_buf_size = 0;
53 dev->iamthif_msg_buf_index = 0;
54 dev->iamthif_canceled = false;
55 dev->iamthif_ioctl = false;
56 dev->iamthif_state = MEI_IAMTHIF_IDLE;
57 dev->iamthif_timer = 0;
58 dev->iamthif_stall_timer = 0;
59 dev->iamthif_open_count = 0;
60}
61
62/**
63 * mei_amthif_host_init - mei initialization amthif client.
64 *
65 * @dev: the device structure
66 *
67 */
68int mei_amthif_host_init(struct mei_device *dev)
69{
70 struct mei_cl *cl = &dev->iamthif_cl;
71 unsigned char *msg_buf;
72 int ret, i;
73
74 dev->iamthif_state = MEI_IAMTHIF_IDLE;
75
76 mei_cl_init(cl, dev);
77
78 i = mei_me_cl_by_uuid(dev, &mei_amthif_guid);
79 if (i < 0) {
80 dev_info(&dev->pdev->dev,
81 "amthif: failed to find the client %d\n", i);
82 return -ENOTTY;
83 }
84
85 cl->me_client_id = dev->me_clients[i].client_id;
86
87 /* Assign iamthif_mtu to the value received from ME */
88
89 dev->iamthif_mtu = dev->me_clients[i].props.max_msg_length;
90 dev_dbg(&dev->pdev->dev, "IAMTHIF_MTU = %d\n",
91 dev->me_clients[i].props.max_msg_length);
92
93 kfree(dev->iamthif_msg_buf);
94 dev->iamthif_msg_buf = NULL;
95
96 /* allocate storage for ME message buffer */
97 msg_buf = kcalloc(dev->iamthif_mtu,
98 sizeof(unsigned char), GFP_KERNEL);
99 if (!msg_buf) {
100 dev_err(&dev->pdev->dev, "amthif: memory allocation for ME message buffer failed.\n");
101 return -ENOMEM;
102 }
103
104 dev->iamthif_msg_buf = msg_buf;
105
106 ret = mei_cl_link(cl, MEI_IAMTHIF_HOST_CLIENT_ID);
107
108 if (ret < 0) {
109 dev_err(&dev->pdev->dev,
110 "amthif: failed link client %d\n", ret);
111 return ret;
112 }
113
114 cl->state = MEI_FILE_CONNECTING;
115
116 ret = mei_cl_connect(cl, NULL);
117
118 dev->iamthif_state = MEI_IAMTHIF_IDLE;
119
120 return ret;
121}
122
123/**
124 * mei_amthif_find_read_list_entry - finds a amthilist entry for current file
125 *
126 * @dev: the device structure
127 * @file: pointer to file object
128 *
129 * returns returned a list entry on success, NULL on failure.
130 */
131struct mei_cl_cb *mei_amthif_find_read_list_entry(struct mei_device *dev,
132 struct file *file)
133{
134 struct mei_cl_cb *cb;
135
136 list_for_each_entry(cb, &dev->amthif_rd_complete_list.list, list) {
137 if (cb->cl && cb->cl == &dev->iamthif_cl &&
138 cb->file_object == file)
139 return cb;
140 }
141 return NULL;
142}
143
144
145/**
146 * mei_amthif_read - read data from AMTHIF client
147 *
148 * @dev: the device structure
149 * @if_num: minor number
150 * @file: pointer to file object
151 * @*ubuf: pointer to user data in user space
152 * @length: data length to read
153 * @offset: data read offset
154 *
155 * Locking: called under "dev->device_lock" lock
156 *
157 * returns
158 * returned data length on success,
159 * zero if no data to read,
160 * negative on failure.
161 */
162int mei_amthif_read(struct mei_device *dev, struct file *file,
163 char __user *ubuf, size_t length, loff_t *offset)
164{
165 int rets;
166 int wait_ret;
167 struct mei_cl_cb *cb = NULL;
168 struct mei_cl *cl = file->private_data;
169 unsigned long timeout;
170 int i;
171
172 /* Only possible if we are in timeout */
173 if (!cl || cl != &dev->iamthif_cl) {
174 dev_dbg(&dev->pdev->dev, "bad file ext.\n");
175 return -ETIME;
176 }
177
178 i = mei_me_cl_by_id(dev, dev->iamthif_cl.me_client_id);
179 if (i < 0) {
180 dev_dbg(&dev->pdev->dev, "amthif client not found.\n");
181 return -ENOTTY;
182 }
183 dev_dbg(&dev->pdev->dev, "checking amthif data\n");
184 cb = mei_amthif_find_read_list_entry(dev, file);
185
186 /* Check for if we can block or not*/
187 if (cb == NULL && file->f_flags & O_NONBLOCK)
188 return -EAGAIN;
189
190
191 dev_dbg(&dev->pdev->dev, "waiting for amthif data\n");
192 while (cb == NULL) {
193 /* unlock the Mutex */
194 mutex_unlock(&dev->device_lock);
195
196 wait_ret = wait_event_interruptible(dev->iamthif_cl.wait,
197 (cb = mei_amthif_find_read_list_entry(dev, file)));
198
199 /* Locking again the Mutex */
200 mutex_lock(&dev->device_lock);
201
202 if (wait_ret)
203 return -ERESTARTSYS;
204
205 dev_dbg(&dev->pdev->dev, "woke up from sleep\n");
206 }
207
208
209 dev_dbg(&dev->pdev->dev, "Got amthif data\n");
210 dev->iamthif_timer = 0;
211
212 if (cb) {
213 timeout = cb->read_time +
214 mei_secs_to_jiffies(MEI_IAMTHIF_READ_TIMER);
215 dev_dbg(&dev->pdev->dev, "amthif timeout = %lud\n",
216 timeout);
217
218 if (time_after(jiffies, timeout)) {
219 dev_dbg(&dev->pdev->dev, "amthif Time out\n");
220 /* 15 sec for the message has expired */
221 list_del(&cb->list);
222 rets = -ETIME;
223 goto free;
224 }
225 }
226 /* if the whole message will fit remove it from the list */
227 if (cb->buf_idx >= *offset && length >= (cb->buf_idx - *offset))
228 list_del(&cb->list);
229 else if (cb->buf_idx > 0 && cb->buf_idx <= *offset) {
230 /* end of the message has been reached */
231 list_del(&cb->list);
232 rets = 0;
233 goto free;
234 }
235 /* else means that not full buffer will be read and do not
236 * remove message from deletion list
237 */
238
239 dev_dbg(&dev->pdev->dev, "amthif cb->response_buffer size - %d\n",
240 cb->response_buffer.size);
241 dev_dbg(&dev->pdev->dev, "amthif cb->buf_idx - %lu\n", cb->buf_idx);
242
243 /* length is being truncated to PAGE_SIZE, however,
244 * the buf_idx may point beyond */
245 length = min_t(size_t, length, (cb->buf_idx - *offset));
246
247 if (copy_to_user(ubuf, cb->response_buffer.data + *offset, length)) {
248 dev_dbg(&dev->pdev->dev, "failed to copy data to userland\n");
249 rets = -EFAULT;
250 } else {
251 rets = length;
252 if ((*offset + length) < cb->buf_idx) {
253 *offset += length;
254 goto out;
255 }
256 }
257free:
258 dev_dbg(&dev->pdev->dev, "free amthif cb memory.\n");
259 *offset = 0;
260 mei_io_cb_free(cb);
261out:
262 return rets;
263}
264
265/**
266 * mei_amthif_send_cmd - send amthif command to the ME
267 *
268 * @dev: the device structure
269 * @cb: mei call back struct
270 *
271 * returns 0 on success, <0 on failure.
272 *
273 */
274static int mei_amthif_send_cmd(struct mei_device *dev, struct mei_cl_cb *cb)
275{
276 struct mei_msg_hdr mei_hdr;
277 int ret;
278
279 if (!dev || !cb)
280 return -ENODEV;
281
282 dev_dbg(&dev->pdev->dev, "write data to amthif client.\n");
283
284 dev->iamthif_state = MEI_IAMTHIF_WRITING;
285 dev->iamthif_current_cb = cb;
286 dev->iamthif_file_object = cb->file_object;
287 dev->iamthif_canceled = false;
288 dev->iamthif_ioctl = true;
289 dev->iamthif_msg_buf_size = cb->request_buffer.size;
290 memcpy(dev->iamthif_msg_buf, cb->request_buffer.data,
291 cb->request_buffer.size);
292
293 ret = mei_cl_flow_ctrl_creds(&dev->iamthif_cl);
294 if (ret < 0)
295 return ret;
296
297 if (ret && mei_hbuf_acquire(dev)) {
298 ret = 0;
299 if (cb->request_buffer.size > mei_hbuf_max_len(dev)) {
300 mei_hdr.length = mei_hbuf_max_len(dev);
301 mei_hdr.msg_complete = 0;
302 } else {
303 mei_hdr.length = cb->request_buffer.size;
304 mei_hdr.msg_complete = 1;
305 }
306
307 mei_hdr.host_addr = dev->iamthif_cl.host_client_id;
308 mei_hdr.me_addr = dev->iamthif_cl.me_client_id;
309 mei_hdr.reserved = 0;
310 mei_hdr.internal = 0;
311 dev->iamthif_msg_buf_index += mei_hdr.length;
312 ret = mei_write_message(dev, &mei_hdr, dev->iamthif_msg_buf);
313 if (ret)
314 return ret;
315
316 if (mei_hdr.msg_complete) {
317 if (mei_cl_flow_ctrl_reduce(&dev->iamthif_cl))
318 return -EIO;
319 dev->iamthif_flow_control_pending = true;
320 dev->iamthif_state = MEI_IAMTHIF_FLOW_CONTROL;
321 dev_dbg(&dev->pdev->dev, "add amthif cb to write waiting list\n");
322 dev->iamthif_current_cb = cb;
323 dev->iamthif_file_object = cb->file_object;
324 list_add_tail(&cb->list, &dev->write_waiting_list.list);
325 } else {
326 dev_dbg(&dev->pdev->dev, "message does not complete, so add amthif cb to write list.\n");
327 list_add_tail(&cb->list, &dev->write_list.list);
328 }
329 } else {
330 list_add_tail(&cb->list, &dev->write_list.list);
331 }
332 return 0;
333}
334
335/**
336 * mei_amthif_write - write amthif data to amthif client
337 *
338 * @dev: the device structure
339 * @cb: mei call back struct
340 *
341 * returns 0 on success, <0 on failure.
342 *
343 */
344int mei_amthif_write(struct mei_device *dev, struct mei_cl_cb *cb)
345{
346 int ret;
347
348 if (!dev || !cb)
349 return -ENODEV;
350
351 ret = mei_io_cb_alloc_resp_buf(cb, dev->iamthif_mtu);
352 if (ret)
353 return ret;
354
355 cb->fop_type = MEI_FOP_WRITE;
356
357 if (!list_empty(&dev->amthif_cmd_list.list) ||
358 dev->iamthif_state != MEI_IAMTHIF_IDLE) {
359 dev_dbg(&dev->pdev->dev,
360 "amthif state = %d\n", dev->iamthif_state);
361 dev_dbg(&dev->pdev->dev, "AMTHIF: add cb to the wait list\n");
362 list_add_tail(&cb->list, &dev->amthif_cmd_list.list);
363 return 0;
364 }
365 return mei_amthif_send_cmd(dev, cb);
366}
367/**
368 * mei_amthif_run_next_cmd
369 *
370 * @dev: the device structure
371 *
372 * returns 0 on success, <0 on failure.
373 */
374void mei_amthif_run_next_cmd(struct mei_device *dev)
375{
376 struct mei_cl_cb *pos = NULL;
377 struct mei_cl_cb *next = NULL;
378 int status;
379
380 if (!dev)
381 return;
382
383 dev->iamthif_msg_buf_size = 0;
384 dev->iamthif_msg_buf_index = 0;
385 dev->iamthif_canceled = false;
386 dev->iamthif_ioctl = true;
387 dev->iamthif_state = MEI_IAMTHIF_IDLE;
388 dev->iamthif_timer = 0;
389 dev->iamthif_file_object = NULL;
390
391 dev_dbg(&dev->pdev->dev, "complete amthif cmd_list cb.\n");
392
393 list_for_each_entry_safe(pos, next, &dev->amthif_cmd_list.list, list) {
394 list_del(&pos->list);
395
396 if (pos->cl && pos->cl == &dev->iamthif_cl) {
397 status = mei_amthif_send_cmd(dev, pos);
398 if (status) {
399 dev_dbg(&dev->pdev->dev,
400 "amthif write failed status = %d\n",
401 status);
402 return;
403 }
404 break;
405 }
406 }
407}
408
409
410unsigned int mei_amthif_poll(struct mei_device *dev,
411 struct file *file, poll_table *wait)
412{
413 unsigned int mask = 0;
414
415 poll_wait(file, &dev->iamthif_cl.wait, wait);
416
417 mutex_lock(&dev->device_lock);
418 if (!mei_cl_is_connected(&dev->iamthif_cl)) {
419
420 mask = POLLERR;
421
422 } else if (dev->iamthif_state == MEI_IAMTHIF_READ_COMPLETE &&
423 dev->iamthif_file_object == file) {
424
425 mask |= (POLLIN | POLLRDNORM);
426 dev_dbg(&dev->pdev->dev, "run next amthif cb\n");
427 mei_amthif_run_next_cmd(dev);
428 }
429 mutex_unlock(&dev->device_lock);
430
431 return mask;
432}
433
434
435
436/**
437 * mei_amthif_irq_write - write iamthif command in irq thread context.
438 *
439 * @dev: the device structure.
440 * @cb_pos: callback block.
441 * @cl: private data of the file object.
442 * @cmpl_list: complete list.
443 *
444 * returns 0, OK; otherwise, error.
445 */
446int mei_amthif_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb,
447 struct mei_cl_cb *cmpl_list)
448{
449 struct mei_device *dev = cl->dev;
450 struct mei_msg_hdr mei_hdr;
451 size_t len = dev->iamthif_msg_buf_size - dev->iamthif_msg_buf_index;
452 u32 msg_slots = mei_data2slots(len);
453 int slots;
454 int rets;
455
456 rets = mei_cl_flow_ctrl_creds(cl);
457 if (rets < 0)
458 return rets;
459
460 if (rets == 0) {
461 cl_dbg(dev, cl, "No flow control credentials: not sending.\n");
462 return 0;
463 }
464
465 mei_hdr.host_addr = cl->host_client_id;
466 mei_hdr.me_addr = cl->me_client_id;
467 mei_hdr.reserved = 0;
468 mei_hdr.internal = 0;
469
470 slots = mei_hbuf_empty_slots(dev);
471
472 if (slots >= msg_slots) {
473 mei_hdr.length = len;
474 mei_hdr.msg_complete = 1;
475 /* Split the message only if we can write the whole host buffer */
476 } else if (slots == dev->hbuf_depth) {
477 msg_slots = slots;
478 len = (slots * sizeof(u32)) - sizeof(struct mei_msg_hdr);
479 mei_hdr.length = len;
480 mei_hdr.msg_complete = 0;
481 } else {
482 /* wait for next time the host buffer is empty */
483 return 0;
484 }
485
486 dev_dbg(&dev->pdev->dev, MEI_HDR_FMT, MEI_HDR_PRM(&mei_hdr));
487
488 rets = mei_write_message(dev, &mei_hdr,
489 dev->iamthif_msg_buf + dev->iamthif_msg_buf_index);
490 if (rets) {
491 dev->iamthif_state = MEI_IAMTHIF_IDLE;
492 cl->status = rets;
493 list_del(&cb->list);
494 return rets;
495 }
496
497 if (mei_cl_flow_ctrl_reduce(cl))
498 return -EIO;
499
500 dev->iamthif_msg_buf_index += mei_hdr.length;
501 cl->status = 0;
502
503 if (mei_hdr.msg_complete) {
504 dev->iamthif_state = MEI_IAMTHIF_FLOW_CONTROL;
505 dev->iamthif_flow_control_pending = true;
506
507 /* save iamthif cb sent to amthif client */
508 cb->buf_idx = dev->iamthif_msg_buf_index;
509 dev->iamthif_current_cb = cb;
510
511 list_move_tail(&cb->list, &dev->write_waiting_list.list);
512 }
513
514
515 return 0;
516}
517
518/**
519 * mei_amthif_irq_read_message - read routine after ISR to
520 * handle the read amthif message
521 *
522 * @dev: the device structure
523 * @mei_hdr: header of amthif message
524 * @complete_list: An instance of our list structure
525 *
526 * returns 0 on success, <0 on failure.
527 */
528int mei_amthif_irq_read_msg(struct mei_device *dev,
529 struct mei_msg_hdr *mei_hdr,
530 struct mei_cl_cb *complete_list)
531{
532 struct mei_cl_cb *cb;
533 unsigned char *buffer;
534
535 BUG_ON(mei_hdr->me_addr != dev->iamthif_cl.me_client_id);
536 BUG_ON(dev->iamthif_state != MEI_IAMTHIF_READING);
537
538 buffer = dev->iamthif_msg_buf + dev->iamthif_msg_buf_index;
539 BUG_ON(dev->iamthif_mtu < dev->iamthif_msg_buf_index + mei_hdr->length);
540
541 mei_read_slots(dev, buffer, mei_hdr->length);
542
543 dev->iamthif_msg_buf_index += mei_hdr->length;
544
545 if (!mei_hdr->msg_complete)
546 return 0;
547
548 dev_dbg(&dev->pdev->dev, "amthif_message_buffer_index =%d\n",
549 mei_hdr->length);
550
551 dev_dbg(&dev->pdev->dev, "completed amthif read.\n ");
552 if (!dev->iamthif_current_cb)
553 return -ENODEV;
554
555 cb = dev->iamthif_current_cb;
556 dev->iamthif_current_cb = NULL;
557
558 if (!cb->cl)
559 return -ENODEV;
560
561 dev->iamthif_stall_timer = 0;
562 cb->buf_idx = dev->iamthif_msg_buf_index;
563 cb->read_time = jiffies;
564 if (dev->iamthif_ioctl && cb->cl == &dev->iamthif_cl) {
565 /* found the iamthif cb */
566 dev_dbg(&dev->pdev->dev, "complete the amthif read cb.\n ");
567 dev_dbg(&dev->pdev->dev, "add the amthif read cb to complete.\n ");
568 list_add_tail(&cb->list, &complete_list->list);
569 }
570 return 0;
571}
572
573/**
574 * mei_amthif_irq_read - prepares to read amthif data.
575 *
576 * @dev: the device structure.
577 * @slots: free slots.
578 *
579 * returns 0, OK; otherwise, error.
580 */
581int mei_amthif_irq_read(struct mei_device *dev, s32 *slots)
582{
583 u32 msg_slots = mei_data2slots(sizeof(struct hbm_flow_control));
584
585 if (*slots < msg_slots)
586 return -EMSGSIZE;
587
588 *slots -= msg_slots;
589
590 if (mei_hbm_cl_flow_control_req(dev, &dev->iamthif_cl)) {
591 dev_dbg(&dev->pdev->dev, "iamthif flow control failed\n");
592 return -EIO;
593 }
594
595 dev_dbg(&dev->pdev->dev, "iamthif flow control success\n");
596 dev->iamthif_state = MEI_IAMTHIF_READING;
597 dev->iamthif_flow_control_pending = false;
598 dev->iamthif_msg_buf_index = 0;
599 dev->iamthif_msg_buf_size = 0;
600 dev->iamthif_stall_timer = MEI_IAMTHIF_STALL_TIMER;
601 dev->hbuf_is_ready = mei_hbuf_is_ready(dev);
602 return 0;
603}
604
605/**
606 * mei_amthif_complete - complete amthif callback.
607 *
608 * @dev: the device structure.
609 * @cb_pos: callback block.
610 */
611void mei_amthif_complete(struct mei_device *dev, struct mei_cl_cb *cb)
612{
613 if (dev->iamthif_canceled != 1) {
614 dev->iamthif_state = MEI_IAMTHIF_READ_COMPLETE;
615 dev->iamthif_stall_timer = 0;
616 memcpy(cb->response_buffer.data,
617 dev->iamthif_msg_buf,
618 dev->iamthif_msg_buf_index);
619 list_add_tail(&cb->list, &dev->amthif_rd_complete_list.list);
620 dev_dbg(&dev->pdev->dev, "amthif read completed\n");
621 dev->iamthif_timer = jiffies;
622 dev_dbg(&dev->pdev->dev, "dev->iamthif_timer = %ld\n",
623 dev->iamthif_timer);
624 } else {
625 mei_amthif_run_next_cmd(dev);
626 }
627
628 dev_dbg(&dev->pdev->dev, "completing amthif call back.\n");
629 wake_up_interruptible(&dev->iamthif_cl.wait);
630}
631
632/**
633 * mei_clear_list - removes all callbacks associated with file
634 * from mei_cb_list
635 *
636 * @dev: device structure.
637 * @file: file structure
638 * @mei_cb_list: callbacks list
639 *
640 * mei_clear_list is called to clear resources associated with file
641 * when application calls close function or Ctrl-C was pressed
642 *
643 * returns true if callback removed from the list, false otherwise
644 */
645static bool mei_clear_list(struct mei_device *dev,
646 const struct file *file, struct list_head *mei_cb_list)
647{
648 struct mei_cl_cb *cb_pos = NULL;
649 struct mei_cl_cb *cb_next = NULL;
650 bool removed = false;
651
652 /* list all list member */
653 list_for_each_entry_safe(cb_pos, cb_next, mei_cb_list, list) {
654 /* check if list member associated with a file */
655 if (file == cb_pos->file_object) {
656 /* remove member from the list */
657 list_del(&cb_pos->list);
658 /* check if cb equal to current iamthif cb */
659 if (dev->iamthif_current_cb == cb_pos) {
660 dev->iamthif_current_cb = NULL;
661 /* send flow control to iamthif client */
662 mei_hbm_cl_flow_control_req(dev,
663 &dev->iamthif_cl);
664 }
665 /* free all allocated buffers */
666 mei_io_cb_free(cb_pos);
667 cb_pos = NULL;
668 removed = true;
669 }
670 }
671 return removed;
672}
673
674/**
675 * mei_clear_lists - removes all callbacks associated with file
676 *
677 * @dev: device structure
678 * @file: file structure
679 *
680 * mei_clear_lists is called to clear resources associated with file
681 * when application calls close function or Ctrl-C was pressed
682 *
683 * returns true if callback removed from the list, false otherwise
684 */
685static bool mei_clear_lists(struct mei_device *dev, struct file *file)
686{
687 bool removed = false;
688
689 /* remove callbacks associated with a file */
690 mei_clear_list(dev, file, &dev->amthif_cmd_list.list);
691 if (mei_clear_list(dev, file, &dev->amthif_rd_complete_list.list))
692 removed = true;
693
694 mei_clear_list(dev, file, &dev->ctrl_rd_list.list);
695
696 if (mei_clear_list(dev, file, &dev->ctrl_wr_list.list))
697 removed = true;
698
699 if (mei_clear_list(dev, file, &dev->write_waiting_list.list))
700 removed = true;
701
702 if (mei_clear_list(dev, file, &dev->write_list.list))
703 removed = true;
704
705 /* check if iamthif_current_cb not NULL */
706 if (dev->iamthif_current_cb && !removed) {
707 /* check file and iamthif current cb association */
708 if (dev->iamthif_current_cb->file_object == file) {
709 /* remove cb */
710 mei_io_cb_free(dev->iamthif_current_cb);
711 dev->iamthif_current_cb = NULL;
712 removed = true;
713 }
714 }
715 return removed;
716}
717
718/**
719* mei_amthif_release - the release function
720*
721* @dev: device structure
722* @file: pointer to file structure
723*
724* returns 0 on success, <0 on error
725*/
726int mei_amthif_release(struct mei_device *dev, struct file *file)
727{
728 if (dev->iamthif_open_count > 0)
729 dev->iamthif_open_count--;
730
731 if (dev->iamthif_file_object == file &&
732 dev->iamthif_state != MEI_IAMTHIF_IDLE) {
733
734 dev_dbg(&dev->pdev->dev, "amthif canceled iamthif state %d\n",
735 dev->iamthif_state);
736 dev->iamthif_canceled = true;
737 if (dev->iamthif_state == MEI_IAMTHIF_READ_COMPLETE) {
738 dev_dbg(&dev->pdev->dev, "run next amthif iamthif cb\n");
739 mei_amthif_run_next_cmd(dev);
740 }
741 }
742
743 if (mei_clear_lists(dev, file))
744 dev->iamthif_state = MEI_IAMTHIF_IDLE;
745
746 return 0;
747}