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