hbm.c 30.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 *
 * 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.
 *
 */

17
#include <linux/export.h>
18 19
#include <linux/sched.h>
#include <linux/wait.h>
20
#include <linux/pm_runtime.h>
21 22 23
#include <linux/slab.h>

#include <linux/mei.h>
24 25

#include "mei_dev.h"
26
#include "hbm.h"
27
#include "client.h"
28

29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
static const char *mei_hbm_status_str(enum mei_hbm_status status)
{
#define MEI_HBM_STATUS(status) case MEI_HBMS_##status: return #status
	switch (status) {
	MEI_HBM_STATUS(SUCCESS);
	MEI_HBM_STATUS(CLIENT_NOT_FOUND);
	MEI_HBM_STATUS(ALREADY_EXISTS);
	MEI_HBM_STATUS(REJECTED);
	MEI_HBM_STATUS(INVALID_PARAMETER);
	MEI_HBM_STATUS(NOT_ALLOWED);
	MEI_HBM_STATUS(ALREADY_STARTED);
	MEI_HBM_STATUS(NOT_STARTED);
	default: return "unknown";
	}
#undef MEI_HBM_STATUS
};

46 47 48 49 50 51 52 53 54
static const char *mei_cl_conn_status_str(enum mei_cl_connect_status status)
{
#define MEI_CL_CS(status) case MEI_CL_CONN_##status: return #status
	switch (status) {
	MEI_CL_CS(SUCCESS);
	MEI_CL_CS(NOT_FOUND);
	MEI_CL_CS(ALREADY_STARTED);
	MEI_CL_CS(OUT_OF_RESOURCES);
	MEI_CL_CS(MESSAGE_SMALL);
55
	MEI_CL_CS(NOT_ALLOWED);
56 57 58 59 60
	default: return "unknown";
	}
#undef MEI_CL_CCS
}

61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
const char *mei_hbm_state_str(enum mei_hbm_state state)
{
#define MEI_HBM_STATE(state) case MEI_HBM_##state: return #state
	switch (state) {
	MEI_HBM_STATE(IDLE);
	MEI_HBM_STATE(STARTING);
	MEI_HBM_STATE(STARTED);
	MEI_HBM_STATE(ENUM_CLIENTS);
	MEI_HBM_STATE(CLIENT_PROPERTIES);
	MEI_HBM_STATE(STOPPED);
	default:
		return "unknown";
	}
#undef MEI_HBM_STATE
}

77 78 79 80 81 82
/**
 * mei_cl_conn_status_to_errno - convert client connect response
 * status to error code
 *
 * @status: client connect response status
 *
83
 * Return: corresponding error code
84 85 86 87 88 89 90 91 92
 */
static int mei_cl_conn_status_to_errno(enum mei_cl_connect_status status)
{
	switch (status) {
	case MEI_CL_CONN_SUCCESS:          return 0;
	case MEI_CL_CONN_NOT_FOUND:        return -ENOTTY;
	case MEI_CL_CONN_ALREADY_STARTED:  return -EBUSY;
	case MEI_CL_CONN_OUT_OF_RESOURCES: return -EBUSY;
	case MEI_CL_CONN_MESSAGE_SMALL:    return -EINVAL;
93
	case MEI_CL_CONN_NOT_ALLOWED:      return -EBUSY;
94 95 96 97
	default:                           return -EINVAL;
	}
}

98 99 100 101 102 103 104 105 106 107 108
/**
 * mei_hbm_idle - set hbm to idle state
 *
 * @dev: the device structure
 */
void mei_hbm_idle(struct mei_device *dev)
{
	dev->init_clients_timer = 0;
	dev->hbm_state = MEI_HBM_IDLE;
}

109 110 111 112 113 114 115
/**
 * mei_hbm_reset - reset hbm counters and book keeping data structurs
 *
 * @dev: the device structure
 */
void mei_hbm_reset(struct mei_device *dev)
{
116
	mei_me_cl_rm_all(dev);
117 118 119 120

	mei_hbm_idle(dev);
}

121 122 123 124 125 126 127 128 129 130 131 132 133 134
/**
 * mei_hbm_hdr - construct hbm header
 *
 * @hdr: hbm header
 * @length: payload length
 */

static inline void mei_hbm_hdr(struct mei_msg_hdr *hdr, size_t length)
{
	hdr->host_addr = 0;
	hdr->me_addr = 0;
	hdr->length = length;
	hdr->msg_complete = 1;
	hdr->reserved = 0;
135
	hdr->internal = 0;
136 137
}

138 139
/**
 * mei_hbm_cl_hdr - construct client hbm header
140
 *
141
 * @cl: client
142 143 144 145 146 147 148 149 150 151 152 153
 * @hbm_cmd: host bus message command
 * @buf: buffer for cl header
 * @len: buffer length
 */
static inline
void mei_hbm_cl_hdr(struct mei_cl *cl, u8 hbm_cmd, void *buf, size_t len)
{
	struct mei_hbm_cl_cmd *cmd = buf;

	memset(cmd, 0, len);

	cmd->hbm_cmd = hbm_cmd;
154
	cmd->host_addr = mei_cl_host_addr(cl);
155
	cmd->me_addr = mei_cl_me_id(cl);
156 157
}

