amthif.c 19.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
/*
 *
 * Intel Management Engine Interface (Intel MEI) Linux driver
 * Copyright (c) 2003-2012, Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 */

#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/aio.h>
#include <linux/pci.h>
#include <linux/ioctl.h>
#include <linux/cdev.h>
#include <linux/list.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/uuid.h>
#include <linux/jiffies.h>
#include <linux/uaccess.h>

33
#include <linux/mei.h>
34 35

#include "mei_dev.h"
36
#include "hbm.h"
T
Tomas Winkler 已提交
37
#include "hw-me.h"
T
Tomas Winkler 已提交
38
#include "client.h"
39

40 41 42
const uuid_le mei_amthif_guid  = UUID_LE(0x12f80028, 0xb4b7, 0x4b2d,
					 0xac, 0xa8, 0x46, 0xe0,
					 0xff, 0x65, 0x81, 0x4c);
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

/**
 * mei_amthif_reset_params - initializes mei device iamthif
 *
 * @dev: the device structure
 */
void mei_amthif_reset_params(struct mei_device *dev)
{
	/* reset iamthif parameters. */
	dev->iamthif_current_cb = NULL;
	dev->iamthif_msg_buf_size = 0;
	dev->iamthif_msg_buf_index = 0;
	dev->iamthif_canceled = false;
	dev->iamthif_ioctl = false;
	dev->iamthif_state = MEI_IAMTHIF_IDLE;
	dev->iamthif_timer = 0;
59
	dev->iamthif_stall_timer = 0;
T
Tomas Winkler 已提交
60
	dev->iamthif_open_count = 0;
61 62 63
}

/**
64
 * mei_amthif_host_init - mei initialization amthif client.
65 66 67 68
 *
 * @dev: the device structure
 *
 */
69
int mei_amthif_host_init(struct mei_device *dev)
70
{
71
	struct mei_cl *cl = &dev->iamthif_cl;
72
	unsigned char *msg_buf;
73
	int ret, i;
74

75 76
	dev->iamthif_state = MEI_IAMTHIF_IDLE;

77
	mei_cl_init(cl, dev);
78

79
	i = mei_me_cl_by_uuid(dev, &mei_amthif_guid);
80
	if (i < 0) {
81 82 83 84
		ret = i;
		dev_info(&dev->pdev->dev,
			"amthif: failed to find the client %d\n", ret);
		return ret;
85 86
	}

87 88
	cl->me_client_id = dev->me_clients[i].client_id;

89 90 91 92 93 94 95 96 97 98 99 100 101
	/* Assign iamthif_mtu to the value received from ME  */

	dev->iamthif_mtu = dev->me_clients[i].props.max_msg_length;
	dev_dbg(&dev->pdev->dev, "IAMTHIF_MTU = %d\n",
			dev->me_clients[i].props.max_msg_length);

	kfree(dev->iamthif_msg_buf);
	dev->iamthif_msg_buf = NULL;

	/* allocate storage for ME message buffer */
	msg_buf = kcalloc(dev->iamthif_mtu,
			sizeof(unsigned char), GFP_KERNEL);
	if (!msg_buf) {
102 103
		dev_err(&dev->pdev->dev, "amthif: memory allocation for ME message buffer failed.\n");
		return -ENOMEM;
104 105 106 107
	}

	dev->iamthif_msg_buf = msg_buf;

108 109 110
	ret = mei_cl_link(cl, MEI_IAMTHIF_HOST_CLIENT_ID);

	if (ret < 0) {
111 112 113
		dev_err(&dev->pdev->dev,
			"amthif: failed link client %d\n", ret);
		return ret;
114 115 116 117 118 119 120 121
	}

	cl->state = MEI_FILE_CONNECTING;

	if (mei_hbm_cl_connect_req(dev, cl)) {
		dev_dbg(&dev->pdev->dev, "amthif: Failed to connect to ME client\n");
		cl->state = MEI_FILE_DISCONNECTED;
		cl->host_client_id = 0;
122
	} else {
123
		cl->timer_count = MEI_CONNECT_TIMEOUT;
124
	}
125
	return 0;
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
}

