init.c 17.6 KB
Newer Older
O
Oren Weil 已提交
1 2 3
/*
 *
 * Intel Management Engine Interface (Intel MEI) Linux driver
4
 * Copyright (c) 2003-2012, Intel Corporation.
O
Oren Weil 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 * 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/pci.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/delay.h>

#include "mei_dev.h"
#include "hw.h"
#include "interface.h"
25
#include <linux/mei.h>
O
Oren Weil 已提交
26

27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
const char *mei_dev_state_str(int state)
{
#define MEI_DEV_STATE(state) case MEI_DEV_##state: return #state
	switch (state) {
	MEI_DEV_STATE(INITIALIZING);
	MEI_DEV_STATE(INIT_CLIENTS);
	MEI_DEV_STATE(ENABLED);
	MEI_DEV_STATE(RESETING);
	MEI_DEV_STATE(DISABLED);
	MEI_DEV_STATE(RECOVERING_FROM_RESET);
	MEI_DEV_STATE(POWER_DOWN);
	MEI_DEV_STATE(POWER_UP);
	default:
		return "unkown";
	}
#undef MEI_DEV_STATE
}


46

O
Oren Weil 已提交
47
/**
48
 * mei_io_list_flush - removes list entry belonging to cl.
O
Oren Weil 已提交
49 50 51 52
 *
 * @list:  An instance of our list structure
 * @cl: private data of the file object
 */
53
void mei_io_list_flush(struct mei_cl_cb *list, struct mei_cl *cl)
O
Oren Weil 已提交
54
{
55 56
	struct mei_cl_cb *pos;
	struct mei_cl_cb *next;
O
Oren Weil 已提交
57

58
	list_for_each_entry_safe(pos, next, &list->list, list) {
59 60
		if (pos->cl) {
			if (mei_cl_cmp_id(cl, pos->cl))
61
				list_del(&pos->list);
O
Oren Weil 已提交
62 63 64
		}
	}
}
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
/**
 * mei_cl_flush_queues - flushes queue lists belonging to cl.
 *
 * @dev: the device structure
 * @cl: private data of the file object
 */
int mei_cl_flush_queues(struct mei_cl *cl)
{
	if (!cl || !cl->dev)
		return -EINVAL;

	dev_dbg(&cl->dev->pdev->dev, "remove list entry belonging to cl\n");
	mei_io_list_flush(&cl->dev->read_list, cl);
	mei_io_list_flush(&cl->dev->write_list, cl);
	mei_io_list_flush(&cl->dev->write_waiting_list, cl);
	mei_io_list_flush(&cl->dev->ctrl_wr_list, cl);
	mei_io_list_flush(&cl->dev->ctrl_rd_list, cl);
82 83
	mei_io_list_flush(&cl->dev->amthif_cmd_list, cl);
	mei_io_list_flush(&cl->dev->amthif_rd_complete_list, cl);
84 85 86 87
	return 0;
}


O
Oren Weil 已提交
88 89 90 91 92 93 94 95

/**
 * init_mei_device - allocates and initializes the mei device structure
 *
 * @pdev: The pci device structure
 *
 * returns The mei_device_device pointer on success, NULL on failure.
 */
96
struct mei_device *mei_device_init(struct pci_dev *pdev)
O
Oren Weil 已提交
97 98 99 100 101 102 103 104 105 106 107 108 109 110
{
	struct mei_device *dev;

	dev = kzalloc(sizeof(struct mei_device), GFP_KERNEL);
	if (!dev)
		return NULL;

	/* setup our list array */
	INIT_LIST_HEAD(&dev->file_list);
	INIT_LIST_HEAD(&dev->wd_cl.link);
	INIT_LIST_HEAD(&dev->iamthif_cl.link);
	mutex_init(&dev->device_lock);
	init_waitqueue_head(&dev->wait_recvd_msg);
	init_waitqueue_head(&dev->wait_stop_wd);
111
	dev->dev_state = MEI_DEV_INITIALIZING;
O
Oren Weil 已提交
112
	dev->iamthif_state = MEI_IAMTHIF_IDLE;
113 114 115 116 117 118

	mei_io_list_init(&dev->read_list);
	mei_io_list_init(&dev->write_list);
	mei_io_list_init(&dev->write_waiting_list);
	mei_io_list_init(&dev->ctrl_wr_list);
	mei_io_list_init(&dev->ctrl_rd_list);
119 120
	mei_io_list_init(&dev->amthif_cmd_list);
	mei_io_list_init(&dev->amthif_rd_complete_list);
O
Oren Weil 已提交
121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
	dev->pdev = pdev;
	return dev;
}