158 159 160 161 162 163
/**
 * mei_hbm_cl_write - write simple hbm client message
 *
 * @dev: the device structure
 * @cl: client
 * @hbm_cmd: host bus message command
164
 * @buf: message buffer
165
 * @len: buffer length
166 167
 *
 * Return: 0 on success, <0 on failure.
168
 */
169 170
static inline int mei_hbm_cl_write(struct mei_device *dev, struct mei_cl *cl,
				   u8 hbm_cmd, void *buf, size_t len)
171
{
172
	struct mei_msg_hdr mei_hdr;
173

174 175
	mei_hbm_hdr(&mei_hdr, len);
	mei_hbm_cl_hdr(cl, hbm_cmd, buf, len);
176

177
	return mei_write_message(dev, &mei_hdr, buf);
178 179
}

180
/**
181 182
 * mei_hbm_cl_addr_equal - check if the client's and
 *	the message address match
183
 *
184 185
 * @cl: client
 * @cmd: hbm client message
186
 *
187
 * Return: true if addresses are the same
188 189
 */
static inline
190
bool mei_hbm_cl_addr_equal(struct mei_cl *cl, struct mei_hbm_cl_cmd *cmd)
191
{
192
	return  mei_cl_host_addr(cl) == cmd->host_addr &&
193
		mei_cl_me_id(cl) == cmd->me_addr;
194 195
}

196 197 198 199 200 201
/**
 * mei_hbm_cl_find_by_cmd - find recipient client
 *
 * @dev: the device structure
 * @buf: a buffer with hbm cl command
 *
202
 * Return: the recipient client or NULL if not found
203 204 205 206 207 208 209 210 211 212 213 214 215 216
 */
static inline
struct mei_cl *mei_hbm_cl_find_by_cmd(struct mei_device *dev, void *buf)
{
	struct mei_hbm_cl_cmd *cmd = (struct mei_hbm_cl_cmd *)buf;
	struct mei_cl *cl;

	list_for_each_entry(cl, &dev->file_list, link)
		if (mei_hbm_cl_addr_equal(cl, cmd))
			return cl;
	return NULL;
}


217 218 219 220 221
/**
 * mei_hbm_start_wait - wait for start response message.
 *
 * @dev: the device structure
 *
222
 * Return: 0 on success and < 0 on failure
223
 */
224 225 226
int mei_hbm_start_wait(struct mei_device *dev)
{
	int ret;
227 228

	if (dev->hbm_state > MEI_HBM_STARTING)
229 230 231
		return 0;

	mutex_unlock(&dev->device_lock);
232 233
	ret = wait_event_timeout(dev->wait_hbm_start,
			dev->hbm_state != MEI_HBM_STARTING,
234
			mei_secs_to_jiffies(MEI_HBM_TIMEOUT));
235 236
	mutex_lock(&dev->device_lock);

237
	if (ret == 0 && (dev->hbm_state <= MEI_HBM_STARTING)) {
238
		dev->hbm_state = MEI_HBM_IDLE;
239
		dev_err(dev->dev, "waiting for mei start failed\n");
240
		return -ETIME;
241 242 243 244
	}
	return 0;
}

245
/**
246
 * mei_hbm_start_req - sends start request message.
247 248
 *
 * @dev: the device structure
249
 *
250
 * Return: 0 on success and < 0 on failure
251
 */
252
int mei_hbm_start_req(struct mei_device *dev)
253
{
254 255
	struct mei_msg_hdr mei_hdr;
	struct hbm_host_version_request start_req;
256
	const size_t len = sizeof(struct hbm_host_version_request);
257
	int ret;
258

259 260
	mei_hbm_reset(dev);

261
	mei_hbm_hdr(&mei_hdr, len);
262 263

	/* host start message */
264 265 266 267
	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;
268

269
	dev->hbm_state = MEI_HBM_IDLE;
270
	ret = mei_write_message(dev, &mei_hdr, &start_req);
271
	if (ret) {
272
		dev_err(dev->dev, "version message write failed: ret = %d\n",
273 274
			ret);
		return ret;
275
	}
276

277
	dev->hbm_state = MEI_HBM_STARTING;
278
	dev->init_clients_timer = MEI_CLIENTS_INIT_TIMEOUT;
279
	mei_schedule_stall_timer(dev);
280
	return 0;
281 282
}

283
/**
284
 * mei_hbm_enum_clients_req - sends enumeration client request message.
285 286 287
 *
 * @dev: the device structure
 *
288
 * Return: 0 on success and < 0 on failure
289
 */