/**
 * mei_amthif_find_read_list_entry - finds a amthilist entry for current file
 *
 * @dev: the device structure
 * @file: pointer to file object
 *
 * returns   returned a list entry on success, NULL on failure.
 */
struct mei_cl_cb *mei_amthif_find_read_list_entry(struct mei_device *dev,
						struct file *file)
{
	struct mei_cl_cb *pos = NULL;
	struct mei_cl_cb *next = NULL;

	list_for_each_entry_safe(pos, next,
143
				&dev->amthif_rd_complete_list.list, list) {
144
		if (pos->cl && pos->cl == &dev->iamthif_cl &&
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
			pos->file_object == file)
			return pos;
	}
	return NULL;
}


/**
 * mei_amthif_read - read data from AMTHIF client
 *
 * @dev: the device structure
 * @if_num:  minor number
 * @file: pointer to file object
 * @*ubuf: pointer to user data in user space
 * @length: data length to read
 * @offset: data read offset
 *
 * Locking: called under "dev->device_lock" lock
 *
 * returns
 *  returned data length on success,
 *  zero if no data to read,
 *  negative on failure.
 */
int mei_amthif_read(struct mei_device *dev, struct file *file,
	       char __user *ubuf, size_t length, loff_t *offset)
{
	int rets;
	int wait_ret;
	struct mei_cl_cb *cb = NULL;
	struct mei_cl *cl = file->private_data;
	unsigned long timeout;
	int i;

179
	/* Only possible if we are in timeout */
180 181 182 183 184 185 186 187
	if (!cl || cl != &dev->iamthif_cl) {
		dev_dbg(&dev->pdev->dev, "bad file ext.\n");
		return -ETIMEDOUT;
	}

	i = mei_me_cl_by_id(dev, dev->iamthif_cl.me_client_id);

	if (i < 0) {
188
		dev_dbg(&dev->pdev->dev, "amthif client not found.\n");
189 190
		return -ENODEV;
	}
191
	dev_dbg(&dev->pdev->dev, "checking amthif data\n");
192 193 194 195 196 197 198
	cb = mei_amthif_find_read_list_entry(dev, file);

	/* Check for if we can block or not*/
	if (cb == NULL && file->f_flags & O_NONBLOCK)
		return -EAGAIN;


199
	dev_dbg(&dev->pdev->dev, "waiting for amthif data\n");
200 201 202 203 204 205 206
	while (cb == NULL) {
		/* unlock the Mutex */
		mutex_unlock(&dev->device_lock);

		wait_ret = wait_event_interruptible(dev->iamthif_cl.wait,
			(cb = mei_amthif_find_read_list_entry(dev, file)));

207 208 209
		/* Locking again the Mutex */
		mutex_lock(&dev->device_lock);

210 211 212 213 214 215 216
		if (wait_ret)
			return -ERESTARTSYS;

		dev_dbg(&dev->pdev->dev, "woke up from sleep\n");
	}


217
	dev_dbg(&dev->pdev->dev, "Got amthif data\n");
218 219 220 221 222
	dev->iamthif_timer = 0;

	if (cb) {
		timeout = cb->read_time +
			mei_secs_to_jiffies(MEI_IAMTHIF_READ_TIMER);
223
		dev_dbg(&dev->pdev->dev, "amthif timeout = %lud\n",
224 225 226
				timeout);

		if  (time_after(jiffies, timeout)) {
227
			dev_dbg(&dev->pdev->dev, "amthif Time out\n");
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
			/* 15 sec for the message has expired */
			list_del(&cb->list);
			rets = -ETIMEDOUT;
			goto free;
		}
	}
	/* if the whole message will fit remove it from the list */
	if (cb->buf_idx >= *offset && length >= (cb->buf_idx - *offset))
		list_del(&cb->list);
	else if (cb->buf_idx > 0 && cb->buf_idx <= *offset) {
		/* end of the message has been reached */
		list_del(&cb->list);
		rets = 0;
		goto free;
	}
		/* else means that not full buffer will be read and do not
		 * remove message from deletion list
		 */

247
	dev_dbg(&dev->pdev->dev, "amthif cb->response_buffer size - %d\n",
248
	    cb->response_buffer.size);
249
	dev_dbg(&dev->pdev->dev, "amthif cb->buf_idx - %lu\n", cb->buf_idx);
250

251
	/* length is being truncated to PAGE_SIZE, however,
252 253 254 255 256 257 258 259 260 261 262 263 264
	 * the buf_idx may point beyond */
	length = min_t(size_t, length, (cb->buf_idx - *offset));

	if (copy_to_user(ubuf, cb->response_buffer.data + *offset, length))
		rets = -EFAULT;
	else {
		rets = length;
		if ((*offset + length) < cb->buf_idx) {
			*offset += length;
			goto out;
		}
	}
free:
265
	dev_dbg(&dev->pdev->dev, "free amthif cb memory.\n");
266 267 268 269 270 271 272
	*offset = 0;
	mei_io_cb_free(cb);
out:
	return rets;
}

