1 /*
2 * ISHTP bus layer messages handling
3 *
4 * Copyright (c) 2003-2016, Intel Corporation.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 */
16
17 #include <linux/export.h>
18 #include <linux/slab.h>
19 #include <linux/sched.h>
20 #include <linux/wait.h>
21 #include <linux/spinlock.h>
22 #include "ishtp-dev.h"
23 #include "hbm.h"
24 #include "client.h"
25
26 /**
27 * ishtp_hbm_fw_cl_allocate() - Allocate FW clients
28 * @dev: ISHTP device instance
29 *
30 * Allocates storage for fw clients
31 */
ishtp_hbm_fw_cl_allocate(struct ishtp_device * dev)32 static void ishtp_hbm_fw_cl_allocate(struct ishtp_device *dev)
33 {
34 struct ishtp_fw_client *clients;
35 int b;
36
37 /* count how many ISH clients we have */
38 for_each_set_bit(b, dev->fw_clients_map, ISHTP_CLIENTS_MAX)
39 dev->fw_clients_num++;
40
41 if (dev->fw_clients_num <= 0)
42 return;
43
44 /* allocate storage for fw clients representation */
45 clients = kcalloc(dev->fw_clients_num, sizeof(struct ishtp_fw_client),
46 GFP_KERNEL);
47 if (!clients) {
48 dev->dev_state = ISHTP_DEV_RESETTING;
49 ish_hw_reset(dev);
50 return;
51 }
52 dev->fw_clients = clients;
53 }
54
55 /**
56 * ishtp_hbm_cl_hdr() - construct client hbm header
57 * @cl: client
58 * @hbm_cmd: host bus message command
59 * @buf: buffer for cl header
60 * @len: buffer length
61 *
62 * Initialize HBM buffer
63 */
ishtp_hbm_cl_hdr(struct ishtp_cl * cl,uint8_t hbm_cmd,void * buf,size_t len)64 static inline void ishtp_hbm_cl_hdr(struct ishtp_cl *cl, uint8_t hbm_cmd,
65 void *buf, size_t len)
66 {
67 struct ishtp_hbm_cl_cmd *cmd = buf;
68
69 memset(cmd, 0, len);
70
71 cmd->hbm_cmd = hbm_cmd;
72 cmd->host_addr = cl->host_client_id;
73 cmd->fw_addr = cl->fw_client_id;
74 }
75
76 /**
77 * ishtp_hbm_cl_addr_equal() - Compare client address
78 * @cl: client
79 * @buf: Client command buffer
80 *
81 * Compare client address with the address in command buffer
82 *
83 * Return: True if they have the same address
84 */
ishtp_hbm_cl_addr_equal(struct ishtp_cl * cl,void * buf)85 static inline bool ishtp_hbm_cl_addr_equal(struct ishtp_cl *cl, void *buf)
86 {
87 struct ishtp_hbm_cl_cmd *cmd = buf;
88
89 return cl->host_client_id == cmd->host_addr &&
90 cl->fw_client_id == cmd->fw_addr;
91 }
92
93 /**
94 * ishtp_hbm_start_wait() - Wait for HBM start message
95 * @dev: ISHTP device instance
96 *
97 * Wait for HBM start message from firmware
98 *
99 * Return: 0 if HBM start is/was received else timeout error
100 */
ishtp_hbm_start_wait(struct ishtp_device * dev)101 int ishtp_hbm_start_wait(struct ishtp_device *dev)
102 {
103 int ret;
104
105 if (dev->hbm_state > ISHTP_HBM_START)
106 return 0;
107
108 dev_dbg(dev->devc, "Going to wait for ishtp start. hbm_state=%08X\n",
109 dev->hbm_state);
110 ret = wait_event_interruptible_timeout(dev->wait_hbm_recvd_msg,
111 dev->hbm_state >= ISHTP_HBM_STARTED,
112 (ISHTP_INTEROP_TIMEOUT * HZ));
113
114 dev_dbg(dev->devc,
115 "Woke up from waiting for ishtp start. hbm_state=%08X\n",
116 dev->hbm_state);
117
118 if (ret <= 0 && (dev->hbm_state <= ISHTP_HBM_START)) {
119 dev->hbm_state = ISHTP_HBM_IDLE;
120 dev_err(dev->devc,
121 "waiting for ishtp start failed. ret=%d hbm_state=%08X\n",
122 ret, dev->hbm_state);
123 return -ETIMEDOUT;
124 }
125 return 0;
126 }
127
128 /**
129 * ishtp_hbm_start_req() - Send HBM start message
130 * @dev: ISHTP device instance
131 *
132 * Send HBM start message to firmware
133 *
134 * Return: 0 if success else error code
135 */
ishtp_hbm_start_req(struct ishtp_device * dev)136 int ishtp_hbm_start_req(struct ishtp_device *dev)
137 {
138 struct ishtp_msg_hdr hdr;
139 unsigned char data[128];
140 struct ishtp_msg_hdr *ishtp_hdr = &hdr;
141 struct hbm_host_version_request *start_req;
142 const size_t len = sizeof(struct hbm_host_version_request);
143
144 ishtp_hbm_hdr(ishtp_hdr, len);
145
146 /* host start message */
147 start_req = (struct hbm_host_version_request *)data;
148 memset(start_req, 0, len);
149 start_req->hbm_cmd = HOST_START_REQ_CMD;
150 start_req->host_version.major_version = HBM_MAJOR_VERSION;
151 start_req->host_version.minor_version = HBM_MINOR_VERSION;
152
153 /*
154 * (!) Response to HBM start may be so quick that this thread would get
155 * preempted BEFORE managing to set hbm_state = ISHTP_HBM_START.
156 * So set it at first, change back to ISHTP_HBM_IDLE upon failure
157 */
158 dev->hbm_state = ISHTP_HBM_START;
159 if (ishtp_write_message(dev, ishtp_hdr, data)) {
160 dev_err(dev->devc, "version message send failed\n");
161 dev->dev_state = ISHTP_DEV_RESETTING;
162 dev->hbm_state = ISHTP_HBM_IDLE;
163 ish_hw_reset(dev);
164 return -ENODEV;
165 }
166
167 return 0;
168 }
169
170 /**
171 * ishtp_hbm_enum_clients_req() - Send client enum req
172 * @dev: ISHTP device instance
173 *
174 * Send enumeration client request message
175 *
176 * Return: 0 if success else error code
177 */
ishtp_hbm_enum_clients_req(struct ishtp_device * dev)178 void ishtp_hbm_enum_clients_req(struct ishtp_device *dev)
179 {
180 struct ishtp_msg_hdr hdr;
181 unsigned char data[128];
182 struct ishtp_msg_hdr *ishtp_hdr = &hdr;
183 struct hbm_host_enum_request *enum_req;
184 const size_t len = sizeof(struct hbm_host_enum_request);
185
186 /* enumerate clients */
187 ishtp_hbm_hdr(ishtp_hdr, len);
188
189 enum_req = (struct hbm_host_enum_request *)data;
190 memset(enum_req, 0, len);
191 enum_req->hbm_cmd = HOST_ENUM_REQ_CMD;
192
193 if (ishtp_write_message(dev, ishtp_hdr, data)) {
194 dev->dev_state = ISHTP_DEV_RESETTING;
195 dev_err(dev->devc, "enumeration request send failed\n");
196 ish_hw_reset(dev);
197 }
198 dev->hbm_state = ISHTP_HBM_ENUM_CLIENTS;
199 }
200
201 /**
202 * ishtp_hbm_prop_req() - Request property
203 * @dev: ISHTP device instance
204 *
205 * Request property for a single client
206 *
207 * Return: 0 if success else error code
208 */
ishtp_hbm_prop_req(struct ishtp_device * dev)209 static int ishtp_hbm_prop_req(struct ishtp_device *dev)
210 {
211
212 struct ishtp_msg_hdr hdr;
213 unsigned char data[128];
214 struct ishtp_msg_hdr *ishtp_hdr = &hdr;
215 struct hbm_props_request *prop_req;
216 const size_t len = sizeof(struct hbm_props_request);
217 unsigned long next_client_index;
218 uint8_t client_num;
219
220 client_num = dev->fw_client_presentation_num;
221
222 next_client_index = find_next_bit(dev->fw_clients_map,
223 ISHTP_CLIENTS_MAX, dev->fw_client_index);
224
225 /* We got all client properties */
226 if (next_client_index == ISHTP_CLIENTS_MAX) {
227 dev->hbm_state = ISHTP_HBM_WORKING;
228 dev->dev_state = ISHTP_DEV_ENABLED;
229
230 for (dev->fw_client_presentation_num = 1;
231 dev->fw_client_presentation_num < client_num + 1;
232 ++dev->fw_client_presentation_num)
233 /* Add new client device */
234 ishtp_bus_new_client(dev);
235 return 0;
236 }
237
238 dev->fw_clients[client_num].client_id = next_client_index;
239
240 ishtp_hbm_hdr(ishtp_hdr, len);
241 prop_req = (struct hbm_props_request *)data;
242
243 memset(prop_req, 0, sizeof(struct hbm_props_request));
244
245 prop_req->hbm_cmd = HOST_CLIENT_PROPERTIES_REQ_CMD;
246 prop_req->address = next_client_index;
247
248 if (ishtp_write_message(dev, ishtp_hdr, data)) {
249 dev->dev_state = ISHTP_DEV_RESETTING;
250 dev_err(dev->devc, "properties request send failed\n");
251 ish_hw_reset(dev);
252 return -EIO;
253 }
254
255 dev->fw_client_index = next_client_index;
256
257 return 0;
258 }
259
260 /**
261 * ishtp_hbm_stop_req() - Send HBM stop
262 * @dev: ISHTP device instance
263 *
264 * Send stop request message
265 */
ishtp_hbm_stop_req(struct ishtp_device * dev)266 static void ishtp_hbm_stop_req(struct ishtp_device *dev)
267 {
268 struct ishtp_msg_hdr hdr;
269 unsigned char data[128];
270 struct ishtp_msg_hdr *ishtp_hdr = &hdr;
271 struct hbm_host_stop_request *req;
272 const size_t len = sizeof(struct hbm_host_stop_request);
273
274 ishtp_hbm_hdr(ishtp_hdr, len);
275 req = (struct hbm_host_stop_request *)data;
276
277 memset(req, 0, sizeof(struct hbm_host_stop_request));
278 req->hbm_cmd = HOST_STOP_REQ_CMD;
279 req->reason = DRIVER_STOP_REQUEST;
280
281 ishtp_write_message(dev, ishtp_hdr, data);
282 }
283
284 /**
285 * ishtp_hbm_cl_flow_control_req() - Send flow control request
286 * @dev: ISHTP device instance
287 * @cl: ISHTP client instance
288 *
289 * Send flow control request
290 *
291 * Return: 0 if success else error code
292 */
ishtp_hbm_cl_flow_control_req(struct ishtp_device * dev,struct ishtp_cl * cl)293 int ishtp_hbm_cl_flow_control_req(struct ishtp_device *dev,
294 struct ishtp_cl *cl)
295 {
296 struct ishtp_msg_hdr hdr;
297 unsigned char data[128];
298 struct ishtp_msg_hdr *ishtp_hdr = &hdr;
299 const size_t len = sizeof(struct hbm_flow_control);
300 int rv;
301 unsigned long flags;
302
303 spin_lock_irqsave(&cl->fc_spinlock, flags);
304 ishtp_hbm_hdr(ishtp_hdr, len);
305 ishtp_hbm_cl_hdr(cl, ISHTP_FLOW_CONTROL_CMD, data, len);
306
307 /*
308 * Sync possible race when RB recycle and packet receive paths
309 * both try to send an out FC
310 */
311 if (cl->out_flow_ctrl_creds) {
312 spin_unlock_irqrestore(&cl->fc_spinlock, flags);
313 return 0;
314 }
315
316 cl->recv_msg_num_frags = 0;
317
318 rv = ishtp_write_message(dev, ishtp_hdr, data);
319 if (!rv) {
320 ++cl->out_flow_ctrl_creds;
321 ++cl->out_flow_ctrl_cnt;
322 cl->ts_out_fc = ktime_get();
323 if (cl->ts_rx) {
324 ktime_t ts_diff = ktime_sub(cl->ts_out_fc, cl->ts_rx);
325 if (ktime_after(ts_diff, cl->ts_max_fc_delay))
326 cl->ts_max_fc_delay = ts_diff;
327 }
328 } else {
329 ++cl->err_send_fc;
330 }
331
332 spin_unlock_irqrestore(&cl->fc_spinlock, flags);
333 return rv;
334 }
335
336 /**
337 * ishtp_hbm_cl_disconnect_req() - Send disconnect request
338 * @dev: ISHTP device instance
339 * @cl: ISHTP client instance
340 *
341 * Send disconnect message to fw
342 *
343 * Return: 0 if success else error code
344 */
ishtp_hbm_cl_disconnect_req(struct ishtp_device * dev,struct ishtp_cl * cl)345 int ishtp_hbm_cl_disconnect_req(struct ishtp_device *dev, struct ishtp_cl *cl)
346 {
347 struct ishtp_msg_hdr hdr;
348 unsigned char data[128];
349 struct ishtp_msg_hdr *ishtp_hdr = &hdr;
350 const size_t len = sizeof(struct hbm_client_connect_request);
351
352 ishtp_hbm_hdr(ishtp_hdr, len);
353 ishtp_hbm_cl_hdr(cl, CLIENT_DISCONNECT_REQ_CMD, data, len);
354
355 return ishtp_write_message(dev, ishtp_hdr, data);
356 }
357
358 /**
359 * ishtp_hbm_cl_disconnect_res() - Get disconnect response
360 * @dev: ISHTP device instance
361 * @rs: Response message
362 *
363 * Received disconnect response from fw
364 */
ishtp_hbm_cl_disconnect_res(struct ishtp_device * dev,struct hbm_client_connect_response * rs)365 static void ishtp_hbm_cl_disconnect_res(struct ishtp_device *dev,
366 struct hbm_client_connect_response *rs)
367 {
368 struct ishtp_cl *cl = NULL;
369 unsigned long flags;
370
371 spin_lock_irqsave(&dev->cl_list_lock, flags);
372 list_for_each_entry(cl, &dev->cl_list, link) {
373 if (!rs->status && ishtp_hbm_cl_addr_equal(cl, rs)) {
374 cl->state = ISHTP_CL_DISCONNECTED;
375 wake_up_interruptible(&cl->wait_ctrl_res);
376 break;
377 }
378 }
379 spin_unlock_irqrestore(&dev->cl_list_lock, flags);
380 }
381
382 /**
383 * ishtp_hbm_cl_connect_req() - Send connect request
384 * @dev: ISHTP device instance
385 * @cl: client device instance
386 *
387 * Send connection request to specific fw client
388 *
389 * Return: 0 if success else error code
390 */
ishtp_hbm_cl_connect_req(struct ishtp_device * dev,struct ishtp_cl * cl)391 int ishtp_hbm_cl_connect_req(struct ishtp_device *dev, struct ishtp_cl *cl)
392 {
393 struct ishtp_msg_hdr hdr;
394 unsigned char data[128];
395 struct ishtp_msg_hdr *ishtp_hdr = &hdr;
396 const size_t len = sizeof(struct hbm_client_connect_request);
397
398 ishtp_hbm_hdr(ishtp_hdr, len);
399 ishtp_hbm_cl_hdr(cl, CLIENT_CONNECT_REQ_CMD, data, len);
400
401 return ishtp_write_message(dev, ishtp_hdr, data);
402 }
403
404 /**
405 * ishtp_hbm_cl_connect_res() - Get connect response
406 * @dev: ISHTP device instance
407 * @rs: Response message
408 *
409 * Received connect response from fw
410 */
ishtp_hbm_cl_connect_res(struct ishtp_device * dev,struct hbm_client_connect_response * rs)411 static void ishtp_hbm_cl_connect_res(struct ishtp_device *dev,
412 struct hbm_client_connect_response *rs)
413 {
414 struct ishtp_cl *cl = NULL;
415 unsigned long flags;
416
417 spin_lock_irqsave(&dev->cl_list_lock, flags);
418 list_for_each_entry(cl, &dev->cl_list, link) {
419 if (ishtp_hbm_cl_addr_equal(cl, rs)) {
420 if (!rs->status) {
421 cl->state = ISHTP_CL_CONNECTED;
422 cl->status = 0;
423 } else {
424 cl->state = ISHTP_CL_DISCONNECTED;
425 cl->status = -ENODEV;
426 }
427 wake_up_interruptible(&cl->wait_ctrl_res);
428 break;
429 }
430 }
431 spin_unlock_irqrestore(&dev->cl_list_lock, flags);
432 }
433
434 /**
435 * ishtp_client_disconnect_request() - Receive disconnect request
436 * @dev: ISHTP device instance
437 * @disconnect_req: disconnect request structure
438 *
439 * Disconnect request bus message from the fw. Send diconnect response.
440 */
ishtp_hbm_fw_disconnect_req(struct ishtp_device * dev,struct hbm_client_connect_request * disconnect_req)441 static void ishtp_hbm_fw_disconnect_req(struct ishtp_device *dev,
442 struct hbm_client_connect_request *disconnect_req)
443 {
444 struct ishtp_cl *cl;
445 const size_t len = sizeof(struct hbm_client_connect_response);
446 unsigned long flags;
447 struct ishtp_msg_hdr hdr;
448 unsigned char data[4]; /* All HBM messages are 4 bytes */
449
450 spin_lock_irqsave(&dev->cl_list_lock, flags);
451 list_for_each_entry(cl, &dev->cl_list, link) {
452 if (ishtp_hbm_cl_addr_equal(cl, disconnect_req)) {
453 cl->state = ISHTP_CL_DISCONNECTED;
454
455 /* send disconnect response */
456 ishtp_hbm_hdr(&hdr, len);
457 ishtp_hbm_cl_hdr(cl, CLIENT_DISCONNECT_RES_CMD, data,
458 len);
459 ishtp_write_message(dev, &hdr, data);
460 break;
461 }
462 }
463 spin_unlock_irqrestore(&dev->cl_list_lock, flags);
464 }
465
466 /**
467 * ishtp_hbm_dma_xfer_ack(() - Receive transfer ACK
468 * @dev: ISHTP device instance
469 * @dma_xfer: HBM transfer message
470 *
471 * Receive ack for ISHTP-over-DMA client message
472 */
ishtp_hbm_dma_xfer_ack(struct ishtp_device * dev,struct dma_xfer_hbm * dma_xfer)473 static void ishtp_hbm_dma_xfer_ack(struct ishtp_device *dev,
474 struct dma_xfer_hbm *dma_xfer)
475 {
476 void *msg;
477 uint64_t offs;
478 struct ishtp_msg_hdr *ishtp_hdr =
479 (struct ishtp_msg_hdr *)&dev->ishtp_msg_hdr;
480 unsigned int msg_offs;
481 struct ishtp_cl *cl;
482
483 for (msg_offs = 0; msg_offs < ishtp_hdr->length;
484 msg_offs += sizeof(struct dma_xfer_hbm)) {
485 offs = dma_xfer->msg_addr - dev->ishtp_host_dma_tx_buf_phys;
486 if (offs > dev->ishtp_host_dma_tx_buf_size) {
487 dev_err(dev->devc, "Bad DMA Tx ack message address\n");
488 return;
489 }
490 if (dma_xfer->msg_length >
491 dev->ishtp_host_dma_tx_buf_size - offs) {
492 dev_err(dev->devc, "Bad DMA Tx ack message size\n");
493 return;
494 }
495
496 /* logical address of the acked mem */
497 msg = (unsigned char *)dev->ishtp_host_dma_tx_buf + offs;
498 ishtp_cl_release_dma_acked_mem(dev, msg, dma_xfer->msg_length);
499
500 list_for_each_entry(cl, &dev->cl_list, link) {
501 if (cl->fw_client_id == dma_xfer->fw_client_id &&
502 cl->host_client_id == dma_xfer->host_client_id)
503 /*
504 * in case that a single ack may be sent
505 * over several dma transfers, and the last msg
506 * addr was inside the acked memory, but not in
507 * its start
508 */
509 if (cl->last_dma_addr >=
510 (unsigned char *)msg &&
511 cl->last_dma_addr <
512 (unsigned char *)msg +
513 dma_xfer->msg_length) {
514 cl->last_dma_acked = 1;
515
516 if (!list_empty(&cl->tx_list.list) &&
517 cl->ishtp_flow_ctrl_creds) {
518 /*
519 * start sending the first msg
520 */
521 ishtp_cl_send_msg(dev, cl);
522 }
523 }
524 }
525 ++dma_xfer;
526 }
527 }
528
529 /**
530 * ishtp_hbm_dma_xfer() - Receive DMA transfer message
531 * @dev: ISHTP device instance
532 * @dma_xfer: HBM transfer message
533 *
534 * Receive ISHTP-over-DMA client message
535 */
ishtp_hbm_dma_xfer(struct ishtp_device * dev,struct dma_xfer_hbm * dma_xfer)536 static void ishtp_hbm_dma_xfer(struct ishtp_device *dev,
537 struct dma_xfer_hbm *dma_xfer)
538 {
539 void *msg;
540 uint64_t offs;
541 struct ishtp_msg_hdr hdr;
542 struct ishtp_msg_hdr *ishtp_hdr =
543 (struct ishtp_msg_hdr *) &dev->ishtp_msg_hdr;
544 struct dma_xfer_hbm *prm = dma_xfer;
545 unsigned int msg_offs;
546
547 for (msg_offs = 0; msg_offs < ishtp_hdr->length;
548 msg_offs += sizeof(struct dma_xfer_hbm)) {
549
550 offs = dma_xfer->msg_addr - dev->ishtp_host_dma_rx_buf_phys;
551 if (offs > dev->ishtp_host_dma_rx_buf_size) {
552 dev_err(dev->devc, "Bad DMA Rx message address\n");
553 return;
554 }
555 if (dma_xfer->msg_length >
556 dev->ishtp_host_dma_rx_buf_size - offs) {
557 dev_err(dev->devc, "Bad DMA Rx message size\n");
558 return;
559 }
560 msg = dev->ishtp_host_dma_rx_buf + offs;
561 recv_ishtp_cl_msg_dma(dev, msg, dma_xfer);
562 dma_xfer->hbm = DMA_XFER_ACK; /* Prepare for response */
563 ++dma_xfer;
564 }
565
566 /* Send DMA_XFER_ACK [...] */
567 ishtp_hbm_hdr(&hdr, ishtp_hdr->length);
568 ishtp_write_message(dev, &hdr, (unsigned char *)prm);
569 }
570
571 /**
572 * ishtp_hbm_dispatch() - HBM dispatch function
573 * @dev: ISHTP device instance
574 * @hdr: bus message
575 *
576 * Bottom half read routine after ISR to handle the read bus message cmd
577 * processing
578 */
ishtp_hbm_dispatch(struct ishtp_device * dev,struct ishtp_bus_message * hdr)579 void ishtp_hbm_dispatch(struct ishtp_device *dev,
580 struct ishtp_bus_message *hdr)
581 {
582 struct ishtp_bus_message *ishtp_msg;
583 struct ishtp_fw_client *fw_client;
584 struct hbm_host_version_response *version_res;
585 struct hbm_client_connect_response *connect_res;
586 struct hbm_client_connect_response *disconnect_res;
587 struct hbm_client_connect_request *disconnect_req;
588 struct hbm_props_response *props_res;
589 struct hbm_host_enum_response *enum_res;
590 struct ishtp_msg_hdr ishtp_hdr;
591 struct dma_alloc_notify dma_alloc_notify;
592 struct dma_xfer_hbm *dma_xfer;
593
594 ishtp_msg = hdr;
595
596 switch (ishtp_msg->hbm_cmd) {
597 case HOST_START_RES_CMD:
598 version_res = (struct hbm_host_version_response *)ishtp_msg;
599 if (!version_res->host_version_supported) {
600 dev->version = version_res->fw_max_version;
601
602 dev->hbm_state = ISHTP_HBM_STOPPED;
603 ishtp_hbm_stop_req(dev);
604 return;
605 }
606
607 dev->version.major_version = HBM_MAJOR_VERSION;
608 dev->version.minor_version = HBM_MINOR_VERSION;
609 if (dev->dev_state == ISHTP_DEV_INIT_CLIENTS &&
610 dev->hbm_state == ISHTP_HBM_START) {
611 dev->hbm_state = ISHTP_HBM_STARTED;
612 ishtp_hbm_enum_clients_req(dev);
613 } else {
614 dev_err(dev->devc,
615 "reset: wrong host start response\n");
616 /* BUG: why do we arrive here? */
617 ish_hw_reset(dev);
618 return;
619 }
620
621 wake_up_interruptible(&dev->wait_hbm_recvd_msg);
622 break;
623
624 case CLIENT_CONNECT_RES_CMD:
625 connect_res = (struct hbm_client_connect_response *)ishtp_msg;
626 ishtp_hbm_cl_connect_res(dev, connect_res);
627 break;
628
629 case CLIENT_DISCONNECT_RES_CMD:
630 disconnect_res =
631 (struct hbm_client_connect_response *)ishtp_msg;
632 ishtp_hbm_cl_disconnect_res(dev, disconnect_res);
633 break;
634
635 case HOST_CLIENT_PROPERTIES_RES_CMD:
636 props_res = (struct hbm_props_response *)ishtp_msg;
637 fw_client = &dev->fw_clients[dev->fw_client_presentation_num];
638
639 if (props_res->status || !dev->fw_clients) {
640 dev_err(dev->devc,
641 "reset: properties response hbm wrong status\n");
642 ish_hw_reset(dev);
643 return;
644 }
645
646 if (fw_client->client_id != props_res->address) {
647 dev_err(dev->devc,
648 "reset: host properties response address mismatch [%02X %02X]\n",
649 fw_client->client_id, props_res->address);
650 ish_hw_reset(dev);
651 return;
652 }
653
654 if (dev->dev_state != ISHTP_DEV_INIT_CLIENTS ||
655 dev->hbm_state != ISHTP_HBM_CLIENT_PROPERTIES) {
656 dev_err(dev->devc,
657 "reset: unexpected properties response\n");
658 ish_hw_reset(dev);
659 return;
660 }
661
662 fw_client->props = props_res->client_properties;
663 dev->fw_client_index++;
664 dev->fw_client_presentation_num++;
665
666 /* request property for the next client */
667 ishtp_hbm_prop_req(dev);
668
669 if (dev->dev_state != ISHTP_DEV_ENABLED)
670 break;
671
672 if (!ishtp_use_dma_transfer())
673 break;
674
675 dev_dbg(dev->devc, "Requesting to use DMA\n");
676 ishtp_cl_alloc_dma_buf(dev);
677 if (dev->ishtp_host_dma_rx_buf) {
678 const size_t len = sizeof(dma_alloc_notify);
679
680 memset(&dma_alloc_notify, 0, sizeof(dma_alloc_notify));
681 dma_alloc_notify.hbm = DMA_BUFFER_ALLOC_NOTIFY;
682 dma_alloc_notify.buf_size =
683 dev->ishtp_host_dma_rx_buf_size;
684 dma_alloc_notify.buf_address =
685 dev->ishtp_host_dma_rx_buf_phys;
686 ishtp_hbm_hdr(&ishtp_hdr, len);
687 ishtp_write_message(dev, &ishtp_hdr,
688 (unsigned char *)&dma_alloc_notify);
689 }
690
691 break;
692
693 case HOST_ENUM_RES_CMD:
694 enum_res = (struct hbm_host_enum_response *) ishtp_msg;
695 memcpy(dev->fw_clients_map, enum_res->valid_addresses, 32);
696 if (dev->dev_state == ISHTP_DEV_INIT_CLIENTS &&
697 dev->hbm_state == ISHTP_HBM_ENUM_CLIENTS) {
698 dev->fw_client_presentation_num = 0;
699 dev->fw_client_index = 0;
700
701 ishtp_hbm_fw_cl_allocate(dev);
702 dev->hbm_state = ISHTP_HBM_CLIENT_PROPERTIES;
703
704 /* first property request */
705 ishtp_hbm_prop_req(dev);
706 } else {
707 dev_err(dev->devc,
708 "reset: unexpected enumeration response hbm\n");
709 ish_hw_reset(dev);
710 return;
711 }
712 break;
713
714 case HOST_STOP_RES_CMD:
715 if (dev->hbm_state != ISHTP_HBM_STOPPED)
716 dev_err(dev->devc, "unexpected stop response\n");
717
718 dev->dev_state = ISHTP_DEV_DISABLED;
719 dev_info(dev->devc, "reset: FW stop response\n");
720 ish_hw_reset(dev);
721 break;
722
723 case CLIENT_DISCONNECT_REQ_CMD:
724 /* search for client */
725 disconnect_req =
726 (struct hbm_client_connect_request *)ishtp_msg;
727 ishtp_hbm_fw_disconnect_req(dev, disconnect_req);
728 break;
729
730 case FW_STOP_REQ_CMD:
731 dev->hbm_state = ISHTP_HBM_STOPPED;
732 break;
733
734 case DMA_BUFFER_ALLOC_RESPONSE:
735 dev->ishtp_host_dma_enabled = 1;
736 break;
737
738 case DMA_XFER:
739 dma_xfer = (struct dma_xfer_hbm *)ishtp_msg;
740 if (!dev->ishtp_host_dma_enabled) {
741 dev_err(dev->devc,
742 "DMA XFER requested but DMA is not enabled\n");
743 break;
744 }
745 ishtp_hbm_dma_xfer(dev, dma_xfer);
746 break;
747
748 case DMA_XFER_ACK:
749 dma_xfer = (struct dma_xfer_hbm *)ishtp_msg;
750 if (!dev->ishtp_host_dma_enabled ||
751 !dev->ishtp_host_dma_tx_buf) {
752 dev_err(dev->devc,
753 "DMA XFER acked but DMA Tx is not enabled\n");
754 break;
755 }
756 ishtp_hbm_dma_xfer_ack(dev, dma_xfer);
757 break;
758
759 default:
760 dev_err(dev->devc, "unknown HBM: %u\n",
761 (unsigned int)ishtp_msg->hbm_cmd);
762
763 break;
764 }
765 }
766
767 /**
768 * bh_hbm_work_fn() - HBM work function
769 * @work: work struct
770 *
771 * Bottom half processing work function (instead of thread handler)
772 * for processing hbm messages
773 */
bh_hbm_work_fn(struct work_struct * work)774 void bh_hbm_work_fn(struct work_struct *work)
775 {
776 unsigned long flags;
777 struct ishtp_device *dev;
778 unsigned char hbm[IPC_PAYLOAD_SIZE];
779
780 dev = container_of(work, struct ishtp_device, bh_hbm_work);
781 spin_lock_irqsave(&dev->rd_msg_spinlock, flags);
782 if (dev->rd_msg_fifo_head != dev->rd_msg_fifo_tail) {
783 memcpy(hbm, dev->rd_msg_fifo + dev->rd_msg_fifo_head,
784 IPC_PAYLOAD_SIZE);
785 dev->rd_msg_fifo_head =
786 (dev->rd_msg_fifo_head + IPC_PAYLOAD_SIZE) %
787 (RD_INT_FIFO_SIZE * IPC_PAYLOAD_SIZE);
788 spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
789 ishtp_hbm_dispatch(dev, (struct ishtp_bus_message *)hbm);
790 } else {
791 spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
792 }
793 }
794
795 /**
796 * recv_hbm() - Receive HBM message
797 * @dev: ISHTP device instance
798 * @ishtp_hdr: received bus message
799 *
800 * Receive and process ISHTP bus messages in ISR context. This will schedule
801 * work function to process message
802 */
recv_hbm(struct ishtp_device * dev,struct ishtp_msg_hdr * ishtp_hdr)803 void recv_hbm(struct ishtp_device *dev, struct ishtp_msg_hdr *ishtp_hdr)
804 {
805 uint8_t rd_msg_buf[ISHTP_RD_MSG_BUF_SIZE];
806 struct ishtp_bus_message *ishtp_msg =
807 (struct ishtp_bus_message *)rd_msg_buf;
808 unsigned long flags;
809
810 dev->ops->ishtp_read(dev, rd_msg_buf, ishtp_hdr->length);
811
812 /* Flow control - handle in place */
813 if (ishtp_msg->hbm_cmd == ISHTP_FLOW_CONTROL_CMD) {
814 struct hbm_flow_control *flow_control =
815 (struct hbm_flow_control *)ishtp_msg;
816 struct ishtp_cl *cl = NULL;
817 unsigned long flags, tx_flags;
818
819 spin_lock_irqsave(&dev->cl_list_lock, flags);
820 list_for_each_entry(cl, &dev->cl_list, link) {
821 if (cl->host_client_id == flow_control->host_addr &&
822 cl->fw_client_id ==
823 flow_control->fw_addr) {
824 /*
825 * NOTE: It's valid only for counting
826 * flow-control implementation to receive a
827 * FC in the middle of sending. Meanwhile not
828 * supported
829 */
830 if (cl->ishtp_flow_ctrl_creds)
831 dev_err(dev->devc,
832 "recv extra FC from FW client %u (host client %u) (FC count was %d)\n",
833 (unsigned int)cl->fw_client_id,
834 (unsigned int)cl->host_client_id,
835 cl->ishtp_flow_ctrl_creds);
836 else {
837 ++cl->ishtp_flow_ctrl_creds;
838 ++cl->ishtp_flow_ctrl_cnt;
839 cl->last_ipc_acked = 1;
840 spin_lock_irqsave(
841 &cl->tx_list_spinlock,
842 tx_flags);
843 if (!list_empty(&cl->tx_list.list)) {
844 /*
845 * start sending the first msg
846 * = the callback function
847 */
848 spin_unlock_irqrestore(
849 &cl->tx_list_spinlock,
850 tx_flags);
851 ishtp_cl_send_msg(dev, cl);
852 } else {
853 spin_unlock_irqrestore(
854 &cl->tx_list_spinlock,
855 tx_flags);
856 }
857 }
858 break;
859 }
860 }
861 spin_unlock_irqrestore(&dev->cl_list_lock, flags);
862 goto eoi;
863 }
864
865 /*
866 * Some messages that are safe for ISR processing and important
867 * to be done "quickly" and in-order, go here
868 */
869 if (ishtp_msg->hbm_cmd == CLIENT_CONNECT_RES_CMD ||
870 ishtp_msg->hbm_cmd == CLIENT_DISCONNECT_RES_CMD ||
871 ishtp_msg->hbm_cmd == CLIENT_DISCONNECT_REQ_CMD ||
872 ishtp_msg->hbm_cmd == DMA_XFER) {
873 ishtp_hbm_dispatch(dev, ishtp_msg);
874 goto eoi;
875 }
876
877 /*
878 * All other HBMs go here.
879 * We schedule HBMs for processing serially by using system wq,
880 * possibly there will be multiple HBMs scheduled at the same time.
881 */
882 spin_lock_irqsave(&dev->rd_msg_spinlock, flags);
883 if ((dev->rd_msg_fifo_tail + IPC_PAYLOAD_SIZE) %
884 (RD_INT_FIFO_SIZE * IPC_PAYLOAD_SIZE) ==
885 dev->rd_msg_fifo_head) {
886 spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
887 dev_err(dev->devc, "BH buffer overflow, dropping HBM %u\n",
888 (unsigned int)ishtp_msg->hbm_cmd);
889 goto eoi;
890 }
891 memcpy(dev->rd_msg_fifo + dev->rd_msg_fifo_tail, ishtp_msg,
892 ishtp_hdr->length);
893 dev->rd_msg_fifo_tail = (dev->rd_msg_fifo_tail + IPC_PAYLOAD_SIZE) %
894 (RD_INT_FIFO_SIZE * IPC_PAYLOAD_SIZE);
895 spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
896 schedule_work(&dev->bh_hbm_work);
897 eoi:
898 return;
899 }
900
901 /**
902 * recv_fixed_cl_msg() - Receive fixed client message
903 * @dev: ISHTP device instance
904 * @ishtp_hdr: received bus message
905 *
906 * Receive and process ISHTP fixed client messages (address == 0)
907 * in ISR context
908 */
recv_fixed_cl_msg(struct ishtp_device * dev,struct ishtp_msg_hdr * ishtp_hdr)909 void recv_fixed_cl_msg(struct ishtp_device *dev,
910 struct ishtp_msg_hdr *ishtp_hdr)
911 {
912 uint8_t rd_msg_buf[ISHTP_RD_MSG_BUF_SIZE];
913
914 dev->print_log(dev,
915 "%s() got fixed client msg from client #%d\n",
916 __func__, ishtp_hdr->fw_addr);
917 dev->ops->ishtp_read(dev, rd_msg_buf, ishtp_hdr->length);
918 if (ishtp_hdr->fw_addr == ISHTP_SYSTEM_STATE_CLIENT_ADDR) {
919 struct ish_system_states_header *msg_hdr =
920 (struct ish_system_states_header *)rd_msg_buf;
921 if (msg_hdr->cmd == SYSTEM_STATE_SUBSCRIBE)
922 ishtp_send_resume(dev);
923 /* if FW request arrived here, the system is not suspended */
924 else
925 dev_err(dev->devc, "unknown fixed client msg [%02X]\n",
926 msg_hdr->cmd);
927 }
928 }
929
930 /**
931 * fix_cl_hdr() - Initialize fixed client header
932 * @hdr: message header
933 * @length: length of message
934 * @cl_addr: Client address
935 *
936 * Initialize message header for fixed client
937 */
fix_cl_hdr(struct ishtp_msg_hdr * hdr,size_t length,uint8_t cl_addr)938 static inline void fix_cl_hdr(struct ishtp_msg_hdr *hdr, size_t length,
939 uint8_t cl_addr)
940 {
941 hdr->host_addr = 0;
942 hdr->fw_addr = cl_addr;
943 hdr->length = length;
944 hdr->msg_complete = 1;
945 hdr->reserved = 0;
946 }
947
948 /*** Suspend and resume notification ***/
949
950 static uint32_t current_state;
951 static uint32_t supported_states = 0 | SUSPEND_STATE_BIT;
952
953 /**
954 * ishtp_send_suspend() - Send suspend message to FW
955 * @dev: ISHTP device instance
956 *
957 * Send suspend message to FW. This is useful for system freeze (non S3) case
958 */
ishtp_send_suspend(struct ishtp_device * dev)959 void ishtp_send_suspend(struct ishtp_device *dev)
960 {
961 struct ishtp_msg_hdr ishtp_hdr;
962 struct ish_system_states_status state_status_msg;
963 const size_t len = sizeof(struct ish_system_states_status);
964
965 fix_cl_hdr(&ishtp_hdr, len, ISHTP_SYSTEM_STATE_CLIENT_ADDR);
966
967 memset(&state_status_msg, 0, len);
968 state_status_msg.hdr.cmd = SYSTEM_STATE_STATUS;
969 state_status_msg.supported_states = supported_states;
970 current_state |= SUSPEND_STATE_BIT;
971 dev->print_log(dev, "%s() sends SUSPEND notification\n", __func__);
972 state_status_msg.states_status = current_state;
973
974 ishtp_write_message(dev, &ishtp_hdr,
975 (unsigned char *)&state_status_msg);
976 }
977 EXPORT_SYMBOL(ishtp_send_suspend);
978
979 /**
980 * ishtp_send_resume() - Send resume message to FW
981 * @dev: ISHTP device instance
982 *
983 * Send resume message to FW. This is useful for system freeze (non S3) case
984 */
ishtp_send_resume(struct ishtp_device * dev)985 void ishtp_send_resume(struct ishtp_device *dev)
986 {
987 struct ishtp_msg_hdr ishtp_hdr;
988 struct ish_system_states_status state_status_msg;
989 const size_t len = sizeof(struct ish_system_states_status);
990
991 fix_cl_hdr(&ishtp_hdr, len, ISHTP_SYSTEM_STATE_CLIENT_ADDR);
992
993 memset(&state_status_msg, 0, len);
994 state_status_msg.hdr.cmd = SYSTEM_STATE_STATUS;
995 state_status_msg.supported_states = supported_states;
996 current_state &= ~SUSPEND_STATE_BIT;
997 dev->print_log(dev, "%s() sends RESUME notification\n", __func__);
998 state_status_msg.states_status = current_state;
999
1000 ishtp_write_message(dev, &ishtp_hdr,
1001 (unsigned char *)&state_status_msg);
1002 }
1003 EXPORT_SYMBOL(ishtp_send_resume);
1004
1005 /**
1006 * ishtp_query_subscribers() - Send query subscribers message
1007 * @dev: ISHTP device instance
1008 *
1009 * Send message to query subscribers
1010 */
ishtp_query_subscribers(struct ishtp_device * dev)1011 void ishtp_query_subscribers(struct ishtp_device *dev)
1012 {
1013 struct ishtp_msg_hdr ishtp_hdr;
1014 struct ish_system_states_query_subscribers query_subscribers_msg;
1015 const size_t len = sizeof(struct ish_system_states_query_subscribers);
1016
1017 fix_cl_hdr(&ishtp_hdr, len, ISHTP_SYSTEM_STATE_CLIENT_ADDR);
1018
1019 memset(&query_subscribers_msg, 0, len);
1020 query_subscribers_msg.hdr.cmd = SYSTEM_STATE_QUERY_SUBSCRIBERS;
1021
1022 ishtp_write_message(dev, &ishtp_hdr,
1023 (unsigned char *)&query_subscribers_msg);
1024 }
1025