/**
 * mei_hw_init - initializes host and fw to start work.
 *
 * @dev: the device structure
 *
 * returns 0 on success, <0 on failure.
 */
int mei_hw_init(struct mei_device *dev)
{
	int err = 0;
	int ret;

	mutex_lock(&dev->device_lock);

	dev->host_hw_state = mei_hcsr_read(dev);
	dev->me_hw_state = mei_mecsr_read(dev);
	dev_dbg(&dev->pdev->dev, "host_hw_state = 0x%08x, mestate = 0x%08x.\n",
	    dev->host_hw_state, dev->me_hw_state);

	/* acknowledge interrupt and stop interupts */
	if ((dev->host_hw_state & H_IS) == H_IS)
		mei_reg_write(dev, H_CSR, dev->host_hw_state);

148 149 150
	/* Doesn't change in runtime */
	dev->hbuf_depth = (dev->host_hw_state & H_CBD) >> 24;

151
	dev->recvd_msg = false;
O
Oren Weil 已提交
152 153 154 155 156 157 158 159 160 161 162
	dev_dbg(&dev->pdev->dev, "reset in start the mei device.\n");

	mei_reset(dev, 1);

	dev_dbg(&dev->pdev->dev, "host_hw_state = 0x%08x, me_hw_state = 0x%08x.\n",
	    dev->host_hw_state, dev->me_hw_state);

	/* wait for ME to turn on ME_RDY */
	if (!dev->recvd_msg) {
		mutex_unlock(&dev->device_lock);
		err = wait_event_interruptible_timeout(dev->wait_recvd_msg,
163 164
			dev->recvd_msg,
			mei_secs_to_jiffies(MEI_INTEROP_TIMEOUT));
O
Oren Weil 已提交
165 166 167
		mutex_lock(&dev->device_lock);
	}

168
	if (err <= 0 && !dev->recvd_msg) {
169
		dev->dev_state = MEI_DEV_DISABLED;
O
Oren Weil 已提交
170 171 172 173 174 175 176 177 178
		dev_dbg(&dev->pdev->dev,
			"wait_event_interruptible_timeout failed"
			"on wait for ME to turn on ME_RDY.\n");
		ret = -ENODEV;
		goto out;
	}

	if (!(((dev->host_hw_state & H_RDY) == H_RDY) &&
	      ((dev->me_hw_state & ME_RDY_HRA) == ME_RDY_HRA))) {
179
		dev->dev_state = MEI_DEV_DISABLED;
O
Oren Weil 已提交
180 181 182 183
		dev_dbg(&dev->pdev->dev,
			"host_hw_state = 0x%08x, me_hw_state = 0x%08x.\n",
			dev->host_hw_state, dev->me_hw_state);

D
Dan Carpenter 已提交
184
		if (!(dev->host_hw_state & H_RDY))
O
Oren Weil 已提交
185 186
			dev_dbg(&dev->pdev->dev, "host turn off H_RDY.\n");

D
Dan Carpenter 已提交
187
		if (!(dev->me_hw_state & ME_RDY_HRA))
O
Oren Weil 已提交
188 189
			dev_dbg(&dev->pdev->dev, "ME turn off ME_RDY.\n");

190
		dev_err(&dev->pdev->dev, "link layer initialization failed.\n");
O
Oren Weil 已提交
191 192 193 194 195 196 197 198 199 200 201
		ret = -ENODEV;
		goto out;
	}

	if (dev->version.major_version != HBM_MAJOR_VERSION ||
	    dev->version.minor_version != HBM_MINOR_VERSION) {
		dev_dbg(&dev->pdev->dev, "MEI start failed.\n");
		ret = -ENODEV;
		goto out;
	}

202
	dev->recvd_msg = false;
O
Oren Weil 已提交
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
	dev_dbg(&dev->pdev->dev, "host_hw_state = 0x%08x, me_hw_state = 0x%08x.\n",
	    dev->host_hw_state, dev->me_hw_state);
	dev_dbg(&dev->pdev->dev, "ME turn on ME_RDY and host turn on H_RDY.\n");
	dev_dbg(&dev->pdev->dev, "link layer has been established.\n");
	dev_dbg(&dev->pdev->dev, "MEI  start success.\n");
	ret = 0;

out:
	mutex_unlock(&dev->device_lock);
	return ret;
}

