3 * Intel Management Engine Interface (Intel MEI) Linux driver
4 * Copyright (c) 2003-2012, Intel Corporation.
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.
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
17 #include <linux/pci.h>
18 #include <linux/sched.h>
19 #include <linux/wait.h>
20 #include <linux/mei.h>
27 * mei_hbm_me_cl_allocate - allocates storage for me clients
29 * @dev: the device structure
33 static void mei_hbm_me_cl_allocate(struct mei_device
*dev
)
35 struct mei_me_client
*clients
;
38 dev
->me_clients_num
= 0;
39 dev
->me_client_presentation_num
= 0;
40 dev
->me_client_index
= 0;
42 /* count how many ME clients we have */
43 for_each_set_bit(b
, dev
->me_clients_map
, MEI_CLIENTS_MAX
)
44 dev
->me_clients_num
++;
46 if (dev
->me_clients_num
== 0)
49 kfree(dev
->me_clients
);
50 dev
->me_clients
= NULL
;
52 dev_dbg(&dev
->pdev
->dev
, "memory allocation for ME clients size=%ld.\n",
53 dev
->me_clients_num
* sizeof(struct mei_me_client
));
54 /* allocate storage for ME clients representation */
55 clients
= kcalloc(dev
->me_clients_num
,
56 sizeof(struct mei_me_client
), GFP_KERNEL
);
58 dev_err(&dev
->pdev
->dev
, "memory allocation for ME clients failed.\n");
59 dev
->dev_state
= MEI_DEV_RESETTING
;
63 dev
->me_clients
= clients
;
68 * mei_hbm_cl_hdr - construct client hbm header
71 * @hbm_cmd: host bus message command
72 * @buf: buffer for cl header
76 void mei_hbm_cl_hdr(struct mei_cl
*cl
, u8 hbm_cmd
, void *buf
, size_t len
)
78 struct mei_hbm_cl_cmd
*cmd
= buf
;
82 cmd
->hbm_cmd
= hbm_cmd
;
83 cmd
->host_addr
= cl
->host_client_id
;
84 cmd
->me_addr
= cl
->me_client_id
;
88 * same_disconn_addr - tells if they have the same address
90 * @file: private data of the file object.
91 * @disconn: disconnection request.
93 * returns true if addres are same
96 bool mei_hbm_cl_addr_equal(struct mei_cl
*cl
, void *buf
)
98 struct mei_hbm_cl_cmd
*cmd
= buf
;
99 return cl
->host_client_id
== cmd
->host_addr
&&
100 cl
->me_client_id
== cmd
->me_addr
;
105 * is_treat_specially_client - checks if the message belongs
106 * to the file private data.
108 * @cl: private data of the file object
109 * @rs: connect response bus message
112 static bool is_treat_specially_client(struct mei_cl
*cl
,
113 struct hbm_client_connect_response
*rs
)
115 if (mei_hbm_cl_addr_equal(cl
, rs
)) {
117 cl
->state
= MEI_FILE_CONNECTED
;
121 cl
->state
= MEI_FILE_DISCONNECTED
;
122 cl
->status
= -ENODEV
;
131 int mei_hbm_start_wait(struct mei_device
*dev
)
134 if (dev
->hbm_state
> MEI_HBM_START
)
137 mutex_unlock(&dev
->device_lock
);
138 ret
= wait_event_interruptible_timeout(dev
->wait_recvd_msg
,
139 dev
->hbm_state
== MEI_HBM_IDLE
||
140 dev
->hbm_state
> MEI_HBM_START
,
141 mei_secs_to_jiffies(MEI_INTEROP_TIMEOUT
));
142 mutex_lock(&dev
->device_lock
);
144 if (ret
<= 0 && (dev
->hbm_state
<= MEI_HBM_START
)) {
145 dev
->hbm_state
= MEI_HBM_IDLE
;
146 dev_err(&dev
->pdev
->dev
, "waiting for mei start failed\n");
153 * mei_hbm_start_req - sends start request message.
155 * @dev: the device structure
157 int mei_hbm_start_req(struct mei_device
*dev
)
159 struct mei_msg_hdr
*mei_hdr
= &dev
->wr_msg
.hdr
;
160 struct hbm_host_version_request
*start_req
;
161 const size_t len
= sizeof(struct hbm_host_version_request
);
163 mei_hbm_hdr(mei_hdr
, len
);
165 /* host start message */
166 start_req
= (struct hbm_host_version_request
*)dev
->wr_msg
.data
;
167 memset(start_req
, 0, len
);
168 start_req
->hbm_cmd
= HOST_START_REQ_CMD
;
169 start_req
->host_version
.major_version
= HBM_MAJOR_VERSION
;
170 start_req
->host_version
.minor_version
= HBM_MINOR_VERSION
;
172 dev
->hbm_state
= MEI_HBM_IDLE
;
173 if (mei_write_message(dev
, mei_hdr
, dev
->wr_msg
.data
)) {
174 dev_err(&dev
->pdev
->dev
, "version message write failed\n");
175 dev
->dev_state
= MEI_DEV_RESETTING
;
179 dev
->hbm_state
= MEI_HBM_START
;
180 dev
->init_clients_timer
= MEI_CLIENTS_INIT_TIMEOUT
;
185 * mei_hbm_enum_clients_req - sends enumeration client request message.
187 * @dev: the device structure
191 static void mei_hbm_enum_clients_req(struct mei_device
*dev
)
193 struct mei_msg_hdr
*mei_hdr
= &dev
->wr_msg
.hdr
;
194 struct hbm_host_enum_request
*enum_req
;
195 const size_t len
= sizeof(struct hbm_host_enum_request
);
196 /* enumerate clients */
197 mei_hbm_hdr(mei_hdr
, len
);
199 enum_req
= (struct hbm_host_enum_request
*)dev
->wr_msg
.data
;
200 memset(enum_req
, 0, len
);
201 enum_req
->hbm_cmd
= HOST_ENUM_REQ_CMD
;
203 if (mei_write_message(dev
, mei_hdr
, dev
->wr_msg
.data
)) {
204 dev
->dev_state
= MEI_DEV_RESETTING
;
205 dev_err(&dev
->pdev
->dev
, "enumeration request write failed.\n");
208 dev
->hbm_state
= MEI_HBM_ENUM_CLIENTS
;
209 dev
->init_clients_timer
= MEI_CLIENTS_INIT_TIMEOUT
;
214 * mei_hbm_prop_req - request property for a single client
216 * @dev: the device structure
221 static int mei_hbm_prop_req(struct mei_device
*dev
)
224 struct mei_msg_hdr
*mei_hdr
= &dev
->wr_msg
.hdr
;
225 struct hbm_props_request
*prop_req
;
226 const size_t len
= sizeof(struct hbm_props_request
);
227 unsigned long next_client_index
;
228 unsigned long client_num
;
231 client_num
= dev
->me_client_presentation_num
;
233 next_client_index
= find_next_bit(dev
->me_clients_map
, MEI_CLIENTS_MAX
,
234 dev
->me_client_index
);
236 /* We got all client properties */
237 if (next_client_index
== MEI_CLIENTS_MAX
) {
238 dev
->hbm_state
= MEI_HBM_STARTED
;
239 schedule_work(&dev
->init_work
);
244 dev
->me_clients
[client_num
].client_id
= next_client_index
;
245 dev
->me_clients
[client_num
].mei_flow_ctrl_creds
= 0;
247 mei_hbm_hdr(mei_hdr
, len
);
248 prop_req
= (struct hbm_props_request
*)dev
->wr_msg
.data
;
250 memset(prop_req
, 0, sizeof(struct hbm_props_request
));
253 prop_req
->hbm_cmd
= HOST_CLIENT_PROPERTIES_REQ_CMD
;
254 prop_req
->address
= next_client_index
;
256 if (mei_write_message(dev
, mei_hdr
, dev
->wr_msg
.data
)) {
257 dev
->dev_state
= MEI_DEV_RESETTING
;
258 dev_err(&dev
->pdev
->dev
, "properties request write failed\n");
264 dev
->init_clients_timer
= MEI_CLIENTS_INIT_TIMEOUT
;
265 dev
->me_client_index
= next_client_index
;
271 * mei_hbm_stop_req_prepare - perpare stop request message
274 * @mei_hdr - mei message header
275 * @data - hbm message body buffer
277 static void mei_hbm_stop_req_prepare(struct mei_device
*dev
,
278 struct mei_msg_hdr
*mei_hdr
, unsigned char *data
)
280 struct hbm_host_stop_request
*req
=
281 (struct hbm_host_stop_request
*)data
;
282 const size_t len
= sizeof(struct hbm_host_stop_request
);
284 mei_hbm_hdr(mei_hdr
, len
);
287 req
->hbm_cmd
= HOST_STOP_REQ_CMD
;
288 req
->reason
= DRIVER_STOP_REQUEST
;
292 * mei_hbm_cl_flow_control_req - sends flow control requst.
294 * @dev: the device structure
297 * This function returns -EIO on write failure
299 int mei_hbm_cl_flow_control_req(struct mei_device
*dev
, struct mei_cl
*cl
)
301 struct mei_msg_hdr
*mei_hdr
= &dev
->wr_msg
.hdr
;
302 const size_t len
= sizeof(struct hbm_flow_control
);
304 mei_hbm_hdr(mei_hdr
, len
);
305 mei_hbm_cl_hdr(cl
, MEI_FLOW_CONTROL_CMD
, dev
->wr_msg
.data
, len
);
307 dev_dbg(&dev
->pdev
->dev
, "sending flow control host client = %d, ME client = %d\n",
308 cl
->host_client_id
, cl
->me_client_id
);
310 return mei_write_message(dev
, mei_hdr
, dev
->wr_msg
.data
);
314 * mei_hbm_add_single_flow_creds - adds single buffer credentials.
316 * @dev: the device structure
317 * @flow: flow control.
319 static void mei_hbm_add_single_flow_creds(struct mei_device
*dev
,
320 struct hbm_flow_control
*flow
)
322 struct mei_me_client
*client
;
325 for (i
= 0; i
< dev
->me_clients_num
; i
++) {
326 client
= &dev
->me_clients
[i
];
327 if (client
&& flow
->me_addr
== client
->client_id
) {
328 if (client
->props
.single_recv_buf
) {
329 client
->mei_flow_ctrl_creds
++;
330 dev_dbg(&dev
->pdev
->dev
, "recv flow ctrl msg ME %d (single).\n",
332 dev_dbg(&dev
->pdev
->dev
, "flow control credentials =%d.\n",
333 client
->mei_flow_ctrl_creds
);
335 BUG(); /* error in flow control */
342 * mei_hbm_cl_flow_control_res - flow control response from me
344 * @dev: the device structure
345 * @flow_control: flow control response bus message
347 static void mei_hbm_cl_flow_control_res(struct mei_device
*dev
,
348 struct hbm_flow_control
*flow_control
)
350 struct mei_cl
*cl
= NULL
;
351 struct mei_cl
*next
= NULL
;
353 if (!flow_control
->host_addr
) {
354 /* single receive buffer */
355 mei_hbm_add_single_flow_creds(dev
, flow_control
);
359 /* normal connection */
360 list_for_each_entry_safe(cl
, next
, &dev
->file_list
, link
) {
361 if (mei_hbm_cl_addr_equal(cl
, flow_control
)) {
362 cl
->mei_flow_ctrl_creds
++;
363 dev_dbg(&dev
->pdev
->dev
, "flow ctrl msg for host %d ME %d.\n",
364 flow_control
->host_addr
, flow_control
->me_addr
);
365 dev_dbg(&dev
->pdev
->dev
, "flow control credentials = %d.\n",
366 cl
->mei_flow_ctrl_creds
);
374 * mei_hbm_cl_disconnect_req - sends disconnect message to fw.
376 * @dev: the device structure
377 * @cl: a client to disconnect from
379 * This function returns -EIO on write failure
381 int mei_hbm_cl_disconnect_req(struct mei_device
*dev
, struct mei_cl
*cl
)
383 struct mei_msg_hdr
*mei_hdr
= &dev
->wr_msg
.hdr
;
384 const size_t len
= sizeof(struct hbm_client_connect_request
);
386 mei_hbm_hdr(mei_hdr
, len
);
387 mei_hbm_cl_hdr(cl
, CLIENT_DISCONNECT_REQ_CMD
, dev
->wr_msg
.data
, len
);
389 return mei_write_message(dev
, mei_hdr
, dev
->wr_msg
.data
);
393 * mei_hbm_cl_disconnect_res - disconnect response from ME
395 * @dev: the device structure
396 * @rs: disconnect response bus message
398 static void mei_hbm_cl_disconnect_res(struct mei_device
*dev
,
399 struct hbm_client_connect_response
*rs
)
402 struct mei_cl_cb
*pos
= NULL
, *next
= NULL
;
404 dev_dbg(&dev
->pdev
->dev
,
405 "disconnect_response:\n"
413 list_for_each_entry_safe(pos
, next
, &dev
->ctrl_rd_list
.list
, list
) {
417 list_del(&pos
->list
);
421 dev_dbg(&dev
->pdev
->dev
, "list_for_each_entry_safe in ctrl_rd_list.\n");
422 if (mei_hbm_cl_addr_equal(cl
, rs
)) {
423 list_del(&pos
->list
);
425 cl
->state
= MEI_FILE_DISCONNECTED
;
435 * mei_hbm_cl_connect_req - send connection request to specific me client
437 * @dev: the device structure
438 * @cl: a client to connect to
440 * returns -EIO on write failure
442 int mei_hbm_cl_connect_req(struct mei_device
*dev
, struct mei_cl
*cl
)
444 struct mei_msg_hdr
*mei_hdr
= &dev
->wr_msg
.hdr
;
445 const size_t len
= sizeof(struct hbm_client_connect_request
);
447 mei_hbm_hdr(mei_hdr
, len
);
448 mei_hbm_cl_hdr(cl
, CLIENT_CONNECT_REQ_CMD
, dev
->wr_msg
.data
, len
);
450 return mei_write_message(dev
, mei_hdr
, dev
->wr_msg
.data
);
454 * mei_hbm_cl_connect_res - connect resposne from the ME
456 * @dev: the device structure
457 * @rs: connect response bus message
459 static void mei_hbm_cl_connect_res(struct mei_device
*dev
,
460 struct hbm_client_connect_response
*rs
)
464 struct mei_cl_cb
*pos
= NULL
, *next
= NULL
;
466 dev_dbg(&dev
->pdev
->dev
,
467 "connect_response:\n"
475 /* if WD or iamthif client treat specially */
477 if (is_treat_specially_client(&dev
->wd_cl
, rs
)) {
478 dev_dbg(&dev
->pdev
->dev
, "successfully connected to WD client.\n");
479 mei_watchdog_register(dev
);
484 if (is_treat_specially_client(&dev
->iamthif_cl
, rs
)) {
485 dev
->iamthif_state
= MEI_IAMTHIF_IDLE
;
488 list_for_each_entry_safe(pos
, next
, &dev
->ctrl_rd_list
.list
, list
) {
492 list_del(&pos
->list
);
495 if (pos
->fop_type
== MEI_FOP_IOCTL
) {
496 if (is_treat_specially_client(cl
, rs
)) {
497 list_del(&pos
->list
);
508 * mei_hbm_fw_disconnect_req - disconnect request initiated by me
509 * host sends disoconnect response
511 * @dev: the device structure.
512 * @disconnect_req: disconnect request bus message from the me
514 static void mei_hbm_fw_disconnect_req(struct mei_device
*dev
,
515 struct hbm_client_connect_request
*disconnect_req
)
517 struct mei_cl
*cl
, *next
;
518 const size_t len
= sizeof(struct hbm_client_connect_response
);
520 list_for_each_entry_safe(cl
, next
, &dev
->file_list
, link
) {
521 if (mei_hbm_cl_addr_equal(cl
, disconnect_req
)) {
522 dev_dbg(&dev
->pdev
->dev
, "disconnect request host client %d ME client %d.\n",
523 disconnect_req
->host_addr
,
524 disconnect_req
->me_addr
);
525 cl
->state
= MEI_FILE_DISCONNECTED
;
527 if (cl
== &dev
->wd_cl
)
528 dev
->wd_pending
= false;
529 else if (cl
== &dev
->iamthif_cl
)
530 dev
->iamthif_timer
= 0;
532 /* prepare disconnect response */
533 mei_hbm_hdr(&dev
->wr_ext_msg
.hdr
, len
);
534 mei_hbm_cl_hdr(cl
, CLIENT_DISCONNECT_RES_CMD
,
535 dev
->wr_ext_msg
.data
, len
);
543 * mei_hbm_version_is_supported - checks whether the driver can
544 * support the hbm version of the device
546 * @dev: the device structure
547 * returns true if driver can support hbm version of the device
549 bool mei_hbm_version_is_supported(struct mei_device
*dev
)
551 return (dev
->version
.major_version
< HBM_MAJOR_VERSION
) ||
552 (dev
->version
.major_version
== HBM_MAJOR_VERSION
&&
553 dev
->version
.minor_version
<= HBM_MINOR_VERSION
);
557 * mei_hbm_dispatch - bottom half read routine after ISR to
558 * handle the read bus message cmd processing.
560 * @dev: the device structure
561 * @mei_hdr: header of bus message
563 void mei_hbm_dispatch(struct mei_device
*dev
, struct mei_msg_hdr
*hdr
)
565 struct mei_bus_message
*mei_msg
;
566 struct mei_me_client
*me_client
;
567 struct hbm_host_version_response
*version_res
;
568 struct hbm_client_connect_response
*connect_res
;
569 struct hbm_client_connect_response
*disconnect_res
;
570 struct hbm_client_connect_request
*disconnect_req
;
571 struct hbm_flow_control
*flow_control
;
572 struct hbm_props_response
*props_res
;
573 struct hbm_host_enum_response
*enum_res
;
575 /* read the message to our buffer */
576 BUG_ON(hdr
->length
>= sizeof(dev
->rd_msg_buf
));
577 mei_read_slots(dev
, dev
->rd_msg_buf
, hdr
->length
);
578 mei_msg
= (struct mei_bus_message
*)dev
->rd_msg_buf
;
580 switch (mei_msg
->hbm_cmd
) {
581 case HOST_START_RES_CMD
:
582 version_res
= (struct hbm_host_version_response
*)mei_msg
;
584 dev_dbg(&dev
->pdev
->dev
, "HBM VERSION: DRIVER=%02d:%02d DEVICE=%02d:%02d\n",
585 HBM_MAJOR_VERSION
, HBM_MINOR_VERSION
,
586 version_res
->me_max_version
.major_version
,
587 version_res
->me_max_version
.minor_version
);
589 if (version_res
->host_version_supported
) {
590 dev
->version
.major_version
= HBM_MAJOR_VERSION
;
591 dev
->version
.minor_version
= HBM_MINOR_VERSION
;
593 dev
->version
.major_version
=
594 version_res
->me_max_version
.major_version
;
595 dev
->version
.minor_version
=
596 version_res
->me_max_version
.minor_version
;
599 if (!mei_hbm_version_is_supported(dev
)) {
600 dev_warn(&dev
->pdev
->dev
, "hbm version mismatch: stopping the driver.\n");
602 dev
->hbm_state
= MEI_HBM_STOP
;
603 mei_hbm_stop_req_prepare(dev
, &dev
->wr_msg
.hdr
,
605 mei_write_message(dev
, &dev
->wr_msg
.hdr
,
611 if (dev
->dev_state
== MEI_DEV_INIT_CLIENTS
&&
612 dev
->hbm_state
== MEI_HBM_START
) {
613 dev
->init_clients_timer
= 0;
614 mei_hbm_enum_clients_req(dev
);
616 dev_err(&dev
->pdev
->dev
, "reset: wrong host start response\n");
621 wake_up_interruptible(&dev
->wait_recvd_msg
);
622 dev_dbg(&dev
->pdev
->dev
, "host start response message received.\n");
625 case CLIENT_CONNECT_RES_CMD
:
626 connect_res
= (struct hbm_client_connect_response
*) mei_msg
;
627 mei_hbm_cl_connect_res(dev
, connect_res
);
628 dev_dbg(&dev
->pdev
->dev
, "client connect response message received.\n");
629 wake_up(&dev
->wait_recvd_msg
);
632 case CLIENT_DISCONNECT_RES_CMD
:
633 disconnect_res
= (struct hbm_client_connect_response
*) mei_msg
;
634 mei_hbm_cl_disconnect_res(dev
, disconnect_res
);
635 dev_dbg(&dev
->pdev
->dev
, "client disconnect response message received.\n");
636 wake_up(&dev
->wait_recvd_msg
);
639 case MEI_FLOW_CONTROL_CMD
:
640 flow_control
= (struct hbm_flow_control
*) mei_msg
;
641 mei_hbm_cl_flow_control_res(dev
, flow_control
);
642 dev_dbg(&dev
->pdev
->dev
, "client flow control response message received.\n");
645 case HOST_CLIENT_PROPERTIES_RES_CMD
:
646 props_res
= (struct hbm_props_response
*)mei_msg
;
647 me_client
= &dev
->me_clients
[dev
->me_client_presentation_num
];
649 if (props_res
->status
|| !dev
->me_clients
) {
650 dev_err(&dev
->pdev
->dev
, "reset: properties response hbm wrong status.\n");
655 if (me_client
->client_id
!= props_res
->address
) {
656 dev_err(&dev
->pdev
->dev
, "reset: host properties response address mismatch\n");
661 if (dev
->dev_state
!= MEI_DEV_INIT_CLIENTS
||
662 dev
->hbm_state
!= MEI_HBM_CLIENT_PROPERTIES
) {
663 dev_err(&dev
->pdev
->dev
, "reset: unexpected properties response\n");
669 me_client
->props
= props_res
->client_properties
;
670 dev
->me_client_index
++;
671 dev
->me_client_presentation_num
++;
673 /* request property for the next client */
674 mei_hbm_prop_req(dev
);
678 case HOST_ENUM_RES_CMD
:
679 enum_res
= (struct hbm_host_enum_response
*) mei_msg
;
680 BUILD_BUG_ON(sizeof(dev
->me_clients_map
)
681 < sizeof(enum_res
->valid_addresses
));
682 memcpy(dev
->me_clients_map
, enum_res
->valid_addresses
,
683 sizeof(enum_res
->valid_addresses
));
684 if (dev
->dev_state
== MEI_DEV_INIT_CLIENTS
&&
685 dev
->hbm_state
== MEI_HBM_ENUM_CLIENTS
) {
686 dev
->init_clients_timer
= 0;
687 mei_hbm_me_cl_allocate(dev
);
688 dev
->hbm_state
= MEI_HBM_CLIENT_PROPERTIES
;
690 /* first property reqeust */
691 mei_hbm_prop_req(dev
);
693 dev_err(&dev
->pdev
->dev
, "reset: unexpected enumeration response hbm.\n");
699 case HOST_STOP_RES_CMD
:
701 if (dev
->hbm_state
!= MEI_HBM_STOP
)
702 dev_err(&dev
->pdev
->dev
, "unexpected stop response hbm.\n");
703 dev
->dev_state
= MEI_DEV_DISABLED
;
704 dev_info(&dev
->pdev
->dev
, "reset: FW stop response.\n");
708 case CLIENT_DISCONNECT_REQ_CMD
:
709 /* search for client */
710 disconnect_req
= (struct hbm_client_connect_request
*)mei_msg
;
711 mei_hbm_fw_disconnect_req(dev
, disconnect_req
);
714 case ME_STOP_REQ_CMD
:
716 dev
->hbm_state
= MEI_HBM_STOP
;
717 mei_hbm_stop_req_prepare(dev
, &dev
->wr_ext_msg
.hdr
,
718 dev
->wr_ext_msg
.data
);