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