/**
 * mei_hw_reset - resets fw via mei csr register.
 *
 * @dev: the device structure
 * @interrupts_enabled: if interrupt should be enabled after reset.
 */
static void mei_hw_reset(struct mei_device *dev, int interrupts_enabled)
{
	dev->host_hw_state |= (H_RST | H_IG);

	if (interrupts_enabled)
		mei_enable_interrupts(dev);
	else
		mei_disable_interrupts(dev);
}

/**
 * mei_reset - resets host and fw.
 *
 * @dev: the device structure
 * @interrupts_enabled: if interrupt should be enabled after reset.
 */
void mei_reset(struct mei_device *dev, int interrupts_enabled)
{
	struct mei_cl *cl_pos = NULL;
	struct mei_cl *cl_next = NULL;
	struct mei_cl_cb *cb_pos = NULL;
	struct mei_cl_cb *cb_next = NULL;
	bool unexpected;

245
	if (dev->dev_state == MEI_DEV_RECOVERING_FROM_RESET) {
246
		dev->need_reset = true;
O
Oren Weil 已提交
247 248 249
		return;
	}

250 251 252 253
	unexpected = (dev->dev_state != MEI_DEV_INITIALIZING &&
			dev->dev_state != MEI_DEV_DISABLED &&
			dev->dev_state != MEI_DEV_POWER_DOWN &&
			dev->dev_state != MEI_DEV_POWER_UP);
O
Oren Weil 已提交
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269

	dev->host_hw_state = mei_hcsr_read(dev);

	dev_dbg(&dev->pdev->dev, "before reset host_hw_state = 0x%08x.\n",
	    dev->host_hw_state);

	mei_hw_reset(dev, interrupts_enabled);

	dev->host_hw_state &= ~H_RST;
	dev->host_hw_state |= H_IG;

	mei_hcsr_set(dev);

	dev_dbg(&dev->pdev->dev, "currently saved host_hw_state = 0x%08x.\n",
	    dev->host_hw_state);

270
	dev->need_reset = false;
O
Oren Weil 已提交
271

272 273 274 275
	if (dev->dev_state != MEI_DEV_INITIALIZING) {
		if (dev->dev_state != MEI_DEV_DISABLED &&
		    dev->dev_state != MEI_DEV_POWER_DOWN)
			dev->dev_state = MEI_DEV_RESETING;
O
Oren Weil 已提交
276 277 278 279 280 281 282 283 284

		list_for_each_entry_safe(cl_pos,
				cl_next, &dev->file_list, link) {
			cl_pos->state = MEI_FILE_DISCONNECTED;
			cl_pos->mei_flow_ctrl_creds = 0;
			cl_pos->read_cb = NULL;
			cl_pos->timer_count = 0;
		}
		/* remove entry if already in list */
285 286
		dev_dbg(&dev->pdev->dev, "remove iamthif and wd from the file list.\n");
		mei_me_cl_unlink(dev, &dev->wd_cl);
O
Oren Weil 已提交
287

288
		mei_me_cl_unlink(dev, &dev->iamthif_cl);
O
Oren Weil 已提交
289

290
		mei_amthif_reset_params(dev);
291
		memset(&dev->wr_ext_msg, 0, sizeof(dev->wr_ext_msg));
O
Oren Weil 已提交
292 293
	}

294
	dev->me_clients_num = 0;
O
Oren Weil 已提交
295
	dev->rd_msg_hdr = 0;
296
	dev->wd_pending = false;
O
Oren Weil 已提交
297 298 299 300 301 302 303 304 305

	/* update the state of the registers after reset */
	dev->host_hw_state = mei_hcsr_read(dev);
	dev->me_hw_state = mei_mecsr_read(dev);

	dev_dbg(&dev->pdev->dev, "after reset host_hw_state = 0x%08x, me_hw_state = 0x%08x.\n",
	    dev->host_hw_state, dev->me_hw_state);

	if (unexpected)
306 307
		dev_warn(&dev->pdev->dev, "unexpected reset: dev_state = %s\n",
			 mei_dev_state_str(dev->dev_state));
O
Oren Weil 已提交
308 309 310 311 312 313 314 315 316

	/* Wake up all readings so they can be interrupted */
	list_for_each_entry_safe(cl_pos, cl_next, &dev->file_list, link) {
		if (waitqueue_active(&cl_pos->rx_wait)) {
			dev_dbg(&dev->pdev->dev, "Waking up client!\n");
			wake_up_interruptible(&cl_pos->rx_wait);
		}
	}
	/* remove all waiting requests */
317 318
	list_for_each_entry_safe(cb_pos, cb_next, &dev->write_list.list, list) {
		list_del(&cb_pos->list);
319
		mei_io_cb_free(cb_pos);
O
Oren Weil 已提交
320 321 322 323 324 325 326 327 328 329 330 331
	}
}



