1 /*************************************************************************** 2 * Copyright (C) 2010-2012 by Bruno Prémont <bonbons@linux-vserver.org> * 3 * * 4 * Based on Logitech G13 driver (v0.4) * 5 * Copyright (C) 2009 by Rick L. Vinyard, Jr. <rvinyard@cs.nmsu.edu> * 6 * * 7 * This program is free software: you can redistribute it and/or modify * 8 * it under the terms of the GNU General Public License as published by * 9 * the Free Software Foundation, version 2 of the License. * 10 * * 11 * This driver is distributed in the hope that it will be useful, but * 12 * WITHOUT ANY WARRANTY; without even the implied warranty of * 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 14 * General Public License for more details. * 15 * * 16 * You should have received a copy of the GNU General Public License * 17 * along with this software. If not see <http://www.gnu.org/licenses/>. * 18 ***************************************************************************/ 19 20 #include <linux/hid.h> 21 #include <linux/hid-debug.h> 22 23 #include <linux/fb.h> 24 #include <linux/seq_file.h> 25 #include <linux/debugfs.h> 26 27 #include <linux/module.h> 28 #include <linux/uaccess.h> 29 30 #include "hid-picolcd.h" 31 32 33 static int picolcd_debug_reset_show(struct seq_file *f, void *p) 34 { 35 if (picolcd_fbinfo((struct picolcd_data *)f->private)) 36 seq_printf(f, "all fb\n"); 37 else 38 seq_printf(f, "all\n"); 39 return 0; 40 } 41 42 static int picolcd_debug_reset_open(struct inode *inode, struct file *f) 43 { 44 return single_open(f, picolcd_debug_reset_show, inode->i_private); 45 } 46 47 static ssize_t picolcd_debug_reset_write(struct file *f, const char __user *user_buf, 48 size_t count, loff_t *ppos) 49 { 50 struct picolcd_data *data = ((struct seq_file *)f->private_data)->private; 51 char buf[32]; 52 size_t cnt = min(count, sizeof(buf)-1); 53 if (copy_from_user(buf, user_buf, cnt)) 54 return -EFAULT; 55 56 while (cnt > 0 && (buf[cnt-1] == ' ' || buf[cnt-1] == '\n')) 57 cnt--; 58 buf[cnt] = '\0'; 59 if (strcmp(buf, "all") == 0) { 60 picolcd_reset(data->hdev); 61 picolcd_fb_reset(data, 1); 62 } else if (strcmp(buf, "fb") == 0) { 63 picolcd_fb_reset(data, 1); 64 } else { 65 return -EINVAL; 66 } 67 return count; 68 } 69 70 static const struct file_operations picolcd_debug_reset_fops = { 71 .owner = THIS_MODULE, 72 .open = picolcd_debug_reset_open, 73 .read = seq_read, 74 .llseek = seq_lseek, 75 .write = picolcd_debug_reset_write, 76 .release = single_release, 77 }; 78 79 /* 80 * The "eeprom" file 81 */ 82 static ssize_t picolcd_debug_eeprom_read(struct file *f, char __user *u, 83 size_t s, loff_t *off) 84 { 85 struct picolcd_data *data = f->private_data; 86 struct picolcd_pending *resp; 87 u8 raw_data[3]; 88 ssize_t ret = -EIO; 89 90 if (s == 0) 91 return -EINVAL; 92 if (*off > 0x0ff) 93 return 0; 94 95 /* prepare buffer with info about what we want to read (addr & len) */ 96 raw_data[0] = *off & 0xff; 97 raw_data[1] = (*off >> 8) & 0xff; 98 raw_data[2] = s < 20 ? s : 20; 99 if (*off + raw_data[2] > 0xff) 100 raw_data[2] = 0x100 - *off; 101 resp = picolcd_send_and_wait(data->hdev, REPORT_EE_READ, raw_data, 102 sizeof(raw_data)); 103 if (!resp) 104 return -EIO; 105 106 if (resp->in_report && resp->in_report->id == REPORT_EE_DATA) { 107 /* successful read :) */ 108 ret = resp->raw_data[2]; 109 if (ret > s) 110 ret = s; 111 if (copy_to_user(u, resp->raw_data+3, ret)) 112 ret = -EFAULT; 113 else 114 *off += ret; 115 } /* anything else is some kind of IO error */ 116 117 kfree(resp); 118 return ret; 119 } 120 121 static ssize_t picolcd_debug_eeprom_write(struct file *f, const char __user *u, 122 size_t s, loff_t *off) 123 { 124 struct picolcd_data *data = f->private_data; 125 struct picolcd_pending *resp; 126 ssize_t ret = -EIO; 127 u8 raw_data[23]; 128 129 if (s == 0) 130 return -EINVAL; 131 if (*off > 0x0ff) 132 return -ENOSPC; 133 134 memset(raw_data, 0, sizeof(raw_data)); 135 raw_data[0] = *off & 0xff; 136 raw_data[1] = (*off >> 8) & 0xff; 137 raw_data[2] = min_t(size_t, 20, s); 138 if (*off + raw_data[2] > 0xff) 139 raw_data[2] = 0x100 - *off; 140 141 if (copy_from_user(raw_data+3, u, min((u8)20, raw_data[2]))) 142 return -EFAULT; 143 resp = picolcd_send_and_wait(data->hdev, REPORT_EE_WRITE, raw_data, 144 sizeof(raw_data)); 145 146 if (!resp) 147 return -EIO; 148 149 if (resp->in_report && resp->in_report->id == REPORT_EE_DATA) { 150 /* check if written data matches */ 151 if (memcmp(raw_data, resp->raw_data, 3+raw_data[2]) == 0) { 152 *off += raw_data[2]; 153 ret = raw_data[2]; 154 } 155 } 156 kfree(resp); 157 return ret; 158 } 159 160 /* 161 * Notes: 162 * - read/write happens in chunks of at most 20 bytes, it's up to userspace 163 * to loop in order to get more data. 164 * - on write errors on otherwise correct write request the bytes 165 * that should have been written are in undefined state. 166 */ 167 static const struct file_operations picolcd_debug_eeprom_fops = { 168 .owner = THIS_MODULE, 169 .open = simple_open, 170 .read = picolcd_debug_eeprom_read, 171 .write = picolcd_debug_eeprom_write, 172 .llseek = generic_file_llseek, 173 }; 174 175 /* 176 * The "flash" file 177 */ 178 /* record a flash address to buf (bounds check to be done by caller) */ 179 static int _picolcd_flash_setaddr(struct picolcd_data *data, u8 *buf, long off) 180 { 181 buf[0] = off & 0xff; 182 buf[1] = (off >> 8) & 0xff; 183 if (data->addr_sz == 3) 184 buf[2] = (off >> 16) & 0xff; 185 return data->addr_sz == 2 ? 2 : 3; 186 } 187 188 /* read a given size of data (bounds check to be done by caller) */ 189 static ssize_t _picolcd_flash_read(struct picolcd_data *data, int report_id, 190 char __user *u, size_t s, loff_t *off) 191 { 192 struct picolcd_pending *resp; 193 u8 raw_data[4]; 194 ssize_t ret = 0; 195 int len_off, err = -EIO; 196 197 while (s > 0) { 198 err = -EIO; 199 len_off = _picolcd_flash_setaddr(data, raw_data, *off); 200 raw_data[len_off] = s > 32 ? 32 : s; 201 resp = picolcd_send_and_wait(data->hdev, report_id, raw_data, len_off+1); 202 if (!resp || !resp->in_report) 203 goto skip; 204 if (resp->in_report->id == REPORT_MEMORY || 205 resp->in_report->id == REPORT_BL_READ_MEMORY) { 206 if (memcmp(raw_data, resp->raw_data, len_off+1) != 0) 207 goto skip; 208 if (copy_to_user(u+ret, resp->raw_data+len_off+1, raw_data[len_off])) { 209 err = -EFAULT; 210 goto skip; 211 } 212 *off += raw_data[len_off]; 213 s -= raw_data[len_off]; 214 ret += raw_data[len_off]; 215 err = 0; 216 } 217 skip: 218 kfree(resp); 219 if (err) 220 return ret > 0 ? ret : err; 221 } 222 return ret; 223 } 224 225 static ssize_t picolcd_debug_flash_read(struct file *f, char __user *u, 226 size_t s, loff_t *off) 227 { 228 struct picolcd_data *data = f->private_data; 229 230 if (s == 0) 231 return -EINVAL; 232 if (*off > 0x05fff) 233 return 0; 234 if (*off + s > 0x05fff) 235 s = 0x06000 - *off; 236 237 if (data->status & PICOLCD_BOOTLOADER) 238 return _picolcd_flash_read(data, REPORT_BL_READ_MEMORY, u, s, off); 239 else 240 return _picolcd_flash_read(data, REPORT_READ_MEMORY, u, s, off); 241 } 242 243 /* erase block aligned to 64bytes boundary */ 244 static ssize_t _picolcd_flash_erase64(struct picolcd_data *data, int report_id, 245 loff_t *off) 246 { 247 struct picolcd_pending *resp; 248 u8 raw_data[3]; 249 int len_off; 250 ssize_t ret = -EIO; 251 252 if (*off & 0x3f) 253 return -EINVAL; 254 255 len_off = _picolcd_flash_setaddr(data, raw_data, *off); 256 resp = picolcd_send_and_wait(data->hdev, report_id, raw_data, len_off); 257 if (!resp || !resp->in_report) 258 goto skip; 259 if (resp->in_report->id == REPORT_MEMORY || 260 resp->in_report->id == REPORT_BL_ERASE_MEMORY) { 261 if (memcmp(raw_data, resp->raw_data, len_off) != 0) 262 goto skip; 263 ret = 0; 264 } 265 skip: 266 kfree(resp); 267 return ret; 268 } 269 270 /* write a given size of data (bounds check to be done by caller) */ 271 static ssize_t _picolcd_flash_write(struct picolcd_data *data, int report_id, 272 const char __user *u, size_t s, loff_t *off) 273 { 274 struct picolcd_pending *resp; 275 u8 raw_data[36]; 276 ssize_t ret = 0; 277 int len_off, err = -EIO; 278 279 while (s > 0) { 280 err = -EIO; 281 len_off = _picolcd_flash_setaddr(data, raw_data, *off); 282 raw_data[len_off] = s > 32 ? 32 : s; 283 if (copy_from_user(raw_data+len_off+1, u, raw_data[len_off])) { 284 err = -EFAULT; 285 break; 286 } 287 resp = picolcd_send_and_wait(data->hdev, report_id, raw_data, 288 len_off+1+raw_data[len_off]); 289 if (!resp || !resp->in_report) 290 goto skip; 291 if (resp->in_report->id == REPORT_MEMORY || 292 resp->in_report->id == REPORT_BL_WRITE_MEMORY) { 293 if (memcmp(raw_data, resp->raw_data, len_off+1+raw_data[len_off]) != 0) 294 goto skip; 295 *off += raw_data[len_off]; 296 s -= raw_data[len_off]; 297 ret += raw_data[len_off]; 298 err = 0; 299 } 300 skip: 301 kfree(resp); 302 if (err) 303 break; 304 } 305 return ret > 0 ? ret : err; 306 } 307 308 static ssize_t picolcd_debug_flash_write(struct file *f, const char __user *u, 309 size_t s, loff_t *off) 310 { 311 struct picolcd_data *data = f->private_data; 312 ssize_t err, ret = 0; 313 int report_erase, report_write; 314 315 if (s == 0) 316 return -EINVAL; 317 if (*off > 0x5fff) 318 return -ENOSPC; 319 if (s & 0x3f) 320 return -EINVAL; 321 if (*off & 0x3f) 322 return -EINVAL; 323 324 if (data->status & PICOLCD_BOOTLOADER) { 325 report_erase = REPORT_BL_ERASE_MEMORY; 326 report_write = REPORT_BL_WRITE_MEMORY; 327 } else { 328 report_erase = REPORT_ERASE_MEMORY; 329 report_write = REPORT_WRITE_MEMORY; 330 } 331 mutex_lock(&data->mutex_flash); 332 while (s > 0) { 333 err = _picolcd_flash_erase64(data, report_erase, off); 334 if (err) 335 break; 336 err = _picolcd_flash_write(data, report_write, u, 64, off); 337 if (err < 0) 338 break; 339 ret += err; 340 *off += err; 341 s -= err; 342 if (err != 64) 343 break; 344 } 345 mutex_unlock(&data->mutex_flash); 346 return ret > 0 ? ret : err; 347 } 348 349 /* 350 * Notes: 351 * - concurrent writing is prevented by mutex and all writes must be 352 * n*64 bytes and 64-byte aligned, each write being preceded by an 353 * ERASE which erases a 64byte block. 354 * If less than requested was written or an error is returned for an 355 * otherwise correct write request the next 64-byte block which should 356 * have been written is in undefined state (mostly: original, erased, 357 * (half-)written with write error) 358 * - reading can happen without special restriction 359 */ 360 static const struct file_operations picolcd_debug_flash_fops = { 361 .owner = THIS_MODULE, 362 .open = simple_open, 363 .read = picolcd_debug_flash_read, 364 .write = picolcd_debug_flash_write, 365 .llseek = generic_file_llseek, 366 }; 367 368 369 /* 370 * Helper code for HID report level dumping/debugging 371 */ 372 static const char * const error_codes[] = { 373 "success", "parameter missing", "data_missing", "block readonly", 374 "block not erasable", "block too big", "section overflow", 375 "invalid command length", "invalid data length", 376 }; 377 378 static void dump_buff_as_hex(char *dst, size_t dst_sz, const u8 *data, 379 const size_t data_len) 380 { 381 int i, j; 382 for (i = j = 0; i < data_len && j + 4 < dst_sz; i++) { 383 dst[j++] = hex_asc[(data[i] >> 4) & 0x0f]; 384 dst[j++] = hex_asc[data[i] & 0x0f]; 385 dst[j++] = ' '; 386 } 387 dst[j] = '\0'; 388 if (j > 0) 389 dst[j-1] = '\n'; 390 if (i < data_len && j > 2) 391 dst[j-2] = dst[j-3] = '.'; 392 } 393 394 void picolcd_debug_out_report(struct picolcd_data *data, 395 struct hid_device *hdev, struct hid_report *report) 396 { 397 u8 raw_data[70]; 398 int raw_size = (report->size >> 3) + 1; 399 char *buff; 400 #define BUFF_SZ 256 401 402 /* Avoid unnecessary overhead if debugfs is disabled */ 403 if (list_empty(&hdev->debug_list)) 404 return; 405 406 buff = kmalloc(BUFF_SZ, GFP_ATOMIC); 407 if (!buff) 408 return; 409 410 snprintf(buff, BUFF_SZ, "\nout report %d (size %d) = ", 411 report->id, raw_size); 412 hid_debug_event(hdev, buff); 413 if (raw_size + 5 > sizeof(raw_data)) { 414 kfree(buff); 415 hid_debug_event(hdev, " TOO BIG\n"); 416 return; 417 } else { 418 raw_data[0] = report->id; 419 hid_output_report(report, raw_data); 420 dump_buff_as_hex(buff, BUFF_SZ, raw_data, raw_size); 421 hid_debug_event(hdev, buff); 422 } 423 424 switch (report->id) { 425 case REPORT_LED_STATE: 426 /* 1 data byte with GPO state */ 427 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 428 "REPORT_LED_STATE", report->id, raw_size-1); 429 hid_debug_event(hdev, buff); 430 snprintf(buff, BUFF_SZ, "\tGPO state: 0x%02x\n", raw_data[1]); 431 hid_debug_event(hdev, buff); 432 break; 433 case REPORT_BRIGHTNESS: 434 /* 1 data byte with brightness */ 435 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 436 "REPORT_BRIGHTNESS", report->id, raw_size-1); 437 hid_debug_event(hdev, buff); 438 snprintf(buff, BUFF_SZ, "\tBrightness: 0x%02x\n", raw_data[1]); 439 hid_debug_event(hdev, buff); 440 break; 441 case REPORT_CONTRAST: 442 /* 1 data byte with contrast */ 443 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 444 "REPORT_CONTRAST", report->id, raw_size-1); 445 hid_debug_event(hdev, buff); 446 snprintf(buff, BUFF_SZ, "\tContrast: 0x%02x\n", raw_data[1]); 447 hid_debug_event(hdev, buff); 448 break; 449 case REPORT_RESET: 450 /* 2 data bytes with reset duration in ms */ 451 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 452 "REPORT_RESET", report->id, raw_size-1); 453 hid_debug_event(hdev, buff); 454 snprintf(buff, BUFF_SZ, "\tDuration: 0x%02x%02x (%dms)\n", 455 raw_data[2], raw_data[1], raw_data[2] << 8 | raw_data[1]); 456 hid_debug_event(hdev, buff); 457 break; 458 case REPORT_LCD_CMD: 459 /* 63 data bytes with LCD commands */ 460 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 461 "REPORT_LCD_CMD", report->id, raw_size-1); 462 hid_debug_event(hdev, buff); 463 /* TODO: format decoding */ 464 break; 465 case REPORT_LCD_DATA: 466 /* 63 data bytes with LCD data */ 467 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 468 "REPORT_LCD_CMD", report->id, raw_size-1); 469 /* TODO: format decoding */ 470 hid_debug_event(hdev, buff); 471 break; 472 case REPORT_LCD_CMD_DATA: 473 /* 63 data bytes with LCD commands and data */ 474 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 475 "REPORT_LCD_CMD", report->id, raw_size-1); 476 /* TODO: format decoding */ 477 hid_debug_event(hdev, buff); 478 break; 479 case REPORT_EE_READ: 480 /* 3 data bytes with read area description */ 481 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 482 "REPORT_EE_READ", report->id, raw_size-1); 483 hid_debug_event(hdev, buff); 484 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n", 485 raw_data[2], raw_data[1]); 486 hid_debug_event(hdev, buff); 487 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]); 488 hid_debug_event(hdev, buff); 489 break; 490 case REPORT_EE_WRITE: 491 /* 3+1..20 data bytes with write area description */ 492 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 493 "REPORT_EE_WRITE", report->id, raw_size-1); 494 hid_debug_event(hdev, buff); 495 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n", 496 raw_data[2], raw_data[1]); 497 hid_debug_event(hdev, buff); 498 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]); 499 hid_debug_event(hdev, buff); 500 if (raw_data[3] == 0) { 501 snprintf(buff, BUFF_SZ, "\tNo data\n"); 502 } else if (raw_data[3] + 4 <= raw_size) { 503 snprintf(buff, BUFF_SZ, "\tData: "); 504 hid_debug_event(hdev, buff); 505 dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]); 506 } else { 507 snprintf(buff, BUFF_SZ, "\tData overflowed\n"); 508 } 509 hid_debug_event(hdev, buff); 510 break; 511 case REPORT_ERASE_MEMORY: 512 case REPORT_BL_ERASE_MEMORY: 513 /* 3 data bytes with pointer inside erase block */ 514 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 515 "REPORT_ERASE_MEMORY", report->id, raw_size-1); 516 hid_debug_event(hdev, buff); 517 switch (data->addr_sz) { 518 case 2: 519 snprintf(buff, BUFF_SZ, "\tAddress inside 64 byte block: 0x%02x%02x\n", 520 raw_data[2], raw_data[1]); 521 break; 522 case 3: 523 snprintf(buff, BUFF_SZ, "\tAddress inside 64 byte block: 0x%02x%02x%02x\n", 524 raw_data[3], raw_data[2], raw_data[1]); 525 break; 526 default: 527 snprintf(buff, BUFF_SZ, "\tNot supported\n"); 528 } 529 hid_debug_event(hdev, buff); 530 break; 531 case REPORT_READ_MEMORY: 532 case REPORT_BL_READ_MEMORY: 533 /* 4 data bytes with read area description */ 534 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 535 "REPORT_READ_MEMORY", report->id, raw_size-1); 536 hid_debug_event(hdev, buff); 537 switch (data->addr_sz) { 538 case 2: 539 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n", 540 raw_data[2], raw_data[1]); 541 hid_debug_event(hdev, buff); 542 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]); 543 break; 544 case 3: 545 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x%02x\n", 546 raw_data[3], raw_data[2], raw_data[1]); 547 hid_debug_event(hdev, buff); 548 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]); 549 break; 550 default: 551 snprintf(buff, BUFF_SZ, "\tNot supported\n"); 552 } 553 hid_debug_event(hdev, buff); 554 break; 555 case REPORT_WRITE_MEMORY: 556 case REPORT_BL_WRITE_MEMORY: 557 /* 4+1..32 data bytes with write adrea description */ 558 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 559 "REPORT_WRITE_MEMORY", report->id, raw_size-1); 560 hid_debug_event(hdev, buff); 561 switch (data->addr_sz) { 562 case 2: 563 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n", 564 raw_data[2], raw_data[1]); 565 hid_debug_event(hdev, buff); 566 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]); 567 hid_debug_event(hdev, buff); 568 if (raw_data[3] == 0) { 569 snprintf(buff, BUFF_SZ, "\tNo data\n"); 570 } else if (raw_data[3] + 4 <= raw_size) { 571 snprintf(buff, BUFF_SZ, "\tData: "); 572 hid_debug_event(hdev, buff); 573 dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]); 574 } else { 575 snprintf(buff, BUFF_SZ, "\tData overflowed\n"); 576 } 577 break; 578 case 3: 579 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x%02x\n", 580 raw_data[3], raw_data[2], raw_data[1]); 581 hid_debug_event(hdev, buff); 582 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]); 583 hid_debug_event(hdev, buff); 584 if (raw_data[4] == 0) { 585 snprintf(buff, BUFF_SZ, "\tNo data\n"); 586 } else if (raw_data[4] + 5 <= raw_size) { 587 snprintf(buff, BUFF_SZ, "\tData: "); 588 hid_debug_event(hdev, buff); 589 dump_buff_as_hex(buff, BUFF_SZ, raw_data+5, raw_data[4]); 590 } else { 591 snprintf(buff, BUFF_SZ, "\tData overflowed\n"); 592 } 593 break; 594 default: 595 snprintf(buff, BUFF_SZ, "\tNot supported\n"); 596 } 597 hid_debug_event(hdev, buff); 598 break; 599 case REPORT_SPLASH_RESTART: 600 /* TODO */ 601 break; 602 case REPORT_EXIT_KEYBOARD: 603 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 604 "REPORT_EXIT_KEYBOARD", report->id, raw_size-1); 605 hid_debug_event(hdev, buff); 606 snprintf(buff, BUFF_SZ, "\tRestart delay: %dms (0x%02x%02x)\n", 607 raw_data[1] | (raw_data[2] << 8), 608 raw_data[2], raw_data[1]); 609 hid_debug_event(hdev, buff); 610 break; 611 case REPORT_VERSION: 612 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 613 "REPORT_VERSION", report->id, raw_size-1); 614 hid_debug_event(hdev, buff); 615 break; 616 case REPORT_DEVID: 617 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 618 "REPORT_DEVID", report->id, raw_size-1); 619 hid_debug_event(hdev, buff); 620 break; 621 case REPORT_SPLASH_SIZE: 622 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 623 "REPORT_SPLASH_SIZE", report->id, raw_size-1); 624 hid_debug_event(hdev, buff); 625 break; 626 case REPORT_HOOK_VERSION: 627 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 628 "REPORT_HOOK_VERSION", report->id, raw_size-1); 629 hid_debug_event(hdev, buff); 630 break; 631 case REPORT_EXIT_FLASHER: 632 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 633 "REPORT_VERSION", report->id, raw_size-1); 634 hid_debug_event(hdev, buff); 635 snprintf(buff, BUFF_SZ, "\tRestart delay: %dms (0x%02x%02x)\n", 636 raw_data[1] | (raw_data[2] << 8), 637 raw_data[2], raw_data[1]); 638 hid_debug_event(hdev, buff); 639 break; 640 default: 641 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n", 642 "<unknown>", report->id, raw_size-1); 643 hid_debug_event(hdev, buff); 644 break; 645 } 646 wake_up_interruptible(&hdev->debug_wait); 647 kfree(buff); 648 } 649 650 void picolcd_debug_raw_event(struct picolcd_data *data, 651 struct hid_device *hdev, struct hid_report *report, 652 u8 *raw_data, int size) 653 { 654 char *buff; 655 656 #define BUFF_SZ 256 657 /* Avoid unnecessary overhead if debugfs is disabled */ 658 if (list_empty(&hdev->debug_list)) 659 return; 660 661 buff = kmalloc(BUFF_SZ, GFP_ATOMIC); 662 if (!buff) 663 return; 664 665 switch (report->id) { 666 case REPORT_ERROR_CODE: 667 /* 2 data bytes with affected report and error code */ 668 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n", 669 "REPORT_ERROR_CODE", report->id, size-1); 670 hid_debug_event(hdev, buff); 671 if (raw_data[2] < ARRAY_SIZE(error_codes)) 672 snprintf(buff, BUFF_SZ, "\tError code 0x%02x (%s) in reply to report 0x%02x\n", 673 raw_data[2], error_codes[raw_data[2]], raw_data[1]); 674 else 675 snprintf(buff, BUFF_SZ, "\tError code 0x%02x in reply to report 0x%02x\n", 676 raw_data[2], raw_data[1]); 677 hid_debug_event(hdev, buff); 678 break; 679 case REPORT_KEY_STATE: 680 /* 2 data bytes with key state */ 681 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n", 682 "REPORT_KEY_STATE", report->id, size-1); 683 hid_debug_event(hdev, buff); 684 if (raw_data[1] == 0) 685 snprintf(buff, BUFF_SZ, "\tNo key pressed\n"); 686 else if (raw_data[2] == 0) 687 snprintf(buff, BUFF_SZ, "\tOne key pressed: 0x%02x (%d)\n", 688 raw_data[1], raw_data[1]); 689 else 690 snprintf(buff, BUFF_SZ, "\tTwo keys pressed: 0x%02x (%d), 0x%02x (%d)\n", 691 raw_data[1], raw_data[1], raw_data[2], raw_data[2]); 692 hid_debug_event(hdev, buff); 693 break; 694 case REPORT_IR_DATA: 695 /* Up to 20 byes of IR scancode data */ 696 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n", 697 "REPORT_IR_DATA", report->id, size-1); 698 hid_debug_event(hdev, buff); 699 if (raw_data[1] == 0) { 700 snprintf(buff, BUFF_SZ, "\tUnexpectedly 0 data length\n"); 701 hid_debug_event(hdev, buff); 702 } else if (raw_data[1] + 1 <= size) { 703 snprintf(buff, BUFF_SZ, "\tData length: %d\n\tIR Data: ", 704 raw_data[1]); 705 hid_debug_event(hdev, buff); 706 dump_buff_as_hex(buff, BUFF_SZ, raw_data+2, raw_data[1]); 707 hid_debug_event(hdev, buff); 708 } else { 709 snprintf(buff, BUFF_SZ, "\tOverflowing data length: %d\n", 710 raw_data[1]-1); 711 hid_debug_event(hdev, buff); 712 } 713 break; 714 case REPORT_EE_DATA: 715 /* Data buffer in response to REPORT_EE_READ or REPORT_EE_WRITE */ 716 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n", 717 "REPORT_EE_DATA", report->id, size-1); 718 hid_debug_event(hdev, buff); 719 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n", 720 raw_data[2], raw_data[1]); 721 hid_debug_event(hdev, buff); 722 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]); 723 hid_debug_event(hdev, buff); 724 if (raw_data[3] == 0) { 725 snprintf(buff, BUFF_SZ, "\tNo data\n"); 726 hid_debug_event(hdev, buff); 727 } else if (raw_data[3] + 4 <= size) { 728 snprintf(buff, BUFF_SZ, "\tData: "); 729 hid_debug_event(hdev, buff); 730 dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]); 731 hid_debug_event(hdev, buff); 732 } else { 733 snprintf(buff, BUFF_SZ, "\tData overflowed\n"); 734 hid_debug_event(hdev, buff); 735 } 736 break; 737 case REPORT_MEMORY: 738 /* Data buffer in response to REPORT_READ_MEMORY or REPORT_WRTIE_MEMORY */ 739 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n", 740 "REPORT_MEMORY", report->id, size-1); 741 hid_debug_event(hdev, buff); 742 switch (data->addr_sz) { 743 case 2: 744 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n", 745 raw_data[2], raw_data[1]); 746 hid_debug_event(hdev, buff); 747 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]); 748 hid_debug_event(hdev, buff); 749 if (raw_data[3] == 0) { 750 snprintf(buff, BUFF_SZ, "\tNo data\n"); 751 } else if (raw_data[3] + 4 <= size) { 752 snprintf(buff, BUFF_SZ, "\tData: "); 753 hid_debug_event(hdev, buff); 754 dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]); 755 } else { 756 snprintf(buff, BUFF_SZ, "\tData overflowed\n"); 757 } 758 break; 759 case 3: 760 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x%02x\n", 761 raw_data[3], raw_data[2], raw_data[1]); 762 hid_debug_event(hdev, buff); 763 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]); 764 hid_debug_event(hdev, buff); 765 if (raw_data[4] == 0) { 766 snprintf(buff, BUFF_SZ, "\tNo data\n"); 767 } else if (raw_data[4] + 5 <= size) { 768 snprintf(buff, BUFF_SZ, "\tData: "); 769 hid_debug_event(hdev, buff); 770 dump_buff_as_hex(buff, BUFF_SZ, raw_data+5, raw_data[4]); 771 } else { 772 snprintf(buff, BUFF_SZ, "\tData overflowed\n"); 773 } 774 break; 775 default: 776 snprintf(buff, BUFF_SZ, "\tNot supported\n"); 777 } 778 hid_debug_event(hdev, buff); 779 break; 780 case REPORT_VERSION: 781 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n", 782 "REPORT_VERSION", report->id, size-1); 783 hid_debug_event(hdev, buff); 784 snprintf(buff, BUFF_SZ, "\tFirmware version: %d.%d\n", 785 raw_data[2], raw_data[1]); 786 hid_debug_event(hdev, buff); 787 break; 788 case REPORT_BL_ERASE_MEMORY: 789 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n", 790 "REPORT_BL_ERASE_MEMORY", report->id, size-1); 791 hid_debug_event(hdev, buff); 792 /* TODO */ 793 break; 794 case REPORT_BL_READ_MEMORY: 795 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n", 796 "REPORT_BL_READ_MEMORY", report->id, size-1); 797 hid_debug_event(hdev, buff); 798 /* TODO */ 799 break; 800 case REPORT_BL_WRITE_MEMORY: 801 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n", 802 "REPORT_BL_WRITE_MEMORY", report->id, size-1); 803 hid_debug_event(hdev, buff); 804 /* TODO */ 805 break; 806 case REPORT_DEVID: 807 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n", 808 "REPORT_DEVID", report->id, size-1); 809 hid_debug_event(hdev, buff); 810 snprintf(buff, BUFF_SZ, "\tSerial: 0x%02x%02x%02x%02x\n", 811 raw_data[1], raw_data[2], raw_data[3], raw_data[4]); 812 hid_debug_event(hdev, buff); 813 snprintf(buff, BUFF_SZ, "\tType: 0x%02x\n", 814 raw_data[5]); 815 hid_debug_event(hdev, buff); 816 break; 817 case REPORT_SPLASH_SIZE: 818 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n", 819 "REPORT_SPLASH_SIZE", report->id, size-1); 820 hid_debug_event(hdev, buff); 821 snprintf(buff, BUFF_SZ, "\tTotal splash space: %d\n", 822 (raw_data[2] << 8) | raw_data[1]); 823 hid_debug_event(hdev, buff); 824 snprintf(buff, BUFF_SZ, "\tUsed splash space: %d\n", 825 (raw_data[4] << 8) | raw_data[3]); 826 hid_debug_event(hdev, buff); 827 break; 828 case REPORT_HOOK_VERSION: 829 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n", 830 "REPORT_HOOK_VERSION", report->id, size-1); 831 hid_debug_event(hdev, buff); 832 snprintf(buff, BUFF_SZ, "\tFirmware version: %d.%d\n", 833 raw_data[1], raw_data[2]); 834 hid_debug_event(hdev, buff); 835 break; 836 default: 837 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n", 838 "<unknown>", report->id, size-1); 839 hid_debug_event(hdev, buff); 840 break; 841 } 842 wake_up_interruptible(&hdev->debug_wait); 843 kfree(buff); 844 } 845 846 void picolcd_init_devfs(struct picolcd_data *data, 847 struct hid_report *eeprom_r, struct hid_report *eeprom_w, 848 struct hid_report *flash_r, struct hid_report *flash_w, 849 struct hid_report *reset) 850 { 851 struct hid_device *hdev = data->hdev; 852 853 mutex_init(&data->mutex_flash); 854 855 /* reset */ 856 if (reset) 857 data->debug_reset = debugfs_create_file("reset", 0600, 858 hdev->debug_dir, data, &picolcd_debug_reset_fops); 859 860 /* eeprom */ 861 if (eeprom_r || eeprom_w) 862 data->debug_eeprom = debugfs_create_file("eeprom", 863 (eeprom_w ? S_IWUSR : 0) | (eeprom_r ? S_IRUSR : 0), 864 hdev->debug_dir, data, &picolcd_debug_eeprom_fops); 865 866 /* flash */ 867 if (flash_r && flash_r->maxfield == 1 && flash_r->field[0]->report_size == 8) 868 data->addr_sz = flash_r->field[0]->report_count - 1; 869 else 870 data->addr_sz = -1; 871 if (data->addr_sz == 2 || data->addr_sz == 3) { 872 data->debug_flash = debugfs_create_file("flash", 873 (flash_w ? S_IWUSR : 0) | (flash_r ? S_IRUSR : 0), 874 hdev->debug_dir, data, &picolcd_debug_flash_fops); 875 } else if (flash_r || flash_w) 876 hid_warn(hdev, "Unexpected FLASH access reports, please submit rdesc for review\n"); 877 } 878 879 void picolcd_exit_devfs(struct picolcd_data *data) 880 { 881 struct dentry *dent; 882 883 dent = data->debug_reset; 884 data->debug_reset = NULL; 885 if (dent) 886 debugfs_remove(dent); 887 dent = data->debug_eeprom; 888 data->debug_eeprom = NULL; 889 if (dent) 890 debugfs_remove(dent); 891 dent = data->debug_flash; 892 data->debug_flash = NULL; 893 if (dent) 894 debugfs_remove(dent); 895 mutex_destroy(&data->mutex_flash); 896 } 897 898