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