290
static int mei_hbm_enum_clients_req(struct mei_device *dev)
291
{
292 293
	struct mei_msg_hdr mei_hdr;
	struct hbm_host_enum_request enum_req;
294
	const size_t len = sizeof(struct hbm_host_enum_request);
295 296
	int ret;

297
	/* enumerate clients */
298
	mei_hbm_hdr(&mei_hdr, len);
299

300 301 302 303 304 305
	memset(&enum_req, 0, len);
	enum_req.hbm_cmd = HOST_ENUM_REQ_CMD;
	enum_req.flags |= dev->hbm_f_dc_supported ?
			  MEI_HBM_ENUM_F_ALLOW_ADD : 0;
	enum_req.flags |= dev->hbm_f_ie_supported ?
			  MEI_HBM_ENUM_F_IMMEDIATE_ENUM : 0;
306

307
	ret = mei_write_message(dev, &mei_hdr, &enum_req);
308
	if (ret) {
309
		dev_err(dev->dev, "enumeration request write failed: ret = %d.\n",
310 311
			ret);
		return ret;
312
	}
313
	dev->hbm_state = MEI_HBM_ENUM_CLIENTS;
314
	dev->init_clients_timer = MEI_CLIENTS_INIT_TIMEOUT;
315
	mei_schedule_stall_timer(dev);
316
	return 0;
317 318
}

319
/**
320 321 322 323 324
 * mei_hbm_me_cl_add - add new me client to the list
 *
 * @dev: the device structure
 * @res: hbm property response
 *
325
 * Return: 0 on success and -ENOMEM on allocation failure
326 327 328 329 330 331
 */

static int mei_hbm_me_cl_add(struct mei_device *dev,
			     struct hbm_props_response *res)
{
	struct mei_me_client *me_cl;
332 333 334
	const uuid_le *uuid = &res->client_properties.protocol_name;

	mei_me_cl_rm_by_uuid(dev, uuid);
335 336 337 338 339

	me_cl = kzalloc(sizeof(struct mei_me_client), GFP_KERNEL);
	if (!me_cl)
		return -ENOMEM;

340 341
	mei_me_cl_init(me_cl);

342 343
	me_cl->props = res->client_properties;
	me_cl->client_id = res->me_addr;
344
	me_cl->tx_flow_ctrl_creds = 0;
345

346 347
	mei_me_cl_add(dev, me_cl);

348 349 350
	return 0;
}

351 352 353 354 355 356 357 358 359 360 361
/**
 * mei_hbm_add_cl_resp - send response to fw on client add request
 *
 * @dev: the device structure
 * @addr: me address
 * @status: response status
 *
 * Return: 0 on success and < 0 on failure
 */
static int mei_hbm_add_cl_resp(struct mei_device *dev, u8 addr, u8 status)
{
362 363
	struct mei_msg_hdr mei_hdr;
	struct hbm_add_client_response resp;
364 365 366 367 368
	const size_t len = sizeof(struct hbm_add_client_response);
	int ret;

	dev_dbg(dev->dev, "adding client response\n");

369
	mei_hbm_hdr(&mei_hdr, len);
370

371 372 373 374
	memset(&resp, 0, sizeof(struct hbm_add_client_response));
	resp.hbm_cmd = MEI_HBM_ADD_CLIENT_RES_CMD;
	resp.me_addr = addr;
	resp.status  = status;
375

376
	ret = mei_write_message(dev, &mei_hdr, &resp);
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403
	if (ret)
		dev_err(dev->dev, "add client response write failed: ret = %d\n",
			ret);
	return ret;
}

/**
 * mei_hbm_fw_add_cl_req - request from the fw to add a client
 *
 * @dev: the device structure
 * @req: add client request
 *
 * Return: 0 on success and < 0 on failure
 */
static int mei_hbm_fw_add_cl_req(struct mei_device *dev,
			      struct hbm_add_client_request *req)
{
	int ret;
	u8 status = MEI_HBMS_SUCCESS;

	BUILD_BUG_ON(sizeof(struct hbm_add_client_request) !=
			sizeof(struct hbm_props_response));

	ret = mei_hbm_me_cl_add(dev, (struct hbm_props_response *)req);
	if (ret)
		status = !MEI_HBMS_SUCCESS;

404 405 406
	if (dev->dev_state == MEI_DEV_ENABLED)
		schedule_work(&dev->bus_rescan_work);

407 408 409
	return mei_hbm_add_cl_resp(dev, req->me_addr, status);
}

410 411 412 413 414 415 416 417 418 419 420 421 422
/**
 * mei_hbm_cl_notify_req - send notification request
 *
 * @dev: the device structure
 * @cl: a client to disconnect from
 * @start: true for start false for stop
 *
 * Return: 0 on success and -EIO on write failure
 */
int mei_hbm_cl_notify_req(struct mei_device *dev,
			  struct mei_cl *cl, u8 start)
{

423 424
	struct mei_msg_hdr mei_hdr;
	struct hbm_notification_request req;
425 426 427
	const size_t len = sizeof(struct hbm_notification_request);
	int ret;

428 429
	mei_hbm_hdr(&mei_hdr, len);
	mei_hbm_cl_hdr(cl, MEI_HBM_NOTIFY_REQ_CMD, &req, len);
430

431
	req.start = start;
432

433
	ret = mei_write_message(dev, &mei_hdr, &req);
434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
	if (ret)
		dev_err(dev->dev, "notify request failed: ret = %d\n", ret);