/**
273
 * mei_amthif_send_cmd - send amthif command to the ME
274 275 276 277 278
 *
 * @dev: the device structure
 * @cb: mei call back struct
 *
 * returns 0 on success, <0 on failure.
279
 *
280
 */
281
static int mei_amthif_send_cmd(struct mei_device *dev, struct mei_cl_cb *cb)
282 283 284 285 286 287 288
{
	struct mei_msg_hdr mei_hdr;
	int ret;

	if (!dev || !cb)
		return -ENODEV;

289
	dev_dbg(&dev->pdev->dev, "write data to amthif client.\n");
290 291 292 293 294 295 296 297 298 299

	dev->iamthif_state = MEI_IAMTHIF_WRITING;
	dev->iamthif_current_cb = cb;
	dev->iamthif_file_object = cb->file_object;
	dev->iamthif_canceled = false;
	dev->iamthif_ioctl = true;
	dev->iamthif_msg_buf_size = cb->request_buffer.size;
	memcpy(dev->iamthif_msg_buf, cb->request_buffer.data,
	       cb->request_buffer.size);

T
Tomas Winkler 已提交
300
	ret = mei_cl_flow_ctrl_creds(&dev->iamthif_cl);
301 302 303
	if (ret < 0)
		return ret;

304
	if (ret && dev->hbuf_is_ready) {
305
		ret = 0;
306
		dev->hbuf_is_ready = false;
307 308
		if (cb->request_buffer.size > mei_hbuf_max_len(dev)) {
			mei_hdr.length = mei_hbuf_max_len(dev);
309 310 311 312 313 314 315 316 317
			mei_hdr.msg_complete = 0;
		} else {
			mei_hdr.length = cb->request_buffer.size;
			mei_hdr.msg_complete = 1;
		}

		mei_hdr.host_addr = dev->iamthif_cl.host_client_id;
		mei_hdr.me_addr = dev->iamthif_cl.me_client_id;
		mei_hdr.reserved = 0;
318
		mei_hdr.internal = 0;
319
		dev->iamthif_msg_buf_index += mei_hdr.length;
320 321 322
		ret = mei_write_message(dev, &mei_hdr, dev->iamthif_msg_buf);
		if (ret)
			return ret;
323 324

		if (mei_hdr.msg_complete) {
T
Tomas Winkler 已提交
325
			if (mei_cl_flow_ctrl_reduce(&dev->iamthif_cl))
326
				return -EIO;
327 328
			dev->iamthif_flow_control_pending = true;
			dev->iamthif_state = MEI_IAMTHIF_FLOW_CONTROL;
329
			dev_dbg(&dev->pdev->dev, "add amthif cb to write waiting list\n");
330 331 332 333
			dev->iamthif_current_cb = cb;
			dev->iamthif_file_object = cb->file_object;
			list_add_tail(&cb->list, &dev->write_waiting_list.list);
		} else {
334
			dev_dbg(&dev->pdev->dev, "message does not complete, so add amthif cb to write list.\n");
335 336 337
			list_add_tail(&cb->list, &dev->write_list.list);
		}
	} else {
338
		if (!dev->hbuf_is_ready)
339 340 341 342 343 344 345 346
			dev_dbg(&dev->pdev->dev, "host buffer is not empty");

		dev_dbg(&dev->pdev->dev, "No flow control credentials, so add iamthif cb to write list.\n");
		list_add_tail(&cb->list, &dev->write_list.list);
	}
	return 0;
}