/**
 * host_start_message - mei host sends start message.
 *
 * @dev: the device structure
 *
 * returns none.
 */
332
void mei_host_start_message(struct mei_device *dev)
O
Oren Weil 已提交
333 334
{
	struct mei_msg_hdr *mei_hdr;
335 336 337 338
	struct hbm_host_version_request *start_req;
	const size_t len = sizeof(struct hbm_host_version_request);

	mei_hdr = mei_hbm_hdr(&dev->wr_msg_buf[0], len);
O
Oren Weil 已提交
339 340

	/* host start message */
341 342 343 344 345 346
	start_req = (struct hbm_host_version_request *)&dev->wr_msg_buf[1];
	memset(start_req, 0, len);
	start_req->hbm_cmd = HOST_START_REQ_CMD;
	start_req->host_version.major_version = HBM_MAJOR_VERSION;
	start_req->host_version.minor_version = HBM_MINOR_VERSION;

347
	dev->recvd_msg = false;
348
	if (mei_write_message(dev, mei_hdr, (unsigned char *)start_req, len)) {
O
Oren Weil 已提交
349
		dev_dbg(&dev->pdev->dev, "write send version message to FW fail.\n");
350
		dev->dev_state = MEI_DEV_RESETING;
O
Oren Weil 已提交
351 352 353
		mei_reset(dev, 1);
	}
	dev->init_clients_state = MEI_START_MESSAGE;
354
	dev->init_clients_timer = MEI_CLIENTS_INIT_TIMEOUT;
O
Oren Weil 已提交
355 356 357 358 359 360 361 362 363 364
	return ;
}

/**
 * host_enum_clients_message - host sends enumeration client request message.
 *
 * @dev: the device structure
 *
 * returns none.
 */
365
void mei_host_enum_clients_message(struct mei_device *dev)
O
Oren Weil 已提交
366 367
{
	struct mei_msg_hdr *mei_hdr;
368 369
	struct hbm_host_enum_request *enum_req;
	const size_t len = sizeof(struct hbm_host_enum_request);
O
Oren Weil 已提交
370
	/* enumerate clients */
371 372 373 374 375 376 377
	mei_hdr = mei_hbm_hdr(&dev->wr_msg_buf[0], len);

	enum_req = (struct hbm_host_enum_request *) &dev->wr_msg_buf[1];
	memset(enum_req, 0, sizeof(struct hbm_host_enum_request));
	enum_req->hbm_cmd = HOST_ENUM_REQ_CMD;

	if (mei_write_message(dev, mei_hdr, (unsigned char *)enum_req, len)) {
378
		dev->dev_state = MEI_DEV_RESETING;
O
Oren Weil 已提交
379 380 381 382
		dev_dbg(&dev->pdev->dev, "write send enumeration request message to FW fail.\n");
		mei_reset(dev, 1);
	}
	dev->init_clients_state = MEI_ENUM_CLIENTS_MESSAGE;
383
	dev->init_clients_timer = MEI_CLIENTS_INIT_TIMEOUT;
384
	return;
O
Oren Weil 已提交
385 386 387 388 389 390 391 392 393 394
}


