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