347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
/**
 * mei_amthif_write - write amthif data to amthif client
 *
 * @dev: the device structure
 * @cb: mei call back struct
 *
 * returns 0 on success, <0 on failure.
 *
 */
int mei_amthif_write(struct mei_device *dev, struct mei_cl_cb *cb)
{
	int ret;

	if (!dev || !cb)
		return -ENODEV;

	ret = mei_io_cb_alloc_resp_buf(cb, dev->iamthif_mtu);
	if (ret)
		return ret;

367
	cb->fop_type = MEI_FOP_IOCTL;
368

369
	if (!list_empty(&dev->amthif_cmd_list.list) ||
370 371 372 373
	    dev->iamthif_state != MEI_IAMTHIF_IDLE) {
		dev_dbg(&dev->pdev->dev,
			"amthif state = %d\n", dev->iamthif_state);
		dev_dbg(&dev->pdev->dev, "AMTHIF: add cb to the wait list\n");
374
		list_add_tail(&cb->list, &dev->amthif_cmd_list.list);
375 376 377 378
		return 0;
	}
	return mei_amthif_send_cmd(dev, cb);
}
379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
/**
 * mei_amthif_run_next_cmd
 *
 * @dev: the device structure
 *
 * returns 0 on success, <0 on failure.
 */
void mei_amthif_run_next_cmd(struct mei_device *dev)
{
	struct mei_cl_cb *pos = NULL;
	struct mei_cl_cb *next = NULL;
	int status;

	if (!dev)
		return;

	dev->iamthif_msg_buf_size = 0;
	dev->iamthif_msg_buf_index = 0;
	dev->iamthif_canceled = false;
	dev->iamthif_ioctl = true;
	dev->iamthif_state = MEI_IAMTHIF_IDLE;
	dev->iamthif_timer = 0;
	dev->iamthif_file_object = NULL;

403
	dev_dbg(&dev->pdev->dev, "complete amthif cmd_list cb.\n");
404

405
	list_for_each_entry_safe(pos, next, &dev->amthif_cmd_list.list, list) {
406 407
		list_del(&pos->list);

408
		if (pos->cl && pos->cl == &dev->iamthif_cl) {
409
			status = mei_amthif_send_cmd(dev, pos);
410 411
			if (status) {
				dev_dbg(&dev->pdev->dev,
412
					"amthif write failed status = %d\n",
413 414 415 416 417 418 419 420
						status);
				return;
			}
			break;
		}
	}
}

421 422 423 424 425

unsigned int mei_amthif_poll(struct mei_device *dev,
		struct file *file, poll_table *wait)
{
	unsigned int mask = 0;
426

427
	poll_wait(file, &dev->iamthif_cl.wait, wait);
428

429
	mutex_lock(&dev->device_lock);
430 431 432 433 434 435 436
	if (!mei_cl_is_connected(&dev->iamthif_cl)) {

		mask = POLLERR;

	} else if (dev->iamthif_state == MEI_IAMTHIF_READ_COMPLETE &&
		   dev->iamthif_file_object == file) {

437
		mask |= (POLLIN | POLLRDNORM);
438
		dev_dbg(&dev->pdev->dev, "run next amthif cb\n");
439 440
		mei_amthif_run_next_cmd(dev);
	}
441 442
	mutex_unlock(&dev->device_lock);

443 444 445 446 447
	return mask;
}



