drivers/input/misc/ims-pcu.c

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