1 /* 2 * Driver for IMS Passenger Control Unit Devices 3 * 4 * Copyright (C) 2013 The IMS Company 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 8 * as published by the Free Software Foundation. 9 */ 10 11 #include <linux/completion.h> 12 #include <linux/device.h> 13 #include <linux/firmware.h> 14 #include <linux/ihex.h> 15 #include <linux/input.h> 16 #include <linux/kernel.h> 17 #include <linux/leds.h> 18 #include <linux/module.h> 19 #include <linux/slab.h> 20 #include <linux/types.h> 21 #include <linux/usb/input.h> 22 #include <linux/usb/cdc.h> 23 #include <asm/unaligned.h> 24 25 #define IMS_PCU_KEYMAP_LEN 32 26 27 struct ims_pcu_buttons { 28 struct input_dev *input; 29 char name[32]; 30 char phys[32]; 31 unsigned short keymap[IMS_PCU_KEYMAP_LEN]; 32 }; 33 34 struct ims_pcu_gamepad { 35 struct input_dev *input; 36 char name[32]; 37 char phys[32]; 38 }; 39 40 struct ims_pcu_backlight { 41 struct led_classdev cdev; 42 char name[32]; 43 }; 44 45 #define IMS_PCU_PART_NUMBER_LEN 15 46 #define IMS_PCU_SERIAL_NUMBER_LEN 8 47 #define IMS_PCU_DOM_LEN 8 48 #define IMS_PCU_FW_VERSION_LEN (9 + 1) 49 #define IMS_PCU_BL_VERSION_LEN (9 + 1) 50 #define IMS_PCU_BL_RESET_REASON_LEN (2 + 1) 51 52 #define IMS_PCU_PCU_B_DEVICE_ID 5 53 54 #define IMS_PCU_BUF_SIZE 128 55 56 struct ims_pcu { 57 struct usb_device *udev; 58 struct device *dev; /* control interface's device, used for logging */ 59 60 unsigned int device_no; 61 62 bool bootloader_mode; 63 64 char part_number[IMS_PCU_PART_NUMBER_LEN]; 65 char serial_number[IMS_PCU_SERIAL_NUMBER_LEN]; 66 char date_of_manufacturing[IMS_PCU_DOM_LEN]; 67 char fw_version[IMS_PCU_FW_VERSION_LEN]; 68 char bl_version[IMS_PCU_BL_VERSION_LEN]; 69 char reset_reason[IMS_PCU_BL_RESET_REASON_LEN]; 70 int update_firmware_status; 71 u8 device_id; 72 73 u8 ofn_reg_addr; 74 75 struct usb_interface *ctrl_intf; 76 77 struct usb_endpoint_descriptor *ep_ctrl; 78 struct urb *urb_ctrl; 79 u8 *urb_ctrl_buf; 80 dma_addr_t ctrl_dma; 81 size_t max_ctrl_size; 82 83 struct usb_interface *data_intf; 84 85 struct usb_endpoint_descriptor *ep_in; 86 struct urb *urb_in; 87 u8 *urb_in_buf; 88 dma_addr_t read_dma; 89 size_t max_in_size; 90 91 struct usb_endpoint_descriptor *ep_out; 92 u8 *urb_out_buf; 93 size_t max_out_size; 94 95 u8 read_buf[IMS_PCU_BUF_SIZE]; 96 u8 read_pos; 97 u8 check_sum; 98 bool have_stx; 99 bool have_dle; 100 101 u8 cmd_buf[IMS_PCU_BUF_SIZE]; 102 u8 ack_id; 103 u8 expected_response; 104 u8 cmd_buf_len; 105 struct completion cmd_done; 106 struct mutex cmd_mutex; 107 108 u32 fw_start_addr; 109 u32 fw_end_addr; 110 struct completion async_firmware_done; 111 112 struct ims_pcu_buttons buttons; 113 struct ims_pcu_gamepad *gamepad; 114 struct ims_pcu_backlight backlight; 115 116 bool setup_complete; /* Input and LED devices have been created */ 117 }; 118 119 120 /********************************************************************* 121 * Buttons Input device support * 122 *********************************************************************/ 123 124 static const unsigned short ims_pcu_keymap_1[] = { 125 [1] = KEY_ATTENDANT_OFF, 126 [2] = KEY_ATTENDANT_ON, 127 [3] = KEY_LIGHTS_TOGGLE, 128 [4] = KEY_VOLUMEUP, 129 [5] = KEY_VOLUMEDOWN, 130 [6] = KEY_INFO, 131 }; 132 133 static const unsigned short ims_pcu_keymap_2[] = { 134 [4] = KEY_VOLUMEUP, 135 [5] = KEY_VOLUMEDOWN, 136 [6] = KEY_INFO, 137 }; 138 139 static const unsigned short ims_pcu_keymap_3[] = { 140 [1] = KEY_HOMEPAGE, 141 [2] = KEY_ATTENDANT_TOGGLE, 142 [3] = KEY_LIGHTS_TOGGLE, 143 [4] = KEY_VOLUMEUP, 144 [5] = KEY_VOLUMEDOWN, 145 [6] = KEY_DISPLAYTOGGLE, 146 [18] = KEY_PLAYPAUSE, 147 }; 148 149 static const unsigned short ims_pcu_keymap_4[] = { 150 [1] = KEY_ATTENDANT_OFF, 151 [2] = KEY_ATTENDANT_ON, 152 [3] = KEY_LIGHTS_TOGGLE, 153 [4] = KEY_VOLUMEUP, 154 [5] = KEY_VOLUMEDOWN, 155 [6] = KEY_INFO, 156 [18] = KEY_PLAYPAUSE, 157 }; 158 159 static const unsigned short ims_pcu_keymap_5[] = { 160 [1] = KEY_ATTENDANT_OFF, 161 [2] = KEY_ATTENDANT_ON, 162 [3] = KEY_LIGHTS_TOGGLE, 163 }; 164 165 struct ims_pcu_device_info { 166 const unsigned short *keymap; 167 size_t keymap_len; 168 bool has_gamepad; 169 }; 170 171 #define IMS_PCU_DEVINFO(_n, _gamepad) \ 172 [_n] = { \ 173 .keymap = ims_pcu_keymap_##_n, \ 174 .keymap_len = ARRAY_SIZE(ims_pcu_keymap_##_n), \ 175 .has_gamepad = _gamepad, \ 176 } 177 178 static const struct ims_pcu_device_info ims_pcu_device_info[] = { 179 IMS_PCU_DEVINFO(1, true), 180 IMS_PCU_DEVINFO(2, true), 181 IMS_PCU_DEVINFO(3, true), 182 IMS_PCU_DEVINFO(4, true), 183 IMS_PCU_DEVINFO(5, false), 184 }; 185 186 static void ims_pcu_buttons_report(struct ims_pcu *pcu, u32 data) 187 { 188 struct ims_pcu_buttons *buttons = &pcu->buttons; 189 struct input_dev *input = buttons->input; 190 int i; 191 192 for (i = 0; i < 32; i++) { 193 unsigned short keycode = buttons->keymap[i]; 194 195 if (keycode != KEY_RESERVED) 196 input_report_key(input, keycode, data & (1UL << i)); 197 } 198 199 input_sync(input); 200 } 201 202 static int ims_pcu_setup_buttons(struct ims_pcu *pcu, 203 const unsigned short *keymap, 204 size_t keymap_len) 205 { 206 struct ims_pcu_buttons *buttons = &pcu->buttons; 207 struct input_dev *input; 208 int i; 209 int error; 210 211 input = input_allocate_device(); 212 if (!input) { 213 dev_err(pcu->dev, 214 "Not enough memory for input input device\n"); 215 return -ENOMEM; 216 } 217 218 snprintf(buttons->name, sizeof(buttons->name), 219 "IMS PCU#%d Button Interface", pcu->device_no); 220 221 usb_make_path(pcu->udev, buttons->phys, sizeof(buttons->phys)); 222 strlcat(buttons->phys, "/input0", sizeof(buttons->phys)); 223 224 memcpy(buttons->keymap, keymap, sizeof(*keymap) * keymap_len); 225 226 input->name = buttons->name; 227 input->phys = buttons->phys; 228 usb_to_input_id(pcu->udev, &input->id); 229 input->dev.parent = &pcu->ctrl_intf->dev; 230 231 input->keycode = buttons->keymap; 232 input->keycodemax = ARRAY_SIZE(buttons->keymap); 233 input->keycodesize = sizeof(buttons->keymap[0]); 234 235 __set_bit(EV_KEY, input->evbit); 236 for (i = 0; i < IMS_PCU_KEYMAP_LEN; i++) 237 __set_bit(buttons->keymap[i], input->keybit); 238 __clear_bit(KEY_RESERVED, input->keybit); 239 240 error = input_register_device(input); 241 if (error) { 242 dev_err(pcu->dev, 243 "Failed to register buttons input device: %d\n", 244 error); 245 input_free_device(input); 246 return error; 247 } 248 249 buttons->input = input; 250 return 0; 251 } 252 253 static void ims_pcu_destroy_buttons(struct ims_pcu *pcu) 254 { 255 struct ims_pcu_buttons *buttons = &pcu->buttons; 256 257 input_unregister_device(buttons->input); 258 } 259 260 261 /********************************************************************* 262 * Gamepad Input device support * 263 *********************************************************************/ 264 265 static void ims_pcu_gamepad_report(struct ims_pcu *pcu, u32 data) 266 { 267 struct ims_pcu_gamepad *gamepad = pcu->gamepad; 268 struct input_dev *input = gamepad->input; 269 int x, y; 270 271 x = !!(data & (1 << 14)) - !!(data & (1 << 13)); 272 y = !!(data & (1 << 12)) - !!(data & (1 << 11)); 273 274 input_report_abs(input, ABS_X, x); 275 input_report_abs(input, ABS_Y, y); 276 277 input_report_key(input, BTN_A, data & (1 << 7)); 278 input_report_key(input, BTN_B, data & (1 << 8)); 279 input_report_key(input, BTN_X, data & (1 << 9)); 280 input_report_key(input, BTN_Y, data & (1 << 10)); 281 input_report_key(input, BTN_START, data & (1 << 15)); 282 input_report_key(input, BTN_SELECT, data & (1 << 16)); 283 284 input_sync(input); 285 } 286 287 static int ims_pcu_setup_gamepad(struct ims_pcu *pcu) 288 { 289 struct ims_pcu_gamepad *gamepad; 290 struct input_dev *input; 291 int error; 292 293 gamepad = kzalloc(sizeof(struct ims_pcu_gamepad), GFP_KERNEL); 294 input = input_allocate_device(); 295 if (!gamepad || !input) { 296 dev_err(pcu->dev, 297 "Not enough memory for gamepad device\n"); 298 error = -ENOMEM; 299 goto err_free_mem; 300 } 301 302 gamepad->input = input; 303 304 snprintf(gamepad->name, sizeof(gamepad->name), 305 "IMS PCU#%d Gamepad Interface", pcu->device_no); 306 307 usb_make_path(pcu->udev, gamepad->phys, sizeof(gamepad->phys)); 308 strlcat(gamepad->phys, "/input1", sizeof(gamepad->phys)); 309 310 input->name = gamepad->name; 311 input->phys = gamepad->phys; 312 usb_to_input_id(pcu->udev, &input->id); 313 input->dev.parent = &pcu->ctrl_intf->dev; 314 315 __set_bit(EV_KEY, input->evbit); 316 __set_bit(BTN_A, input->keybit); 317 __set_bit(BTN_B, input->keybit); 318 __set_bit(BTN_X, input->keybit); 319 __set_bit(BTN_Y, input->keybit); 320 __set_bit(BTN_START, input->keybit); 321 __set_bit(BTN_SELECT, input->keybit); 322 323 __set_bit(EV_ABS, input->evbit); 324 input_set_abs_params(input, ABS_X, -1, 1, 0, 0); 325 input_set_abs_params(input, ABS_Y, -1, 1, 0, 0); 326 327 error = input_register_device(input); 328 if (error) { 329 dev_err(pcu->dev, 330 "Failed to register gamepad input device: %d\n", 331 error); 332 goto err_free_mem; 333 } 334 335 pcu->gamepad = gamepad; 336 return 0; 337 338 err_free_mem: 339 input_free_device(input); 340 kfree(gamepad); 341 return -ENOMEM; 342 } 343 344 static void ims_pcu_destroy_gamepad(struct ims_pcu *pcu) 345 { 346 struct ims_pcu_gamepad *gamepad = pcu->gamepad; 347 348 input_unregister_device(gamepad->input); 349 kfree(gamepad); 350 } 351 352 353 /********************************************************************* 354 * PCU Communication protocol handling * 355 *********************************************************************/ 356 357 #define IMS_PCU_PROTOCOL_STX 0x02 358 #define IMS_PCU_PROTOCOL_ETX 0x03 359 #define IMS_PCU_PROTOCOL_DLE 0x10 360 361 /* PCU commands */ 362 #define IMS_PCU_CMD_STATUS 0xa0 363 #define IMS_PCU_CMD_PCU_RESET 0xa1 364 #define IMS_PCU_CMD_RESET_REASON 0xa2 365 #define IMS_PCU_CMD_SEND_BUTTONS 0xa3 366 #define IMS_PCU_CMD_JUMP_TO_BTLDR 0xa4 367 #define IMS_PCU_CMD_GET_INFO 0xa5 368 #define IMS_PCU_CMD_SET_BRIGHTNESS 0xa6 369 #define IMS_PCU_CMD_EEPROM 0xa7 370 #define IMS_PCU_CMD_GET_FW_VERSION 0xa8 371 #define IMS_PCU_CMD_GET_BL_VERSION 0xa9 372 #define IMS_PCU_CMD_SET_INFO 0xab 373 #define IMS_PCU_CMD_GET_BRIGHTNESS 0xac 374 #define IMS_PCU_CMD_GET_DEVICE_ID 0xae 375 #define IMS_PCU_CMD_SPECIAL_INFO 0xb0 376 #define IMS_PCU_CMD_BOOTLOADER 0xb1 /* Pass data to bootloader */ 377 #define IMS_PCU_CMD_OFN_SET_CONFIG 0xb3 378 #define IMS_PCU_CMD_OFN_GET_CONFIG 0xb4 379 380 /* PCU responses */ 381 #define IMS_PCU_RSP_STATUS 0xc0 382 #define IMS_PCU_RSP_PCU_RESET 0 /* Originally 0xc1 */ 383 #define IMS_PCU_RSP_RESET_REASON 0xc2 384 #define IMS_PCU_RSP_SEND_BUTTONS 0xc3 385 #define IMS_PCU_RSP_JUMP_TO_BTLDR 0 /* Originally 0xc4 */ 386 #define IMS_PCU_RSP_GET_INFO 0xc5 387 #define IMS_PCU_RSP_SET_BRIGHTNESS 0xc6 388 #define IMS_PCU_RSP_EEPROM 0xc7 389 #define IMS_PCU_RSP_GET_FW_VERSION 0xc8 390 #define IMS_PCU_RSP_GET_BL_VERSION 0xc9 391 #define IMS_PCU_RSP_SET_INFO 0xcb 392 #define IMS_PCU_RSP_GET_BRIGHTNESS 0xcc 393 #define IMS_PCU_RSP_CMD_INVALID 0xcd 394 #define IMS_PCU_RSP_GET_DEVICE_ID 0xce 395 #define IMS_PCU_RSP_SPECIAL_INFO 0xd0 396 #define IMS_PCU_RSP_BOOTLOADER 0xd1 /* Bootloader response */ 397 #define IMS_PCU_RSP_OFN_SET_CONFIG 0xd2 398 #define IMS_PCU_RSP_OFN_GET_CONFIG 0xd3 399 400 401 #define IMS_PCU_RSP_EVNT_BUTTONS 0xe0 /* Unsolicited, button state */ 402 #define IMS_PCU_GAMEPAD_MASK 0x0001ff80UL /* Bits 7 through 16 */ 403 404 405 #define IMS_PCU_MIN_PACKET_LEN 3 406 #define IMS_PCU_DATA_OFFSET 2 407 408 #define IMS_PCU_CMD_WRITE_TIMEOUT 100 /* msec */ 409 #define IMS_PCU_CMD_RESPONSE_TIMEOUT 500 /* msec */ 410 411 static void ims_pcu_report_events(struct ims_pcu *pcu) 412 { 413 u32 data = get_unaligned_be32(&pcu->read_buf[3]); 414 415 ims_pcu_buttons_report(pcu, data & ~IMS_PCU_GAMEPAD_MASK); 416 if (pcu->gamepad) 417 ims_pcu_gamepad_report(pcu, data); 418 } 419 420 static void ims_pcu_handle_response(struct ims_pcu *pcu) 421 { 422 switch (pcu->read_buf[0]) { 423 case IMS_PCU_RSP_EVNT_BUTTONS: 424 if (likely(pcu->setup_complete)) 425 ims_pcu_report_events(pcu); 426 break; 427 428 default: 429 /* 430 * See if we got command completion. 431 * If both the sequence and response code match save 432 * the data and signal completion. 433 */ 434 if (pcu->read_buf[0] == pcu->expected_response && 435 pcu->read_buf[1] == pcu->ack_id - 1) { 436 437 memcpy(pcu->cmd_buf, pcu->read_buf, pcu->read_pos); 438 pcu->cmd_buf_len = pcu->read_pos; 439 complete(&pcu->cmd_done); 440 } 441 break; 442 } 443 } 444 445 static void ims_pcu_process_data(struct ims_pcu *pcu, struct urb *urb) 446 { 447 int i; 448 449 for (i = 0; i < urb->actual_length; i++) { 450 u8 data = pcu->urb_in_buf[i]; 451 452 /* Skip everything until we get Start Xmit */ 453 if (!pcu->have_stx && data != IMS_PCU_PROTOCOL_STX) 454 continue; 455 456 if (pcu->have_dle) { 457 pcu->have_dle = false; 458 pcu->read_buf[pcu->read_pos++] = data; 459 pcu->check_sum += data; 460 continue; 461 } 462 463 switch (data) { 464 case IMS_PCU_PROTOCOL_STX: 465 if (pcu->have_stx) 466 dev_warn(pcu->dev, 467 "Unexpected STX at byte %d, discarding old data\n", 468 pcu->read_pos); 469 pcu->have_stx = true; 470 pcu->have_dle = false; 471 pcu->read_pos = 0; 472 pcu->check_sum = 0; 473 break; 474 475 case IMS_PCU_PROTOCOL_DLE: 476 pcu->have_dle = true; 477 break; 478 479 case IMS_PCU_PROTOCOL_ETX: 480 if (pcu->read_pos < IMS_PCU_MIN_PACKET_LEN) { 481 dev_warn(pcu->dev, 482 "Short packet received (%d bytes), ignoring\n", 483 pcu->read_pos); 484 } else if (pcu->check_sum != 0) { 485 dev_warn(pcu->dev, 486 "Invalid checksum in packet (%d bytes), ignoring\n", 487 pcu->read_pos); 488 } else { 489 ims_pcu_handle_response(pcu); 490 } 491 492 pcu->have_stx = false; 493 pcu->have_dle = false; 494 pcu->read_pos = 0; 495 break; 496 497 default: 498 pcu->read_buf[pcu->read_pos++] = data; 499 pcu->check_sum += data; 500 break; 501 } 502 } 503 } 504 505 static bool ims_pcu_byte_needs_escape(u8 byte) 506 { 507 return byte == IMS_PCU_PROTOCOL_STX || 508 byte == IMS_PCU_PROTOCOL_ETX || 509 byte == IMS_PCU_PROTOCOL_DLE; 510 } 511 512 static int ims_pcu_send_cmd_chunk(struct ims_pcu *pcu, 513 u8 command, int chunk, int len) 514 { 515 int error; 516 517 error = usb_bulk_msg(pcu->udev, 518 usb_sndbulkpipe(pcu->udev, 519 pcu->ep_out->bEndpointAddress), 520 pcu->urb_out_buf, len, 521 NULL, IMS_PCU_CMD_WRITE_TIMEOUT); 522 if (error < 0) { 523 dev_dbg(pcu->dev, 524 "Sending 0x%02x command failed at chunk %d: %d\n", 525 command, chunk, error); 526 return error; 527 } 528 529 return 0; 530 } 531 532 static int ims_pcu_send_command(struct ims_pcu *pcu, 533 u8 command, const u8 *data, int len) 534 { 535 int count = 0; 536 int chunk = 0; 537 int delta; 538 int i; 539 int error; 540 u8 csum = 0; 541 u8 ack_id; 542 543 pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_STX; 544 545 /* We know the command need not be escaped */ 546 pcu->urb_out_buf[count++] = command; 547 csum += command; 548 549 ack_id = pcu->ack_id++; 550 if (ack_id == 0xff) 551 ack_id = pcu->ack_id++; 552 553 if (ims_pcu_byte_needs_escape(ack_id)) 554 pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_DLE; 555 556 pcu->urb_out_buf[count++] = ack_id; 557 csum += ack_id; 558 559 for (i = 0; i < len; i++) { 560 561 delta = ims_pcu_byte_needs_escape(data[i]) ? 2 : 1; 562 if (count + delta >= pcu->max_out_size) { 563 error = ims_pcu_send_cmd_chunk(pcu, command, 564 ++chunk, count); 565 if (error) 566 return error; 567 568 count = 0; 569 } 570 571 if (delta == 2) 572 pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_DLE; 573 574 pcu->urb_out_buf[count++] = data[i]; 575 csum += data[i]; 576 } 577 578 csum = 1 + ~csum; 579 580 delta = ims_pcu_byte_needs_escape(csum) ? 3 : 2; 581 if (count + delta >= pcu->max_out_size) { 582 error = ims_pcu_send_cmd_chunk(pcu, command, ++chunk, count); 583 if (error) 584 return error; 585 586 count = 0; 587 } 588 589 if (delta == 3) 590 pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_DLE; 591 592 pcu->urb_out_buf[count++] = csum; 593 pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_ETX; 594 595 return ims_pcu_send_cmd_chunk(pcu, command, ++chunk, count); 596 } 597 598 static int __ims_pcu_execute_command(struct ims_pcu *pcu, 599 u8 command, const void *data, size_t len, 600 u8 expected_response, int response_time) 601 { 602 int error; 603 604 pcu->expected_response = expected_response; 605 init_completion(&pcu->cmd_done); 606 607 error = ims_pcu_send_command(pcu, command, data, len); 608 if (error) 609 return error; 610 611 if (expected_response && 612 !wait_for_completion_timeout(&pcu->cmd_done, 613 msecs_to_jiffies(response_time))) { 614 dev_dbg(pcu->dev, "Command 0x%02x timed out\n", command); 615 return -ETIMEDOUT; 616 } 617 618 return 0; 619 } 620 621 #define ims_pcu_execute_command(pcu, code, data, len) \ 622 __ims_pcu_execute_command(pcu, \ 623 IMS_PCU_CMD_##code, data, len, \ 624 IMS_PCU_RSP_##code, \ 625 IMS_PCU_CMD_RESPONSE_TIMEOUT) 626 627 #define ims_pcu_execute_query(pcu, code) \ 628 ims_pcu_execute_command(pcu, code, NULL, 0) 629 630 /* Bootloader commands */ 631 #define IMS_PCU_BL_CMD_QUERY_DEVICE 0xa1 632 #define IMS_PCU_BL_CMD_UNLOCK_CONFIG 0xa2 633 #define IMS_PCU_BL_CMD_ERASE_APP 0xa3 634 #define IMS_PCU_BL_CMD_PROGRAM_DEVICE 0xa4 635 #define IMS_PCU_BL_CMD_PROGRAM_COMPLETE 0xa5 636 #define IMS_PCU_BL_CMD_READ_APP 0xa6 637 #define IMS_PCU_BL_CMD_RESET_DEVICE 0xa7 638 #define IMS_PCU_BL_CMD_LAUNCH_APP 0xa8 639 640 /* Bootloader commands */ 641 #define IMS_PCU_BL_RSP_QUERY_DEVICE 0xc1 642 #define IMS_PCU_BL_RSP_UNLOCK_CONFIG 0xc2 643 #define IMS_PCU_BL_RSP_ERASE_APP 0xc3 644 #define IMS_PCU_BL_RSP_PROGRAM_DEVICE 0xc4 645 #define IMS_PCU_BL_RSP_PROGRAM_COMPLETE 0xc5 646 #define IMS_PCU_BL_RSP_READ_APP 0xc6 647 #define IMS_PCU_BL_RSP_RESET_DEVICE 0 /* originally 0xa7 */ 648 #define IMS_PCU_BL_RSP_LAUNCH_APP 0 /* originally 0xa8 */ 649 650 #define IMS_PCU_BL_DATA_OFFSET 3 651 652 static int __ims_pcu_execute_bl_command(struct ims_pcu *pcu, 653 u8 command, const void *data, size_t len, 654 u8 expected_response, int response_time) 655 { 656 int error; 657 658 pcu->cmd_buf[0] = command; 659 if (data) 660 memcpy(&pcu->cmd_buf[1], data, len); 661 662 error = __ims_pcu_execute_command(pcu, 663 IMS_PCU_CMD_BOOTLOADER, pcu->cmd_buf, len + 1, 664 expected_response ? IMS_PCU_RSP_BOOTLOADER : 0, 665 response_time); 666 if (error) { 667 dev_err(pcu->dev, 668 "Failure when sending 0x%02x command to bootloader, error: %d\n", 669 pcu->cmd_buf[0], error); 670 return error; 671 } 672 673 if (expected_response && pcu->cmd_buf[2] != expected_response) { 674 dev_err(pcu->dev, 675 "Unexpected response from bootloader: 0x%02x, wanted 0x%02x\n", 676 pcu->cmd_buf[2], expected_response); 677 return -EINVAL; 678 } 679 680 return 0; 681 } 682 683 #define ims_pcu_execute_bl_command(pcu, code, data, len, timeout) \ 684 __ims_pcu_execute_bl_command(pcu, \ 685 IMS_PCU_BL_CMD_##code, data, len, \ 686 IMS_PCU_BL_RSP_##code, timeout) \ 687 688 #define IMS_PCU_INFO_PART_OFFSET 2 689 #define IMS_PCU_INFO_DOM_OFFSET 17 690 #define IMS_PCU_INFO_SERIAL_OFFSET 25 691 692 #define IMS_PCU_SET_INFO_SIZE 31 693 694 static int ims_pcu_get_info(struct ims_pcu *pcu) 695 { 696 int error; 697 698 error = ims_pcu_execute_query(pcu, GET_INFO); 699 if (error) { 700 dev_err(pcu->dev, 701 "GET_INFO command failed, error: %d\n", error); 702 return error; 703 } 704 705 memcpy(pcu->part_number, 706 &pcu->cmd_buf[IMS_PCU_INFO_PART_OFFSET], 707 sizeof(pcu->part_number)); 708 memcpy(pcu->date_of_manufacturing, 709 &pcu->cmd_buf[IMS_PCU_INFO_DOM_OFFSET], 710 sizeof(pcu->date_of_manufacturing)); 711 memcpy(pcu->serial_number, 712 &pcu->cmd_buf[IMS_PCU_INFO_SERIAL_OFFSET], 713 sizeof(pcu->serial_number)); 714 715 return 0; 716 } 717 718 static int ims_pcu_set_info(struct ims_pcu *pcu) 719 { 720 int error; 721 722 memcpy(&pcu->cmd_buf[IMS_PCU_INFO_PART_OFFSET], 723 pcu->part_number, sizeof(pcu->part_number)); 724 memcpy(&pcu->cmd_buf[IMS_PCU_INFO_DOM_OFFSET], 725 pcu->date_of_manufacturing, sizeof(pcu->date_of_manufacturing)); 726 memcpy(&pcu->cmd_buf[IMS_PCU_INFO_SERIAL_OFFSET], 727 pcu->serial_number, sizeof(pcu->serial_number)); 728 729 error = ims_pcu_execute_command(pcu, SET_INFO, 730 &pcu->cmd_buf[IMS_PCU_DATA_OFFSET], 731 IMS_PCU_SET_INFO_SIZE); 732 if (error) { 733 dev_err(pcu->dev, 734 "Failed to update device information, error: %d\n", 735 error); 736 return error; 737 } 738 739 return 0; 740 } 741 742 static int ims_pcu_switch_to_bootloader(struct ims_pcu *pcu) 743 { 744 int error; 745 746 /* Execute jump to the bootoloader */ 747 error = ims_pcu_execute_command(pcu, JUMP_TO_BTLDR, NULL, 0); 748 if (error) { 749 dev_err(pcu->dev, 750 "Failure when sending JUMP TO BOOLTLOADER command, error: %d\n", 751 error); 752 return error; 753 } 754 755 return 0; 756 } 757 758 /********************************************************************* 759 * Firmware Update handling * 760 *********************************************************************/ 761 762 #define IMS_PCU_FIRMWARE_NAME "imspcu.fw" 763 764 struct ims_pcu_flash_fmt { 765 __le32 addr; 766 u8 len; 767 u8 data[]; 768 }; 769 770 static unsigned int ims_pcu_count_fw_records(const struct firmware *fw) 771 { 772 const struct ihex_binrec *rec = (const struct ihex_binrec *)fw->data; 773 unsigned int count = 0; 774 775 while (rec) { 776 count++; 777 rec = ihex_next_binrec(rec); 778 } 779 780 return count; 781 } 782 783 static int ims_pcu_verify_block(struct ims_pcu *pcu, 784 u32 addr, u8 len, const u8 *data) 785 { 786 struct ims_pcu_flash_fmt *fragment; 787 int error; 788 789 fragment = (void *)&pcu->cmd_buf[1]; 790 put_unaligned_le32(addr, &fragment->addr); 791 fragment->len = len; 792 793 error = ims_pcu_execute_bl_command(pcu, READ_APP, NULL, 5, 794 IMS_PCU_CMD_RESPONSE_TIMEOUT); 795 if (error) { 796 dev_err(pcu->dev, 797 "Failed to retrieve block at 0x%08x, len %d, error: %d\n", 798 addr, len, error); 799 return error; 800 } 801 802 fragment = (void *)&pcu->cmd_buf[IMS_PCU_BL_DATA_OFFSET]; 803 if (get_unaligned_le32(&fragment->addr) != addr || 804 fragment->len != len) { 805 dev_err(pcu->dev, 806 "Wrong block when retrieving 0x%08x (0x%08x), len %d (%d)\n", 807 addr, get_unaligned_le32(&fragment->addr), 808 len, fragment->len); 809 return -EINVAL; 810 } 811 812 if (memcmp(fragment->data, data, len)) { 813 dev_err(pcu->dev, 814 "Mismatch in block at 0x%08x, len %d\n", 815 addr, len); 816 return -EINVAL; 817 } 818 819 return 0; 820 } 821 822 static int ims_pcu_flash_firmware(struct ims_pcu *pcu, 823 const struct firmware *fw, 824 unsigned int n_fw_records) 825 { 826 const struct ihex_binrec *rec = (const struct ihex_binrec *)fw->data; 827 struct ims_pcu_flash_fmt *fragment; 828 unsigned int count = 0; 829 u32 addr; 830 u8 len; 831 int error; 832 833 error = ims_pcu_execute_bl_command(pcu, ERASE_APP, NULL, 0, 2000); 834 if (error) { 835 dev_err(pcu->dev, 836 "Failed to erase application image, error: %d\n", 837 error); 838 return error; 839 } 840 841 while (rec) { 842 /* 843 * The firmware format is messed up for some reason. 844 * The address twice that of what is needed for some 845 * reason and we end up overwriting half of the data 846 * with the next record. 847 */ 848 addr = be32_to_cpu(rec->addr) / 2; 849 len = be16_to_cpu(rec->len); 850 851 fragment = (void *)&pcu->cmd_buf[1]; 852 put_unaligned_le32(addr, &fragment->addr); 853 fragment->len = len; 854 memcpy(fragment->data, rec->data, len); 855 856 error = ims_pcu_execute_bl_command(pcu, PROGRAM_DEVICE, 857 NULL, len + 5, 858 IMS_PCU_CMD_RESPONSE_TIMEOUT); 859 if (error) { 860 dev_err(pcu->dev, 861 "Failed to write block at 0x%08x, len %d, error: %d\n", 862 addr, len, error); 863 return error; 864 } 865 866 if (addr >= pcu->fw_start_addr && addr < pcu->fw_end_addr) { 867 error = ims_pcu_verify_block(pcu, addr, len, rec->data); 868 if (error) 869 return error; 870 } 871 872 count++; 873 pcu->update_firmware_status = (count * 100) / n_fw_records; 874 875 rec = ihex_next_binrec(rec); 876 } 877 878 error = ims_pcu_execute_bl_command(pcu, PROGRAM_COMPLETE, 879 NULL, 0, 2000); 880 if (error) 881 dev_err(pcu->dev, 882 "Failed to send PROGRAM_COMPLETE, error: %d\n", 883 error); 884 885 return 0; 886 } 887 888 static int ims_pcu_handle_firmware_update(struct ims_pcu *pcu, 889 const struct firmware *fw) 890 { 891 unsigned int n_fw_records; 892 int retval; 893 894 dev_info(pcu->dev, "Updating firmware %s, size: %zu\n", 895 IMS_PCU_FIRMWARE_NAME, fw->size); 896 897 n_fw_records = ims_pcu_count_fw_records(fw); 898 899 retval = ims_pcu_flash_firmware(pcu, fw, n_fw_records); 900 if (retval) 901 goto out; 902 903 retval = ims_pcu_execute_bl_command(pcu, LAUNCH_APP, NULL, 0, 0); 904 if (retval) 905 dev_err(pcu->dev, 906 "Failed to start application image, error: %d\n", 907 retval); 908 909 out: 910 pcu->update_firmware_status = retval; 911 sysfs_notify(&pcu->dev->kobj, NULL, "update_firmware_status"); 912 return retval; 913 } 914 915 static void ims_pcu_process_async_firmware(const struct firmware *fw, 916 void *context) 917 { 918 struct ims_pcu *pcu = context; 919 int error; 920 921 if (!fw) { 922 dev_err(pcu->dev, "Failed to get firmware %s\n", 923 IMS_PCU_FIRMWARE_NAME); 924 goto out; 925 } 926 927 error = ihex_validate_fw(fw); 928 if (error) { 929 dev_err(pcu->dev, "Firmware %s is invalid\n", 930 IMS_PCU_FIRMWARE_NAME); 931 goto out; 932 } 933 934 mutex_lock(&pcu->cmd_mutex); 935 ims_pcu_handle_firmware_update(pcu, fw); 936 mutex_unlock(&pcu->cmd_mutex); 937 938 release_firmware(fw); 939 940 out: 941 complete(&pcu->async_firmware_done); 942 } 943 944 /********************************************************************* 945 * Backlight LED device support * 946 *********************************************************************/ 947 948 #define IMS_PCU_MAX_BRIGHTNESS 31998 949 950 static int ims_pcu_backlight_set_brightness(struct led_classdev *cdev, 951 enum led_brightness value) 952 { 953 struct ims_pcu_backlight *backlight = 954 container_of(cdev, struct ims_pcu_backlight, cdev); 955 struct ims_pcu *pcu = 956 container_of(backlight, struct ims_pcu, backlight); 957 __le16 br_val = cpu_to_le16(value); 958 int error; 959 960 mutex_lock(&pcu->cmd_mutex); 961 962 error = ims_pcu_execute_command(pcu, SET_BRIGHTNESS, 963 &br_val, sizeof(br_val)); 964 if (error && error != -ENODEV) 965 dev_warn(pcu->dev, 966 "Failed to set desired brightness %u, error: %d\n", 967 value, error); 968 969 mutex_unlock(&pcu->cmd_mutex); 970 971 return error; 972 } 973 974 static enum led_brightness 975 ims_pcu_backlight_get_brightness(struct led_classdev *cdev) 976 { 977 struct ims_pcu_backlight *backlight = 978 container_of(cdev, struct ims_pcu_backlight, cdev); 979 struct ims_pcu *pcu = 980 container_of(backlight, struct ims_pcu, backlight); 981 int brightness; 982 int error; 983 984 mutex_lock(&pcu->cmd_mutex); 985 986 error = ims_pcu_execute_query(pcu, GET_BRIGHTNESS); 987 if (error) { 988 dev_warn(pcu->dev, 989 "Failed to get current brightness, error: %d\n", 990 error); 991 /* Assume the LED is OFF */ 992 brightness = LED_OFF; 993 } else { 994 brightness = 995 get_unaligned_le16(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET]); 996 } 997 998 mutex_unlock(&pcu->cmd_mutex); 999 1000 return brightness; 1001 } 1002 1003 static int ims_pcu_setup_backlight(struct ims_pcu *pcu) 1004 { 1005 struct ims_pcu_backlight *backlight = &pcu->backlight; 1006 int error; 1007 1008 snprintf(backlight->name, sizeof(backlight->name), 1009 "pcu%d::kbd_backlight", pcu->device_no); 1010 1011 backlight->cdev.name = backlight->name; 1012 backlight->cdev.max_brightness = IMS_PCU_MAX_BRIGHTNESS; 1013 backlight->cdev.brightness_get = ims_pcu_backlight_get_brightness; 1014 backlight->cdev.brightness_set_blocking = 1015 ims_pcu_backlight_set_brightness; 1016 1017 error = led_classdev_register(pcu->dev, &backlight->cdev); 1018 if (error) { 1019 dev_err(pcu->dev, 1020 "Failed to register backlight LED device, error: %d\n", 1021 error); 1022 return error; 1023 } 1024 1025 return 0; 1026 } 1027 1028 static void ims_pcu_destroy_backlight(struct ims_pcu *pcu) 1029 { 1030 struct ims_pcu_backlight *backlight = &pcu->backlight; 1031 1032 led_classdev_unregister(&backlight->cdev); 1033 } 1034 1035 1036 /********************************************************************* 1037 * Sysfs attributes handling * 1038 *********************************************************************/ 1039 1040 struct ims_pcu_attribute { 1041 struct device_attribute dattr; 1042 size_t field_offset; 1043 int field_length; 1044 }; 1045 1046 static ssize_t ims_pcu_attribute_show(struct device *dev, 1047 struct device_attribute *dattr, 1048 char *buf) 1049 { 1050 struct usb_interface *intf = to_usb_interface(dev); 1051 struct ims_pcu *pcu = usb_get_intfdata(intf); 1052 struct ims_pcu_attribute *attr = 1053 container_of(dattr, struct ims_pcu_attribute, dattr); 1054 char *field = (char *)pcu + attr->field_offset; 1055 1056 return scnprintf(buf, PAGE_SIZE, "%.*s\n", attr->field_length, field); 1057 } 1058 1059 static ssize_t ims_pcu_attribute_store(struct device *dev, 1060 struct device_attribute *dattr, 1061 const char *buf, size_t count) 1062 { 1063 1064 struct usb_interface *intf = to_usb_interface(dev); 1065 struct ims_pcu *pcu = usb_get_intfdata(intf); 1066 struct ims_pcu_attribute *attr = 1067 container_of(dattr, struct ims_pcu_attribute, dattr); 1068 char *field = (char *)pcu + attr->field_offset; 1069 size_t data_len; 1070 int error; 1071 1072 if (count > attr->field_length) 1073 return -EINVAL; 1074 1075 data_len = strnlen(buf, attr->field_length); 1076 if (data_len > attr->field_length) 1077 return -EINVAL; 1078 1079 error = mutex_lock_interruptible(&pcu->cmd_mutex); 1080 if (error) 1081 return error; 1082 1083 memset(field, 0, attr->field_length); 1084 memcpy(field, buf, data_len); 1085 1086 error = ims_pcu_set_info(pcu); 1087 1088 /* 1089 * Even if update failed, let's fetch the info again as we just 1090 * clobbered one of the fields. 1091 */ 1092 ims_pcu_get_info(pcu); 1093 1094 mutex_unlock(&pcu->cmd_mutex); 1095 1096 return error < 0 ? error : count; 1097 } 1098 1099 #define IMS_PCU_ATTR(_field, _mode) \ 1100 struct ims_pcu_attribute ims_pcu_attr_##_field = { \ 1101 .dattr = __ATTR(_field, _mode, \ 1102 ims_pcu_attribute_show, \ 1103 ims_pcu_attribute_store), \ 1104 .field_offset = offsetof(struct ims_pcu, _field), \ 1105 .field_length = sizeof(((struct ims_pcu *)NULL)->_field), \ 1106 } 1107 1108 #define IMS_PCU_RO_ATTR(_field) \ 1109 IMS_PCU_ATTR(_field, S_IRUGO) 1110 #define IMS_PCU_RW_ATTR(_field) \ 1111 IMS_PCU_ATTR(_field, S_IRUGO | S_IWUSR) 1112 1113 static IMS_PCU_RW_ATTR(part_number); 1114 static IMS_PCU_RW_ATTR(serial_number); 1115 static IMS_PCU_RW_ATTR(date_of_manufacturing); 1116 1117 static IMS_PCU_RO_ATTR(fw_version); 1118 static IMS_PCU_RO_ATTR(bl_version); 1119 static IMS_PCU_RO_ATTR(reset_reason); 1120 1121 static ssize_t ims_pcu_reset_device(struct device *dev, 1122 struct device_attribute *dattr, 1123 const char *buf, size_t count) 1124 { 1125 static const u8 reset_byte = 1; 1126 struct usb_interface *intf = to_usb_interface(dev); 1127 struct ims_pcu *pcu = usb_get_intfdata(intf); 1128 int value; 1129 int error; 1130 1131 error = kstrtoint(buf, 0, &value); 1132 if (error) 1133 return error; 1134 1135 if (value != 1) 1136 return -EINVAL; 1137 1138 dev_info(pcu->dev, "Attempting to reset device\n"); 1139 1140 error = ims_pcu_execute_command(pcu, PCU_RESET, &reset_byte, 1); 1141 if (error) { 1142 dev_info(pcu->dev, 1143 "Failed to reset device, error: %d\n", 1144 error); 1145 return error; 1146 } 1147 1148 return count; 1149 } 1150 1151 static DEVICE_ATTR(reset_device, S_IWUSR, NULL, ims_pcu_reset_device); 1152 1153 static ssize_t ims_pcu_update_firmware_store(struct device *dev, 1154 struct device_attribute *dattr, 1155 const char *buf, size_t count) 1156 { 1157 struct usb_interface *intf = to_usb_interface(dev); 1158 struct ims_pcu *pcu = usb_get_intfdata(intf); 1159 const struct firmware *fw = NULL; 1160 int value; 1161 int error; 1162 1163 error = kstrtoint(buf, 0, &value); 1164 if (error) 1165 return error; 1166 1167 if (value != 1) 1168 return -EINVAL; 1169 1170 error = mutex_lock_interruptible(&pcu->cmd_mutex); 1171 if (error) 1172 return error; 1173 1174 error = request_ihex_firmware(&fw, IMS_PCU_FIRMWARE_NAME, pcu->dev); 1175 if (error) { 1176 dev_err(pcu->dev, "Failed to request firmware %s, error: %d\n", 1177 IMS_PCU_FIRMWARE_NAME, error); 1178 goto out; 1179 } 1180 1181 /* 1182 * If we are already in bootloader mode we can proceed with 1183 * flashing the firmware. 1184 * 1185 * If we are in application mode, then we need to switch into 1186 * bootloader mode, which will cause the device to disconnect 1187 * and reconnect as different device. 1188 */ 1189 if (pcu->bootloader_mode) 1190 error = ims_pcu_handle_firmware_update(pcu, fw); 1191 else 1192 error = ims_pcu_switch_to_bootloader(pcu); 1193 1194 release_firmware(fw); 1195 1196 out: 1197 mutex_unlock(&pcu->cmd_mutex); 1198 return error ?: count; 1199 } 1200 1201 static DEVICE_ATTR(update_firmware, S_IWUSR, 1202 NULL, ims_pcu_update_firmware_store); 1203 1204 static ssize_t 1205 ims_pcu_update_firmware_status_show(struct device *dev, 1206 struct device_attribute *dattr, 1207 char *buf) 1208 { 1209 struct usb_interface *intf = to_usb_interface(dev); 1210 struct ims_pcu *pcu = usb_get_intfdata(intf); 1211 1212 return scnprintf(buf, PAGE_SIZE, "%d\n", pcu->update_firmware_status); 1213 } 1214 1215 static DEVICE_ATTR(update_firmware_status, S_IRUGO, 1216 ims_pcu_update_firmware_status_show, NULL); 1217 1218 static struct attribute *ims_pcu_attrs[] = { 1219 &ims_pcu_attr_part_number.dattr.attr, 1220 &ims_pcu_attr_serial_number.dattr.attr, 1221 &ims_pcu_attr_date_of_manufacturing.dattr.attr, 1222 &ims_pcu_attr_fw_version.dattr.attr, 1223 &ims_pcu_attr_bl_version.dattr.attr, 1224 &ims_pcu_attr_reset_reason.dattr.attr, 1225 &dev_attr_reset_device.attr, 1226 &dev_attr_update_firmware.attr, 1227 &dev_attr_update_firmware_status.attr, 1228 NULL 1229 }; 1230 1231 static umode_t ims_pcu_is_attr_visible(struct kobject *kobj, 1232 struct attribute *attr, int n) 1233 { 1234 struct device *dev = container_of(kobj, struct device, kobj); 1235 struct usb_interface *intf = to_usb_interface(dev); 1236 struct ims_pcu *pcu = usb_get_intfdata(intf); 1237 umode_t mode = attr->mode; 1238 1239 if (pcu->bootloader_mode) { 1240 if (attr != &dev_attr_update_firmware_status.attr && 1241 attr != &dev_attr_update_firmware.attr && 1242 attr != &dev_attr_reset_device.attr) { 1243 mode = 0; 1244 } 1245 } else { 1246 if (attr == &dev_attr_update_firmware_status.attr) 1247 mode = 0; 1248 } 1249 1250 return mode; 1251 } 1252 1253 static const struct attribute_group ims_pcu_attr_group = { 1254 .is_visible = ims_pcu_is_attr_visible, 1255 .attrs = ims_pcu_attrs, 1256 }; 1257 1258 /* Support for a separate OFN attribute group */ 1259 1260 #define OFN_REG_RESULT_OFFSET 2 1261 1262 static int ims_pcu_read_ofn_config(struct ims_pcu *pcu, u8 addr, u8 *data) 1263 { 1264 int error; 1265 s16 result; 1266 1267 error = ims_pcu_execute_command(pcu, OFN_GET_CONFIG, 1268 &addr, sizeof(addr)); 1269 if (error) 1270 return error; 1271 1272 result = (s16)get_unaligned_le16(pcu->cmd_buf + OFN_REG_RESULT_OFFSET); 1273 if (result < 0) 1274 return -EIO; 1275 1276 /* We only need LSB */ 1277 *data = pcu->cmd_buf[OFN_REG_RESULT_OFFSET]; 1278 return 0; 1279 } 1280 1281 static int ims_pcu_write_ofn_config(struct ims_pcu *pcu, u8 addr, u8 data) 1282 { 1283 u8 buffer[] = { addr, data }; 1284 int error; 1285 s16 result; 1286 1287 error = ims_pcu_execute_command(pcu, OFN_SET_CONFIG, 1288 &buffer, sizeof(buffer)); 1289 if (error) 1290 return error; 1291 1292 result = (s16)get_unaligned_le16(pcu->cmd_buf + OFN_REG_RESULT_OFFSET); 1293 if (result < 0) 1294 return -EIO; 1295 1296 return 0; 1297 } 1298 1299 static ssize_t ims_pcu_ofn_reg_data_show(struct device *dev, 1300 struct device_attribute *dattr, 1301 char *buf) 1302 { 1303 struct usb_interface *intf = to_usb_interface(dev); 1304 struct ims_pcu *pcu = usb_get_intfdata(intf); 1305 int error; 1306 u8 data; 1307 1308 mutex_lock(&pcu->cmd_mutex); 1309 error = ims_pcu_read_ofn_config(pcu, pcu->ofn_reg_addr, &data); 1310 mutex_unlock(&pcu->cmd_mutex); 1311 1312 if (error) 1313 return error; 1314 1315 return scnprintf(buf, PAGE_SIZE, "%x\n", data); 1316 } 1317 1318 static ssize_t ims_pcu_ofn_reg_data_store(struct device *dev, 1319 struct device_attribute *dattr, 1320 const char *buf, size_t count) 1321 { 1322 struct usb_interface *intf = to_usb_interface(dev); 1323 struct ims_pcu *pcu = usb_get_intfdata(intf); 1324 int error; 1325 u8 value; 1326 1327 error = kstrtou8(buf, 0, &value); 1328 if (error) 1329 return error; 1330 1331 mutex_lock(&pcu->cmd_mutex); 1332 error = ims_pcu_write_ofn_config(pcu, pcu->ofn_reg_addr, value); 1333 mutex_unlock(&pcu->cmd_mutex); 1334 1335 return error ?: count; 1336 } 1337 1338 static DEVICE_ATTR(reg_data, S_IRUGO | S_IWUSR, 1339 ims_pcu_ofn_reg_data_show, ims_pcu_ofn_reg_data_store); 1340 1341 static ssize_t ims_pcu_ofn_reg_addr_show(struct device *dev, 1342 struct device_attribute *dattr, 1343 char *buf) 1344 { 1345 struct usb_interface *intf = to_usb_interface(dev); 1346 struct ims_pcu *pcu = usb_get_intfdata(intf); 1347 int error; 1348 1349 mutex_lock(&pcu->cmd_mutex); 1350 error = scnprintf(buf, PAGE_SIZE, "%x\n", pcu->ofn_reg_addr); 1351 mutex_unlock(&pcu->cmd_mutex); 1352 1353 return error; 1354 } 1355 1356 static ssize_t ims_pcu_ofn_reg_addr_store(struct device *dev, 1357 struct device_attribute *dattr, 1358 const char *buf, size_t count) 1359 { 1360 struct usb_interface *intf = to_usb_interface(dev); 1361 struct ims_pcu *pcu = usb_get_intfdata(intf); 1362 int error; 1363 u8 value; 1364 1365 error = kstrtou8(buf, 0, &value); 1366 if (error) 1367 return error; 1368 1369 mutex_lock(&pcu->cmd_mutex); 1370 pcu->ofn_reg_addr = value; 1371 mutex_unlock(&pcu->cmd_mutex); 1372 1373 return count; 1374 } 1375 1376 static DEVICE_ATTR(reg_addr, S_IRUGO | S_IWUSR, 1377 ims_pcu_ofn_reg_addr_show, ims_pcu_ofn_reg_addr_store); 1378 1379 struct ims_pcu_ofn_bit_attribute { 1380 struct device_attribute dattr; 1381 u8 addr; 1382 u8 nr; 1383 }; 1384 1385 static ssize_t ims_pcu_ofn_bit_show(struct device *dev, 1386 struct device_attribute *dattr, 1387 char *buf) 1388 { 1389 struct usb_interface *intf = to_usb_interface(dev); 1390 struct ims_pcu *pcu = usb_get_intfdata(intf); 1391 struct ims_pcu_ofn_bit_attribute *attr = 1392 container_of(dattr, struct ims_pcu_ofn_bit_attribute, dattr); 1393 int error; 1394 u8 data; 1395 1396 mutex_lock(&pcu->cmd_mutex); 1397 error = ims_pcu_read_ofn_config(pcu, attr->addr, &data); 1398 mutex_unlock(&pcu->cmd_mutex); 1399 1400 if (error) 1401 return error; 1402 1403 return scnprintf(buf, PAGE_SIZE, "%d\n", !!(data & (1 << attr->nr))); 1404 } 1405 1406 static ssize_t ims_pcu_ofn_bit_store(struct device *dev, 1407 struct device_attribute *dattr, 1408 const char *buf, size_t count) 1409 { 1410 struct usb_interface *intf = to_usb_interface(dev); 1411 struct ims_pcu *pcu = usb_get_intfdata(intf); 1412 struct ims_pcu_ofn_bit_attribute *attr = 1413 container_of(dattr, struct ims_pcu_ofn_bit_attribute, dattr); 1414 int error; 1415 int value; 1416 u8 data; 1417 1418 error = kstrtoint(buf, 0, &value); 1419 if (error) 1420 return error; 1421 1422 if (value > 1) 1423 return -EINVAL; 1424 1425 mutex_lock(&pcu->cmd_mutex); 1426 1427 error = ims_pcu_read_ofn_config(pcu, attr->addr, &data); 1428 if (!error) { 1429 if (value) 1430 data |= 1U << attr->nr; 1431 else 1432 data &= ~(1U << attr->nr); 1433 1434 error = ims_pcu_write_ofn_config(pcu, attr->addr, data); 1435 } 1436 1437 mutex_unlock(&pcu->cmd_mutex); 1438 1439 return error ?: count; 1440 } 1441 1442 #define IMS_PCU_OFN_BIT_ATTR(_field, _addr, _nr) \ 1443 struct ims_pcu_ofn_bit_attribute ims_pcu_ofn_attr_##_field = { \ 1444 .dattr = __ATTR(_field, S_IWUSR | S_IRUGO, \ 1445 ims_pcu_ofn_bit_show, ims_pcu_ofn_bit_store), \ 1446 .addr = _addr, \ 1447 .nr = _nr, \ 1448 } 1449 1450 static IMS_PCU_OFN_BIT_ATTR(engine_enable, 0x60, 7); 1451 static IMS_PCU_OFN_BIT_ATTR(speed_enable, 0x60, 6); 1452 static IMS_PCU_OFN_BIT_ATTR(assert_enable, 0x60, 5); 1453 static IMS_PCU_OFN_BIT_ATTR(xyquant_enable, 0x60, 4); 1454 static IMS_PCU_OFN_BIT_ATTR(xyscale_enable, 0x60, 1); 1455 1456 static IMS_PCU_OFN_BIT_ATTR(scale_x2, 0x63, 6); 1457 static IMS_PCU_OFN_BIT_ATTR(scale_y2, 0x63, 7); 1458 1459 static struct attribute *ims_pcu_ofn_attrs[] = { 1460 &dev_attr_reg_data.attr, 1461 &dev_attr_reg_addr.attr, 1462 &ims_pcu_ofn_attr_engine_enable.dattr.attr, 1463 &ims_pcu_ofn_attr_speed_enable.dattr.attr, 1464 &ims_pcu_ofn_attr_assert_enable.dattr.attr, 1465 &ims_pcu_ofn_attr_xyquant_enable.dattr.attr, 1466 &ims_pcu_ofn_attr_xyscale_enable.dattr.attr, 1467 &ims_pcu_ofn_attr_scale_x2.dattr.attr, 1468 &ims_pcu_ofn_attr_scale_y2.dattr.attr, 1469 NULL 1470 }; 1471 1472 static const struct attribute_group ims_pcu_ofn_attr_group = { 1473 .name = "ofn", 1474 .attrs = ims_pcu_ofn_attrs, 1475 }; 1476 1477 static void ims_pcu_irq(struct urb *urb) 1478 { 1479 struct ims_pcu *pcu = urb->context; 1480 int retval, status; 1481 1482 status = urb->status; 1483 1484 switch (status) { 1485 case 0: 1486 /* success */ 1487 break; 1488 case -ECONNRESET: 1489 case -ENOENT: 1490 case -ESHUTDOWN: 1491 /* this urb is terminated, clean up */ 1492 dev_dbg(pcu->dev, "%s - urb shutting down with status: %d\n", 1493 __func__, status); 1494 return; 1495 default: 1496 dev_dbg(pcu->dev, "%s - nonzero urb status received: %d\n", 1497 __func__, status); 1498 goto exit; 1499 } 1500 1501 dev_dbg(pcu->dev, "%s: received %d: %*ph\n", __func__, 1502 urb->actual_length, urb->actual_length, pcu->urb_in_buf); 1503 1504 if (urb == pcu->urb_in) 1505 ims_pcu_process_data(pcu, urb); 1506 1507 exit: 1508 retval = usb_submit_urb(urb, GFP_ATOMIC); 1509 if (retval && retval != -ENODEV) 1510 dev_err(pcu->dev, "%s - usb_submit_urb failed with result %d\n", 1511 __func__, retval); 1512 } 1513 1514 static int ims_pcu_buffers_alloc(struct ims_pcu *pcu) 1515 { 1516 int error; 1517 1518 pcu->urb_in_buf = usb_alloc_coherent(pcu->udev, pcu->max_in_size, 1519 GFP_KERNEL, &pcu->read_dma); 1520 if (!pcu->urb_in_buf) { 1521 dev_err(pcu->dev, 1522 "Failed to allocate memory for read buffer\n"); 1523 return -ENOMEM; 1524 } 1525 1526 pcu->urb_in = usb_alloc_urb(0, GFP_KERNEL); 1527 if (!pcu->urb_in) { 1528 dev_err(pcu->dev, "Failed to allocate input URB\n"); 1529 error = -ENOMEM; 1530 goto err_free_urb_in_buf; 1531 } 1532 1533 pcu->urb_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1534 pcu->urb_in->transfer_dma = pcu->read_dma; 1535 1536 usb_fill_bulk_urb(pcu->urb_in, pcu->udev, 1537 usb_rcvbulkpipe(pcu->udev, 1538 pcu->ep_in->bEndpointAddress), 1539 pcu->urb_in_buf, pcu->max_in_size, 1540 ims_pcu_irq, pcu); 1541 1542 /* 1543 * We are using usb_bulk_msg() for sending so there is no point 1544 * in allocating memory with usb_alloc_coherent(). 1545 */ 1546 pcu->urb_out_buf = kmalloc(pcu->max_out_size, GFP_KERNEL); 1547 if (!pcu->urb_out_buf) { 1548 dev_err(pcu->dev, "Failed to allocate memory for write buffer\n"); 1549 error = -ENOMEM; 1550 goto err_free_in_urb; 1551 } 1552 1553 pcu->urb_ctrl_buf = usb_alloc_coherent(pcu->udev, pcu->max_ctrl_size, 1554 GFP_KERNEL, &pcu->ctrl_dma); 1555 if (!pcu->urb_ctrl_buf) { 1556 dev_err(pcu->dev, 1557 "Failed to allocate memory for read buffer\n"); 1558 error = -ENOMEM; 1559 goto err_free_urb_out_buf; 1560 } 1561 1562 pcu->urb_ctrl = usb_alloc_urb(0, GFP_KERNEL); 1563 if (!pcu->urb_ctrl) { 1564 dev_err(pcu->dev, "Failed to allocate input URB\n"); 1565 error = -ENOMEM; 1566 goto err_free_urb_ctrl_buf; 1567 } 1568 1569 pcu->urb_ctrl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1570 pcu->urb_ctrl->transfer_dma = pcu->ctrl_dma; 1571 1572 usb_fill_int_urb(pcu->urb_ctrl, pcu->udev, 1573 usb_rcvintpipe(pcu->udev, 1574 pcu->ep_ctrl->bEndpointAddress), 1575 pcu->urb_ctrl_buf, pcu->max_ctrl_size, 1576 ims_pcu_irq, pcu, pcu->ep_ctrl->bInterval); 1577 1578 return 0; 1579 1580 err_free_urb_ctrl_buf: 1581 usb_free_coherent(pcu->udev, pcu->max_ctrl_size, 1582 pcu->urb_ctrl_buf, pcu->ctrl_dma); 1583 err_free_urb_out_buf: 1584 kfree(pcu->urb_out_buf); 1585 err_free_in_urb: 1586 usb_free_urb(pcu->urb_in); 1587 err_free_urb_in_buf: 1588 usb_free_coherent(pcu->udev, pcu->max_in_size, 1589 pcu->urb_in_buf, pcu->read_dma); 1590 return error; 1591 } 1592 1593 static void ims_pcu_buffers_free(struct ims_pcu *pcu) 1594 { 1595 usb_kill_urb(pcu->urb_in); 1596 usb_free_urb(pcu->urb_in); 1597 1598 usb_free_coherent(pcu->udev, pcu->max_out_size, 1599 pcu->urb_in_buf, pcu->read_dma); 1600 1601 kfree(pcu->urb_out_buf); 1602 1603 usb_kill_urb(pcu->urb_ctrl); 1604 usb_free_urb(pcu->urb_ctrl); 1605 1606 usb_free_coherent(pcu->udev, pcu->max_ctrl_size, 1607 pcu->urb_ctrl_buf, pcu->ctrl_dma); 1608 } 1609 1610 static const struct usb_cdc_union_desc * 1611 ims_pcu_get_cdc_union_desc(struct usb_interface *intf) 1612 { 1613 const void *buf = intf->altsetting->extra; 1614 size_t buflen = intf->altsetting->extralen; 1615 struct usb_cdc_union_desc *union_desc; 1616 1617 if (!buf) { 1618 dev_err(&intf->dev, "Missing descriptor data\n"); 1619 return NULL; 1620 } 1621 1622 if (!buflen) { 1623 dev_err(&intf->dev, "Zero length descriptor\n"); 1624 return NULL; 1625 } 1626 1627 while (buflen >= sizeof(*union_desc)) { 1628 union_desc = (struct usb_cdc_union_desc *)buf; 1629 1630 if (union_desc->bLength > buflen) { 1631 dev_err(&intf->dev, "Too large descriptor\n"); 1632 return NULL; 1633 } 1634 1635 if (union_desc->bDescriptorType == USB_DT_CS_INTERFACE && 1636 union_desc->bDescriptorSubType == USB_CDC_UNION_TYPE) { 1637 dev_dbg(&intf->dev, "Found union header\n"); 1638 1639 if (union_desc->bLength >= sizeof(*union_desc)) 1640 return union_desc; 1641 1642 dev_err(&intf->dev, 1643 "Union descriptor too short (%d vs %zd)\n", 1644 union_desc->bLength, sizeof(*union_desc)); 1645 return NULL; 1646 } 1647 1648 buflen -= union_desc->bLength; 1649 buf += union_desc->bLength; 1650 } 1651 1652 dev_err(&intf->dev, "Missing CDC union descriptor\n"); 1653 return NULL; 1654 } 1655 1656 static int ims_pcu_parse_cdc_data(struct usb_interface *intf, struct ims_pcu *pcu) 1657 { 1658 const struct usb_cdc_union_desc *union_desc; 1659 struct usb_host_interface *alt; 1660 1661 union_desc = ims_pcu_get_cdc_union_desc(intf); 1662 if (!union_desc) 1663 return -EINVAL; 1664 1665 pcu->ctrl_intf = usb_ifnum_to_if(pcu->udev, 1666 union_desc->bMasterInterface0); 1667 if (!pcu->ctrl_intf) 1668 return -EINVAL; 1669 1670 alt = pcu->ctrl_intf->cur_altsetting; 1671 1672 if (alt->desc.bNumEndpoints < 1) 1673 return -ENODEV; 1674 1675 pcu->ep_ctrl = &alt->endpoint[0].desc; 1676 pcu->max_ctrl_size = usb_endpoint_maxp(pcu->ep_ctrl); 1677 1678 pcu->data_intf = usb_ifnum_to_if(pcu->udev, 1679 union_desc->bSlaveInterface0); 1680 if (!pcu->data_intf) 1681 return -EINVAL; 1682 1683 alt = pcu->data_intf->cur_altsetting; 1684 if (alt->desc.bNumEndpoints != 2) { 1685 dev_err(pcu->dev, 1686 "Incorrect number of endpoints on data interface (%d)\n", 1687 alt->desc.bNumEndpoints); 1688 return -EINVAL; 1689 } 1690 1691 pcu->ep_out = &alt->endpoint[0].desc; 1692 if (!usb_endpoint_is_bulk_out(pcu->ep_out)) { 1693 dev_err(pcu->dev, 1694 "First endpoint on data interface is not BULK OUT\n"); 1695 return -EINVAL; 1696 } 1697 1698 pcu->max_out_size = usb_endpoint_maxp(pcu->ep_out); 1699 if (pcu->max_out_size < 8) { 1700 dev_err(pcu->dev, 1701 "Max OUT packet size is too small (%zd)\n", 1702 pcu->max_out_size); 1703 return -EINVAL; 1704 } 1705 1706 pcu->ep_in = &alt->endpoint[1].desc; 1707 if (!usb_endpoint_is_bulk_in(pcu->ep_in)) { 1708 dev_err(pcu->dev, 1709 "Second endpoint on data interface is not BULK IN\n"); 1710 return -EINVAL; 1711 } 1712 1713 pcu->max_in_size = usb_endpoint_maxp(pcu->ep_in); 1714 if (pcu->max_in_size < 8) { 1715 dev_err(pcu->dev, 1716 "Max IN packet size is too small (%zd)\n", 1717 pcu->max_in_size); 1718 return -EINVAL; 1719 } 1720 1721 return 0; 1722 } 1723 1724 static int ims_pcu_start_io(struct ims_pcu *pcu) 1725 { 1726 int error; 1727 1728 error = usb_submit_urb(pcu->urb_ctrl, GFP_KERNEL); 1729 if (error) { 1730 dev_err(pcu->dev, 1731 "Failed to start control IO - usb_submit_urb failed with result: %d\n", 1732 error); 1733 return -EIO; 1734 } 1735 1736 error = usb_submit_urb(pcu->urb_in, GFP_KERNEL); 1737 if (error) { 1738 dev_err(pcu->dev, 1739 "Failed to start IO - usb_submit_urb failed with result: %d\n", 1740 error); 1741 usb_kill_urb(pcu->urb_ctrl); 1742 return -EIO; 1743 } 1744 1745 return 0; 1746 } 1747 1748 static void ims_pcu_stop_io(struct ims_pcu *pcu) 1749 { 1750 usb_kill_urb(pcu->urb_in); 1751 usb_kill_urb(pcu->urb_ctrl); 1752 } 1753 1754 static int ims_pcu_line_setup(struct ims_pcu *pcu) 1755 { 1756 struct usb_host_interface *interface = pcu->ctrl_intf->cur_altsetting; 1757 struct usb_cdc_line_coding *line = (void *)pcu->cmd_buf; 1758 int error; 1759 1760 memset(line, 0, sizeof(*line)); 1761 line->dwDTERate = cpu_to_le32(57600); 1762 line->bDataBits = 8; 1763 1764 error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0), 1765 USB_CDC_REQ_SET_LINE_CODING, 1766 USB_TYPE_CLASS | USB_RECIP_INTERFACE, 1767 0, interface->desc.bInterfaceNumber, 1768 line, sizeof(struct usb_cdc_line_coding), 1769 5000); 1770 if (error < 0) { 1771 dev_err(pcu->dev, "Failed to set line coding, error: %d\n", 1772 error); 1773 return error; 1774 } 1775 1776 error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0), 1777 USB_CDC_REQ_SET_CONTROL_LINE_STATE, 1778 USB_TYPE_CLASS | USB_RECIP_INTERFACE, 1779 0x03, interface->desc.bInterfaceNumber, 1780 NULL, 0, 5000); 1781 if (error < 0) { 1782 dev_err(pcu->dev, "Failed to set line state, error: %d\n", 1783 error); 1784 return error; 1785 } 1786 1787 return 0; 1788 } 1789 1790 static int ims_pcu_get_device_info(struct ims_pcu *pcu) 1791 { 1792 int error; 1793 1794 error = ims_pcu_get_info(pcu); 1795 if (error) 1796 return error; 1797 1798 error = ims_pcu_execute_query(pcu, GET_FW_VERSION); 1799 if (error) { 1800 dev_err(pcu->dev, 1801 "GET_FW_VERSION command failed, error: %d\n", error); 1802 return error; 1803 } 1804 1805 snprintf(pcu->fw_version, sizeof(pcu->fw_version), 1806 "%02d%02d%02d%02d.%c%c", 1807 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5], 1808 pcu->cmd_buf[6], pcu->cmd_buf[7]); 1809 1810 error = ims_pcu_execute_query(pcu, GET_BL_VERSION); 1811 if (error) { 1812 dev_err(pcu->dev, 1813 "GET_BL_VERSION command failed, error: %d\n", error); 1814 return error; 1815 } 1816 1817 snprintf(pcu->bl_version, sizeof(pcu->bl_version), 1818 "%02d%02d%02d%02d.%c%c", 1819 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5], 1820 pcu->cmd_buf[6], pcu->cmd_buf[7]); 1821 1822 error = ims_pcu_execute_query(pcu, RESET_REASON); 1823 if (error) { 1824 dev_err(pcu->dev, 1825 "RESET_REASON command failed, error: %d\n", error); 1826 return error; 1827 } 1828 1829 snprintf(pcu->reset_reason, sizeof(pcu->reset_reason), 1830 "%02x", pcu->cmd_buf[IMS_PCU_DATA_OFFSET]); 1831 1832 dev_dbg(pcu->dev, 1833 "P/N: %s, MD: %s, S/N: %s, FW: %s, BL: %s, RR: %s\n", 1834 pcu->part_number, 1835 pcu->date_of_manufacturing, 1836 pcu->serial_number, 1837 pcu->fw_version, 1838 pcu->bl_version, 1839 pcu->reset_reason); 1840 1841 return 0; 1842 } 1843 1844 static int ims_pcu_identify_type(struct ims_pcu *pcu, u8 *device_id) 1845 { 1846 int error; 1847 1848 error = ims_pcu_execute_query(pcu, GET_DEVICE_ID); 1849 if (error) { 1850 dev_err(pcu->dev, 1851 "GET_DEVICE_ID command failed, error: %d\n", error); 1852 return error; 1853 } 1854 1855 *device_id = pcu->cmd_buf[IMS_PCU_DATA_OFFSET]; 1856 dev_dbg(pcu->dev, "Detected device ID: %d\n", *device_id); 1857 1858 return 0; 1859 } 1860 1861 static int ims_pcu_init_application_mode(struct ims_pcu *pcu) 1862 { 1863 static atomic_t device_no = ATOMIC_INIT(-1); 1864 1865 const struct ims_pcu_device_info *info; 1866 int error; 1867 1868 error = ims_pcu_get_device_info(pcu); 1869 if (error) { 1870 /* Device does not respond to basic queries, hopeless */ 1871 return error; 1872 } 1873 1874 error = ims_pcu_identify_type(pcu, &pcu->device_id); 1875 if (error) { 1876 dev_err(pcu->dev, 1877 "Failed to identify device, error: %d\n", error); 1878 /* 1879 * Do not signal error, but do not create input nor 1880 * backlight devices either, let userspace figure this 1881 * out (flash a new firmware?). 1882 */ 1883 return 0; 1884 } 1885 1886 if (pcu->device_id >= ARRAY_SIZE(ims_pcu_device_info) || 1887 !ims_pcu_device_info[pcu->device_id].keymap) { 1888 dev_err(pcu->dev, "Device ID %d is not valid\n", pcu->device_id); 1889 /* Same as above, punt to userspace */ 1890 return 0; 1891 } 1892 1893 /* Device appears to be operable, complete initialization */ 1894 pcu->device_no = atomic_inc_return(&device_no); 1895 1896 /* 1897 * PCU-B devices, both GEN_1 and GEN_2 do not have OFN sensor 1898 */ 1899 if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID) { 1900 error = sysfs_create_group(&pcu->dev->kobj, 1901 &ims_pcu_ofn_attr_group); 1902 if (error) 1903 return error; 1904 } 1905 1906 error = ims_pcu_setup_backlight(pcu); 1907 if (error) 1908 return error; 1909 1910 info = &ims_pcu_device_info[pcu->device_id]; 1911 error = ims_pcu_setup_buttons(pcu, info->keymap, info->keymap_len); 1912 if (error) 1913 goto err_destroy_backlight; 1914 1915 if (info->has_gamepad) { 1916 error = ims_pcu_setup_gamepad(pcu); 1917 if (error) 1918 goto err_destroy_buttons; 1919 } 1920 1921 pcu->setup_complete = true; 1922 1923 return 0; 1924 1925 err_destroy_buttons: 1926 ims_pcu_destroy_buttons(pcu); 1927 err_destroy_backlight: 1928 ims_pcu_destroy_backlight(pcu); 1929 return error; 1930 } 1931 1932 static void ims_pcu_destroy_application_mode(struct ims_pcu *pcu) 1933 { 1934 if (pcu->setup_complete) { 1935 pcu->setup_complete = false; 1936 mb(); /* make sure flag setting is not reordered */ 1937 1938 if (pcu->gamepad) 1939 ims_pcu_destroy_gamepad(pcu); 1940 ims_pcu_destroy_buttons(pcu); 1941 ims_pcu_destroy_backlight(pcu); 1942 1943 if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID) 1944 sysfs_remove_group(&pcu->dev->kobj, 1945 &ims_pcu_ofn_attr_group); 1946 } 1947 } 1948 1949 static int ims_pcu_init_bootloader_mode(struct ims_pcu *pcu) 1950 { 1951 int error; 1952 1953 error = ims_pcu_execute_bl_command(pcu, QUERY_DEVICE, NULL, 0, 1954 IMS_PCU_CMD_RESPONSE_TIMEOUT); 1955 if (error) { 1956 dev_err(pcu->dev, "Bootloader does not respond, aborting\n"); 1957 return error; 1958 } 1959 1960 pcu->fw_start_addr = 1961 get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 11]); 1962 pcu->fw_end_addr = 1963 get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 15]); 1964 1965 dev_info(pcu->dev, 1966 "Device is in bootloader mode (addr 0x%08x-0x%08x), requesting firmware\n", 1967 pcu->fw_start_addr, pcu->fw_end_addr); 1968 1969 error = request_firmware_nowait(THIS_MODULE, true, 1970 IMS_PCU_FIRMWARE_NAME, 1971 pcu->dev, GFP_KERNEL, pcu, 1972 ims_pcu_process_async_firmware); 1973 if (error) { 1974 /* This error is not fatal, let userspace have another chance */ 1975 complete(&pcu->async_firmware_done); 1976 } 1977 1978 return 0; 1979 } 1980 1981 static void ims_pcu_destroy_bootloader_mode(struct ims_pcu *pcu) 1982 { 1983 /* Make sure our initial firmware request has completed */ 1984 wait_for_completion(&pcu->async_firmware_done); 1985 } 1986 1987 #define IMS_PCU_APPLICATION_MODE 0 1988 #define IMS_PCU_BOOTLOADER_MODE 1 1989 1990 static struct usb_driver ims_pcu_driver; 1991 1992 static int ims_pcu_probe(struct usb_interface *intf, 1993 const struct usb_device_id *id) 1994 { 1995 struct usb_device *udev = interface_to_usbdev(intf); 1996 struct ims_pcu *pcu; 1997 int error; 1998 1999 pcu = kzalloc(sizeof(struct ims_pcu), GFP_KERNEL); 2000 if (!pcu) 2001 return -ENOMEM; 2002 2003 pcu->dev = &intf->dev; 2004 pcu->udev = udev; 2005 pcu->bootloader_mode = id->driver_info == IMS_PCU_BOOTLOADER_MODE; 2006 mutex_init(&pcu->cmd_mutex); 2007 init_completion(&pcu->cmd_done); 2008 init_completion(&pcu->async_firmware_done); 2009 2010 error = ims_pcu_parse_cdc_data(intf, pcu); 2011 if (error) 2012 goto err_free_mem; 2013 2014 error = usb_driver_claim_interface(&ims_pcu_driver, 2015 pcu->data_intf, pcu); 2016 if (error) { 2017 dev_err(&intf->dev, 2018 "Unable to claim corresponding data interface: %d\n", 2019 error); 2020 goto err_free_mem; 2021 } 2022 2023 usb_set_intfdata(pcu->ctrl_intf, pcu); 2024 usb_set_intfdata(pcu->data_intf, pcu); 2025 2026 error = ims_pcu_buffers_alloc(pcu); 2027 if (error) 2028 goto err_unclaim_intf; 2029 2030 error = ims_pcu_start_io(pcu); 2031 if (error) 2032 goto err_free_buffers; 2033 2034 error = ims_pcu_line_setup(pcu); 2035 if (error) 2036 goto err_stop_io; 2037 2038 error = sysfs_create_group(&intf->dev.kobj, &ims_pcu_attr_group); 2039 if (error) 2040 goto err_stop_io; 2041 2042 error = pcu->bootloader_mode ? 2043 ims_pcu_init_bootloader_mode(pcu) : 2044 ims_pcu_init_application_mode(pcu); 2045 if (error) 2046 goto err_remove_sysfs; 2047 2048 return 0; 2049 2050 err_remove_sysfs: 2051 sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group); 2052 err_stop_io: 2053 ims_pcu_stop_io(pcu); 2054 err_free_buffers: 2055 ims_pcu_buffers_free(pcu); 2056 err_unclaim_intf: 2057 usb_driver_release_interface(&ims_pcu_driver, pcu->data_intf); 2058 err_free_mem: 2059 kfree(pcu); 2060 return error; 2061 } 2062 2063 static void ims_pcu_disconnect(struct usb_interface *intf) 2064 { 2065 struct ims_pcu *pcu = usb_get_intfdata(intf); 2066 struct usb_host_interface *alt = intf->cur_altsetting; 2067 2068 usb_set_intfdata(intf, NULL); 2069 2070 /* 2071 * See if we are dealing with control or data interface. The cleanup 2072 * happens when we unbind primary (control) interface. 2073 */ 2074 if (alt->desc.bInterfaceClass != USB_CLASS_COMM) 2075 return; 2076 2077 sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group); 2078 2079 ims_pcu_stop_io(pcu); 2080 2081 if (pcu->bootloader_mode) 2082 ims_pcu_destroy_bootloader_mode(pcu); 2083 else 2084 ims_pcu_destroy_application_mode(pcu); 2085 2086 ims_pcu_buffers_free(pcu); 2087 kfree(pcu); 2088 } 2089 2090 #ifdef CONFIG_PM 2091 static int ims_pcu_suspend(struct usb_interface *intf, 2092 pm_message_t message) 2093 { 2094 struct ims_pcu *pcu = usb_get_intfdata(intf); 2095 struct usb_host_interface *alt = intf->cur_altsetting; 2096 2097 if (alt->desc.bInterfaceClass == USB_CLASS_COMM) 2098 ims_pcu_stop_io(pcu); 2099 2100 return 0; 2101 } 2102 2103 static int ims_pcu_resume(struct usb_interface *intf) 2104 { 2105 struct ims_pcu *pcu = usb_get_intfdata(intf); 2106 struct usb_host_interface *alt = intf->cur_altsetting; 2107 int retval = 0; 2108 2109 if (alt->desc.bInterfaceClass == USB_CLASS_COMM) { 2110 retval = ims_pcu_start_io(pcu); 2111 if (retval == 0) 2112 retval = ims_pcu_line_setup(pcu); 2113 } 2114 2115 return retval; 2116 } 2117 #endif 2118 2119 static const struct usb_device_id ims_pcu_id_table[] = { 2120 { 2121 USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0082, 2122 USB_CLASS_COMM, 2123 USB_CDC_SUBCLASS_ACM, 2124 USB_CDC_ACM_PROTO_AT_V25TER), 2125 .driver_info = IMS_PCU_APPLICATION_MODE, 2126 }, 2127 { 2128 USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0083, 2129 USB_CLASS_COMM, 2130 USB_CDC_SUBCLASS_ACM, 2131 USB_CDC_ACM_PROTO_AT_V25TER), 2132 .driver_info = IMS_PCU_BOOTLOADER_MODE, 2133 }, 2134 { } 2135 }; 2136 2137 static struct usb_driver ims_pcu_driver = { 2138 .name = "ims_pcu", 2139 .id_table = ims_pcu_id_table, 2140 .probe = ims_pcu_probe, 2141 .disconnect = ims_pcu_disconnect, 2142 #ifdef CONFIG_PM 2143 .suspend = ims_pcu_suspend, 2144 .resume = ims_pcu_resume, 2145 .reset_resume = ims_pcu_resume, 2146 #endif 2147 }; 2148 2149 module_usb_driver(ims_pcu_driver); 2150 2151 MODULE_DESCRIPTION("IMS Passenger Control Unit driver"); 2152 MODULE_AUTHOR("Dmitry Torokhov <dmitry.torokhov@gmail.com>"); 2153 MODULE_LICENSE("GPL"); 2154