/**
 * allocate_me_clients_storage - allocates storage for me clients
 *
 * @dev: the device structure
 *
 * returns none.
 */
395
void mei_allocate_me_clients_storage(struct mei_device *dev)
O
Oren Weil 已提交
396 397 398 399 400 401
{
	struct mei_me_client *clients;
	int b;

	/* count how many ME clients we have */
	for_each_set_bit(b, dev->me_clients_map, MEI_CLIENTS_MAX)
402
		dev->me_clients_num++;
O
Oren Weil 已提交
403

404
	if (dev->me_clients_num <= 0)
O
Oren Weil 已提交
405 406 407 408 409 410 411 412
		return ;


	if (dev->me_clients != NULL) {
		kfree(dev->me_clients);
		dev->me_clients = NULL;
	}
	dev_dbg(&dev->pdev->dev, "memory allocation for ME clients size=%zd.\n",
413
		dev->me_clients_num * sizeof(struct mei_me_client));
O
Oren Weil 已提交
414
	/* allocate storage for ME clients representation */
415
	clients = kcalloc(dev->me_clients_num,
O
Oren Weil 已提交
416 417 418
			sizeof(struct mei_me_client), GFP_KERNEL);
	if (!clients) {
		dev_dbg(&dev->pdev->dev, "memory allocation for ME clients failed.\n");
419
		dev->dev_state = MEI_DEV_RESETING;
O
Oren Weil 已提交
420 421 422 423 424 425
		mei_reset(dev, 1);
		return ;
	}
	dev->me_clients = clients;
	return ;
}
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461

void mei_host_client_init(struct work_struct *work)
{
	struct mei_device *dev = container_of(work,
					      struct mei_device, init_work);
	struct mei_client_properties *client_props;
	int i;

	mutex_lock(&dev->device_lock);

	bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX);
	dev->open_handle_count = 0;

	/*
	 * Reserving the first three client IDs
	 * 0: Reserved for MEI Bus Message communications
	 * 1: Reserved for Watchdog
	 * 2: Reserved for AMTHI
	 */
	bitmap_set(dev->host_clients_map, 0, 3);

	for (i = 0; i < dev->me_clients_num; i++) {
		client_props = &dev->me_clients[i].props;

		if (!uuid_le_cmp(client_props->protocol_name, mei_amthi_guid))
			mei_amthif_host_init(dev);
		else if (!uuid_le_cmp(client_props->protocol_name, mei_wd_guid))
			mei_wd_host_init(dev);
	}

	dev->dev_state = MEI_DEV_ENABLED;

	mutex_unlock(&dev->device_lock);
}