	return ret;
}

/**
 *  notify_res_to_fop - convert notification response to the proper
 *      notification FOP
 *
 * @cmd: client notification start response command
 *
 * Return:  MEI_FOP_NOTIFY_START or MEI_FOP_NOTIFY_STOP;
 */
static inline enum mei_cb_file_ops notify_res_to_fop(struct mei_hbm_cl_cmd *cmd)
{
	struct hbm_notification_response *rs =
		(struct hbm_notification_response *)cmd;

453
	return mei_cl_notify_req2fop(rs->start);
454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520
}

/**
 * mei_hbm_cl_notify_start_res - update the client state according
 *       notify start response
 *
 * @dev: the device structure
 * @cl: mei host client
 * @cmd: client notification start response command
 */
static void mei_hbm_cl_notify_start_res(struct mei_device *dev,
					struct mei_cl *cl,
					struct mei_hbm_cl_cmd *cmd)
{
	struct hbm_notification_response *rs =
		(struct hbm_notification_response *)cmd;

	cl_dbg(dev, cl, "hbm: notify start response status=%d\n", rs->status);

	if (rs->status == MEI_HBMS_SUCCESS ||
	    rs->status == MEI_HBMS_ALREADY_STARTED) {
		cl->notify_en = true;
		cl->status = 0;
	} else {
		cl->status = -EINVAL;
	}
}

/**
 * mei_hbm_cl_notify_stop_res - update the client state according
 *       notify stop response
 *
 * @dev: the device structure
 * @cl: mei host client
 * @cmd: client notification stop response command
 */
static void mei_hbm_cl_notify_stop_res(struct mei_device *dev,
				       struct mei_cl *cl,
				       struct mei_hbm_cl_cmd *cmd)
{
	struct hbm_notification_response *rs =
		(struct hbm_notification_response *)cmd;

	cl_dbg(dev, cl, "hbm: notify stop response status=%d\n", rs->status);

	if (rs->status == MEI_HBMS_SUCCESS ||
	    rs->status == MEI_HBMS_NOT_STARTED) {
		cl->notify_en = false;
		cl->status = 0;
	} else {
		/* TODO: spec is not clear yet about other possible issues */
		cl->status = -EINVAL;
	}
}

/**
 * mei_hbm_cl_notify - signal notification event
 *
 * @dev: the device structure
 * @cmd: notification client message
 */
static void mei_hbm_cl_notify(struct mei_device *dev,
			      struct mei_hbm_cl_cmd *cmd)
{
	struct mei_cl *cl;

	cl = mei_hbm_cl_find_by_cmd(dev, cmd);
521 522
	if (cl)
		mei_cl_notify(cl);
523 524
}

525
/**
526
 * mei_hbm_prop_req - request property for a single client
527 528
 *
 * @dev: the device structure
529
 * @start_idx: client index to start search
530
 *
531
 * Return: 0 on success and < 0 on failure
532
 */
533
static int mei_hbm_prop_req(struct mei_device *dev, unsigned long start_idx)
534
{
535 536
	struct mei_msg_hdr mei_hdr;
	struct hbm_props_request prop_req;
537
	const size_t len = sizeof(struct hbm_props_request);
538
	unsigned long addr;
539
	int ret;
540

541
	addr = find_next_bit(dev->me_clients_map, MEI_CLIENTS_MAX, start_idx);
542 543

	/* We got all client properties */
544
	if (addr == MEI_CLIENTS_MAX) {
545
		dev->hbm_state = MEI_HBM_STARTED;
546
		mei_host_client_init(dev);
547 548 549 550

		return 0;
	}

551
	mei_hbm_hdr(&mei_hdr, len);
552

553
	memset(&prop_req, 0, sizeof(struct hbm_props_request));
554

555 556
	prop_req.hbm_cmd = HOST_CLIENT_PROPERTIES_REQ_CMD;
	prop_req.me_addr = addr;
557

558
	ret = mei_write_message(dev, &mei_hdr, &prop_req);
559
	if (ret) {
560
		dev_err(dev->dev, "properties request write failed: ret = %d\n",
561 562
			ret);
		return ret;
563 564 565
	}

	dev->init_clients_timer = MEI_CLIENTS_INIT_TIMEOUT;
566
	mei_schedule_stall_timer(dev);
567 568 569 570

	return 0;
}

571
/**
572 573 574 575 576
 * mei_hbm_pg - sends pg command
 *
 * @dev: the device structure
 * @pg_cmd: the pg command code
 *
577
 * Return: -EIO on write failure
578
 *         -EOPNOTSUPP if the operation is not supported by the protocol
579 580 581
 */
int mei_hbm_pg(struct mei_device *dev, u8 pg_cmd)
{
582 583
	struct mei_msg_hdr mei_hdr;
	struct hbm_power_gate req;
584 585 586
	const size_t len = sizeof(struct hbm_power_gate);
	int ret;

587 588 589
	if (!dev->hbm_f_pg_supported)
		return -EOPNOTSUPP;

590
	mei_hbm_hdr(&mei_hdr, len);
591

592 593
	memset(&req, 0, len);
	req.hbm_cmd = pg_cmd;
594

595
	ret = mei_write_message(dev, &mei_hdr, &req);
596
	if (ret)
597
		dev_err(dev->dev, "power gate command write failed.\n");
598 599 600 601
	return ret;
}
EXPORT_SYMBOL_GPL(mei_hbm_pg);