448
/**
449
 * mei_amthif_irq_write_completed - processes completed iamthif operation.
450 451 452 453 454 455 456 457 458
 *
 * @dev: the device structure.
 * @slots: free slots.
 * @cb_pos: callback block.
 * @cl: private data of the file object.
 * @cmpl_list: complete list.
 *
 * returns 0, OK; otherwise, error.
 */
459 460
int mei_amthif_irq_write_complete(struct mei_cl *cl, struct mei_cl_cb *cb,
				  s32 *slots, struct mei_cl_cb *cmpl_list)
461
{
462
	struct mei_device *dev = cl->dev;
463
	struct mei_msg_hdr mei_hdr;
464
	size_t len = dev->iamthif_msg_buf_size - dev->iamthif_msg_buf_index;
T
Tomas Winkler 已提交
465
	u32 msg_slots = mei_data2slots(len);
466
	int rets;
467

468 469 470 471 472 473 474 475 476
	rets = mei_cl_flow_ctrl_creds(cl);
	if (rets < 0)
		return rets;

	if (rets == 0) {
		cl_dbg(dev, cl, "No flow control credentials: not sending.\n");
		return 0;
	}

477 478 479
	mei_hdr.host_addr = cl->host_client_id;
	mei_hdr.me_addr = cl->me_client_id;
	mei_hdr.reserved = 0;
480
	mei_hdr.internal = 0;
481 482

	if (*slots >= msg_slots) {
483 484
		mei_hdr.length = len;
		mei_hdr.msg_complete = 1;
485 486 487 488
	/* Split the message only if we can write the whole host buffer */
	} else if (*slots == dev->hbuf_depth) {
		msg_slots = *slots;
		len = (*slots * sizeof(u32)) - sizeof(struct mei_msg_hdr);
489 490
		mei_hdr.length = len;
		mei_hdr.msg_complete = 0;
491 492 493 494
	} else {
		/* wait for next time the host buffer is empty */
		return 0;
	}
495

496
	dev_dbg(&dev->pdev->dev, MEI_HDR_FMT,  MEI_HDR_PRM(&mei_hdr));
497

498
	*slots -=  msg_slots;
499 500 501 502 503 504 505
	rets = mei_write_message(dev, &mei_hdr,
			dev->iamthif_msg_buf + dev->iamthif_msg_buf_index);
	if (rets) {
		dev->iamthif_state = MEI_IAMTHIF_IDLE;
		cl->status = rets;
		list_del(&cb->list);
		return rets;
506
	}
507

T
Tomas Winkler 已提交
508
	if (mei_cl_flow_ctrl_reduce(cl))
509
		return -EIO;
510

511
	dev->iamthif_msg_buf_index += mei_hdr.length;
512
	cl->status = 0;
513

514
	if (mei_hdr.msg_complete) {
515 516 517
		dev->iamthif_state = MEI_IAMTHIF_FLOW_CONTROL;
		dev->iamthif_flow_control_pending = true;

518
		/* save iamthif cb sent to amthif client */
519 520 521 522
		cb->buf_idx = dev->iamthif_msg_buf_index;
		dev->iamthif_current_cb = cb;

		list_move_tail(&cb->list, &dev->write_waiting_list.list);
523 524
	}

525

526 527 528 529 530
	return 0;
}

/**
 * mei_amthif_irq_read_message - read routine after ISR to
531
 *			handle the read amthif message
532 533
 *
 * @dev: the device structure
534
 * @mei_hdr: header of amthif message
535
 * @complete_list: An instance of our list structure
536 537 538
 *
 * returns 0 on success, <0 on failure.
 */