int mei_host_client_enumerate(struct mei_device *dev)
O
Oren Weil 已提交
462
{
463 464 465 466

	struct mei_msg_hdr *mei_hdr;
	struct hbm_props_request *prop_req;
	const size_t len = sizeof(struct hbm_props_request);
467 468
	unsigned long next_client_index;
	u8 client_num;
469

O
Oren Weil 已提交
470

471
	client_num = dev->me_client_presentation_num;
472

473 474
	next_client_index = find_next_bit(dev->me_clients_map, MEI_CLIENTS_MAX,
					  dev->me_client_index);
O
Oren Weil 已提交
475

476 477 478
	/* We got all client properties */
	if (next_client_index == MEI_CLIENTS_MAX) {
		schedule_work(&dev->init_work);
O
Oren Weil 已提交
479

480 481
		return 0;
	}
O
Oren Weil 已提交
482

483 484
	dev->me_clients[client_num].client_id = next_client_index;
	dev->me_clients[client_num].mei_flow_ctrl_creds = 0;
O
Oren Weil 已提交
485

486 487
	mei_hdr = mei_hbm_hdr(&dev->wr_msg_buf[0], len);
	prop_req = (struct hbm_props_request *)&dev->wr_msg_buf[1];
O
Oren Weil 已提交
488

489 490 491 492 493 494 495 496 497 498 499 500 501
	memset(prop_req, 0, sizeof(struct hbm_props_request));


	prop_req->hbm_cmd = HOST_CLIENT_PROPERTIES_REQ_CMD;
	prop_req->address = next_client_index;

	if (mei_write_message(dev, mei_hdr, (unsigned char *) prop_req,
			      mei_hdr->length)) {
		dev->dev_state = MEI_DEV_RESETING;
		dev_err(&dev->pdev->dev, "Properties request command failed\n");
		mei_reset(dev, 1);

		return -EIO;
O
Oren Weil 已提交
502 503
	}

504 505 506
	dev->init_clients_timer = MEI_CLIENTS_INIT_TIMEOUT;
	dev->me_client_index = next_client_index;

507
	return 0;
O
Oren Weil 已提交
508 509 510 511 512 513 514 515
}

/**
 * mei_init_file_private - initializes private file structure.
 *
 * @priv: private file structure to be initialized
 * @file: the file structure
 */
516
void mei_cl_init(struct mei_cl *priv, struct mei_device *dev)
O
Oren Weil 已提交
517 518 519 520 521 522 523 524 525 526 527
{
	memset(priv, 0, sizeof(struct mei_cl));
	init_waitqueue_head(&priv->wait);
	init_waitqueue_head(&priv->rx_wait);
	init_waitqueue_head(&priv->tx_wait);
	INIT_LIST_HEAD(&priv->link);
	priv->reading_state = MEI_IDLE;
	priv->writing_state = MEI_IDLE;
	priv->dev = dev;
}

528
int mei_me_cl_by_uuid(const struct mei_device *dev, const uuid_le *cuuid)
O
Oren Weil 已提交
529
{
530
	int i, res = -ENOENT;
O
Oren Weil 已提交
531

532
	for (i = 0; i < dev->me_clients_num; ++i)
533
		if (uuid_le_cmp(*cuuid,
O
Oren Weil 已提交
534 535 536 537 538 539 540 541 542 543
				dev->me_clients[i].props.protocol_name) == 0) {
			res = i;
			break;
		}

	return res;
}


/**
544 545 546
 * mei_me_cl_link - create link between host and me clinet and add
 *   me_cl to the list
 *
O
Oren Weil 已提交
547
 * @dev: the device structure
548 549 550
 * @cl: link between me and host client assocated with opened file descriptor
 * @cuuid: uuid of ME client
 * @client_id: id of the host client
O
Oren Weil 已提交
551
 *
552 553 554
 * returns ME client index if ME client
 *	-EINVAL on incorrect values
 *	-ENONET if client not found
O
Oren Weil 已提交
555
 */
556 557
int mei_me_cl_link(struct mei_device *dev, struct mei_cl *cl,
			const uuid_le *cuuid, u8 host_cl_id)
O
Oren Weil 已提交
558 559 560
{
	int i;

561 562
	if (!dev || !cl || !cuuid)
		return -EINVAL;
O
Oren Weil 已提交
563 564

	/* check for valid client id */
565
	i = mei_me_cl_by_uuid(dev, cuuid);
O
Oren Weil 已提交
566
	if (i >= 0) {
567 568 569
		cl->me_client_id = dev->me_clients[i].client_id;
		cl->state = MEI_FILE_CONNECTING;
		cl->host_client_id = host_cl_id;
O
Oren Weil 已提交
570

571
		list_add_tail(&cl->link, &dev->file_list);
O
Oren Weil 已提交
572 573 574
		return (u8)i;
	}

575
	return -ENOENT;
O
Oren Weil 已提交
576
}
577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594
/**
 * mei_me_cl_unlink - remove me_cl from the list
 *
 * @dev: the device structure
 * @host_client_id: host client id to be removed
 */