602
/**
Tomas Winkler's avatar
Tomas Winkler committed
603
 * mei_hbm_stop_req - send stop request message
604
 *
605
 * @dev: mei device
Tomas Winkler's avatar
Tomas Winkler committed
606
 *
607
 * Return: -EIO on write failure
608
 */
Tomas Winkler's avatar
Tomas Winkler committed
609
static int mei_hbm_stop_req(struct mei_device *dev)
610
{
611 612
	struct mei_msg_hdr mei_hdr;
	struct hbm_host_stop_request req;
613 614
	const size_t len = sizeof(struct hbm_host_stop_request);

615
	mei_hbm_hdr(&mei_hdr, len);
616

617 618 619
	memset(&req, 0, len);
	req.hbm_cmd = HOST_STOP_REQ_CMD;
	req.reason = DRIVER_STOP_REQUEST;
Tomas Winkler's avatar
Tomas Winkler committed
620

621
	return mei_write_message(dev, &mei_hdr, &req);
622 623
}

624
/**
625
 * mei_hbm_cl_flow_control_req - sends flow control request.
626 627
 *
 * @dev: the device structure
628
 * @cl: client info
629
 *
630
 * Return: -EIO on write failure
631
 */
632
int mei_hbm_cl_flow_control_req(struct mei_device *dev, struct mei_cl *cl)
633
{
634
	struct hbm_flow_control req;
635

636
	cl_dbg(dev, cl, "sending flow control\n");
637 638
	return mei_hbm_cl_write(dev, cl, MEI_FLOW_CONTROL_CMD,
				&req, sizeof(req));
639 640
}

641
/**
642
 * mei_hbm_add_single_tx_flow_ctrl_creds - adds single buffer credentials.
643
 *
644
 * @dev: the device structure
645
 * @fctrl: flow control response bus message
646
 *
647
 * Return: 0 on success, < 0 otherwise
648
 */
649 650
static int mei_hbm_add_single_tx_flow_ctrl_creds(struct mei_device *dev,
						 struct hbm_flow_control *fctrl)
651
{
652
	struct mei_me_client *me_cl;
653
	int rets;
654

655
	me_cl = mei_me_cl_by_id(dev, fctrl->me_addr);
656
	if (!me_cl) {
657
		dev_err(dev->dev, "no such me client %d\n", fctrl->me_addr);
658
		return -ENOENT;
659 660
	}

661 662 663 664
	if (WARN_ON(me_cl->props.single_recv_buf == 0)) {
		rets = -EINVAL;
		goto out;
	}
665

666
	me_cl->tx_flow_ctrl_creds++;
667
	dev_dbg(dev->dev, "recv flow ctrl msg ME %d (single) creds = %d.\n",
668
		fctrl->me_addr, me_cl->tx_flow_ctrl_creds);
669

670 671 672 673
	rets = 0;
out:
	mei_me_cl_put(me_cl);
	return rets;
674 675 676 677 678 679
}

/**
 * mei_hbm_cl_flow_control_res - flow control response from me
 *
 * @dev: the device structure
680
 * @fctrl: flow control response bus message
681
 */
682 683
static void mei_hbm_cl_tx_flow_ctrl_creds_res(struct mei_device *dev,
					       struct hbm_flow_control *fctrl)
684
{
685
	struct mei_cl *cl;
686

687
	if (!fctrl->host_addr) {
688
		/* single receive buffer */
689
		mei_hbm_add_single_tx_flow_ctrl_creds(dev, fctrl);
690 691 692
		return;
	}

693
	cl = mei_hbm_cl_find_by_cmd(dev, fctrl);
694
	if (cl) {
695
		cl->tx_flow_ctrl_creds++;
696
		cl_dbg(dev, cl, "flow control creds = %d.\n",
697
				cl->tx_flow_ctrl_creds);
698 699 700 701
	}
}


702
/**
703
 * mei_hbm_cl_disconnect_req - sends disconnect message to fw.
704 705
 *
 * @dev: the device structure
706
 * @cl: a client to disconnect from
707
 *
708
 * Return: -EIO on write failure
709
 */
710
int mei_hbm_cl_disconnect_req(struct mei_device *dev, struct mei_cl *cl)
711
{
712
	struct hbm_client_connect_request req;
713

714 715
	return mei_hbm_cl_write(dev, cl, CLIENT_DISCONNECT_REQ_CMD,
				&req, sizeof(req));
716 717
}

Tomas Winkler's avatar
Tomas Winkler committed
718 719 720 721 722 723
/**
 * mei_hbm_cl_disconnect_rsp - sends disconnect respose to the FW
 *
 * @dev: the device structure
 * @cl: a client to disconnect from
 *
724
 * Return: -EIO on write failure
Tomas Winkler's avatar
Tomas Winkler committed
725 726 727
 */