539 540 541
int mei_amthif_irq_read_msg(struct mei_device *dev,
			    struct mei_msg_hdr *mei_hdr,
			    struct mei_cl_cb *complete_list)
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
{
	struct mei_cl_cb *cb;
	unsigned char *buffer;

	BUG_ON(mei_hdr->me_addr != dev->iamthif_cl.me_client_id);
	BUG_ON(dev->iamthif_state != MEI_IAMTHIF_READING);

	buffer = dev->iamthif_msg_buf + dev->iamthif_msg_buf_index;
	BUG_ON(dev->iamthif_mtu < dev->iamthif_msg_buf_index + mei_hdr->length);

	mei_read_slots(dev, buffer, mei_hdr->length);

	dev->iamthif_msg_buf_index += mei_hdr->length;

	if (!mei_hdr->msg_complete)
		return 0;

559
	dev_dbg(&dev->pdev->dev, "amthif_message_buffer_index =%d\n",
560 561
			mei_hdr->length);

562
	dev_dbg(&dev->pdev->dev, "completed amthif read.\n ");
563 564 565 566 567 568
	if (!dev->iamthif_current_cb)
		return -ENODEV;

	cb = dev->iamthif_current_cb;
	dev->iamthif_current_cb = NULL;

569
	if (!cb->cl)
570 571 572 573 574
		return -ENODEV;

	dev->iamthif_stall_timer = 0;
	cb->buf_idx = dev->iamthif_msg_buf_index;
	cb->read_time = jiffies;
575
	if (dev->iamthif_ioctl && cb->cl == &dev->iamthif_cl) {
576
		/* found the iamthif cb */
577 578
		dev_dbg(&dev->pdev->dev, "complete the amthif read cb.\n ");
		dev_dbg(&dev->pdev->dev, "add the amthif read cb to complete.\n ");
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
		list_add_tail(&cb->list, &complete_list->list);
	}
	return 0;
}

/**
 * mei_amthif_irq_read - prepares to read amthif data.
 *
 * @dev: the device structure.
 * @slots: free slots.
 *
 * returns 0, OK; otherwise, error.
 */
int mei_amthif_irq_read(struct mei_device *dev, s32 *slots)
{
T
Tomas Winkler 已提交
594
	u32 msg_slots = mei_data2slots(sizeof(struct hbm_flow_control));
595

T
Tomas Winkler 已提交
596
	if (*slots < msg_slots)
597
		return -EMSGSIZE;
T
Tomas Winkler 已提交
598 599 600

	*slots -= msg_slots;

601
	if (mei_hbm_cl_flow_control_req(dev, &dev->iamthif_cl)) {
602 603 604 605 606 607 608 609 610 611
		dev_dbg(&dev->pdev->dev, "iamthif flow control failed\n");
		return -EIO;
	}

	dev_dbg(&dev->pdev->dev, "iamthif flow control success\n");
	dev->iamthif_state = MEI_IAMTHIF_READING;
	dev->iamthif_flow_control_pending = false;
	dev->iamthif_msg_buf_index = 0;
	dev->iamthif_msg_buf_size = 0;
	dev->iamthif_stall_timer = MEI_IAMTHIF_STALL_TIMER;
612
	dev->hbuf_is_ready = mei_hbuf_is_ready(dev);
613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629
	return 0;
}

/**
 * mei_amthif_complete - complete amthif callback.
 *
 * @dev: the device structure.
 * @cb_pos: callback block.
 */
void mei_amthif_complete(struct mei_device *dev, struct mei_cl_cb *cb)
{
	if (dev->iamthif_canceled != 1) {
		dev->iamthif_state = MEI_IAMTHIF_READ_COMPLETE;
		dev->iamthif_stall_timer = 0;
		memcpy(cb->response_buffer.data,
				dev->iamthif_msg_buf,
				dev->iamthif_msg_buf_index);
630
		list_add_tail(&cb->list, &dev->amthif_rd_complete_list.list);
631
		dev_dbg(&dev->pdev->dev, "amthif read completed\n");
632 633 634 635 636 637 638
		dev->iamthif_timer = jiffies;
		dev_dbg(&dev->pdev->dev, "dev->iamthif_timer = %ld\n",
				dev->iamthif_timer);
	} else {
		mei_amthif_run_next_cmd(dev);
	}

639
	dev_dbg(&dev->pdev->dev, "completing amthif call back.\n");
640 641 642
	wake_up_interruptible(&dev->iamthif_cl.wait);
}

