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