void mei_me_cl_unlink(struct mei_device *dev, struct mei_cl *cl)
{
	struct mei_cl *pos, *next;
	list_for_each_entry_safe(pos, next, &dev->file_list, link) {
		if (cl->host_client_id == pos->host_client_id) {
			dev_dbg(&dev->pdev->dev, "remove host client = %d, ME client = %d\n",
					pos->host_client_id, pos->me_client_id);
			list_del_init(&pos->link);
			break;
		}
	}
}
O
Oren Weil 已提交
595 596 597 598 599 600 601

/**
 * mei_alloc_file_private - allocates a private file structure and sets it up.
 * @file: the file structure
 *
 * returns  The allocated file or NULL on failure
 */
602
struct mei_cl *mei_cl_allocate(struct mei_device *dev)
O
Oren Weil 已提交
603
{
604
	struct mei_cl *cl;
O
Oren Weil 已提交
605

606 607
	cl = kmalloc(sizeof(struct mei_cl), GFP_KERNEL);
	if (!cl)
O
Oren Weil 已提交
608 609
		return NULL;

610
	mei_cl_init(cl, dev);
O
Oren Weil 已提交
611

612
	return cl;
O
Oren Weil 已提交
613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629
}



/**
 * mei_disconnect_host_client - sends disconnect message to fw from host client.
 *
 * @dev: the device structure
 * @cl: private data of the file object
 *
 * Locking: called under "dev->device_lock" lock
 *
 * returns 0 on success, <0 on failure.
 */
int mei_disconnect_host_client(struct mei_device *dev, struct mei_cl *cl)
{
	struct mei_cl_cb *cb;
630
	int rets, err;
O
Oren Weil 已提交
631 632 633 634 635 636 637

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

	if (cl->state != MEI_FILE_DISCONNECTING)
		return 0;

638
	cb = mei_io_cb_init(cl, NULL);
O
Oren Weil 已提交
639 640 641
	if (!cb)
		return -ENOMEM;

642
	cb->fop_type = MEI_FOP_CLOSE;
O
Oren Weil 已提交
643
	if (dev->mei_host_buffer_is_empty) {
644
		dev->mei_host_buffer_is_empty = false;
O
Oren Weil 已提交
645 646 647 648 649
		if (mei_disconnect(dev, cl)) {
			rets = -ENODEV;
			dev_dbg(&dev->pdev->dev, "failed to call mei_disconnect.\n");
			goto free;
		}
650
		mdelay(10); /* Wait for hardware disconnection ready */
651
		list_add_tail(&cb->list, &dev->ctrl_rd_list.list);
O
Oren Weil 已提交
652 653
	} else {
		dev_dbg(&dev->pdev->dev, "add disconnect cb to control write list\n");
654 655
		list_add_tail(&cb->list, &dev->ctrl_wr_list.list);

O
Oren Weil 已提交
656 657 658 659
	}
	mutex_unlock(&dev->device_lock);

	err = wait_event_timeout(dev->wait_recvd_msg,
660 661
			MEI_FILE_DISCONNECTED == cl->state,
			mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
O
Oren Weil 已提交
662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679

	mutex_lock(&dev->device_lock);
	if (MEI_FILE_DISCONNECTED == cl->state) {
		rets = 0;
		dev_dbg(&dev->pdev->dev, "successfully disconnected from FW client.\n");
	} else {
		rets = -ENODEV;
		if (MEI_FILE_DISCONNECTED != cl->state)
			dev_dbg(&dev->pdev->dev, "wrong status client disconnect.\n");

		if (err)
			dev_dbg(&dev->pdev->dev,
					"wait failed disconnect err=%08x\n",
					err);

		dev_dbg(&dev->pdev->dev, "failed to disconnect from FW client.\n");
	}

680 681
	mei_io_list_flush(&dev->ctrl_rd_list, cl);
	mei_io_list_flush(&dev->ctrl_wr_list, cl);
O
Oren Weil 已提交
682
free:
683
	mei_io_cb_free(cb);
O
Oren Weil 已提交
684 685 686
	return rets;
}