drivers/staging/greybus/hid.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * HID class driver for the Greybus.
   4  *
   5  * Copyright 2014 Google Inc.
   6  * Copyright 2014 Linaro Ltd.
   7  */
   8
   9 #include <linux/bitops.h>
  10 #include <linux/hid.h>
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/mutex.h>
  14 #include <linux/slab.h>
  15 #include <linux/greybus.h>
  16
  17 /* Greybus HID device's structure */
  18 struct gb_hid {
  19         struct gb_bundle *bundle;
  20         struct gb_connection            *connection;
  21
  22         struct hid_device               *hid;
  23         struct gb_hid_desc_response     hdesc;
  24
  25         unsigned long                   flags;
  26 #define GB_HID_STARTED                  0x01
  27 #define GB_HID_READ_PENDING             0x04
  28
  29         unsigned int                    bufsize;
  30         char                            *inbuf;
  31 };
  32
  33 /* Routines to get controller's information over greybus */
  34
  35 /* Operations performed on greybus */
  36 static int gb_hid_get_desc(struct gb_hid *ghid)
  37 {
  38         return gb_operation_sync(ghid->connection, GB_HID_TYPE_GET_DESC, NULL,
  39                                  0, &ghid->hdesc, sizeof(ghid->hdesc));
  40 }
  41
  42 static int gb_hid_get_report_desc(struct gb_hid *ghid, char *rdesc)
  43 {
  44         int ret;
  45
  46         ret = gb_pm_runtime_get_sync(ghid->bundle);
  47         if (ret)
  48                 return ret;
  49
  50         ret = gb_operation_sync(ghid->connection, GB_HID_TYPE_GET_REPORT_DESC,
  51                                 NULL, 0, rdesc,
  52                                 le16_to_cpu(ghid->hdesc.wReportDescLength));
  53
  54         gb_pm_runtime_put_autosuspend(ghid->bundle);
  55
  56         return ret;
  57 }
  58
  59 static int gb_hid_set_power(struct gb_hid *ghid, int type)
  60 {
  61         int ret;
  62
  63         ret = gb_pm_runtime_get_sync(ghid->bundle);
  64         if (ret)
  65                 return ret;
  66
  67         ret = gb_operation_sync(ghid->connection, type, NULL, 0, NULL, 0);
  68
  69         gb_pm_runtime_put_autosuspend(ghid->bundle);
  70
  71         return ret;
  72 }
  73
  74 static int gb_hid_get_report(struct gb_hid *ghid, u8 report_type, u8 report_id,
  75                              unsigned char *buf, int len)
  76 {
  77         struct gb_hid_get_report_request request;
  78         int ret;
  79
  80         ret = gb_pm_runtime_get_sync(ghid->bundle);
  81         if (ret)
  82                 return ret;
  83
  84         request.report_type = report_type;
  85         request.report_id = report_id;
  86
  87         ret = gb_operation_sync(ghid->connection, GB_HID_TYPE_GET_REPORT,
  88                                 &request, sizeof(request), buf, len);
  89
  90         gb_pm_runtime_put_autosuspend(ghid->bundle);
  91
  92         return ret;
  93 }
  94
  95 static int gb_hid_set_report(struct gb_hid *ghid, u8 report_type, u8 report_id,
  96                              unsigned char *buf, int len)
  97 {
  98         struct gb_hid_set_report_request *request;
  99         struct gb_operation *operation;
 100         int ret, size = sizeof(*request) + len - 1;
 101
 102         ret = gb_pm_runtime_get_sync(ghid->bundle);
 103         if (ret)
 104                 return ret;
 105
 106         operation = gb_operation_create(ghid->connection,
 107                                         GB_HID_TYPE_SET_REPORT, size, 0,
 108                                         GFP_KERNEL);
 109         if (!operation) {
 110                 gb_pm_runtime_put_autosuspend(ghid->bundle);
 111                 return -ENOMEM;
 112         }
 113
 114         request = operation->request->payload;
 115         request->report_type = report_type;
 116         request->report_id = report_id;
 117         memcpy(request->report, buf, len);
 118
 119         ret = gb_operation_request_send_sync(operation);
 120         if (ret) {
 121                 dev_err(&operation->connection->bundle->dev,
 122                         "failed to set report: %d\n", ret);
 123         } else {
 124                 ret = len;
 125         }
 126
 127         gb_operation_put(operation);
 128         gb_pm_runtime_put_autosuspend(ghid->bundle);
 129
 130         return ret;
 131 }
 132
 133 static int gb_hid_request_handler(struct gb_operation *op)
 134 {
 135         struct gb_connection *connection = op->connection;
 136         struct gb_hid *ghid = gb_connection_get_data(connection);
 137         struct gb_hid_input_report_request *request = op->request->payload;
 138
 139         if (op->type != GB_HID_TYPE_IRQ_EVENT) {
 140                 dev_err(&connection->bundle->dev,
 141                         "unsupported unsolicited request\n");
 142                 return -EINVAL;
 143         }
 144
 145         if (test_bit(GB_HID_STARTED, &ghid->flags))
 146                 hid_input_report(ghid->hid, HID_INPUT_REPORT,
 147                                  request->report, op->request->payload_size, 1);
 148
 149         return 0;
 150 }
 151
 152 static int gb_hid_report_len(struct hid_report *report)
 153 {
 154         return ((report->size - 1) >> 3) + 1 +
 155                 report->device->report_enum[report->type].numbered;
 156 }
 157
 158 static void gb_hid_find_max_report(struct hid_device *hid, unsigned int type,
 159                                    unsigned int *max)
 160 {
 161         struct hid_report *report;
 162         unsigned int size;
 163
 164         list_for_each_entry(report, &hid->report_enum[type].report_list, list) {
 165                 size = gb_hid_report_len(report);
 166                 if (*max < size)
 167                         *max = size;
 168         }
 169 }
 170
 171 static void gb_hid_free_buffers(struct gb_hid *ghid)
 172 {
 173         kfree(ghid->inbuf);
 174         ghid->inbuf = NULL;
 175         ghid->bufsize = 0;
 176 }
 177
 178 static int gb_hid_alloc_buffers(struct gb_hid *ghid, size_t bufsize)
 179 {
 180         ghid->inbuf = kzalloc(bufsize, GFP_KERNEL);
 181         if (!ghid->inbuf)
 182                 return -ENOMEM;
 183
 184         ghid->bufsize = bufsize;
 185
 186         return 0;
 187 }
 188
 189 /* Routines dealing with reports */
 190 static void gb_hid_init_report(struct gb_hid *ghid, struct hid_report *report)
 191 {
 192         unsigned int size;
 193
 194         size = gb_hid_report_len(report);
 195         if (gb_hid_get_report(ghid, report->type, report->id, ghid->inbuf,
 196                               size))
 197                 return;
 198
 199         /*
 200          * hid->driver_lock is held as we are in probe function,
 201          * we just need to setup the input fields, so using
 202          * hid_report_raw_event is safe.
 203          */
 204         hid_report_raw_event(ghid->hid, report->type, ghid->inbuf, size, 1);
 205 }
 206
 207 static void gb_hid_init_reports(struct gb_hid *ghid)
 208 {
 209         struct hid_device *hid = ghid->hid;
 210         struct hid_report *report;
 211
 212         list_for_each_entry(report,
 213                             &hid->report_enum[HID_INPUT_REPORT].report_list,
 214                             list)
 215                 gb_hid_init_report(ghid, report);
 216
 217         list_for_each_entry(report,
 218                             &hid->report_enum[HID_FEATURE_REPORT].report_list,
 219                             list)
 220                 gb_hid_init_report(ghid, report);
 221 }
 222
 223 static int __gb_hid_get_raw_report(struct hid_device *hid,
 224                                    unsigned char report_number, __u8 *buf, size_t count,
 225                                    unsigned char report_type)
 226 {
 227         struct gb_hid *ghid = hid->driver_data;
 228         int ret;
 229
 230         if (report_type == HID_OUTPUT_REPORT)
 231                 return -EINVAL;
 232
 233         ret = gb_hid_get_report(ghid, report_type, report_number, buf, count);
 234         if (!ret)
 235                 ret = count;
 236
 237         return ret;
 238 }
 239
 240 static int __gb_hid_output_raw_report(struct hid_device *hid, __u8 *buf,
 241                                       size_t len, unsigned char report_type)
 242 {
 243         struct gb_hid *ghid = hid->driver_data;
 244         int report_id = buf[0];
 245         int ret;
 246
 247         if (report_type == HID_INPUT_REPORT)
 248                 return -EINVAL;
 249
 250         if (report_id) {
 251                 buf++;
 252                 len--;
 253         }
 254
 255         ret = gb_hid_set_report(ghid, report_type, report_id, buf, len);
 256         if (report_id && ret >= 0)
 257                 ret++; /* add report_id to the number of transferred bytes */
 258
 259         return 0;
 260 }
 261
 262 static int gb_hid_raw_request(struct hid_device *hid, unsigned char reportnum,
 263                               __u8 *buf, size_t len, unsigned char rtype,
 264                               int reqtype)
 265 {
 266         switch (reqtype) {
 267         case HID_REQ_GET_REPORT:
 268                 return __gb_hid_get_raw_report(hid, reportnum, buf, len, rtype);
 269         case HID_REQ_SET_REPORT:
 270                 if (buf[0] != reportnum)
 271                         return -EINVAL;
 272                 return __gb_hid_output_raw_report(hid, buf, len, rtype);
 273         default:
 274                 return -EIO;
 275         }
 276 }
 277
 278 /* HID Callbacks */
 279 static int gb_hid_parse(struct hid_device *hid)
 280 {
 281         struct gb_hid *ghid = hid->driver_data;
 282         unsigned int rsize;
 283         char *rdesc;
 284         int ret;
 285
 286         rsize = le16_to_cpu(ghid->hdesc.wReportDescLength);
 287         if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) {
 288                 dbg_hid("weird size of report descriptor (%u)\n", rsize);
 289                 return -EINVAL;
 290         }
 291
 292         rdesc = kzalloc(rsize, GFP_KERNEL);
 293         if (!rdesc)
 294                 return -ENOMEM;
 295
 296         ret = gb_hid_get_report_desc(ghid, rdesc);
 297         if (ret) {
 298                 hid_err(hid, "reading report descriptor failed\n");
 299                 goto free_rdesc;
 300         }
 301
 302         ret = hid_parse_report(hid, rdesc, rsize);
 303         if (ret)
 304                 dbg_hid("parsing report descriptor failed\n");
 305
 306 free_rdesc:
 307         kfree(rdesc);
 308
 309         return ret;
 310 }
 311
 312 static int gb_hid_start(struct hid_device *hid)
 313 {
 314         struct gb_hid *ghid = hid->driver_data;
 315         unsigned int bufsize = HID_MIN_BUFFER_SIZE;
 316         int ret;
 317
 318         gb_hid_find_max_report(hid, HID_INPUT_REPORT, &bufsize);
 319         gb_hid_find_max_report(hid, HID_OUTPUT_REPORT, &bufsize);
 320         gb_hid_find_max_report(hid, HID_FEATURE_REPORT, &bufsize);
 321
 322         if (bufsize > HID_MAX_BUFFER_SIZE)
 323                 bufsize = HID_MAX_BUFFER_SIZE;
 324
 325         ret = gb_hid_alloc_buffers(ghid, bufsize);
 326         if (ret)
 327                 return ret;
 328
 329         if (!(hid->quirks & HID_QUIRK_NO_INIT_REPORTS))
 330                 gb_hid_init_reports(ghid);
 331
 332         return 0;
 333 }
 334
 335 static void gb_hid_stop(struct hid_device *hid)
 336 {
 337         struct gb_hid *ghid = hid->driver_data;
 338
 339         gb_hid_free_buffers(ghid);
 340 }
 341
 342 static int gb_hid_open(struct hid_device *hid)
 343 {
 344         struct gb_hid *ghid = hid->driver_data;
 345         int ret;
 346
 347         ret = gb_hid_set_power(ghid, GB_HID_TYPE_PWR_ON);
 348         if (ret < 0)
 349                 return ret;
 350
 351         set_bit(GB_HID_STARTED, &ghid->flags);
 352         return 0;
 353 }
 354
 355 static void gb_hid_close(struct hid_device *hid)
 356 {
 357         struct gb_hid *ghid = hid->driver_data;
 358         int ret;
 359
 360         clear_bit(GB_HID_STARTED, &ghid->flags);
 361
 362         /* Save some power */
 363         ret = gb_hid_set_power(ghid, GB_HID_TYPE_PWR_OFF);
 364         if (ret)
 365                 dev_err(&ghid->connection->bundle->dev,
 366                         "failed to power off (%d)\n", ret);
 367 }
 368
 369 static int gb_hid_power(struct hid_device *hid, int lvl)
 370 {
 371         struct gb_hid *ghid = hid->driver_data;
 372
 373         switch (lvl) {
 374         case PM_HINT_FULLON:
 375                 return gb_hid_set_power(ghid, GB_HID_TYPE_PWR_ON);
 376         case PM_HINT_NORMAL:
 377                 return gb_hid_set_power(ghid, GB_HID_TYPE_PWR_OFF);
 378         }
 379
 380         return 0;
 381 }
 382
 383 /* HID structure to pass callbacks */
 384 static struct hid_ll_driver gb_hid_ll_driver = {
 385         .parse = gb_hid_parse,
 386         .start = gb_hid_start,
 387         .stop = gb_hid_stop,
 388         .open = gb_hid_open,
 389         .close = gb_hid_close,
 390         .power = gb_hid_power,
 391         .raw_request = gb_hid_raw_request,
 392 };
 393
 394 static int gb_hid_init(struct gb_hid *ghid)
 395 {
 396         struct hid_device *hid = ghid->hid;
 397         int ret;
 398
 399         ret = gb_hid_get_desc(ghid);
 400         if (ret)
 401                 return ret;
 402
 403         hid->version = le16_to_cpu(ghid->hdesc.bcdHID);
 404         hid->vendor = le16_to_cpu(ghid->hdesc.wVendorID);
 405         hid->product = le16_to_cpu(ghid->hdesc.wProductID);
 406         hid->country = ghid->hdesc.bCountryCode;
 407
 408         hid->driver_data = ghid;
 409         hid->ll_driver = &gb_hid_ll_driver;
 410         hid->dev.parent = &ghid->connection->bundle->dev;
 411 //      hid->bus = BUS_GREYBUS; /* Need a bustype for GREYBUS in <linux/input.h> */
 412
 413         /* Set HID device's name */
 414         snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X",
 415                  dev_name(&ghid->connection->bundle->dev),
 416                  hid->vendor, hid->product);
 417
 418         return 0;
 419 }
 420
 421 static int gb_hid_probe(struct gb_bundle *bundle,
 422                         const struct greybus_bundle_id *id)
 423 {
 424         struct greybus_descriptor_cport *cport_desc;
 425         struct gb_connection *connection;
 426         struct hid_device *hid;
 427         struct gb_hid *ghid;
 428         int ret;
 429
 430         if (bundle->num_cports != 1)
 431                 return -ENODEV;
 432
 433         cport_desc = &bundle->cport_desc[0];
 434         if (cport_desc->protocol_id != GREYBUS_PROTOCOL_HID)
 435                 return -ENODEV;
 436
 437         ghid = kzalloc(sizeof(*ghid), GFP_KERNEL);
 438         if (!ghid)
 439                 return -ENOMEM;
 440
 441         connection = gb_connection_create(bundle, le16_to_cpu(cport_desc->id),
 442                                           gb_hid_request_handler);
 443         if (IS_ERR(connection)) {
 444                 ret = PTR_ERR(connection);
 445                 goto err_free_ghid;
 446         }
 447
 448         gb_connection_set_data(connection, ghid);
 449         ghid->connection = connection;
 450
 451         hid = hid_allocate_device();
 452         if (IS_ERR(hid)) {
 453                 ret = PTR_ERR(hid);
 454                 goto err_connection_destroy;
 455         }
 456
 457         ghid->hid = hid;
 458         ghid->bundle = bundle;
 459
 460         greybus_set_drvdata(bundle, ghid);
 461
 462         ret = gb_connection_enable(connection);
 463         if (ret)
 464                 goto err_destroy_hid;
 465
 466         ret = gb_hid_init(ghid);
 467         if (ret)
 468                 goto err_connection_disable;
 469
 470         ret = hid_add_device(hid);
 471         if (ret) {
 472                 hid_err(hid, "can't add hid device: %d\n", ret);
 473                 goto err_connection_disable;
 474         }
 475
 476         gb_pm_runtime_put_autosuspend(bundle);
 477
 478         return 0;
 479
 480 err_connection_disable:
 481         gb_connection_disable(connection);
 482 err_destroy_hid:
 483         hid_destroy_device(hid);
 484 err_connection_destroy:
 485         gb_connection_destroy(connection);
 486 err_free_ghid:
 487         kfree(ghid);
 488
 489         return ret;
 490 }
 491
 492 static void gb_hid_disconnect(struct gb_bundle *bundle)
 493 {
 494         struct gb_hid *ghid = greybus_get_drvdata(bundle);
 495
 496         if (gb_pm_runtime_get_sync(bundle))
 497                 gb_pm_runtime_get_noresume(bundle);
 498
 499         hid_destroy_device(ghid->hid);
 500         gb_connection_disable(ghid->connection);
 501         gb_connection_destroy(ghid->connection);
 502         kfree(ghid);
 503 }
 504
 505 static const struct greybus_bundle_id gb_hid_id_table[] = {
 506         { GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_HID) },
 507         { }
 508 };
 509 MODULE_DEVICE_TABLE(greybus, gb_hid_id_table);
 510
 511 static struct greybus_driver gb_hid_driver = {
 512         .name           = "hid",
 513         .probe          = gb_hid_probe,
 514         .disconnect     = gb_hid_disconnect,
 515         .id_table       = gb_hid_id_table,
 516 };
 517 module_greybus_driver(gb_hid_driver);
 518
 519 MODULE_LICENSE("GPL v2");