drivers/staging/greybus/hid.c

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