643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
/**
 * mei_clear_list - removes all callbacks associated with file
 *		from mei_cb_list
 *
 * @dev: device structure.
 * @file: file structure
 * @mei_cb_list: callbacks list
 *
 * mei_clear_list is called to clear resources associated with file
 * when application calls close function or Ctrl-C was pressed
 *
 * returns true if callback removed from the list, false otherwise
 */
static bool mei_clear_list(struct mei_device *dev,
		const struct file *file, struct list_head *mei_cb_list)
{
	struct mei_cl_cb *cb_pos = NULL;
	struct mei_cl_cb *cb_next = NULL;
	bool removed = false;

	/* list all list member */
	list_for_each_entry_safe(cb_pos, cb_next, mei_cb_list, list) {
		/* check if list member associated with a file */
		if (file == cb_pos->file_object) {
			/* remove member from the list */
			list_del(&cb_pos->list);
			/* check if cb equal to current iamthif cb */
			if (dev->iamthif_current_cb == cb_pos) {
				dev->iamthif_current_cb = NULL;
				/* send flow control to iamthif client */
673 674
				mei_hbm_cl_flow_control_req(dev,
							&dev->iamthif_cl);
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703
			}
			/* free all allocated buffers */
			mei_io_cb_free(cb_pos);
			cb_pos = NULL;
			removed = true;
		}
	}
	return removed;
}

/**
 * mei_clear_lists - removes all callbacks associated with file
 *
 * @dev: device structure
 * @file: file structure
 *
 * mei_clear_lists is called to clear resources associated with file
 * when application calls close function or Ctrl-C was pressed
 *
 * returns true if callback removed from the list, false otherwise
 */
static bool mei_clear_lists(struct mei_device *dev, struct file *file)
{
	bool removed = false;

	/* remove callbacks associated with a file */
	mei_clear_list(dev, file, &dev->amthif_cmd_list.list);
	if (mei_clear_list(dev, file, &dev->amthif_rd_complete_list.list))
		removed = true;
704

705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731
	mei_clear_list(dev, file, &dev->ctrl_rd_list.list);

	if (mei_clear_list(dev, file, &dev->ctrl_wr_list.list))
		removed = true;

	if (mei_clear_list(dev, file, &dev->write_waiting_list.list))
		removed = true;

	if (mei_clear_list(dev, file, &dev->write_list.list))
		removed = true;

	/* check if iamthif_current_cb not NULL */
	if (dev->iamthif_current_cb && !removed) {
		/* check file and iamthif current cb association */
		if (dev->iamthif_current_cb->file_object == file) {
			/* remove cb */
			mei_io_cb_free(dev->iamthif_current_cb);
			dev->iamthif_current_cb = NULL;
			removed = true;
		}
	}
	return removed;
}

/**
* mei_amthif_release - the release function
*
732
*  @dev: device structure
733 734 735 736 737 738
*  @file: pointer to file structure
*
*  returns 0 on success, <0 on error
*/
int mei_amthif_release(struct mei_device *dev, struct file *file)
{
T
Tomas Winkler 已提交
739 740
	if (dev->iamthif_open_count > 0)
		dev->iamthif_open_count--;
741 742 743 744

	if (dev->iamthif_file_object == file &&
	    dev->iamthif_state != MEI_IAMTHIF_IDLE) {

745
		dev_dbg(&dev->pdev->dev, "amthif canceled iamthif state %d\n",
746 747 748
		    dev->iamthif_state);
		dev->iamthif_canceled = true;
		if (dev->iamthif_state == MEI_IAMTHIF_READ_COMPLETE) {
749
			dev_dbg(&dev->pdev->dev, "run next amthif iamthif cb\n");
750 751 752 753 754 755 756 757 758
			mei_amthif_run_next_cmd(dev);
		}
	}

	if (mei_clear_lists(dev, file))
		dev->iamthif_state = MEI_IAMTHIF_IDLE;

	return 0;
}