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