source: src/linux/universal/linux-3.18/drivers/input/misc/ims-pcu.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 5 weeks ago

update

File size: 52.6 KB
Line 
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
27struct 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
34struct ims_pcu_gamepad {
35        struct input_dev *input;
36        char name[32];
37        char phys[32];
38};
39
40struct 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
58struct 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
126static 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
135static const unsigned short ims_pcu_keymap_2[] = {
136        [4] = KEY_VOLUMEUP,
137        [5] = KEY_VOLUMEDOWN,
138        [6] = KEY_INFO,
139};
140
141static 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
151static 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
161static const unsigned short ims_pcu_keymap_5[] = {
162        [1] = KEY_ATTENDANT_OFF,
163        [2] = KEY_ATTENDANT_ON,
164        [3] = KEY_LIGHTS_TOGGLE,
165};
166
167struct 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
180static 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
188static 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
204static 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
255static 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
267static 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
289static 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
340err_free_mem:
341        input_free_device(input);
342        kfree(gamepad);
343        return -ENOMEM;
344}
345
346static 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
413static 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
422static 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
447static 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
507static 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
514static 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
534static 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
600static 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
654static 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
696static 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
720static 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
744static 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   "imspcu.fw"
765
766struct ims_pcu_flash_fmt {
767        __le32 addr;
768        u8 len;
769        u8 data[];
770};
771
772static 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
785static 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
824static 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
890static 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
911out:
912        pcu->update_firmware_status = retval;
913        sysfs_notify(&pcu->dev->kobj, NULL, "update_firmware_status");
914        return retval;
915}
916
917static 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
942out:
943        complete(&pcu->async_firmware_done);
944}
945
946/*********************************************************************
947 *             Backlight LED device support                          *
948 *********************************************************************/
949
950#define IMS_PCU_MAX_BRIGHTNESS          31998
951
952static 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
974static 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
984static enum led_brightness
985ims_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
1013static 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
1038static 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
1051struct ims_pcu_attribute {
1052        struct device_attribute dattr;
1053        size_t field_offset;
1054        int field_length;
1055};
1056
1057static 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
1070static 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)                                     \
1111struct 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
1124static IMS_PCU_RW_ATTR(part_number);
1125static IMS_PCU_RW_ATTR(serial_number);
1126static IMS_PCU_RW_ATTR(date_of_manufacturing);
1127
1128static IMS_PCU_RO_ATTR(fw_version);
1129static IMS_PCU_RO_ATTR(bl_version);
1130static IMS_PCU_RO_ATTR(reset_reason);
1131
1132static 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
1162static DEVICE_ATTR(reset_device, S_IWUSR, NULL, ims_pcu_reset_device);
1163
1164static 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 = request_ihex_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
1207out:
1208        mutex_unlock(&pcu->cmd_mutex);
1209        return error ?: count;
1210}
1211
1212static DEVICE_ATTR(update_firmware, S_IWUSR,
1213                   NULL, ims_pcu_update_firmware_store);
1214
1215static ssize_t
1216ims_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
1226static DEVICE_ATTR(update_firmware_status, S_IRUGO,
1227                   ims_pcu_update_firmware_status_show, NULL);
1228
1229static 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
1242static 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
1264static 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
1273static 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
1292static 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
1310static 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
1329static 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
1349static DEVICE_ATTR(reg_data, S_IRUGO | S_IWUSR,
1350                   ims_pcu_ofn_reg_data_show, ims_pcu_ofn_reg_data_store);
1351
1352static 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
1367static 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
1387static DEVICE_ATTR(reg_addr, S_IRUGO | S_IWUSR,
1388                   ims_pcu_ofn_reg_addr_show, ims_pcu_ofn_reg_addr_store);
1389
1390struct ims_pcu_ofn_bit_attribute {
1391        struct device_attribute dattr;
1392        u8 addr;
1393        u8 nr;
1394};
1395
1396static 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
1417static 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)                        \
1454struct 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
1461static IMS_PCU_OFN_BIT_ATTR(engine_enable,   0x60, 7);
1462static IMS_PCU_OFN_BIT_ATTR(speed_enable,    0x60, 6);
1463static IMS_PCU_OFN_BIT_ATTR(assert_enable,   0x60, 5);
1464static IMS_PCU_OFN_BIT_ATTR(xyquant_enable,  0x60, 4);
1465static IMS_PCU_OFN_BIT_ATTR(xyscale_enable,  0x60, 1);
1466
1467static IMS_PCU_OFN_BIT_ATTR(scale_x2,        0x63, 6);
1468static IMS_PCU_OFN_BIT_ATTR(scale_y2,        0x63, 7);
1469
1470static 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
1483static struct attribute_group ims_pcu_ofn_attr_group = {
1484        .name   = "ofn",
1485        .attrs  = ims_pcu_ofn_attrs,
1486};
1487
1488static 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
1518exit:
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
1525static 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
1591err_free_urb_ctrl_buf:
1592        usb_free_coherent(pcu->udev, pcu->max_ctrl_size,
1593                          pcu->urb_ctrl_buf, pcu->ctrl_dma);
1594err_free_urb_out_buf:
1595        kfree(pcu->urb_out_buf);
1596err_free_in_urb:
1597        usb_free_urb(pcu->urb_in);
1598err_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
1604static 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
1621static const struct usb_cdc_union_desc *
1622ims_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 > 0) {
1639                union_desc = (struct usb_cdc_union_desc *)buf;
1640
1641                if (union_desc->bDescriptorType == USB_DT_CS_INTERFACE &&
1642                    union_desc->bDescriptorSubType == USB_CDC_UNION_TYPE) {
1643                        dev_dbg(&intf->dev, "Found union header\n");
1644                        return union_desc;
1645                }
1646
1647                buflen -= union_desc->bLength;
1648                buf += union_desc->bLength;
1649        }
1650
1651        dev_err(&intf->dev, "Missing CDC union descriptor\n");
1652        return NULL;
1653}
1654
1655static int ims_pcu_parse_cdc_data(struct usb_interface *intf, struct ims_pcu *pcu)
1656{
1657        const struct usb_cdc_union_desc *union_desc;
1658        struct usb_host_interface *alt;
1659
1660        union_desc = ims_pcu_get_cdc_union_desc(intf);
1661        if (!union_desc)
1662                return -EINVAL;
1663
1664        pcu->ctrl_intf = usb_ifnum_to_if(pcu->udev,
1665                                         union_desc->bMasterInterface0);
1666        if (!pcu->ctrl_intf)
1667                return -EINVAL;
1668
1669        alt = pcu->ctrl_intf->cur_altsetting;
1670
1671        if (alt->desc.bNumEndpoints < 1)
1672                return -ENODEV;
1673
1674        pcu->ep_ctrl = &alt->endpoint[0].desc;
1675        pcu->max_ctrl_size = usb_endpoint_maxp(pcu->ep_ctrl);
1676
1677        pcu->data_intf = usb_ifnum_to_if(pcu->udev,
1678                                         union_desc->bSlaveInterface0);
1679        if (!pcu->data_intf)
1680                return -EINVAL;
1681
1682        alt = pcu->data_intf->cur_altsetting;
1683        if (alt->desc.bNumEndpoints != 2) {
1684                dev_err(pcu->dev,
1685                        "Incorrect number of endpoints on data interface (%d)\n",
1686                        alt->desc.bNumEndpoints);
1687                return -EINVAL;
1688        }
1689
1690        pcu->ep_out = &alt->endpoint[0].desc;
1691        if (!usb_endpoint_is_bulk_out(pcu->ep_out)) {
1692                dev_err(pcu->dev,
1693                        "First endpoint on data interface is not BULK OUT\n");
1694                return -EINVAL;
1695        }
1696
1697        pcu->max_out_size = usb_endpoint_maxp(pcu->ep_out);
1698        if (pcu->max_out_size < 8) {
1699                dev_err(pcu->dev,
1700                        "Max OUT packet size is too small (%zd)\n",
1701                        pcu->max_out_size);
1702                return -EINVAL;
1703        }
1704
1705        pcu->ep_in = &alt->endpoint[1].desc;
1706        if (!usb_endpoint_is_bulk_in(pcu->ep_in)) {
1707                dev_err(pcu->dev,
1708                        "Second endpoint on data interface is not BULK IN\n");
1709                return -EINVAL;
1710        }
1711
1712        pcu->max_in_size = usb_endpoint_maxp(pcu->ep_in);
1713        if (pcu->max_in_size < 8) {
1714                dev_err(pcu->dev,
1715                        "Max IN packet size is too small (%zd)\n",
1716                        pcu->max_in_size);
1717                return -EINVAL;
1718        }
1719
1720        return 0;
1721}
1722
1723static int ims_pcu_start_io(struct ims_pcu *pcu)
1724{
1725        int error;
1726
1727        error = usb_submit_urb(pcu->urb_ctrl, GFP_KERNEL);
1728        if (error) {
1729                dev_err(pcu->dev,
1730                        "Failed to start control IO - usb_submit_urb failed with result: %d\n",
1731                        error);
1732                return -EIO;
1733        }
1734
1735        error = usb_submit_urb(pcu->urb_in, GFP_KERNEL);
1736        if (error) {
1737                dev_err(pcu->dev,
1738                        "Failed to start IO - usb_submit_urb failed with result: %d\n",
1739                        error);
1740                usb_kill_urb(pcu->urb_ctrl);
1741                return -EIO;
1742        }
1743
1744        return 0;
1745}
1746
1747static void ims_pcu_stop_io(struct ims_pcu *pcu)
1748{
1749        usb_kill_urb(pcu->urb_in);
1750        usb_kill_urb(pcu->urb_ctrl);
1751}
1752
1753static int ims_pcu_line_setup(struct ims_pcu *pcu)
1754{
1755        struct usb_host_interface *interface = pcu->ctrl_intf->cur_altsetting;
1756        struct usb_cdc_line_coding *line = (void *)pcu->cmd_buf;
1757        int error;
1758
1759        memset(line, 0, sizeof(*line));
1760        line->dwDTERate = cpu_to_le32(57600);
1761        line->bDataBits = 8;
1762
1763        error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
1764                                USB_CDC_REQ_SET_LINE_CODING,
1765                                USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1766                                0, interface->desc.bInterfaceNumber,
1767                                line, sizeof(struct usb_cdc_line_coding),
1768                                5000);
1769        if (error < 0) {
1770                dev_err(pcu->dev, "Failed to set line coding, error: %d\n",
1771                        error);
1772                return error;
1773        }
1774
1775        error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
1776                                USB_CDC_REQ_SET_CONTROL_LINE_STATE,
1777                                USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1778                                0x03, interface->desc.bInterfaceNumber,
1779                                NULL, 0, 5000);
1780        if (error < 0) {
1781                dev_err(pcu->dev, "Failed to set line state, error: %d\n",
1782                        error);
1783                return error;
1784        }
1785
1786        return 0;
1787}
1788
1789static int ims_pcu_get_device_info(struct ims_pcu *pcu)
1790{
1791        int error;
1792
1793        error = ims_pcu_get_info(pcu);
1794        if (error)
1795                return error;
1796
1797        error = ims_pcu_execute_query(pcu, GET_FW_VERSION);
1798        if (error) {
1799                dev_err(pcu->dev,
1800                        "GET_FW_VERSION command failed, error: %d\n", error);
1801                return error;
1802        }
1803
1804        snprintf(pcu->fw_version, sizeof(pcu->fw_version),
1805                 "%02d%02d%02d%02d.%c%c",
1806                 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5],
1807                 pcu->cmd_buf[6], pcu->cmd_buf[7]);
1808
1809        error = ims_pcu_execute_query(pcu, GET_BL_VERSION);
1810        if (error) {
1811                dev_err(pcu->dev,
1812                        "GET_BL_VERSION command failed, error: %d\n", error);
1813                return error;
1814        }
1815
1816        snprintf(pcu->bl_version, sizeof(pcu->bl_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, RESET_REASON);
1822        if (error) {
1823                dev_err(pcu->dev,
1824                        "RESET_REASON command failed, error: %d\n", error);
1825                return error;
1826        }
1827
1828        snprintf(pcu->reset_reason, sizeof(pcu->reset_reason),
1829                 "%02x", pcu->cmd_buf[IMS_PCU_DATA_OFFSET]);
1830
1831        dev_dbg(pcu->dev,
1832                "P/N: %s, MD: %s, S/N: %s, FW: %s, BL: %s, RR: %s\n",
1833                pcu->part_number,
1834                pcu->date_of_manufacturing,
1835                pcu->serial_number,
1836                pcu->fw_version,
1837                pcu->bl_version,
1838                pcu->reset_reason);
1839
1840        return 0;
1841}
1842
1843static int ims_pcu_identify_type(struct ims_pcu *pcu, u8 *device_id)
1844{
1845        int error;
1846
1847        error = ims_pcu_execute_query(pcu, GET_DEVICE_ID);
1848        if (error) {
1849                dev_err(pcu->dev,
1850                        "GET_DEVICE_ID command failed, error: %d\n", error);
1851                return error;
1852        }
1853
1854        *device_id = pcu->cmd_buf[IMS_PCU_DATA_OFFSET];
1855        dev_dbg(pcu->dev, "Detected device ID: %d\n", *device_id);
1856
1857        return 0;
1858}
1859
1860static int ims_pcu_init_application_mode(struct ims_pcu *pcu)
1861{
1862        static atomic_t device_no = ATOMIC_INIT(0);
1863
1864        const struct ims_pcu_device_info *info;
1865        int error;
1866
1867        error = ims_pcu_get_device_info(pcu);
1868        if (error) {
1869                /* Device does not respond to basic queries, hopeless */
1870                return error;
1871        }
1872
1873        error = ims_pcu_identify_type(pcu, &pcu->device_id);
1874        if (error) {
1875                dev_err(pcu->dev,
1876                        "Failed to identify device, error: %d\n", error);
1877                /*
1878                 * Do not signal error, but do not create input nor
1879                 * backlight devices either, let userspace figure this
1880                 * out (flash a new firmware?).
1881                 */
1882                return 0;
1883        }
1884
1885        if (pcu->device_id >= ARRAY_SIZE(ims_pcu_device_info) ||
1886            !ims_pcu_device_info[pcu->device_id].keymap) {
1887                dev_err(pcu->dev, "Device ID %d is not valid\n", pcu->device_id);
1888                /* Same as above, punt to userspace */
1889                return 0;
1890        }
1891
1892        /* Device appears to be operable, complete initialization */
1893        pcu->device_no = atomic_inc_return(&device_no) - 1;
1894
1895        /*
1896         * PCU-B devices, both GEN_1 and GEN_2 do not have OFN sensor
1897         */
1898        if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID) {
1899                error = sysfs_create_group(&pcu->dev->kobj,
1900                                           &ims_pcu_ofn_attr_group);
1901                if (error)
1902                        return error;
1903        }
1904
1905        error = ims_pcu_setup_backlight(pcu);
1906        if (error)
1907                return error;
1908
1909        info = &ims_pcu_device_info[pcu->device_id];
1910        error = ims_pcu_setup_buttons(pcu, info->keymap, info->keymap_len);
1911        if (error)
1912                goto err_destroy_backlight;
1913
1914        if (info->has_gamepad) {
1915                error = ims_pcu_setup_gamepad(pcu);
1916                if (error)
1917                        goto err_destroy_buttons;
1918        }
1919
1920        pcu->setup_complete = true;
1921
1922        return 0;
1923
1924err_destroy_buttons:
1925        ims_pcu_destroy_buttons(pcu);
1926err_destroy_backlight:
1927        ims_pcu_destroy_backlight(pcu);
1928        return error;
1929}
1930
1931static void ims_pcu_destroy_application_mode(struct ims_pcu *pcu)
1932{
1933        if (pcu->setup_complete) {
1934                pcu->setup_complete = false;
1935                mb(); /* make sure flag setting is not reordered */
1936
1937                if (pcu->gamepad)
1938                        ims_pcu_destroy_gamepad(pcu);
1939                ims_pcu_destroy_buttons(pcu);
1940                ims_pcu_destroy_backlight(pcu);
1941
1942                if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID)
1943                        sysfs_remove_group(&pcu->dev->kobj,
1944                                           &ims_pcu_ofn_attr_group);
1945        }
1946}
1947
1948static int ims_pcu_init_bootloader_mode(struct ims_pcu *pcu)
1949{
1950        int error;
1951
1952        error = ims_pcu_execute_bl_command(pcu, QUERY_DEVICE, NULL, 0,
1953                                           IMS_PCU_CMD_RESPONSE_TIMEOUT);
1954        if (error) {
1955                dev_err(pcu->dev, "Bootloader does not respond, aborting\n");
1956                return error;
1957        }
1958
1959        pcu->fw_start_addr =
1960                get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 11]);
1961        pcu->fw_end_addr =
1962                get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 15]);
1963
1964        dev_info(pcu->dev,
1965                 "Device is in bootloader mode (addr 0x%08x-0x%08x), requesting firmware\n",
1966                 pcu->fw_start_addr, pcu->fw_end_addr);
1967
1968        error = request_firmware_nowait(THIS_MODULE, true,
1969                                        IMS_PCU_FIRMWARE_NAME,
1970                                        pcu->dev, GFP_KERNEL, pcu,
1971                                        ims_pcu_process_async_firmware);
1972        if (error) {
1973                /* This error is not fatal, let userspace have another chance */
1974                complete(&pcu->async_firmware_done);
1975        }
1976
1977        return 0;
1978}
1979
1980static void ims_pcu_destroy_bootloader_mode(struct ims_pcu *pcu)
1981{
1982        /* Make sure our initial firmware request has completed */
1983        wait_for_completion(&pcu->async_firmware_done);
1984}
1985
1986#define IMS_PCU_APPLICATION_MODE        0
1987#define IMS_PCU_BOOTLOADER_MODE         1
1988
1989static struct usb_driver ims_pcu_driver;
1990
1991static int ims_pcu_probe(struct usb_interface *intf,
1992                         const struct usb_device_id *id)
1993{
1994        struct usb_device *udev = interface_to_usbdev(intf);
1995        struct ims_pcu *pcu;
1996        int error;
1997
1998        pcu = kzalloc(sizeof(struct ims_pcu), GFP_KERNEL);
1999        if (!pcu)
2000                return -ENOMEM;
2001
2002        pcu->dev = &intf->dev;
2003        pcu->udev = udev;
2004        pcu->bootloader_mode = id->driver_info == IMS_PCU_BOOTLOADER_MODE;
2005        mutex_init(&pcu->cmd_mutex);
2006        init_completion(&pcu->cmd_done);
2007        init_completion(&pcu->async_firmware_done);
2008
2009        error = ims_pcu_parse_cdc_data(intf, pcu);
2010        if (error)
2011                goto err_free_mem;
2012
2013        error = usb_driver_claim_interface(&ims_pcu_driver,
2014                                           pcu->data_intf, pcu);
2015        if (error) {
2016                dev_err(&intf->dev,
2017                        "Unable to claim corresponding data interface: %d\n",
2018                        error);
2019                goto err_free_mem;
2020        }
2021
2022        usb_set_intfdata(pcu->ctrl_intf, pcu);
2023        usb_set_intfdata(pcu->data_intf, pcu);
2024
2025        error = ims_pcu_buffers_alloc(pcu);
2026        if (error)
2027                goto err_unclaim_intf;
2028
2029        error = ims_pcu_start_io(pcu);
2030        if (error)
2031                goto err_free_buffers;
2032
2033        error = ims_pcu_line_setup(pcu);
2034        if (error)
2035                goto err_stop_io;
2036
2037        error = sysfs_create_group(&intf->dev.kobj, &ims_pcu_attr_group);
2038        if (error)
2039                goto err_stop_io;
2040
2041        error = pcu->bootloader_mode ?
2042                        ims_pcu_init_bootloader_mode(pcu) :
2043                        ims_pcu_init_application_mode(pcu);
2044        if (error)
2045                goto err_remove_sysfs;
2046
2047        return 0;
2048
2049err_remove_sysfs:
2050        sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group);
2051err_stop_io:
2052        ims_pcu_stop_io(pcu);
2053err_free_buffers:
2054        ims_pcu_buffers_free(pcu);
2055err_unclaim_intf:
2056        usb_driver_release_interface(&ims_pcu_driver, pcu->data_intf);
2057err_free_mem:
2058        kfree(pcu);
2059        return error;
2060}
2061
2062static void ims_pcu_disconnect(struct usb_interface *intf)
2063{
2064        struct ims_pcu *pcu = usb_get_intfdata(intf);
2065        struct usb_host_interface *alt = intf->cur_altsetting;
2066
2067        usb_set_intfdata(intf, NULL);
2068
2069        /*
2070         * See if we are dealing with control or data interface. The cleanup
2071         * happens when we unbind primary (control) interface.
2072         */
2073        if (alt->desc.bInterfaceClass != USB_CLASS_COMM)
2074                return;
2075
2076        sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group);
2077
2078        ims_pcu_stop_io(pcu);
2079
2080        if (pcu->bootloader_mode)
2081                ims_pcu_destroy_bootloader_mode(pcu);
2082        else
2083                ims_pcu_destroy_application_mode(pcu);
2084
2085        ims_pcu_buffers_free(pcu);
2086        kfree(pcu);
2087}
2088
2089#ifdef CONFIG_PM
2090static int ims_pcu_suspend(struct usb_interface *intf,
2091                           pm_message_t message)
2092{
2093        struct ims_pcu *pcu = usb_get_intfdata(intf);
2094        struct usb_host_interface *alt = intf->cur_altsetting;
2095
2096        if (alt->desc.bInterfaceClass == USB_CLASS_COMM)
2097                ims_pcu_stop_io(pcu);
2098
2099        return 0;
2100}
2101
2102static int ims_pcu_resume(struct usb_interface *intf)
2103{
2104        struct ims_pcu *pcu = usb_get_intfdata(intf);
2105        struct usb_host_interface *alt = intf->cur_altsetting;
2106        int retval = 0;
2107
2108        if (alt->desc.bInterfaceClass == USB_CLASS_COMM) {
2109                retval = ims_pcu_start_io(pcu);
2110                if (retval == 0)
2111                        retval = ims_pcu_line_setup(pcu);
2112        }
2113
2114        return retval;
2115}
2116#endif
2117
2118static const struct usb_device_id ims_pcu_id_table[] = {
2119        {
2120                USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0082,
2121                                        USB_CLASS_COMM,
2122                                        USB_CDC_SUBCLASS_ACM,
2123                                        USB_CDC_ACM_PROTO_AT_V25TER),
2124                .driver_info = IMS_PCU_APPLICATION_MODE,
2125        },
2126        {
2127                USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0083,
2128                                        USB_CLASS_COMM,
2129                                        USB_CDC_SUBCLASS_ACM,
2130                                        USB_CDC_ACM_PROTO_AT_V25TER),
2131                .driver_info = IMS_PCU_BOOTLOADER_MODE,
2132        },
2133        { }
2134};
2135
2136static struct usb_driver ims_pcu_driver = {
2137        .name                   = "ims_pcu",
2138        .id_table               = ims_pcu_id_table,
2139        .probe                  = ims_pcu_probe,
2140        .disconnect             = ims_pcu_disconnect,
2141#ifdef CONFIG_PM
2142        .suspend                = ims_pcu_suspend,
2143        .resume                 = ims_pcu_resume,
2144        .reset_resume           = ims_pcu_resume,
2145#endif
2146};
2147
2148module_usb_driver(ims_pcu_driver);
2149
2150MODULE_DESCRIPTION("IMS Passenger Control Unit driver");
2151MODULE_AUTHOR("Dmitry Torokhov <dmitry.torokhov@gmail.com>");
2152MODULE_LICENSE("GPL");
Note: See TracBrowser for help on using the repository browser.