int mei_hbm_cl_disconnect_rsp(struct mei_device *dev, struct mei_cl *cl)
{
728
	struct hbm_client_connect_response resp;
729

730 731
	return mei_hbm_cl_write(dev, cl, CLIENT_DISCONNECT_RES_CMD,
				&resp, sizeof(resp));
Tomas Winkler's avatar
Tomas Winkler committed
732 733
}

734
/**
735 736
 * mei_hbm_cl_disconnect_res - update the client state according
 *       disconnect response
737
 *
738
 * @dev: the device structure
739 740
 * @cl: mei host client
 * @cmd: disconnect client response host bus message
741
 */
742
static void mei_hbm_cl_disconnect_res(struct mei_device *dev, struct mei_cl *cl,
743
				      struct mei_hbm_cl_cmd *cmd)
744
{
745 746
	struct hbm_client_connect_response *rs =
		(struct hbm_client_connect_response *)cmd;
747

748
	cl_dbg(dev, cl, "hbm: disconnect response status=%d\n", rs->status);
749

750
	if (rs->status == MEI_CL_DISCONN_SUCCESS)
751
		cl->state = MEI_FILE_DISCONNECT_REPLY;
752
	cl->status = 0;
753 754
}

755
/**
756
 * mei_hbm_cl_connect_req - send connection request to specific me client
757 758
 *
 * @dev: the device structure
759
 * @cl: a client to connect to
760
 *
761
 * Return: -EIO on write failure
762
 */
763
int mei_hbm_cl_connect_req(struct mei_device *dev, struct mei_cl *cl)
764
{
765
	struct hbm_client_connect_request req;
766

767 768
	return mei_hbm_cl_write(dev, cl, CLIENT_CONNECT_REQ_CMD,
				&req, sizeof(req));
769 770
}

771
/**
772 773
 * mei_hbm_cl_connect_res - update the client state according
 *        connection response
774
 *
775
 * @dev: the device structure
776 777
 * @cl: mei host client
 * @cmd: connect client response host bus message
778
 */
779
static void mei_hbm_cl_connect_res(struct mei_device *dev, struct mei_cl *cl,
780
				   struct mei_hbm_cl_cmd *cmd)
781
{
782 783
	struct hbm_client_connect_response *rs =
		(struct hbm_client_connect_response *)cmd;
784

785
	cl_dbg(dev, cl, "hbm: connect response status=%s\n",
786
			mei_cl_conn_status_str(rs->status));
787

788 789
	if (rs->status == MEI_CL_CONN_SUCCESS)
		cl->state = MEI_FILE_CONNECTED;
790
	else {
791
		cl->state = MEI_FILE_DISCONNECT_REPLY;
792
		if (rs->status == MEI_CL_CONN_NOT_FOUND) {
793
			mei_me_cl_del(dev, cl->me_cl);
794 795 796
			if (dev->dev_state == MEI_DEV_ENABLED)
				schedule_work(&dev->bus_rescan_work);
		}
797
	}
798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
	cl->status = mei_cl_conn_status_to_errno(rs->status);
}

/**
 * mei_hbm_cl_res - process hbm response received on behalf
 *         an client
 *
 * @dev: the device structure
 * @rs:  hbm client message
 * @fop_type: file operation type
 */
static void mei_hbm_cl_res(struct mei_device *dev,
			   struct mei_hbm_cl_cmd *rs,
			   enum mei_cb_file_ops fop_type)
{
	struct mei_cl *cl;
	struct mei_cl_cb *cb, *next;
815

816
	cl = NULL;
817
	list_for_each_entry_safe(cb, next, &dev->ctrl_rd_list, list) {
818

819
		cl = cb->cl;
820

821
		if (cb->fop_type != fop_type)
822
			continue;
823

824
		if (mei_hbm_cl_addr_equal(cl, rs)) {
825
			list_del_init(&cb->list);
826
			break;
827 828
		}
	}
829 830 831 832

	if (!cl)
		return;

833 834
	switch (fop_type) {
	case MEI_FOP_CONNECT:
835
		mei_hbm_cl_connect_res(dev, cl, rs);
836 837
		break;
	case MEI_FOP_DISCONNECT:
838
		mei_hbm_cl_disconnect_res(dev, cl, rs);
839
		break;
840 841 842 843 844 845
	case MEI_FOP_NOTIFY_START:
		mei_hbm_cl_notify_start_res(dev, cl, rs);
		break;
	case MEI_FOP_NOTIFY_STOP:
		mei_hbm_cl_notify_stop_res(dev, cl, rs);
		break;
846 847 848 849
	default:
		return;
	}

850
	cl->timer_count = 0;
851
	wake_up(&cl->wait);
852 853 854
}


855
/**
856 857
 * mei_hbm_fw_disconnect_req - disconnect request initiated by ME firmware
 *  host sends disconnect response
858 859
 *
 * @dev: the device structure.
860
 * @disconnect_req: disconnect request bus message from the me
Tomas Winkler's avatar
Tomas Winkler committed
861
 *
862
 * Return: -ENOMEM on allocation failure
863
 */
