Lines Matching defs:pcu
183 static void ims_pcu_buttons_report(struct ims_pcu *pcu, u32 data)
185 struct ims_pcu_buttons *buttons = &pcu->buttons;
199 static int ims_pcu_setup_buttons(struct ims_pcu *pcu,
203 struct ims_pcu_buttons *buttons = &pcu->buttons;
210 dev_err(pcu->dev,
216 "IMS PCU#%d Button Interface", pcu->device_no);
218 usb_make_path(pcu->udev, buttons->phys, sizeof(buttons->phys));
225 usb_to_input_id(pcu->udev, &input->id);
226 input->dev.parent = &pcu->ctrl_intf->dev;
239 dev_err(pcu->dev,
250 static void ims_pcu_destroy_buttons(struct ims_pcu *pcu)
252 struct ims_pcu_buttons *buttons = &pcu->buttons;
262 static void ims_pcu_gamepad_report(struct ims_pcu *pcu, u32 data)
264 struct ims_pcu_gamepad *gamepad = pcu->gamepad;
284 static int ims_pcu_setup_gamepad(struct ims_pcu *pcu)
293 dev_err(pcu->dev,
302 "IMS PCU#%d Gamepad Interface", pcu->device_no);
304 usb_make_path(pcu->udev, gamepad->phys, sizeof(gamepad->phys));
309 usb_to_input_id(pcu->udev, &input->id);
310 input->dev.parent = &pcu->ctrl_intf->dev;
326 dev_err(pcu->dev,
332 pcu->gamepad = gamepad;
341 static void ims_pcu_destroy_gamepad(struct ims_pcu *pcu)
343 struct ims_pcu_gamepad *gamepad = pcu->gamepad;
408 static void ims_pcu_report_events(struct ims_pcu *pcu)
410 u32 data = get_unaligned_be32(&pcu->read_buf[3]);
412 ims_pcu_buttons_report(pcu, data & ~IMS_PCU_GAMEPAD_MASK);
413 if (pcu->gamepad)
414 ims_pcu_gamepad_report(pcu, data);
417 static void ims_pcu_handle_response(struct ims_pcu *pcu)
419 switch (pcu->read_buf[0]) {
421 if (likely(pcu->setup_complete))
422 ims_pcu_report_events(pcu);
431 if (pcu->read_buf[0] == pcu->expected_response &&
432 pcu->read_buf[1] == pcu->ack_id - 1) {
434 memcpy(pcu->cmd_buf, pcu->read_buf, pcu->read_pos);
435 pcu->cmd_buf_len = pcu->read_pos;
436 complete(&pcu->cmd_done);
442 static void ims_pcu_process_data(struct ims_pcu *pcu, struct urb *urb)
447 u8 data = pcu->urb_in_buf[i];
450 if (!pcu->have_stx && data != IMS_PCU_PROTOCOL_STX)
453 if (pcu->have_dle) {
454 pcu->have_dle = false;
455 pcu->read_buf[pcu->read_pos++] = data;
456 pcu->check_sum += data;
462 if (pcu->have_stx)
463 dev_warn(pcu->dev,
465 pcu->read_pos);
466 pcu->have_stx = true;
467 pcu->have_dle = false;
468 pcu->read_pos = 0;
469 pcu->check_sum = 0;
473 pcu->have_dle = true;
477 if (pcu->read_pos < IMS_PCU_MIN_PACKET_LEN) {
478 dev_warn(pcu->dev,
480 pcu->read_pos);
481 } else if (pcu->check_sum != 0) {
482 dev_warn(pcu->dev,
484 pcu->read_pos);
486 ims_pcu_handle_response(pcu);
489 pcu->have_stx = false;
490 pcu->have_dle = false;
491 pcu->read_pos = 0;
495 pcu->read_buf[pcu->read_pos++] = data;
496 pcu->check_sum += data;
509 static int ims_pcu_send_cmd_chunk(struct ims_pcu *pcu,
514 error = usb_bulk_msg(pcu->udev,
515 usb_sndbulkpipe(pcu->udev,
516 pcu->ep_out->bEndpointAddress),
517 pcu->urb_out_buf, len,
520 dev_dbg(pcu->dev,
529 static int ims_pcu_send_command(struct ims_pcu *pcu,
540 pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_STX;
543 pcu->urb_out_buf[count++] = command;
546 ack_id = pcu->ack_id++;
548 ack_id = pcu->ack_id++;
551 pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_DLE;
553 pcu->urb_out_buf[count++] = ack_id;
559 if (count + delta >= pcu->max_out_size) {
560 error = ims_pcu_send_cmd_chunk(pcu, command,
569 pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_DLE;
571 pcu->urb_out_buf[count++] = data[i];
578 if (count + delta >= pcu->max_out_size) {
579 error = ims_pcu_send_cmd_chunk(pcu, command, ++chunk, count);
587 pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_DLE;
589 pcu->urb_out_buf[count++] = csum;
590 pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_ETX;
592 return ims_pcu_send_cmd_chunk(pcu, command, ++chunk, count);
595 static int __ims_pcu_execute_command(struct ims_pcu *pcu,
601 pcu->expected_response = expected_response;
602 init_completion(&pcu->cmd_done);
604 error = ims_pcu_send_command(pcu, command, data, len);
609 !wait_for_completion_timeout(&pcu->cmd_done,
611 dev_dbg(pcu->dev, "Command 0x%02x timed out\n", command);
618 #define ims_pcu_execute_command(pcu, code, data, len) \
619 __ims_pcu_execute_command(pcu, \
624 #define ims_pcu_execute_query(pcu, code) \
625 ims_pcu_execute_command(pcu, code, NULL, 0)
649 static int __ims_pcu_execute_bl_command(struct ims_pcu *pcu,
655 pcu->cmd_buf[0] = command;
657 memcpy(&pcu->cmd_buf[1], data, len);
659 error = __ims_pcu_execute_command(pcu,
660 IMS_PCU_CMD_BOOTLOADER, pcu->cmd_buf, len + 1,
664 dev_err(pcu->dev,
666 pcu->cmd_buf[0], error);
670 if (expected_response && pcu->cmd_buf[2] != expected_response) {
671 dev_err(pcu->dev,
673 pcu->cmd_buf[2], expected_response);
680 #define ims_pcu_execute_bl_command(pcu, code, data, len, timeout) \
681 __ims_pcu_execute_bl_command(pcu, \
691 static int ims_pcu_get_info(struct ims_pcu *pcu)
695 error = ims_pcu_execute_query(pcu, GET_INFO);
697 dev_err(pcu->dev,
702 memcpy(pcu->part_number,
703 &pcu->cmd_buf[IMS_PCU_INFO_PART_OFFSET],
704 sizeof(pcu->part_number));
705 memcpy(pcu->date_of_manufacturing,
706 &pcu->cmd_buf[IMS_PCU_INFO_DOM_OFFSET],
707 sizeof(pcu->date_of_manufacturing));
708 memcpy(pcu->serial_number,
709 &pcu->cmd_buf[IMS_PCU_INFO_SERIAL_OFFSET],
710 sizeof(pcu->serial_number));
715 static int ims_pcu_set_info(struct ims_pcu *pcu)
719 memcpy(&pcu->cmd_buf[IMS_PCU_INFO_PART_OFFSET],
720 pcu->part_number, sizeof(pcu->part_number));
721 memcpy(&pcu->cmd_buf[IMS_PCU_INFO_DOM_OFFSET],
722 pcu->date_of_manufacturing, sizeof(pcu->date_of_manufacturing));
723 memcpy(&pcu->cmd_buf[IMS_PCU_INFO_SERIAL_OFFSET],
724 pcu->serial_number, sizeof(pcu->serial_number));
726 error = ims_pcu_execute_command(pcu, SET_INFO,
727 &pcu->cmd_buf[IMS_PCU_DATA_OFFSET],
730 dev_err(pcu->dev,
739 static int ims_pcu_switch_to_bootloader(struct ims_pcu *pcu)
744 error = ims_pcu_execute_command(pcu, JUMP_TO_BTLDR, NULL, 0);
746 dev_err(pcu->dev,
780 static int ims_pcu_verify_block(struct ims_pcu *pcu,
786 fragment = (void *)&pcu->cmd_buf[1];
790 error = ims_pcu_execute_bl_command(pcu, READ_APP, NULL, 5,
793 dev_err(pcu->dev,
799 fragment = (void *)&pcu->cmd_buf[IMS_PCU_BL_DATA_OFFSET];
802 dev_err(pcu->dev,
810 dev_err(pcu->dev,
819 static int ims_pcu_flash_firmware(struct ims_pcu *pcu,
830 error = ims_pcu_execute_bl_command(pcu, ERASE_APP, NULL, 0, 2000);
832 dev_err(pcu->dev,
848 fragment = (void *)&pcu->cmd_buf[1];
853 error = ims_pcu_execute_bl_command(pcu, PROGRAM_DEVICE,
857 dev_err(pcu->dev,
863 if (addr >= pcu->fw_start_addr && addr < pcu->fw_end_addr) {
864 error = ims_pcu_verify_block(pcu, addr, len, rec->data);
870 pcu->update_firmware_status = (count * 100) / n_fw_records;
875 error = ims_pcu_execute_bl_command(pcu, PROGRAM_COMPLETE,
878 dev_err(pcu->dev,
885 static int ims_pcu_handle_firmware_update(struct ims_pcu *pcu,
891 dev_info(pcu->dev, "Updating firmware %s, size: %zu\n",
896 retval = ims_pcu_flash_firmware(pcu, fw, n_fw_records);
900 retval = ims_pcu_execute_bl_command(pcu, LAUNCH_APP, NULL, 0, 0);
902 dev_err(pcu->dev,
907 pcu->update_firmware_status = retval;
908 sysfs_notify(&pcu->dev->kobj, NULL, "update_firmware_status");
915 struct ims_pcu *pcu = context;
919 dev_err(pcu->dev, "Failed to get firmware %s\n",
926 dev_err(pcu->dev, "Firmware %s is invalid\n",
931 mutex_lock(&pcu->cmd_mutex);
932 ims_pcu_handle_firmware_update(pcu, fw);
933 mutex_unlock(&pcu->cmd_mutex);
938 complete(&pcu->async_firmware_done);
952 struct ims_pcu *pcu =
957 mutex_lock(&pcu->cmd_mutex);
959 error = ims_pcu_execute_command(pcu, SET_BRIGHTNESS,
962 dev_warn(pcu->dev,
966 mutex_unlock(&pcu->cmd_mutex);
976 struct ims_pcu *pcu =
981 mutex_lock(&pcu->cmd_mutex);
983 error = ims_pcu_execute_query(pcu, GET_BRIGHTNESS);
985 dev_warn(pcu->dev,
992 get_unaligned_le16(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET]);
995 mutex_unlock(&pcu->cmd_mutex);
1000 static int ims_pcu_setup_backlight(struct ims_pcu *pcu)
1002 struct ims_pcu_backlight *backlight = &pcu->backlight;
1006 "pcu%d::kbd_backlight", pcu->device_no);
1014 error = led_classdev_register(pcu->dev, &backlight->cdev);
1016 dev_err(pcu->dev,
1025 static void ims_pcu_destroy_backlight(struct ims_pcu *pcu)
1027 struct ims_pcu_backlight *backlight = &pcu->backlight;
1048 struct ims_pcu *pcu = usb_get_intfdata(intf);
1051 char *field = (char *)pcu + attr->field_offset;
1062 struct ims_pcu *pcu = usb_get_intfdata(intf);
1065 char *field = (char *)pcu + attr->field_offset;
1076 error = mutex_lock_interruptible(&pcu->cmd_mutex);
1083 error = ims_pcu_set_info(pcu);
1089 ims_pcu_get_info(pcu);
1091 mutex_unlock(&pcu->cmd_mutex);
1124 struct ims_pcu *pcu = usb_get_intfdata(intf);
1135 dev_info(pcu->dev, "Attempting to reset device\n");
1137 error = ims_pcu_execute_command(pcu, PCU_RESET, &reset_byte, 1);
1139 dev_info(pcu->dev,
1155 struct ims_pcu *pcu = usb_get_intfdata(intf);
1167 error = mutex_lock_interruptible(&pcu->cmd_mutex);
1171 error = request_ihex_firmware(&fw, IMS_PCU_FIRMWARE_NAME, pcu->dev);
1173 dev_err(pcu->dev, "Failed to request firmware %s, error: %d\n",
1186 if (pcu->bootloader_mode)
1187 error = ims_pcu_handle_firmware_update(pcu, fw);
1189 error = ims_pcu_switch_to_bootloader(pcu);
1194 mutex_unlock(&pcu->cmd_mutex);
1207 struct ims_pcu *pcu = usb_get_intfdata(intf);
1209 return sysfs_emit(buf, "%d\n", pcu->update_firmware_status);
1233 struct ims_pcu *pcu = usb_get_intfdata(intf);
1236 if (pcu->bootloader_mode) {
1259 static int ims_pcu_read_ofn_config(struct ims_pcu *pcu, u8 addr, u8 *data)
1264 error = ims_pcu_execute_command(pcu, OFN_GET_CONFIG,
1269 result = (s16)get_unaligned_le16(pcu->cmd_buf + OFN_REG_RESULT_OFFSET);
1274 *data = pcu->cmd_buf[OFN_REG_RESULT_OFFSET];
1278 static int ims_pcu_write_ofn_config(struct ims_pcu *pcu, u8 addr, u8 data)
1284 error = ims_pcu_execute_command(pcu, OFN_SET_CONFIG,
1289 result = (s16)get_unaligned_le16(pcu->cmd_buf + OFN_REG_RESULT_OFFSET);
1301 struct ims_pcu *pcu = usb_get_intfdata(intf);
1305 mutex_lock(&pcu->cmd_mutex);
1306 error = ims_pcu_read_ofn_config(pcu, pcu->ofn_reg_addr, &data);
1307 mutex_unlock(&pcu->cmd_mutex);
1320 struct ims_pcu *pcu = usb_get_intfdata(intf);
1328 mutex_lock(&pcu->cmd_mutex);
1329 error = ims_pcu_write_ofn_config(pcu, pcu->ofn_reg_addr, value);
1330 mutex_unlock(&pcu->cmd_mutex);
1343 struct ims_pcu *pcu = usb_get_intfdata(intf);
1346 mutex_lock(&pcu->cmd_mutex);
1347 error = sysfs_emit(buf, "%x\n", pcu->ofn_reg_addr);
1348 mutex_unlock(&pcu->cmd_mutex);
1358 struct ims_pcu *pcu = usb_get_intfdata(intf);
1366 mutex_lock(&pcu->cmd_mutex);
1367 pcu->ofn_reg_addr = value;
1368 mutex_unlock(&pcu->cmd_mutex);
1387 struct ims_pcu *pcu = usb_get_intfdata(intf);
1393 mutex_lock(&pcu->cmd_mutex);
1394 error = ims_pcu_read_ofn_config(pcu, attr->addr, &data);
1395 mutex_unlock(&pcu->cmd_mutex);
1408 struct ims_pcu *pcu = usb_get_intfdata(intf);
1422 mutex_lock(&pcu->cmd_mutex);
1424 error = ims_pcu_read_ofn_config(pcu, attr->addr, &data);
1431 error = ims_pcu_write_ofn_config(pcu, attr->addr, data);
1434 mutex_unlock(&pcu->cmd_mutex);
1476 struct ims_pcu *pcu = urb->context;
1489 dev_dbg(pcu->dev, "%s - urb shutting down with status: %d\n",
1493 dev_dbg(pcu->dev, "%s - nonzero urb status received: %d\n",
1498 dev_dbg(pcu->dev, "%s: received %d: %*ph\n", __func__,
1499 urb->actual_length, urb->actual_length, pcu->urb_in_buf);
1501 if (urb == pcu->urb_in)
1502 ims_pcu_process_data(pcu, urb);
1507 dev_err(pcu->dev, "%s - usb_submit_urb failed with result %d\n",
1511 static int ims_pcu_buffers_alloc(struct ims_pcu *pcu)
1515 pcu->urb_in_buf = usb_alloc_coherent(pcu->udev, pcu->max_in_size,
1516 GFP_KERNEL, &pcu->read_dma);
1517 if (!pcu->urb_in_buf) {
1518 dev_err(pcu->dev,
1523 pcu->urb_in = usb_alloc_urb(0, GFP_KERNEL);
1524 if (!pcu->urb_in) {
1525 dev_err(pcu->dev, "Failed to allocate input URB\n");
1530 pcu->urb_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1531 pcu->urb_in->transfer_dma = pcu->read_dma;
1533 usb_fill_bulk_urb(pcu->urb_in, pcu->udev,
1534 usb_rcvbulkpipe(pcu->udev,
1535 pcu->ep_in->bEndpointAddress),
1536 pcu->urb_in_buf, pcu->max_in_size,
1537 ims_pcu_irq, pcu);
1543 pcu->urb_out_buf = kmalloc(pcu->max_out_size, GFP_KERNEL);
1544 if (!pcu->urb_out_buf) {
1545 dev_err(pcu->dev, "Failed to allocate memory for write buffer\n");
1550 pcu->urb_ctrl_buf = usb_alloc_coherent(pcu->udev, pcu->max_ctrl_size,
1551 GFP_KERNEL, &pcu->ctrl_dma);
1552 if (!pcu->urb_ctrl_buf) {
1553 dev_err(pcu->dev,
1559 pcu->urb_ctrl = usb_alloc_urb(0, GFP_KERNEL);
1560 if (!pcu->urb_ctrl) {
1561 dev_err(pcu->dev, "Failed to allocate input URB\n");
1566 pcu->urb_ctrl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1567 pcu->urb_ctrl->transfer_dma = pcu->ctrl_dma;
1569 usb_fill_int_urb(pcu->urb_ctrl, pcu->udev,
1570 usb_rcvintpipe(pcu->udev,
1571 pcu->ep_ctrl->bEndpointAddress),
1572 pcu->urb_ctrl_buf, pcu->max_ctrl_size,
1573 ims_pcu_irq, pcu, pcu->ep_ctrl->bInterval);
1578 usb_free_coherent(pcu->udev, pcu->max_ctrl_size,
1579 pcu->urb_ctrl_buf, pcu->ctrl_dma);
1581 kfree(pcu->urb_out_buf);
1583 usb_free_urb(pcu->urb_in);
1585 usb_free_coherent(pcu->udev, pcu->max_in_size,
1586 pcu->urb_in_buf, pcu->read_dma);
1590 static void ims_pcu_buffers_free(struct ims_pcu *pcu)
1592 usb_kill_urb(pcu->urb_in);
1593 usb_free_urb(pcu->urb_in);
1595 usb_free_coherent(pcu->udev, pcu->max_out_size,
1596 pcu->urb_in_buf, pcu->read_dma);
1598 kfree(pcu->urb_out_buf);
1600 usb_kill_urb(pcu->urb_ctrl);
1601 usb_free_urb(pcu->urb_ctrl);
1603 usb_free_coherent(pcu->udev, pcu->max_ctrl_size,
1604 pcu->urb_ctrl_buf, pcu->ctrl_dma);
1653 static int ims_pcu_parse_cdc_data(struct usb_interface *intf, struct ims_pcu *pcu)
1662 pcu->ctrl_intf = usb_ifnum_to_if(pcu->udev,
1664 if (!pcu->ctrl_intf)
1667 alt = pcu->ctrl_intf->cur_altsetting;
1672 pcu->ep_ctrl = &alt->endpoint[0].desc;
1673 pcu->max_ctrl_size = usb_endpoint_maxp(pcu->ep_ctrl);
1675 pcu->data_intf = usb_ifnum_to_if(pcu->udev,
1677 if (!pcu->data_intf)
1680 alt = pcu->data_intf->cur_altsetting;
1682 dev_err(pcu->dev,
1688 pcu->ep_out = &alt->endpoint[0].desc;
1689 if (!usb_endpoint_is_bulk_out(pcu->ep_out)) {
1690 dev_err(pcu->dev,
1695 pcu->max_out_size = usb_endpoint_maxp(pcu->ep_out);
1696 if (pcu->max_out_size < 8) {
1697 dev_err(pcu->dev,
1699 pcu->max_out_size);
1703 pcu->ep_in = &alt->endpoint[1].desc;
1704 if (!usb_endpoint_is_bulk_in(pcu->ep_in)) {
1705 dev_err(pcu->dev,
1710 pcu->max_in_size = usb_endpoint_maxp(pcu->ep_in);
1711 if (pcu->max_in_size < 8) {
1712 dev_err(pcu->dev,
1714 pcu->max_in_size);
1721 static int ims_pcu_start_io(struct ims_pcu *pcu)
1725 error = usb_submit_urb(pcu->urb_ctrl, GFP_KERNEL);
1727 dev_err(pcu->dev,
1733 error = usb_submit_urb(pcu->urb_in, GFP_KERNEL);
1735 dev_err(pcu->dev,
1738 usb_kill_urb(pcu->urb_ctrl);
1745 static void ims_pcu_stop_io(struct ims_pcu *pcu)
1747 usb_kill_urb(pcu->urb_in);
1748 usb_kill_urb(pcu->urb_ctrl);
1751 static int ims_pcu_line_setup(struct ims_pcu *pcu)
1753 struct usb_host_interface *interface = pcu->ctrl_intf->cur_altsetting;
1754 struct usb_cdc_line_coding *line = (void *)pcu->cmd_buf;
1761 error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
1768 dev_err(pcu->dev, "Failed to set line coding, error: %d\n",
1773 error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
1779 dev_err(pcu->dev, "Failed to set line state, error: %d\n",
1787 static int ims_pcu_get_device_info(struct ims_pcu *pcu)
1791 error = ims_pcu_get_info(pcu);
1795 error = ims_pcu_execute_query(pcu, GET_FW_VERSION);
1797 dev_err(pcu->dev,
1802 snprintf(pcu->fw_version, sizeof(pcu->fw_version),
1804 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5],
1805 pcu->cmd_buf[6], pcu->cmd_buf[7]);
1807 error = ims_pcu_execute_query(pcu, GET_BL_VERSION);
1809 dev_err(pcu->dev,
1814 snprintf(pcu->bl_version, sizeof(pcu->bl_version),
1816 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5],
1817 pcu->cmd_buf[6], pcu->cmd_buf[7]);
1819 error = ims_pcu_execute_query(pcu, RESET_REASON);
1821 dev_err(pcu->dev,
1826 snprintf(pcu->reset_reason, sizeof(pcu->reset_reason),
1827 "%02x", pcu->cmd_buf[IMS_PCU_DATA_OFFSET]);
1829 dev_dbg(pcu->dev,
1831 pcu->part_number,
1832 pcu->date_of_manufacturing,
1833 pcu->serial_number,
1834 pcu->fw_version,
1835 pcu->bl_version,
1836 pcu->reset_reason);
1841 static int ims_pcu_identify_type(struct ims_pcu *pcu, u8 *device_id)
1845 error = ims_pcu_execute_query(pcu, GET_DEVICE_ID);
1847 dev_err(pcu->dev,
1852 *device_id = pcu->cmd_buf[IMS_PCU_DATA_OFFSET];
1853 dev_dbg(pcu->dev, "Detected device ID: %d\n", *device_id);
1858 static int ims_pcu_init_application_mode(struct ims_pcu *pcu)
1865 error = ims_pcu_get_device_info(pcu);
1871 error = ims_pcu_identify_type(pcu, &pcu->device_id);
1873 dev_err(pcu->dev,
1883 if (pcu->device_id >= ARRAY_SIZE(ims_pcu_device_info) ||
1884 !ims_pcu_device_info[pcu->device_id].keymap) {
1885 dev_err(pcu->dev, "Device ID %d is not valid\n", pcu->device_id);
1891 pcu->device_no = atomic_inc_return(&device_no);
1896 if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID) {
1897 error = sysfs_create_group(&pcu->dev->kobj,
1903 error = ims_pcu_setup_backlight(pcu);
1907 info = &ims_pcu_device_info[pcu->device_id];
1908 error = ims_pcu_setup_buttons(pcu, info->keymap, info->keymap_len);
1913 error = ims_pcu_setup_gamepad(pcu);
1918 pcu->setup_complete = true;
1923 ims_pcu_destroy_buttons(pcu);
1925 ims_pcu_destroy_backlight(pcu);
1929 static void ims_pcu_destroy_application_mode(struct ims_pcu *pcu)
1931 if (pcu->setup_complete) {
1932 pcu->setup_complete = false;
1935 if (pcu->gamepad)
1936 ims_pcu_destroy_gamepad(pcu);
1937 ims_pcu_destroy_buttons(pcu);
1938 ims_pcu_destroy_backlight(pcu);
1940 if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID)
1941 sysfs_remove_group(&pcu->dev->kobj,
1946 static int ims_pcu_init_bootloader_mode(struct ims_pcu *pcu)
1950 error = ims_pcu_execute_bl_command(pcu, QUERY_DEVICE, NULL, 0,
1953 dev_err(pcu->dev, "Bootloader does not respond, aborting\n");
1957 pcu->fw_start_addr =
1958 get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 11]);
1959 pcu->fw_end_addr =
1960 get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 15]);
1962 dev_info(pcu->dev,
1964 pcu->fw_start_addr, pcu->fw_end_addr);
1968 pcu->dev, GFP_KERNEL, pcu,
1972 complete(&pcu->async_firmware_done);
1978 static void ims_pcu_destroy_bootloader_mode(struct ims_pcu *pcu)
1981 wait_for_completion(&pcu->async_firmware_done);
1993 struct ims_pcu *pcu;
1996 pcu = kzalloc(sizeof(struct ims_pcu), GFP_KERNEL);
1997 if (!pcu)
2000 pcu->dev = &intf->dev;
2001 pcu->udev = udev;
2002 pcu->bootloader_mode = id->driver_info == IMS_PCU_BOOTLOADER_MODE;
2003 mutex_init(&pcu->cmd_mutex);
2004 init_completion(&pcu->cmd_done);
2005 init_completion(&pcu->async_firmware_done);
2007 error = ims_pcu_parse_cdc_data(intf, pcu);
2012 pcu->data_intf, pcu);
2020 usb_set_intfdata(pcu->ctrl_intf, pcu);
2022 error = ims_pcu_buffers_alloc(pcu);
2026 error = ims_pcu_start_io(pcu);
2030 error = ims_pcu_line_setup(pcu);
2038 error = pcu->bootloader_mode ?
2039 ims_pcu_init_bootloader_mode(pcu) :
2040 ims_pcu_init_application_mode(pcu);
2049 ims_pcu_stop_io(pcu);
2051 ims_pcu_buffers_free(pcu);
2053 usb_driver_release_interface(&ims_pcu_driver, pcu->data_intf);
2055 kfree(pcu);
2061 struct ims_pcu *pcu = usb_get_intfdata(intf);
2075 ims_pcu_stop_io(pcu);
2077 if (pcu->bootloader_mode)
2078 ims_pcu_destroy_bootloader_mode(pcu);
2080 ims_pcu_destroy_application_mode(pcu);
2082 ims_pcu_buffers_free(pcu);
2083 kfree(pcu);
2090 struct ims_pcu *pcu = usb_get_intfdata(intf);
2094 ims_pcu_stop_io(pcu);
2101 struct ims_pcu *pcu = usb_get_intfdata(intf);
2106 retval = ims_pcu_start_io(pcu);
2108 retval = ims_pcu_line_setup(pcu);