drivers/input/misc/ims-pcu.c

   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 <asm/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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
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
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
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, 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 *
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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");