Tomas Winkler's avatar
Tomas Winkler committed
864
static int mei_hbm_fw_disconnect_req(struct mei_device *dev,
865 866
		struct hbm_client_connect_request *disconnect_req)
{
867
	struct mei_cl *cl;
Tomas Winkler's avatar
Tomas Winkler committed
868
	struct mei_cl_cb *cb;
869

870 871
	cl = mei_hbm_cl_find_by_cmd(dev, disconnect_req);
	if (cl) {
872
		cl_warn(dev, cl, "fw disconnect request received\n");
873
		cl->state = MEI_FILE_DISCONNECTING;
874 875
		cl->timer_count = 0;

876 877
		cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DISCONNECT_RSP,
					       NULL);
878 879
		if (!cb)
			return -ENOMEM;
880
	}
Tomas Winkler's avatar
Tomas Winkler committed
881
	return 0;
882 883
}

884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905
/**
 * mei_hbm_pg_enter_res - PG enter response received
 *
 * @dev: the device structure.
 *
 * Return: 0 on success, -EPROTO on state mismatch
 */
static int mei_hbm_pg_enter_res(struct mei_device *dev)
{
	if (mei_pg_state(dev) != MEI_PG_OFF ||
	    dev->pg_event != MEI_PG_EVENT_WAIT) {
		dev_err(dev->dev, "hbm: pg entry response: state mismatch [%s, %d]\n",
			mei_pg_state_str(mei_pg_state(dev)), dev->pg_event);
		return -EPROTO;
	}

	dev->pg_event = MEI_PG_EVENT_RECEIVED;
	wake_up(&dev->wait_pg);

	return 0;
}

906 907 908 909 910 911 912 913 914 915 916
/**
 * mei_hbm_pg_resume - process with PG resume
 *
 * @dev: the device structure.
 */
void mei_hbm_pg_resume(struct mei_device *dev)
{
	pm_request_resume(dev->dev);
}
EXPORT_SYMBOL_GPL(mei_hbm_pg_resume);

917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945
/**
 * mei_hbm_pg_exit_res - PG exit response received
 *
 * @dev: the device structure.
 *
 * Return: 0 on success, -EPROTO on state mismatch
 */
static int mei_hbm_pg_exit_res(struct mei_device *dev)
{
	if (mei_pg_state(dev) != MEI_PG_ON ||
	    (dev->pg_event != MEI_PG_EVENT_WAIT &&
	     dev->pg_event != MEI_PG_EVENT_IDLE)) {
		dev_err(dev->dev, "hbm: pg exit response: state mismatch [%s, %d]\n",
			mei_pg_state_str(mei_pg_state(dev)), dev->pg_event);
		return -EPROTO;
	}

	switch (dev->pg_event) {
	case MEI_PG_EVENT_WAIT:
		dev->pg_event = MEI_PG_EVENT_RECEIVED;
		wake_up(&dev->wait_pg);
		break;
	case MEI_PG_EVENT_IDLE:
		/*
		* If the driver is not waiting on this then
		* this is HW initiated exit from PG.
		* Start runtime pm resume sequence to exit from PG.
		*/
		dev->pg_event = MEI_PG_EVENT_RECEIVED;
946
		mei_hbm_pg_resume(dev);
947 948 949 950 951 952 953 954 955 956
		break;
	default:
		WARN(1, "hbm: pg exit response: unexpected pg event = %d\n",
		     dev->pg_event);
		return -EPROTO;
	}

	return 0;
}

957
/**
958
 * mei_hbm_config_features - check what hbm features and commands
959 960 961 962 963 964 965 966 967 968 969 970 971 972
 *        are supported by the fw
 *
 * @dev: the device structure
 */
static void mei_hbm_config_features(struct mei_device *dev)
{
	/* Power Gating Isolation Support */
	dev->hbm_f_pg_supported = 0;
	if (dev->version.major_version > HBM_MAJOR_VERSION_PGI)
		dev->hbm_f_pg_supported = 1;

	if (dev->version.major_version == HBM_MAJOR_VERSION_PGI &&
	    dev->version.minor_version >= HBM_MINOR_VERSION_PGI)
		dev->hbm_f_pg_supported = 1;
973 974 975

	if (dev->version.major_version >= HBM_MAJOR_VERSION_DC)
		dev->hbm_f_dc_supported = 1;
976

977 978 979
	if (dev->version.major_version >= HBM_MAJOR_VERSION_IE)
		dev->hbm_f_ie_supported = 1;

980 981 982
	/* disconnect on connect timeout instead of link reset */
	if (dev->version.major_version >= HBM_MAJOR_VERSION_DOT)
		dev->hbm_f_dot_supported = 1;
983 984 985 986

	/* Notification Event Support */
	if (dev->version.major_version >= HBM_MAJOR_VERSION_EV)
		dev->hbm_f_ev_supported = 1;
987 988 989 990

	/* Fixed Address Client Support */
	if (dev->version.major_version >= HBM_MAJOR_VERSION_FA)
		dev->hbm_f_fa_supported = 1;
991 992 993 994

	/* OS ver message Support */
	if (dev->version.major_version >= HBM_MAJOR_VERSION_OS)
		dev->hbm_f_os_supported = 1;
995
}
996

