Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/hid/hid
[sfrench/cifs-2.6.git] / drivers / hid / intel-ish-hid / ishtp-hid-client.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * ISHTP client driver for HID (ISH)
4  *
5  * Copyright (c) 2014-2016, Intel Corporation.
6  */
7
8 #include <linux/module.h>
9 #include <linux/hid.h>
10 #include <linux/intel-ish-client-if.h>
11 #include <linux/sched.h>
12 #include "ishtp-hid.h"
13
14 /* Rx ring buffer pool size */
15 #define HID_CL_RX_RING_SIZE     32
16 #define HID_CL_TX_RING_SIZE     16
17
18 #define cl_data_to_dev(client_data) ishtp_device(client_data->cl_device)
19
20 /**
21  * report_bad_packets() - Report bad packets
22  * @hid_ishtp_cl:       Client instance to get stats
23  * @recv_buf:           Raw received host interface message
24  * @cur_pos:            Current position index in payload
25  * @payload_len:        Length of payload expected
26  *
27  * Dumps error in case bad packet is received
28  */
29 static void report_bad_packet(struct ishtp_cl *hid_ishtp_cl, void *recv_buf,
30                               size_t cur_pos,  size_t payload_len)
31 {
32         struct hostif_msg *recv_msg = recv_buf;
33         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
34
35         dev_err(cl_data_to_dev(client_data), "[hid-ish]: BAD packet %02X\n"
36                 "total_bad=%u cur_pos=%u\n"
37                 "[%02X %02X %02X %02X]\n"
38                 "payload_len=%u\n"
39                 "multi_packet_cnt=%u\n"
40                 "is_response=%02X\n",
41                 recv_msg->hdr.command, client_data->bad_recv_cnt,
42                 (unsigned int)cur_pos,
43                 ((unsigned char *)recv_msg)[0], ((unsigned char *)recv_msg)[1],
44                 ((unsigned char *)recv_msg)[2], ((unsigned char *)recv_msg)[3],
45                 (unsigned int)payload_len, client_data->multi_packet_cnt,
46                 recv_msg->hdr.command & ~CMD_MASK);
47 }
48
49 /**
50  * process_recv() - Received and parse incoming packet
51  * @hid_ishtp_cl:       Client instance to get stats
52  * @recv_buf:           Raw received host interface message
53  * @data_len:           length of the message
54  *
55  * Parse the incoming packet. If it is a response packet then it will update
56  * per instance flags and wake up the caller waiting to for the response.
57  */
58 static void process_recv(struct ishtp_cl *hid_ishtp_cl, void *recv_buf,
59                          size_t data_len)
60 {
61         struct hostif_msg *recv_msg;
62         unsigned char *payload;
63         struct device_info *dev_info;
64         int i, j;
65         size_t  payload_len, total_len, cur_pos, raw_len;
66         int report_type;
67         struct report_list *reports_list;
68         char *reports;
69         size_t report_len;
70         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
71         int curr_hid_dev = client_data->cur_hid_dev;
72         struct ishtp_hid_data *hid_data = NULL;
73         struct hid_device *hid = NULL;
74
75         payload = recv_buf + sizeof(struct hostif_msg_hdr);
76         total_len = data_len;
77         cur_pos = 0;
78
79         do {
80                 if (cur_pos + sizeof(struct hostif_msg) > total_len) {
81                         dev_err(cl_data_to_dev(client_data),
82                                 "[hid-ish]: error, received %u which is less than data header %u\n",
83                                 (unsigned int)data_len,
84                                 (unsigned int)sizeof(struct hostif_msg_hdr));
85                         ++client_data->bad_recv_cnt;
86                         ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
87                         break;
88                 }
89
90                 recv_msg = (struct hostif_msg *)(recv_buf + cur_pos);
91                 payload_len = recv_msg->hdr.size;
92
93                 /* Sanity checks */
94                 if (cur_pos + payload_len + sizeof(struct hostif_msg) >
95                                 total_len) {
96                         ++client_data->bad_recv_cnt;
97                         report_bad_packet(hid_ishtp_cl, recv_msg, cur_pos,
98                                           payload_len);
99                         ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
100                         break;
101                 }
102
103                 hid_ishtp_trace(client_data,  "%s %d\n",
104                                 __func__, recv_msg->hdr.command & CMD_MASK);
105
106                 switch (recv_msg->hdr.command & CMD_MASK) {
107                 case HOSTIF_DM_ENUM_DEVICES:
108                         if ((!(recv_msg->hdr.command & ~CMD_MASK) ||
109                                         client_data->init_done)) {
110                                 ++client_data->bad_recv_cnt;
111                                 report_bad_packet(hid_ishtp_cl, recv_msg,
112                                                   cur_pos,
113                                                   payload_len);
114                                 ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
115                                 break;
116                         }
117                         client_data->hid_dev_count = (unsigned int)*payload;
118                         if (!client_data->hid_devices)
119                                 client_data->hid_devices = devm_kcalloc(
120                                                 cl_data_to_dev(client_data),
121                                                 client_data->hid_dev_count,
122                                                 sizeof(struct device_info),
123                                                 GFP_KERNEL);
124                         if (!client_data->hid_devices) {
125                                 dev_err(cl_data_to_dev(client_data),
126                                 "Mem alloc failed for hid device info\n");
127                                 wake_up_interruptible(&client_data->init_wait);
128                                 break;
129                         }
130                         for (i = 0; i < client_data->hid_dev_count; ++i) {
131                                 if (1 + sizeof(struct device_info) * i >=
132                                                 payload_len) {
133                                         dev_err(cl_data_to_dev(client_data),
134                                                 "[hid-ish]: [ENUM_DEVICES]: content size %zu is bigger than payload_len %zu\n",
135                                                 1 + sizeof(struct device_info)
136                                                 * i, payload_len);
137                                 }
138
139                                 if (1 + sizeof(struct device_info) * i >=
140                                                 data_len)
141                                         break;
142
143                                 dev_info = (struct device_info *)(payload + 1 +
144                                         sizeof(struct device_info) * i);
145                                 if (client_data->hid_devices)
146                                         memcpy(client_data->hid_devices + i,
147                                                dev_info,
148                                                sizeof(struct device_info));
149                         }
150
151                         client_data->enum_devices_done = true;
152                         wake_up_interruptible(&client_data->init_wait);
153
154                         break;
155
156                 case HOSTIF_GET_HID_DESCRIPTOR:
157                         if ((!(recv_msg->hdr.command & ~CMD_MASK) ||
158                                         client_data->init_done)) {
159                                 ++client_data->bad_recv_cnt;
160                                 report_bad_packet(hid_ishtp_cl, recv_msg,
161                                                   cur_pos,
162                                                   payload_len);
163                                 ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
164                                 break;
165                         }
166                         if (!client_data->hid_descr[curr_hid_dev])
167                                 client_data->hid_descr[curr_hid_dev] =
168                                 devm_kmalloc(cl_data_to_dev(client_data),
169                                              payload_len, GFP_KERNEL);
170                         if (client_data->hid_descr[curr_hid_dev]) {
171                                 memcpy(client_data->hid_descr[curr_hid_dev],
172                                        payload, payload_len);
173                                 client_data->hid_descr_size[curr_hid_dev] =
174                                         payload_len;
175                                 client_data->hid_descr_done = true;
176                         }
177                         wake_up_interruptible(&client_data->init_wait);
178
179                         break;
180
181                 case HOSTIF_GET_REPORT_DESCRIPTOR:
182                         if ((!(recv_msg->hdr.command & ~CMD_MASK) ||
183                                         client_data->init_done)) {
184                                 ++client_data->bad_recv_cnt;
185                                 report_bad_packet(hid_ishtp_cl, recv_msg,
186                                                   cur_pos,
187                                                   payload_len);
188                                 ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
189                                 break;
190                         }
191                         if (!client_data->report_descr[curr_hid_dev])
192                                 client_data->report_descr[curr_hid_dev] =
193                                 devm_kmalloc(cl_data_to_dev(client_data),
194                                              payload_len, GFP_KERNEL);
195                         if (client_data->report_descr[curr_hid_dev])  {
196                                 memcpy(client_data->report_descr[curr_hid_dev],
197                                        payload,
198                                        payload_len);
199                                 client_data->report_descr_size[curr_hid_dev] =
200                                         payload_len;
201                                 client_data->report_descr_done = true;
202                         }
203                         wake_up_interruptible(&client_data->init_wait);
204
205                         break;
206
207                 case HOSTIF_GET_FEATURE_REPORT:
208                         report_type = HID_FEATURE_REPORT;
209                         goto    do_get_report;
210
211                 case HOSTIF_GET_INPUT_REPORT:
212                         report_type = HID_INPUT_REPORT;
213 do_get_report:
214                         /* Get index of device that matches this id */
215                         for (i = 0; i < client_data->num_hid_devices; ++i) {
216                                 if (recv_msg->hdr.device_id ==
217                                           client_data->hid_devices[i].dev_id) {
218                                         hid = client_data->hid_sensor_hubs[i];
219                                         if (!hid)
220                                                 break;
221
222                                         hid_data = hid->driver_data;
223                                         if (hid_data->raw_get_req) {
224                                                 raw_len =
225                                                   (hid_data->raw_buf_size <
226                                                                 payload_len) ?
227                                                   hid_data->raw_buf_size :
228                                                   payload_len;
229
230                                                 memcpy(hid_data->raw_buf,
231                                                        payload, raw_len);
232                                         } else {
233                                                 hid_input_report
234                                                         (hid, report_type,
235                                                          payload, payload_len,
236                                                          0);
237                                         }
238
239                                         ishtp_hid_wakeup(hid);
240                                         break;
241                                 }
242                         }
243                         break;
244
245                 case HOSTIF_SET_FEATURE_REPORT:
246                         /* Get index of device that matches this id */
247                         for (i = 0; i < client_data->num_hid_devices; ++i) {
248                                 if (recv_msg->hdr.device_id ==
249                                         client_data->hid_devices[i].dev_id)
250                                         if (client_data->hid_sensor_hubs[i]) {
251                                                 ishtp_hid_wakeup(
252                                                 client_data->hid_sensor_hubs[
253                                                         i]);
254                                                 break;
255                                         }
256                         }
257                         break;
258
259                 case HOSTIF_PUBLISH_INPUT_REPORT:
260                         report_type = HID_INPUT_REPORT;
261                         for (i = 0; i < client_data->num_hid_devices; ++i)
262                                 if (recv_msg->hdr.device_id ==
263                                         client_data->hid_devices[i].dev_id)
264                                         if (client_data->hid_sensor_hubs[i])
265                                                 hid_input_report(
266                                                 client_data->hid_sensor_hubs[
267                                                                         i],
268                                                 report_type, payload,
269                                                 payload_len, 0);
270                         break;
271
272                 case HOSTIF_PUBLISH_INPUT_REPORT_LIST:
273                         report_type = HID_INPUT_REPORT;
274                         reports_list = (struct report_list *)payload;
275                         reports = (char *)reports_list->reports;
276
277                         for (j = 0; j < reports_list->num_of_reports; j++) {
278                                 recv_msg = (struct hostif_msg *)(reports +
279                                         sizeof(uint16_t));
280                                 report_len = *(uint16_t *)reports;
281                                 payload = reports + sizeof(uint16_t) +
282                                         sizeof(struct hostif_msg_hdr);
283                                 payload_len = report_len -
284                                         sizeof(struct hostif_msg_hdr);
285
286                                 for (i = 0; i < client_data->num_hid_devices;
287                                      ++i)
288                                         if (recv_msg->hdr.device_id ==
289                                         client_data->hid_devices[i].dev_id &&
290                                         client_data->hid_sensor_hubs[i]) {
291                                                 hid_input_report(
292                                                 client_data->hid_sensor_hubs[
293                                                                         i],
294                                                 report_type,
295                                                 payload, payload_len,
296                                                 0);
297                                         }
298
299                                 reports += sizeof(uint16_t) + report_len;
300                         }
301                         break;
302                 default:
303                         ++client_data->bad_recv_cnt;
304                         report_bad_packet(hid_ishtp_cl, recv_msg, cur_pos,
305                                           payload_len);
306                         ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
307                         break;
308
309                 }
310
311                 if (!cur_pos && cur_pos + payload_len +
312                                 sizeof(struct hostif_msg) < total_len)
313                         ++client_data->multi_packet_cnt;
314
315                 cur_pos += payload_len + sizeof(struct hostif_msg);
316                 payload += payload_len + sizeof(struct hostif_msg);
317
318         } while (cur_pos < total_len);
319 }
320
321 /**
322  * ish_cl_event_cb() - bus driver callback for incoming message/packet
323  * @device:     Pointer to the the ishtp client device for which this message
324  *              is targeted
325  *
326  * Remove the packet from the list and process the message by calling
327  * process_recv
328  */
329 static void ish_cl_event_cb(struct ishtp_cl_device *device)
330 {
331         struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(device);
332         struct ishtp_cl_rb *rb_in_proc;
333         size_t r_length;
334
335         if (!hid_ishtp_cl)
336                 return;
337
338         while ((rb_in_proc = ishtp_cl_rx_get_rb(hid_ishtp_cl)) != NULL) {
339                 if (!rb_in_proc->buffer.data)
340                         return;
341
342                 r_length = rb_in_proc->buf_idx;
343
344                 /* decide what to do with received data */
345                 process_recv(hid_ishtp_cl, rb_in_proc->buffer.data, r_length);
346
347                 ishtp_cl_io_rb_recycle(rb_in_proc);
348         }
349 }
350
351 /**
352  * hid_ishtp_set_feature() - send request to ISH FW to set a feature request
353  * @hid:        hid device instance for this request
354  * @buf:        feature buffer
355  * @len:        Length of feature buffer
356  * @report_id:  Report id for the feature set request
357  *
358  * This is called from hid core .request() callback. This function doesn't wait
359  * for response.
360  */
361 void hid_ishtp_set_feature(struct hid_device *hid, char *buf, unsigned int len,
362                            int report_id)
363 {
364         struct ishtp_hid_data *hid_data =  hid->driver_data;
365         struct ishtp_cl_data *client_data = hid_data->client_data;
366         struct hostif_msg *msg = (struct hostif_msg *)buf;
367         int     rv;
368         int     i;
369
370         hid_ishtp_trace(client_data,  "%s hid %p\n", __func__, hid);
371
372         rv = ishtp_hid_link_ready_wait(client_data);
373         if (rv) {
374                 hid_ishtp_trace(client_data,  "%s hid %p link not ready\n",
375                                 __func__, hid);
376                 return;
377         }
378
379         memset(msg, 0, sizeof(struct hostif_msg));
380         msg->hdr.command = HOSTIF_SET_FEATURE_REPORT;
381         for (i = 0; i < client_data->num_hid_devices; ++i) {
382                 if (hid == client_data->hid_sensor_hubs[i]) {
383                         msg->hdr.device_id =
384                                 client_data->hid_devices[i].dev_id;
385                         break;
386                 }
387         }
388
389         if (i == client_data->num_hid_devices)
390                 return;
391
392         rv = ishtp_cl_send(client_data->hid_ishtp_cl, buf, len);
393         if (rv)
394                 hid_ishtp_trace(client_data,  "%s hid %p send failed\n",
395                                 __func__, hid);
396 }
397
398 /**
399  * hid_ishtp_get_report() - request to get feature/input report
400  * @hid:        hid device instance for this request
401  * @report_id:  Report id for the get request
402  * @report_type:        Report type for the this request
403  *
404  * This is called from hid core .request() callback. This function will send
405  * request to FW and return without waiting for response.
406  */
407 void hid_ishtp_get_report(struct hid_device *hid, int report_id,
408                           int report_type)
409 {
410         struct ishtp_hid_data *hid_data =  hid->driver_data;
411         struct ishtp_cl_data *client_data = hid_data->client_data;
412         struct hostif_msg_to_sensor msg = {};
413         int     rv;
414         int     i;
415
416         hid_ishtp_trace(client_data,  "%s hid %p\n", __func__, hid);
417         rv = ishtp_hid_link_ready_wait(client_data);
418         if (rv) {
419                 hid_ishtp_trace(client_data,  "%s hid %p link not ready\n",
420                                 __func__, hid);
421                 return;
422         }
423
424         msg.hdr.command = (report_type == HID_FEATURE_REPORT) ?
425                 HOSTIF_GET_FEATURE_REPORT : HOSTIF_GET_INPUT_REPORT;
426         for (i = 0; i < client_data->num_hid_devices; ++i) {
427                 if (hid == client_data->hid_sensor_hubs[i]) {
428                         msg.hdr.device_id =
429                                 client_data->hid_devices[i].dev_id;
430                         break;
431                 }
432         }
433
434         if (i == client_data->num_hid_devices)
435                 return;
436
437         msg.report_id = report_id;
438         rv = ishtp_cl_send(client_data->hid_ishtp_cl, (uint8_t *)&msg,
439                             sizeof(msg));
440         if (rv)
441                 hid_ishtp_trace(client_data,  "%s hid %p send failed\n",
442                                 __func__, hid);
443 }
444
445 /**
446  * ishtp_hid_link_ready_wait() - Wait for link ready
447  * @client_data:        client data instance
448  *
449  * If the transport link started suspend process, then wait, till either
450  * resumed or timeout
451  *
452  * Return: 0 on success, non zero on error
453  */
454 int ishtp_hid_link_ready_wait(struct ishtp_cl_data *client_data)
455 {
456         int rc;
457
458         if (client_data->suspended) {
459                 hid_ishtp_trace(client_data,  "wait for link ready\n");
460                 rc = wait_event_interruptible_timeout(
461                                         client_data->ishtp_resume_wait,
462                                         !client_data->suspended,
463                                         5 * HZ);
464
465                 if (rc == 0) {
466                         hid_ishtp_trace(client_data,  "link not ready\n");
467                         return -EIO;
468                 }
469                 hid_ishtp_trace(client_data,  "link ready\n");
470         }
471
472         return 0;
473 }
474
475 /**
476  * ishtp_enum_enum_devices() - Enumerate hid devices
477  * @hid_ishtp_cl:       client instance
478  *
479  * Helper function to send request to firmware to enumerate HID devices
480  *
481  * Return: 0 on success, non zero on error
482  */
483 static int ishtp_enum_enum_devices(struct ishtp_cl *hid_ishtp_cl)
484 {
485         struct hostif_msg msg;
486         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
487         int retry_count;
488         int rv;
489
490         /* Send HOSTIF_DM_ENUM_DEVICES */
491         memset(&msg, 0, sizeof(struct hostif_msg));
492         msg.hdr.command = HOSTIF_DM_ENUM_DEVICES;
493         rv = ishtp_cl_send(hid_ishtp_cl, (unsigned char *)&msg,
494                            sizeof(struct hostif_msg));
495         if (rv)
496                 return rv;
497
498         retry_count = 0;
499         while (!client_data->enum_devices_done &&
500                retry_count < 10) {
501                 wait_event_interruptible_timeout(client_data->init_wait,
502                                          client_data->enum_devices_done,
503                                          3 * HZ);
504                 ++retry_count;
505                 if (!client_data->enum_devices_done)
506                         /* Send HOSTIF_DM_ENUM_DEVICES */
507                         rv = ishtp_cl_send(hid_ishtp_cl,
508                                            (unsigned char *) &msg,
509                                            sizeof(struct hostif_msg));
510         }
511         if (!client_data->enum_devices_done) {
512                 dev_err(cl_data_to_dev(client_data),
513                         "[hid-ish]: timed out waiting for enum_devices\n");
514                 return -ETIMEDOUT;
515         }
516         if (!client_data->hid_devices) {
517                 dev_err(cl_data_to_dev(client_data),
518                         "[hid-ish]: failed to allocate HID dev structures\n");
519                 return -ENOMEM;
520         }
521
522         client_data->num_hid_devices = client_data->hid_dev_count;
523         dev_info(ishtp_device(client_data->cl_device),
524                 "[hid-ish]: enum_devices_done OK, num_hid_devices=%d\n",
525                 client_data->num_hid_devices);
526
527         return  0;
528 }
529
530 /**
531  * ishtp_get_hid_descriptor() - Get hid descriptor
532  * @hid_ishtp_cl:       client instance
533  * @index:              Index into the hid_descr array
534  *
535  * Helper function to send request to firmware get HID descriptor of a device
536  *
537  * Return: 0 on success, non zero on error
538  */
539 static int ishtp_get_hid_descriptor(struct ishtp_cl *hid_ishtp_cl, int index)
540 {
541         struct hostif_msg msg;
542         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
543         int rv;
544
545         /* Get HID descriptor */
546         client_data->hid_descr_done = false;
547         memset(&msg, 0, sizeof(struct hostif_msg));
548         msg.hdr.command = HOSTIF_GET_HID_DESCRIPTOR;
549         msg.hdr.device_id = client_data->hid_devices[index].dev_id;
550         rv = ishtp_cl_send(hid_ishtp_cl, (unsigned char *) &msg,
551                            sizeof(struct hostif_msg));
552         if (rv)
553                 return rv;
554
555         if (!client_data->hid_descr_done) {
556                 wait_event_interruptible_timeout(client_data->init_wait,
557                                                  client_data->hid_descr_done,
558                                                  3 * HZ);
559                 if (!client_data->hid_descr_done) {
560                         dev_err(cl_data_to_dev(client_data),
561                                 "[hid-ish]: timed out for hid_descr_done\n");
562                         return -EIO;
563                 }
564
565                 if (!client_data->hid_descr[index]) {
566                         dev_err(cl_data_to_dev(client_data),
567                                 "[hid-ish]: allocation HID desc fail\n");
568                         return -ENOMEM;
569                 }
570         }
571
572         return 0;
573 }
574
575 /**
576  * ishtp_get_report_descriptor() - Get report descriptor
577  * @hid_ishtp_cl:       client instance
578  * @index:              Index into the hid_descr array
579  *
580  * Helper function to send request to firmware get HID report descriptor of
581  * a device
582  *
583  * Return: 0 on success, non zero on error
584  */
585 static int ishtp_get_report_descriptor(struct ishtp_cl *hid_ishtp_cl,
586                                        int index)
587 {
588         struct hostif_msg msg;
589         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
590         int rv;
591
592         /* Get report descriptor */
593         client_data->report_descr_done = false;
594         memset(&msg, 0, sizeof(struct hostif_msg));
595         msg.hdr.command = HOSTIF_GET_REPORT_DESCRIPTOR;
596         msg.hdr.device_id = client_data->hid_devices[index].dev_id;
597         rv = ishtp_cl_send(hid_ishtp_cl, (unsigned char *) &msg,
598                            sizeof(struct hostif_msg));
599         if (rv)
600                 return rv;
601
602         if (!client_data->report_descr_done)
603                 wait_event_interruptible_timeout(client_data->init_wait,
604                                          client_data->report_descr_done,
605                                          3 * HZ);
606         if (!client_data->report_descr_done) {
607                 dev_err(cl_data_to_dev(client_data),
608                                 "[hid-ish]: timed out for report descr\n");
609                 return -EIO;
610         }
611         if (!client_data->report_descr[index]) {
612                 dev_err(cl_data_to_dev(client_data),
613                         "[hid-ish]: failed to alloc report descr\n");
614                 return -ENOMEM;
615         }
616
617         return 0;
618 }
619
620 /**
621  * hid_ishtp_cl_init() - Init function for ISHTP client
622  * @hid_ishtp_cl:       ISHTP client instance
623  * @reset:              true if called for init after reset
624  *
625  * This function complete the initializtion of the client. The summary of
626  * processing:
627  * - Send request to enumerate the hid clients
628  *      Get the HID descriptor for each enumearated device
629  *      Get report description of each device
630  *      Register each device wik hid core by calling ishtp_hid_probe
631  *
632  * Return: 0 on success, non zero on error
633  */
634 static int hid_ishtp_cl_init(struct ishtp_cl *hid_ishtp_cl, int reset)
635 {
636         struct ishtp_device *dev;
637         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
638         struct ishtp_fw_client *fw_client;
639         int i;
640         int rv;
641
642         dev_dbg(cl_data_to_dev(client_data), "%s\n", __func__);
643         hid_ishtp_trace(client_data,  "%s reset flag: %d\n", __func__, reset);
644
645         rv = ishtp_cl_link(hid_ishtp_cl);
646         if (rv) {
647                 dev_err(cl_data_to_dev(client_data),
648                         "ishtp_cl_link failed\n");
649                 return  -ENOMEM;
650         }
651
652         client_data->init_done = 0;
653
654         dev = ishtp_get_ishtp_device(hid_ishtp_cl);
655
656         /* Connect to FW client */
657         ishtp_set_tx_ring_size(hid_ishtp_cl, HID_CL_TX_RING_SIZE);
658         ishtp_set_rx_ring_size(hid_ishtp_cl, HID_CL_RX_RING_SIZE);
659
660         fw_client = ishtp_fw_cl_get_client(dev, &hid_ishtp_guid);
661         if (!fw_client) {
662                 dev_err(cl_data_to_dev(client_data),
663                         "ish client uuid not found\n");
664                 return -ENOENT;
665         }
666         ishtp_cl_set_fw_client_id(hid_ishtp_cl,
667                                   ishtp_get_fw_client_id(fw_client));
668         ishtp_set_connection_state(hid_ishtp_cl, ISHTP_CL_CONNECTING);
669
670         rv = ishtp_cl_connect(hid_ishtp_cl);
671         if (rv) {
672                 dev_err(cl_data_to_dev(client_data),
673                         "client connect fail\n");
674                 goto err_cl_unlink;
675         }
676
677         hid_ishtp_trace(client_data,  "%s client connected\n", __func__);
678
679         /* Register read callback */
680         ishtp_register_event_cb(client_data->cl_device, ish_cl_event_cb);
681
682         rv = ishtp_enum_enum_devices(hid_ishtp_cl);
683         if (rv)
684                 goto err_cl_disconnect;
685
686         hid_ishtp_trace(client_data,  "%s enumerated device count %d\n",
687                         __func__, client_data->num_hid_devices);
688
689         for (i = 0; i < client_data->num_hid_devices; ++i) {
690                 client_data->cur_hid_dev = i;
691
692                 rv = ishtp_get_hid_descriptor(hid_ishtp_cl, i);
693                 if (rv)
694                         goto err_cl_disconnect;
695
696                 rv = ishtp_get_report_descriptor(hid_ishtp_cl, i);
697                 if (rv)
698                         goto err_cl_disconnect;
699
700                 if (!reset) {
701                         rv = ishtp_hid_probe(i, client_data);
702                         if (rv) {
703                                 dev_err(cl_data_to_dev(client_data),
704                                 "[hid-ish]: HID probe for #%u failed: %d\n",
705                                 i, rv);
706                                 goto err_cl_disconnect;
707                         }
708                 }
709         } /* for() on all hid devices */
710
711         client_data->init_done = 1;
712         client_data->suspended = false;
713         wake_up_interruptible(&client_data->ishtp_resume_wait);
714         hid_ishtp_trace(client_data,  "%s successful init\n", __func__);
715         return 0;
716
717 err_cl_disconnect:
718         ishtp_set_connection_state(hid_ishtp_cl, ISHTP_CL_DISCONNECTING);
719         ishtp_cl_disconnect(hid_ishtp_cl);
720 err_cl_unlink:
721         ishtp_cl_unlink(hid_ishtp_cl);
722         return rv;
723 }
724
725 /**
726  * hid_ishtp_cl_deinit() - Deinit function for ISHTP client
727  * @hid_ishtp_cl:       ISHTP client instance
728  *
729  * Unlink and free hid client
730  */
731 static void hid_ishtp_cl_deinit(struct ishtp_cl *hid_ishtp_cl)
732 {
733         ishtp_cl_unlink(hid_ishtp_cl);
734         ishtp_cl_flush_queues(hid_ishtp_cl);
735
736         /* disband and free all Tx and Rx client-level rings */
737         ishtp_cl_free(hid_ishtp_cl);
738 }
739
740 static void hid_ishtp_cl_reset_handler(struct work_struct *work)
741 {
742         struct ishtp_cl_data *client_data;
743         struct ishtp_cl *hid_ishtp_cl;
744         struct ishtp_cl_device *cl_device;
745         int retry;
746         int rv;
747
748         client_data = container_of(work, struct ishtp_cl_data, work);
749
750         hid_ishtp_cl = client_data->hid_ishtp_cl;
751         cl_device = client_data->cl_device;
752
753         hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
754                         hid_ishtp_cl);
755         dev_dbg(ishtp_device(client_data->cl_device), "%s\n", __func__);
756
757         hid_ishtp_cl_deinit(hid_ishtp_cl);
758
759         hid_ishtp_cl = ishtp_cl_allocate(cl_device);
760         if (!hid_ishtp_cl)
761                 return;
762
763         ishtp_set_drvdata(cl_device, hid_ishtp_cl);
764         ishtp_set_client_data(hid_ishtp_cl, client_data);
765         client_data->hid_ishtp_cl = hid_ishtp_cl;
766
767         client_data->num_hid_devices = 0;
768
769         for (retry = 0; retry < 3; ++retry) {
770                 rv = hid_ishtp_cl_init(hid_ishtp_cl, 1);
771                 if (!rv)
772                         break;
773                 dev_err(cl_data_to_dev(client_data), "Retry reset init\n");
774         }
775         if (rv) {
776                 dev_err(cl_data_to_dev(client_data), "Reset Failed\n");
777                 hid_ishtp_trace(client_data, "%s Failed hid_ishtp_cl %p\n",
778                                 __func__, hid_ishtp_cl);
779         }
780 }
781
782 void (*hid_print_trace)(void *unused, const char *format, ...);
783
784 /**
785  * hid_ishtp_cl_probe() - ISHTP client driver probe
786  * @cl_device:          ISHTP client device instance
787  *
788  * This function gets called on device create on ISHTP bus
789  *
790  * Return: 0 on success, non zero on error
791  */
792 static int hid_ishtp_cl_probe(struct ishtp_cl_device *cl_device)
793 {
794         struct ishtp_cl *hid_ishtp_cl;
795         struct ishtp_cl_data *client_data;
796         int rv;
797
798         if (!cl_device)
799                 return  -ENODEV;
800
801         client_data = devm_kzalloc(ishtp_device(cl_device),
802                                    sizeof(*client_data),
803                                    GFP_KERNEL);
804         if (!client_data)
805                 return -ENOMEM;
806
807         hid_ishtp_cl = ishtp_cl_allocate(cl_device);
808         if (!hid_ishtp_cl)
809                 return -ENOMEM;
810
811         ishtp_set_drvdata(cl_device, hid_ishtp_cl);
812         ishtp_set_client_data(hid_ishtp_cl, client_data);
813         client_data->hid_ishtp_cl = hid_ishtp_cl;
814         client_data->cl_device = cl_device;
815
816         init_waitqueue_head(&client_data->init_wait);
817         init_waitqueue_head(&client_data->ishtp_resume_wait);
818
819         INIT_WORK(&client_data->work, hid_ishtp_cl_reset_handler);
820
821         hid_print_trace = ishtp_trace_callback(cl_device);
822
823         rv = hid_ishtp_cl_init(hid_ishtp_cl, 0);
824         if (rv) {
825                 ishtp_cl_free(hid_ishtp_cl);
826                 return rv;
827         }
828         ishtp_get_device(cl_device);
829
830         return 0;
831 }
832
833 /**
834  * hid_ishtp_cl_remove() - ISHTP client driver remove
835  * @cl_device:          ISHTP client device instance
836  *
837  * This function gets called on device remove on ISHTP bus
838  *
839  * Return: 0
840  */
841 static int hid_ishtp_cl_remove(struct ishtp_cl_device *cl_device)
842 {
843         struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);
844         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
845
846         hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
847                         hid_ishtp_cl);
848
849         dev_dbg(ishtp_device(cl_device), "%s\n", __func__);
850         ishtp_set_connection_state(hid_ishtp_cl, ISHTP_CL_DISCONNECTING);
851         ishtp_cl_disconnect(hid_ishtp_cl);
852         ishtp_put_device(cl_device);
853         ishtp_hid_remove(client_data);
854         hid_ishtp_cl_deinit(hid_ishtp_cl);
855
856         hid_ishtp_cl = NULL;
857
858         client_data->num_hid_devices = 0;
859
860         return 0;
861 }
862
863 /**
864  * hid_ishtp_cl_reset() - ISHTP client driver reset
865  * @cl_device:          ISHTP client device instance
866  *
867  * This function gets called on device reset on ISHTP bus
868  *
869  * Return: 0
870  */
871 static int hid_ishtp_cl_reset(struct ishtp_cl_device *cl_device)
872 {
873         struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);
874         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
875
876         hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
877                         hid_ishtp_cl);
878
879         schedule_work(&client_data->work);
880
881         return 0;
882 }
883
884 /**
885  * hid_ishtp_cl_suspend() - ISHTP client driver suspend
886  * @device:     device instance
887  *
888  * This function gets called on system suspend
889  *
890  * Return: 0
891  */
892 static int hid_ishtp_cl_suspend(struct device *device)
893 {
894         struct ishtp_cl_device *cl_device = ishtp_dev_to_cl_device(device);
895         struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);
896         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
897
898         hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
899                         hid_ishtp_cl);
900         client_data->suspended = true;
901
902         return 0;
903 }
904
905 /**
906  * hid_ishtp_cl_resume() - ISHTP client driver resume
907  * @device:     device instance
908  *
909  * This function gets called on system resume
910  *
911  * Return: 0
912  */
913 static int hid_ishtp_cl_resume(struct device *device)
914 {
915         struct ishtp_cl_device *cl_device = ishtp_dev_to_cl_device(device);
916         struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);
917         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
918
919         hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
920                         hid_ishtp_cl);
921         client_data->suspended = false;
922         return 0;
923 }
924
925 static const struct dev_pm_ops hid_ishtp_pm_ops = {
926         .suspend = hid_ishtp_cl_suspend,
927         .resume = hid_ishtp_cl_resume,
928 };
929
930 static struct ishtp_cl_driver   hid_ishtp_cl_driver = {
931         .name = "ish-hid",
932         .guid = &hid_ishtp_guid,
933         .probe = hid_ishtp_cl_probe,
934         .remove = hid_ishtp_cl_remove,
935         .reset = hid_ishtp_cl_reset,
936         .driver.pm = &hid_ishtp_pm_ops,
937 };
938
939 static int __init ish_hid_init(void)
940 {
941         int     rv;
942
943         /* Register ISHTP client device driver with ISHTP Bus */
944         rv = ishtp_cl_driver_register(&hid_ishtp_cl_driver, THIS_MODULE);
945
946         return rv;
947
948 }
949
950 static void __exit ish_hid_exit(void)
951 {
952         ishtp_cl_driver_unregister(&hid_ishtp_cl_driver);
953 }
954
955 late_initcall(ish_hid_init);
956 module_exit(ish_hid_exit);
957
958 MODULE_DESCRIPTION("ISH ISHTP HID client driver");
959 /* Primary author */
960 MODULE_AUTHOR("Daniel Drubin <daniel.drubin@intel.com>");
961 /*
962  * Several modification for multi instance support
963  * suspend/resume and clean up
964  */
965 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
966
967 MODULE_LICENSE("GPL");
968 MODULE_ALIAS("ishtp:*");