Tomas Winkler's avatar
Tomas Winkler committed
997 998 999 1000 1001
/**
 * mei_hbm_version_is_supported - checks whether the driver can
 *     support the hbm version of the device
 *
 * @dev: the device structure
1002
 * Return: true if driver can support hbm version of the device
Tomas Winkler's avatar
Tomas Winkler committed
1003 1004 1005 1006 1007 1008 1009 1010
 */
bool mei_hbm_version_is_supported(struct mei_device *dev)
{
	return	(dev->version.major_version < HBM_MAJOR_VERSION) ||
		(dev->version.major_version == HBM_MAJOR_VERSION &&
		 dev->version.minor_version <= HBM_MINOR_VERSION);
}

1011 1012 1013 1014 1015
/**
 * mei_hbm_dispatch - bottom half read routine after ISR to
 * handle the read bus message cmd processing.
 *
 * @dev: the device structure
1016
 * @hdr: header of bus message
1017
 *
1018
 * Return: 0 on success and < 0 on failure
1019
 */
1020
int mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr)
1021 1022 1023 1024 1025
{
	struct mei_bus_message *mei_msg;
	struct hbm_host_version_response *version_res;
	struct hbm_props_response *props_res;
	struct hbm_host_enum_response *enum_res;
1026 1027
	struct hbm_add_client_request *add_cl_req;
	int ret;
1028

1029 1030
	struct mei_hbm_cl_cmd *cl_cmd;
	struct hbm_client_connect_request *disconnect_req;
1031
	struct hbm_flow_control *fctrl;
1032

1033 1034 1035 1036
	/* read the message to our buffer */
	BUG_ON(hdr->length >= sizeof(dev->rd_msg_buf));
	mei_read_slots(dev, dev->rd_msg_buf, hdr->length);
	mei_msg = (struct mei_bus_message *)dev->rd_msg_buf;
1037
	cl_cmd  = (struct mei_hbm_cl_cmd *)mei_msg;
1038

1039 1040 1041 1042
	/* ignore spurious message and prevent reset nesting
	 * hbm is put to idle during system reset
	 */
	if (dev->hbm_state == MEI_HBM_IDLE) {
1043
		dev_dbg(dev->dev, "hbm: state is idle ignore spurious messages\n");
1044 1045 1046
		return 0;
	}

1047 1048
	switch (mei_msg->hbm_cmd) {
	case HOST_START_RES_CMD:
1049
		dev_dbg(dev->dev, "hbm: start: response message received.\n");
1050 1051 1052

		dev->init_clients_timer = 0;

1053
		version_res = (struct hbm_host_version_response *)mei_msg;
Tomas Winkler's avatar
Tomas Winkler committed
1054

1055
		dev_dbg(dev->dev, "HBM VERSION: DRIVER=%02d:%02d DEVICE=%02d:%02d\n",
Tomas Winkler's avatar
Tomas Winkler committed
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070
				HBM_MAJOR_VERSION, HBM_MINOR_VERSION,
				version_res->me_max_version.major_version,
				version_res->me_max_version.minor_version);

		if (version_res->host_version_supported) {
			dev->version.major_version = HBM_MAJOR_VERSION;
			dev->version.minor_version = HBM_MINOR_VERSION;
		} else {
			dev->version.major_version =
				version_res->me_max_version.major_version;
			dev->version.minor_version =
				version_res->me_max_version.minor_version;
		}

		if (!mei_hbm_version_is_supported(dev)) {
1071
			dev_warn(dev->dev, "hbm: start: version mismatch - stopping the driver.\n");
1072

1073
			dev->hbm_state = MEI_HBM_STOPPED;
Tomas Winkler's avatar
Tomas Winkler committed
1074
			if (mei_hbm_stop_req(dev)) {
1075
				dev_err(dev->dev, "hbm: start: failed to send stop request\n");
1076 1077 1078 1079
				return -EIO;
			}
			break;
		}
1080

1081 1082
		mei_hbm_config_features(dev);

1083
		if (dev->dev_state != MEI_DEV_INIT_CLIENTS ||
1084
		    dev->hbm_state != MEI_HBM_STARTING) {
1085
			dev_err(dev->dev, "hbm: start: state mismatch, [%d, %d]\n",
1086 1087
				dev->dev_state, dev->hbm_state);
			return -EPROTO;
1088
		}
1089

1090
		if (mei_hbm_enum_clients_req(dev)) {
1091
			dev_err(dev->dev, "hbm: start: failed to send enumeration request\n");
1092
			return -EIO;
1093 1094
		}

1095
		wake_up(&dev->wait_hbm_start);
1096 1097 1098
		break;

	case CLIENT_CONNECT_RES_CMD:
1099
		dev_dbg(dev->dev, "hbm: client connect response: message received.\n");
Tomas Winkler's avatar