// SPDX-License-Identifier: GPL-2.0-only
/*
 * Driver for IMS Passenger Control Unit Devices
 *
 * Copyright (C) 2013 The IMS Company
 */

#include <linux/completion.h>
#include <linux/device.h>
#include <linux/firmware.h>
#include <linux/ihex.h>
#include <linux/input.h>
#include <linux/kernel.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/usb/input.h>
#include <linux/usb/cdc.h>
#include <asm/unaligned.h>

#define IMS_PCU_KEYMAP_LEN              32

struct ims_pcu_buttons {
        struct input_dev *input;
        char name[32];
        char phys[32];
        unsigned short keymap[IMS_PCU_KEYMAP_LEN];
};

struct ims_pcu_gamepad {
        struct input_dev *input;
        char name[32];
        char phys[32];
};

struct ims_pcu_backlight {
        struct led_classdev cdev;
        struct work_struct work;
        enum led_brightness desired_brightness;
        char name[32];
};

#define IMS_PCU_PART_NUMBER_LEN         15
#define IMS_PCU_SERIAL_NUMBER_LEN       8
#define IMS_PCU_DOM_LEN                 8
#define IMS_PCU_FW_VERSION_LEN          (9 + 1)
#define IMS_PCU_BL_VERSION_LEN          (9 + 1)
#define IMS_PCU_BL_RESET_REASON_LEN     (2 + 1)

#define IMS_PCU_PCU_B_DEVICE_ID         5

#define IMS_PCU_BUF_SIZE                128

struct ims_pcu {
        struct usb_device *udev;
        struct device *dev; /* control interface's device, used for logging */

        unsigned int device_no;

        bool bootloader_mode;

        char part_number[IMS_PCU_PART_NUMBER_LEN];
        char serial_number[IMS_PCU_SERIAL_NUMBER_LEN];
        char date_of_manufacturing[IMS_PCU_DOM_LEN];
        char fw_version[IMS_PCU_FW_VERSION_LEN];
        char bl_version[IMS_PCU_BL_VERSION_LEN];
        char reset_reason[IMS_PCU_BL_RESET_REASON_LEN];
        int update_firmware_status;
        u8 device_id;

        u8 ofn_reg_addr;

        struct usb_interface *ctrl_intf;

        struct usb_endpoint_descriptor *ep_ctrl;
        struct urb *urb_ctrl;
        u8 *urb_ctrl_buf;
        dma_addr_t ctrl_dma;
        size_t max_ctrl_size;

        struct usb_interface *data_intf;

        struct usb_endpoint_descriptor *ep_in;
        struct urb *urb_in;
        u8 *urb_in_buf;
        dma_addr_t read_dma;
        size_t max_in_size;

        struct usb_endpoint_descriptor *ep_out;
        u8 *urb_out_buf;
        size_t max_out_size;

        u8 read_buf[IMS_PCU_BUF_SIZE];
        u8 read_pos;
        u8 check_sum;
        bool have_stx;
        bool have_dle;

        u8 cmd_buf[IMS_PCU_BUF_SIZE];
        u8 ack_id;
        u8 expected_response;
        u8 cmd_buf_len;
        struct completion cmd_done;
        struct mutex cmd_mutex;

        u32 fw_start_addr;
        u32 fw_end_addr;
        struct completion async_firmware_done;

        struct ims_pcu_buttons buttons;
        struct ims_pcu_gamepad *gamepad;
        struct ims_pcu_backlight backlight;

        bool setup_complete; /* Input and LED devices have been created */
};


/*********************************************************************
 *             Buttons Input device support                          *
 *********************************************************************/

static const unsigned short ims_pcu_keymap_1[] = {
        [1] = KEY_ATTENDANT_OFF,
        [2] = KEY_ATTENDANT_ON,
        [3] = KEY_LIGHTS_TOGGLE,
        [4] = KEY_VOLUMEUP,
        [5] = KEY_VOLUMEDOWN,
        [6] = KEY_INFO,
};

static const unsigned short ims_pcu_keymap_2[] = {
        [4] = KEY_VOLUMEUP,
        [5] = KEY_VOLUMEDOWN,
        [6] = KEY_INFO,
};

static const unsigned short ims_pcu_keymap_3[] = {
        [1] = KEY_HOMEPAGE,
        [2] = KEY_ATTENDANT_TOGGLE,
        [3] = KEY_LIGHTS_TOGGLE,
        [4] = KEY_VOLUMEUP,
        [5] = KEY_VOLUMEDOWN,
        [6] = KEY_DISPLAYTOGGLE,
        [18] = KEY_PLAYPAUSE,
};

static const unsigned short ims_pcu_keymap_4[] = {
        [1] = KEY_ATTENDANT_OFF,
        [2] = KEY_ATTENDANT_ON,
        [3] = KEY_LIGHTS_TOGGLE,
        [4] = KEY_VOLUMEUP,
        [5] = KEY_VOLUMEDOWN,
        [6] = KEY_INFO,
        [18] = KEY_PLAYPAUSE,
};

static const unsigned short ims_pcu_keymap_5[] = {
        [1] = KEY_ATTENDANT_OFF,
        [2] = KEY_ATTENDANT_ON,
        [3] = KEY_LIGHTS_TOGGLE,
};

struct ims_pcu_device_info {
        const unsigned short *keymap;
        size_t keymap_len;
        bool has_gamepad;
};

#define IMS_PCU_DEVINFO(_n, _gamepad)                           \
        [_n] = {                                                \
                .keymap = ims_pcu_keymap_##_n,                  \
                .keymap_len = ARRAY_SIZE(ims_pcu_keymap_##_n),  \
                .has_gamepad = _gamepad,                        \
        }

static const struct ims_pcu_device_info ims_pcu_device_info[] = {
        IMS_PCU_DEVINFO(1, true),
        IMS_PCU_DEVINFO(2, true),
        IMS_PCU_DEVINFO(3, true),
        IMS_PCU_DEVINFO(4, true),
        IMS_PCU_DEVINFO(5, false),
};

static void ims_pcu_buttons_report(struct ims_pcu *pcu, u32 data)
{
        struct ims_pcu_buttons *buttons = &pcu->buttons;
        struct input_dev *input = buttons->input;
        int i;

        for (i = 0; i < 32; i++) {
                unsigned short keycode = buttons->keymap[i];

                if (keycode != KEY_RESERVED)
                        input_report_key(input, keycode, data & (1UL << i));
        }

        input_sync(input);
}

static int ims_pcu_setup_buttons(struct ims_pcu *pcu,
                                 const unsigned short *keymap,
                                 size_t keymap_len)
{
        struct ims_pcu_buttons *buttons = &pcu->buttons;
        struct input_dev *input;
        int i;
        int error;

        input = input_allocate_device();
        if (!input) {
                dev_err(pcu->dev,
                        "Not enough memory for input input device\n");
                return -ENOMEM;
        }

        snprintf(buttons->name, sizeof(buttons->name),
                 "IMS PCU#%d Button Interface", pcu->device_no);

        usb_make_path(pcu->udev, buttons->phys, sizeof(buttons->phys));
        strlcat(buttons->phys, "/input0", sizeof(buttons->phys));

        memcpy(buttons->keymap, keymap, sizeof(*keymap) * keymap_len);

        input->name = buttons->name;
        input->phys = buttons->phys;
        usb_to_input_id(pcu->udev, &input->id);
        input->dev.parent = &pcu->ctrl_intf->dev;

        input->keycode = buttons->keymap;
        input->keycodemax = ARRAY_SIZE(buttons->keymap);
        input->keycodesize = sizeof(buttons->keymap[0]);

        __set_bit(EV_KEY, input->evbit);
        for (i = 0; i < IMS_PCU_KEYMAP_LEN; i++)
                __set_bit(buttons->keymap[i], input->keybit);
        __clear_bit(KEY_RESERVED, input->keybit);

        error = input_register_device(input);
        if (error) {
                dev_err(pcu->dev,
                        "Failed to register buttons input device: %d\n",
                        error);
                input_free_device(input);
                return error;
        }

        buttons->input = input;
        return 0;
}

static void ims_pcu_destroy_buttons(struct ims_pcu *pcu)
{
        struct ims_pcu_buttons *buttons = &pcu->buttons;

        input_unregister_device(buttons->input);
}


/*********************************************************************
 *             Gamepad Input device support                          *
 *********************************************************************/

static void ims_pcu_gamepad_report(struct ims_pcu *pcu, u32 data)
{
        struct ims_pcu_gamepad *gamepad = pcu->gamepad;
        struct input_dev *input = gamepad->input;
        int x, y;

        x = !!(data & (1 << 14)) - !!(data & (1 << 13));
        y = !!(data & (1 << 12)) - !!(data & (1 << 11));

        input_report_abs(input, ABS_X, x);
        input_report_abs(input, ABS_Y, y);

        input_report_key(input, BTN_A, data & (1 << 7));
        input_report_key(input, BTN_B, data & (1 << 8));
        input_report_key(input, BTN_X, data & (1 << 9));
        input_report_key(input, BTN_Y, data & (1 << 10));
        input_report_key(input, BTN_START, data & (1 << 15));
        input_report_key(input, BTN_SELECT, data & (1 << 16));

        input_sync(input);
}

static int ims_pcu_setup_gamepad(struct ims_pcu *pcu)
{
        struct ims_pcu_gamepad *gamepad;
        struct input_dev *input;
        int error;

        gamepad = kzalloc(sizeof(struct ims_pcu_gamepad), GFP_KERNEL);
        input = input_allocate_device();
        if (!gamepad || !input) {
                dev_err(pcu->dev,
                        "Not enough memory for gamepad device\n");
                error = -ENOMEM;
                goto err_free_mem;
        }

        gamepad->input = input;

        snprintf(gamepad->name, sizeof(gamepad->name),
                 "IMS PCU#%d Gamepad Interface", pcu->device_no);

        usb_make_path(pcu->udev, gamepad->phys, sizeof(gamepad->phys));
        strlcat(gamepad->phys, "/input1", sizeof(gamepad->phys));

        input->name = gamepad->name;
        input->phys = gamepad->phys;
        usb_to_input_id(pcu->udev, &input->id);
        input->dev.parent = &pcu->ctrl_intf->dev;

        __set_bit(EV_KEY, input->evbit);
        __set_bit(BTN_A, input->keybit);
        __set_bit(BTN_B, input->keybit);
        __set_bit(BTN_X, input->keybit);
        __set_bit(BTN_Y, input->keybit);
        __set_bit(BTN_START, input->keybit);
        __set_bit(BTN_SELECT, input->keybit);

        __set_bit(EV_ABS, input->evbit);
        input_set_abs_params(input, ABS_X, -1, 1, 0, 0);
        input_set_abs_params(input, ABS_Y, -1, 1, 0, 0);

        error = input_register_device(input);
        if (error) {
                dev_err(pcu->dev,
                        "Failed to register gamepad input device: %d\n",
                        error);
                goto err_free_mem;
        }

        pcu->gamepad = gamepad;
        return 0;

err_free_mem:
        input_free_device(input);
        kfree(gamepad);
        return -ENOMEM;
}

static void ims_pcu_destroy_gamepad(struct ims_pcu *pcu)
{
        struct ims_pcu_gamepad *gamepad = pcu->gamepad;

        input_unregister_device(gamepad->input);
        kfree(gamepad);
}


/*********************************************************************
 *             PCU Communication protocol handling                   *
 *********************************************************************/

#define IMS_PCU_PROTOCOL_STX            0x02
#define IMS_PCU_PROTOCOL_ETX            0x03
#define IMS_PCU_PROTOCOL_DLE            0x10

/* PCU commands */
#define IMS_PCU_CMD_STATUS              0xa0
#define IMS_PCU_CMD_PCU_RESET           0xa1
#define IMS_PCU_CMD_RESET_REASON        0xa2
#define IMS_PCU_CMD_SEND_BUTTONS        0xa3
#define IMS_PCU_CMD_JUMP_TO_BTLDR       0xa4
#define IMS_PCU_CMD_GET_INFO            0xa5
#define IMS_PCU_CMD_SET_BRIGHTNESS      0xa6
#define IMS_PCU_CMD_EEPROM              0xa7
#define IMS_PCU_CMD_GET_FW_VERSION      0xa8
#define IMS_PCU_CMD_GET_BL_VERSION      0xa9
#define IMS_PCU_CMD_SET_INFO            0xab
#define IMS_PCU_CMD_GET_BRIGHTNESS      0xac
#define IMS_PCU_CMD_GET_DEVICE_ID       0xae
#define IMS_PCU_CMD_SPECIAL_INFO        0xb0
#define IMS_PCU_CMD_BOOTLOADER          0xb1    /* Pass data to bootloader */
#define IMS_PCU_CMD_OFN_SET_CONFIG      0xb3
#define IMS_PCU_CMD_OFN_GET_CONFIG      0xb4

/* PCU responses */
#define IMS_PCU_RSP_STATUS              0xc0
#define IMS_PCU_RSP_PCU_RESET           0       /* Originally 0xc1 */
#define IMS_PCU_RSP_RESET_REASON        0xc2
#define IMS_PCU_RSP_SEND_BUTTONS        0xc3
#define IMS_PCU_RSP_JUMP_TO_BTLDR       0       /* Originally 0xc4 */
#define IMS_PCU_RSP_GET_INFO            0xc5
#define IMS_PCU_RSP_SET_BRIGHTNESS      0xc6
#define IMS_PCU_RSP_EEPROM              0xc7
#define IMS_PCU_RSP_GET_FW_VERSION      0xc8
#define IMS_PCU_RSP_GET_BL_VERSION      0xc9
#define IMS_PCU_RSP_SET_INFO            0xcb
#define IMS_PCU_RSP_GET_BRIGHTNESS      0xcc
#define IMS_PCU_RSP_CMD_INVALID         0xcd
#define IMS_PCU_RSP_GET_DEVICE_ID       0xce
#define IMS_PCU_RSP_SPECIAL_INFO        0xd0
#define IMS_PCU_RSP_BOOTLOADER          0xd1    /* Bootloader response */
#define IMS_PCU_RSP_OFN_SET_CONFIG      0xd2
#define IMS_PCU_RSP_OFN_GET_CONFIG      0xd3


#define IMS_PCU_RSP_EVNT_BUTTONS        0xe0    /* Unsolicited, button state */
#define IMS_PCU_GAMEPAD_MASK            0x0001ff80UL    /* Bits 7 through 16 */


#define IMS_PCU_MIN_PACKET_LEN          3
#define IMS_PCU_DATA_OFFSET             2

#define IMS_PCU_CMD_WRITE_TIMEOUT       100 /* msec */
#define IMS_PCU_CMD_RESPONSE_TIMEOUT    500 /* msec */

static void ims_pcu_report_events(struct ims_pcu *pcu)
{
        u32 data = get_unaligned_be32(&pcu->read_buf[3]);

        ims_pcu_buttons_report(pcu, data & ~IMS_PCU_GAMEPAD_MASK);
        if (pcu->gamepad)
                ims_pcu_gamepad_report(pcu, data);
}

static void ims_pcu_handle_response(struct ims_pcu *pcu)
{
        switch (pcu->read_buf[0]) {
        case IMS_PCU_RSP_EVNT_BUTTONS:
                if (likely(pcu->setup_complete))
                        ims_pcu_report_events(pcu);
                break;

        default:
                /*
                 * See if we got command completion.
                 * If both the sequence and response code match save
                 * the data and signal completion.
                 */
                if (pcu->read_buf[0] == pcu->expected_response &&
                    pcu->read_buf[1] == pcu->ack_id - 1) {

                        memcpy(pcu->cmd_buf, pcu->read_buf, pcu->read_pos);
                        pcu->cmd_buf_len = pcu->read_pos;
                        complete(&pcu->cmd_done);
                }
                break;
        }
}

static void ims_pcu_process_data(struct ims_pcu *pcu, struct urb *urb)
{
        int i;

        for (i = 0; i < urb->actual_length; i++) {
                u8 data = pcu->urb_in_buf[i];

                /* Skip everything until we get Start Xmit */
                if (!pcu->have_stx && data != IMS_PCU_PROTOCOL_STX)
                        continue;

                if (pcu->have_dle) {
                        pcu->have_dle = false;
                        pcu->read_buf[pcu->read_pos++] = data;
                        pcu->check_sum += data;
                        continue;
                }

                switch (data) {
                case IMS_PCU_PROTOCOL_STX:
                        if (pcu->have_stx)
                                dev_warn(pcu->dev,
                                         "Unexpected STX at byte %d, discarding old data\n",
                                         pcu->read_pos);
                        pcu->have_stx = true;
                        pcu->have_dle = false;
                        pcu->read_pos = 0;
                        pcu->check_sum = 0;
                        break;

                case IMS_PCU_PROTOCOL_DLE:
                        pcu->have_dle = true;
                        break;

                case IMS_PCU_PROTOCOL_ETX:
                        if (pcu->read_pos < IMS_PCU_MIN_PACKET_LEN) {
                                dev_warn(pcu->dev,
                                         "Short packet received (%d bytes), ignoring\n",
                                         pcu->read_pos);
                        } else if (pcu->check_sum != 0) {
                                dev_warn(pcu->dev,
                                         "Invalid checksum in packet (%d bytes), ignoring\n",
                                         pcu->read_pos);
                        } else {
                                ims_pcu_handle_response(pcu);
                        }

                        pcu->have_stx = false;
                        pcu->have_dle = false;
                        pcu->read_pos = 0;
                        break;

                default:
                        pcu->read_buf[pcu->read_pos++] = data;
                        pcu->check_sum += data;
                        break;
                }
        }
}

static bool ims_pcu_byte_needs_escape(u8 byte)
{
        return byte == IMS_PCU_PROTOCOL_STX ||
               byte == IMS_PCU_PROTOCOL_ETX ||
               byte == IMS_PCU_PROTOCOL_DLE;
}

static int ims_pcu_send_cmd_chunk(struct ims_pcu *pcu,
                                  u8 command, int chunk, int len)
{
        int error;

        error = usb_bulk_msg(pcu->udev,
                             usb_sndbulkpipe(pcu->udev,
                                             pcu->ep_out->bEndpointAddress),
                             pcu->urb_out_buf, len,
                             NULL, IMS_PCU_CMD_WRITE_TIMEOUT);
        if (error < 0) {
                dev_dbg(pcu->dev,
                        "Sending 0x%02x command failed at chunk %d: %d\n",
                        command, chunk, error);
                return error;
        }

        return 0;
}

static int ims_pcu_send_command(struct ims_pcu *pcu,
                                u8 command, const u8 *data, int len)
{
        int count = 0;
        int chunk = 0;
        int delta;
        int i;
        int error;
        u8 csum = 0;
        u8 ack_id;

        pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_STX;

        /* We know the command need not be escaped */
        pcu->urb_out_buf[count++] = command;
        csum += command;

        ack_id = pcu->ack_id++;
        if (ack_id == 0xff)
                ack_id = pcu->ack_id++;

        if (ims_pcu_byte_needs_escape(ack_id))
                pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_DLE;

        pcu->urb_out_buf[count++] = ack_id;
        csum += ack_id;

        for (i = 0; i < len; i++) {

                delta = ims_pcu_byte_needs_escape(data[i]) ? 2 : 1;
                if (count + delta >= pcu->max_out_size) {
                        error = ims_pcu_send_cmd_chunk(pcu, command,
                                                       ++chunk, count);
                        if (error)
                                return error;

                        count = 0;
                }

                if (delta == 2)
                        pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_DLE;

                pcu->urb_out_buf[count++] = data[i];
                csum += data[i];
        }

        csum = 1 + ~csum;

        delta = ims_pcu_byte_needs_escape(csum) ? 3 : 2;
        if (count + delta >= pcu->max_out_size) {
                error = ims_pcu_send_cmd_chunk(pcu, command, ++chunk, count);
                if (error)
                        return error;

                count = 0;
        }

        if (delta == 3)
                pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_DLE;

        pcu->urb_out_buf[count++] = csum;
        pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_ETX;

        return ims_pcu_send_cmd_chunk(pcu, command, ++chunk, count);
}

static int __ims_pcu_execute_command(struct ims_pcu *pcu,
                                     u8 command, const void *data, size_t len,
                                     u8 expected_response, int response_time)
{
        int error;

        pcu->expected_response = expected_response;
        init_completion(&pcu->cmd_done);

        error = ims_pcu_send_command(pcu, command, data, len);
        if (error)
                return error;

        if (expected_response &&
            !wait_for_completion_timeout(&pcu->cmd_done,
                                         msecs_to_jiffies(response_time))) {
                dev_dbg(pcu->dev, "Command 0x%02x timed out\n", command);
                return -ETIMEDOUT;
        }

        return 0;
}

#define ims_pcu_execute_command(pcu, code, data, len)                   \
        __ims_pcu_execute_command(pcu,                                  \
                                  IMS_PCU_CMD_##code, data, len,        \
                                  IMS_PCU_RSP_##code,                   \
                                  IMS_PCU_CMD_RESPONSE_TIMEOUT)

#define ims_pcu_execute_query(pcu, code)                                \
        ims_pcu_execute_command(pcu, code, NULL, 0)

/* Bootloader commands */
#define IMS_PCU_BL_CMD_QUERY_DEVICE     0xa1
#define IMS_PCU_BL_CMD_UNLOCK_CONFIG    0xa2
#define IMS_PCU_BL_CMD_ERASE_APP        0xa3
#define IMS_PCU_BL_CMD_PROGRAM_DEVICE   0xa4
#define IMS_PCU_BL_CMD_PROGRAM_COMPLETE 0xa5
#define IMS_PCU_BL_CMD_READ_APP         0xa6
#define IMS_PCU_BL_CMD_RESET_DEVICE     0xa7
#define IMS_PCU_BL_CMD_LAUNCH_APP       0xa8

/* Bootloader commands */
#define IMS_PCU_BL_RSP_QUERY_DEVICE     0xc1
#define IMS_PCU_BL_RSP_UNLOCK_CONFIG    0xc2
#define IMS_PCU_BL_RSP_ERASE_APP        0xc3
#define IMS_PCU_BL_RSP_PROGRAM_DEVICE   0xc4
#define IMS_PCU_BL_RSP_PROGRAM_COMPLETE 0xc5
#define IMS_PCU_BL_RSP_READ_APP         0xc6
#define IMS_PCU_BL_RSP_RESET_DEVICE     0       /* originally 0xa7 */
#define IMS_PCU_BL_RSP_LAUNCH_APP       0       /* originally 0xa8 */

#define IMS_PCU_BL_DATA_OFFSET          3

static int __ims_pcu_execute_bl_command(struct ims_pcu *pcu,
                                        u8 command, const void *data, size_t len,
                                        u8 expected_response, int response_time)
{
        int error;

        pcu->cmd_buf[0] = command;
        if (data)
                memcpy(&pcu->cmd_buf[1], data, len);

        error = __ims_pcu_execute_command(pcu,
                                IMS_PCU_CMD_BOOTLOADER, pcu->cmd_buf, len + 1,
                                expected_response ? IMS_PCU_RSP_BOOTLOADER : 0,
                                response_time);
        if (error) {
                dev_err(pcu->dev,
                        "Failure when sending 0x%02x command to bootloader, error: %d\n",
                        pcu->cmd_buf[0], error);
                return error;
        }

        if (expected_response && pcu->cmd_buf[2] != expected_response) {
                dev_err(pcu->dev,
                        "Unexpected response from bootloader: 0x%02x, wanted 0x%02x\n",
                        pcu->cmd_buf[2], expected_response);
                return -EINVAL;
        }

        return 0;
}

#define ims_pcu_execute_bl_command(pcu, code, data, len, timeout)       \
        __ims_pcu_execute_bl_command(pcu,                               \
                                     IMS_PCU_BL_CMD_##code, data, len,  \
                                     IMS_PCU_BL_RSP_##code, timeout)    \

#define IMS_PCU_INFO_PART_OFFSET        2
#define IMS_PCU_INFO_DOM_OFFSET         17
#define IMS_PCU_INFO_SERIAL_OFFSET      25

#define IMS_PCU_SET_INFO_SIZE           31

static int ims_pcu_get_info(struct ims_pcu *pcu)
{
        int error;

        error = ims_pcu_execute_query(pcu, GET_INFO);
        if (error) {
                dev_err(pcu->dev,
                        "GET_INFO command failed, error: %d\n", error);
                return error;
        }

        memcpy(pcu->part_number,
               &pcu->cmd_buf[IMS_PCU_INFO_PART_OFFSET],
               sizeof(pcu->part_number));
        memcpy(pcu->date_of_manufacturing,
               &pcu->cmd_buf[IMS_PCU_INFO_DOM_OFFSET],
               sizeof(pcu->date_of_manufacturing));
        memcpy(pcu->serial_number,
               &pcu->cmd_buf[IMS_PCU_INFO_SERIAL_OFFSET],
               sizeof(pcu->serial_number));

        return 0;
}

static int ims_pcu_set_info(struct ims_pcu *pcu)
{
        int error;

        memcpy(&pcu->cmd_buf[IMS_PCU_INFO_PART_OFFSET],
               pcu->part_number, sizeof(pcu->part_number));
        memcpy(&pcu->cmd_buf[IMS_PCU_INFO_DOM_OFFSET],
               pcu->date_of_manufacturing, sizeof(pcu->date_of_manufacturing));
        memcpy(&pcu->cmd_buf[IMS_PCU_INFO_SERIAL_OFFSET],
               pcu->serial_number, sizeof(pcu->serial_number));

        error = ims_pcu_execute_command(pcu, SET_INFO,
                                        &pcu->cmd_buf[IMS_PCU_DATA_OFFSET],
                                        IMS_PCU_SET_INFO_SIZE);
        if (error) {
                dev_err(pcu->dev,
                        "Failed to update device information, error: %d\n",
                        error);
                return error;
        }

        return 0;
}

static int ims_pcu_switch_to_bootloader(struct ims_pcu *pcu)
{
        int error;

        /* Execute jump to the bootoloader */
        error = ims_pcu_execute_command(pcu, JUMP_TO_BTLDR, NULL, 0);
        if (error) {
                dev_err(pcu->dev,
                        "Failure when sending JUMP TO BOOLTLOADER command, error: %d\n",
                        error);
                return error;
        }

        return 0;
}

/*********************************************************************
 *             Firmware Update handling                              *
 *********************************************************************/

#define IMS_PCU_FIRMWARE_NAME   "imspcu.fw"

struct ims_pcu_flash_fmt {
        __le32 addr;
        u8 len;
        u8 data[];
};

static unsigned int ims_pcu_count_fw_records(const struct firmware *fw)
{
        const struct ihex_binrec *rec = (const struct ihex_binrec *)fw->data;
        unsigned int count = 0;

        while (rec) {
                count++;
                rec = ihex_next_binrec(rec);
        }

        return count;
}

static int ims_pcu_verify_block(struct ims_pcu *pcu,
                                u32 addr, u8 len, const u8 *data)
{
        struct ims_pcu_flash_fmt *fragment;
        int error;

        fragment = (void *)&pcu->cmd_buf[1];
        put_unaligned_le32(addr, &fragment->addr);
        fragment->len = len;

        error = ims_pcu_execute_bl_command(pcu, READ_APP, NULL, 5,
                                        IMS_PCU_CMD_RESPONSE_TIMEOUT);
        if (error) {
                dev_err(pcu->dev,
                        "Failed to retrieve block at 0x%08x, len %d, error: %d\n",
                        addr, len, error);
                return error;
        }

        fragment = (void *)&pcu->cmd_buf[IMS_PCU_BL_DATA_OFFSET];
        if (get_unaligned_le32(&fragment->addr) != addr ||
            fragment->len != len) {
                dev_err(pcu->dev,
                        "Wrong block when retrieving 0x%08x (0x%08x), len %d (%d)\n",
                        addr, get_unaligned_le32(&fragment->addr),
                        len, fragment->len);
                return -EINVAL;
        }

        if (memcmp(fragment->data, data, len)) {
                dev_err(pcu->dev,
                        "Mismatch in block at 0x%08x, len %d\n",
                        addr, len);
                return -EINVAL;
        }

        return 0;
}

static int ims_pcu_flash_firmware(struct ims_pcu *pcu,
                                  const struct firmware *fw,
                                  unsigned int n_fw_records)
{
        const struct ihex_binrec *rec = (const struct ihex_binrec *)fw->data;
        struct ims_pcu_flash_fmt *fragment;
        unsigned int count = 0;
        u32 addr;
        u8 len;
        int error;

        error = ims_pcu_execute_bl_command(pcu, ERASE_APP, NULL, 0, 2000);
        if (error) {
                dev_err(pcu->dev,
                        "Failed to erase application image, error: %d\n",
                        error);
                return error;
        }

        while (rec) {
                /*
                 * The firmware format is messed up for some reason.
                 * The address twice that of what is needed for some
                 * reason and we end up overwriting half of the data
                 * with the next record.
                 */
                addr = be32_to_cpu(rec->addr) / 2;
                len = be16_to_cpu(rec->len);

                fragment = (void *)&pcu->cmd_buf[1];
                put_unaligned_le32(addr, &fragment->addr);
                fragment->len = len;
                memcpy(fragment->data, rec->data, len);

                error = ims_pcu_execute_bl_command(pcu, PROGRAM_DEVICE,
                                                NULL, len + 5,
                                                IMS_PCU_CMD_RESPONSE_TIMEOUT);
                if (error) {
                        dev_err(pcu->dev,
                                "Failed to write block at 0x%08x, len %d, error: %d\n",
                                addr, len, error);
                        return error;
                }

                if (addr >= pcu->fw_start_addr && addr < pcu->fw_end_addr) {
                        error = ims_pcu_verify_block(pcu, addr, len, rec->data);
                        if (error)
                                return error;
                }

                count++;
                pcu->update_firmware_status = (count * 100) / n_fw_records;

                rec = ihex_next_binrec(rec);
        }

        error = ims_pcu_execute_bl_command(pcu, PROGRAM_COMPLETE,
                                            NULL, 0, 2000);
        if (error)
                dev_err(pcu->dev,
                        "Failed to send PROGRAM_COMPLETE, error: %d\n",
                        error);

        return 0;
}

static int ims_pcu_handle_firmware_update(struct ims_pcu *pcu,
                                          const struct firmware *fw)
{
        unsigned int n_fw_records;
        int retval;

        dev_info(pcu->dev, "Updating firmware %s, size: %zu\n",
                 IMS_PCU_FIRMWARE_NAME, fw->size);

        n_fw_records = ims_pcu_count_fw_records(fw);

        retval = ims_pcu_flash_firmware(pcu, fw, n_fw_records);
        if (retval)
                goto out;

        retval = ims_pcu_execute_bl_command(pcu, LAUNCH_APP, NULL, 0, 0);
        if (retval)
                dev_err(pcu->dev,
                        "Failed to start application image, error: %d\n",
                        retval);

out:
        pcu->update_firmware_status = retval;
        sysfs_notify(&pcu->dev->kobj, NULL, "update_firmware_status");
        return retval;
}

static void ims_pcu_process_async_firmware(const struct firmware *fw,
                                           void *context)
{
        struct ims_pcu *pcu = context;
        int error;

        if (!fw) {
                dev_err(pcu->dev, "Failed to get firmware %s\n",
                        IMS_PCU_FIRMWARE_NAME);
                goto out;
        }

        error = ihex_validate_fw(fw);
        if (error) {
                dev_err(pcu->dev, "Firmware %s is invalid\n",
                        IMS_PCU_FIRMWARE_NAME);
                goto out;
        }

        mutex_lock(&pcu->cmd_mutex);
        ims_pcu_handle_firmware_update(pcu, fw);
        mutex_unlock(&pcu->cmd_mutex);

        release_firmware(fw);

out:
        complete(&pcu->async_firmware_done);
}

/*********************************************************************
 *             Backlight LED device support                          *
 *********************************************************************/

#define IMS_PCU_MAX_BRIGHTNESS          31998

static void ims_pcu_backlight_work(struct work_struct *work)
{
        struct ims_pcu_backlight *backlight =
                        container_of(work, struct ims_pcu_backlight, work);
        struct ims_pcu *pcu =
                        container_of(backlight, struct ims_pcu, backlight);
        int desired_brightness = backlight->desired_brightness;
        __le16 br_val = cpu_to_le16(desired_brightness);
        int error;

        mutex_lock(&pcu->cmd_mutex);

        error = ims_pcu_execute_command(pcu, SET_BRIGHTNESS,
                                        &br_val, sizeof(br_val));
        if (error && error != -ENODEV)
                dev_warn(pcu->dev,
                         "Failed to set desired brightness %u, error: %d\n",
                         desired_brightness, error);

        mutex_unlock(&pcu->cmd_mutex);
}

static void ims_pcu_backlight_set_brightness(struct led_classdev *cdev,
                                             enum led_brightness value)
{
        struct ims_pcu_backlight *backlight =
                        container_of(cdev, struct ims_pcu_backlight, cdev);

        backlight->desired_brightness = value;
        schedule_work(&backlight->work);
}

static enum led_brightness
ims_pcu_backlight_get_brightness(struct led_classdev *cdev)
{
        struct ims_pcu_backlight *backlight =
                        container_of(cdev, struct ims_pcu_backlight, cdev);
        struct ims_pcu *pcu =
                        container_of(backlight, struct ims_pcu, backlight);
        int brightness;
        int error;

        mutex_lock(&pcu->cmd_mutex);

        error = ims_pcu_execute_query(pcu, GET_BRIGHTNESS);
        if (error) {
                dev_warn(pcu->dev,
                         "Failed to get current brightness, error: %d\n",
                         error);
                /* Assume the LED is OFF */
                brightness = LED_OFF;
        } else {

                brightness =
                        get_unaligned_le16(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET]);
        }

        mutex_unlock(&pcu->cmd_mutex);

        return brightness;
}

static int ims_pcu_setup_backlight(struct ims_pcu *pcu)
{
        struct ims_pcu_backlight *backlight = &pcu->backlight;
        int error;

        INIT_WORK(&backlight->work, ims_pcu_backlight_work);
        snprintf(backlight->name, sizeof(backlight->name),
                 "pcu%d::kbd_backlight", pcu->device_no);

        backlight->cdev.name = backlight->name;
        backlight->cdev.max_brightness = IMS_PCU_MAX_BRIGHTNESS;
        backlight->cdev.brightness_get = ims_pcu_backlight_get_brightness;
        backlight->cdev.brightness_set = ims_pcu_backlight_set_brightness;

        error = led_classdev_register(pcu->dev, &backlight->cdev);
        if (error) {
                dev_err(pcu->dev,
                        "Failed to register backlight LED device, error: %d\n",
                        error);
                return error;
        }

        return 0;
}

static void ims_pcu_destroy_backlight(struct ims_pcu *pcu)
{
        struct ims_pcu_backlight *backlight = &pcu->backlight;

        led_classdev_unregister(&backlight->cdev);
        cancel_work_sync(&backlight->work);
}


/*********************************************************************
 *             Sysfs attributes handling                             *
 *********************************************************************/

struct ims_pcu_attribute {
        struct device_attribute dattr;
        size_t field_offset;
        int field_length;
};

static ssize_t ims_pcu_attribute_show(struct device *dev,
                                      struct device_attribute *dattr,
                                      char *buf)
{
        struct usb_interface *intf = to_usb_interface(dev);
        struct ims_pcu *pcu = usb_get_intfdata(intf);
        struct ims_pcu_attribute *attr =
                        container_of(dattr, struct ims_pcu_attribute, dattr);
        char *field = (char *)pcu + attr->field_offset;

        return scnprintf(buf, PAGE_SIZE, "%.*s\n", attr->field_length, field);
}

static ssize_t ims_pcu_attribute_store(struct device *dev,
                                       struct device_attribute *dattr,
                                       const char *buf, size_t count)
{

        struct usb_interface *intf = to_usb_interface(dev);
        struct ims_pcu *pcu = usb_get_intfdata(intf);
        struct ims_pcu_attribute *attr =
                        container_of(dattr, struct ims_pcu_attribute, dattr);
        char *field = (char *)pcu + attr->field_offset;
        size_t data_len;
        int error;

        if (count > attr->field_length)
                return -EINVAL;

        data_len = strnlen(buf, attr->field_length);
        if (data_len > attr->field_length)
                return -EINVAL;

        error = mutex_lock_interruptible(&pcu->cmd_mutex);
        if (error)
                return error;

        memset(field, 0, attr->field_length);
        memcpy(field, buf, data_len);

        error = ims_pcu_set_info(pcu);

        /*
         * Even if update failed, let's fetch the info again as we just
         * clobbered one of the fields.
         */
        ims_pcu_get_info(pcu);

        mutex_unlock(&pcu->cmd_mutex);

        return error < 0 ? error : count;
}

#define IMS_PCU_ATTR(_field, _mode)                                     \
struct ims_pcu_attribute ims_pcu_attr_##_field = {                      \
        .dattr = __ATTR(_field, _mode,                                  \
                        ims_pcu_attribute_show,                         \
                        ims_pcu_attribute_store),                       \
        .field_offset = offsetof(struct ims_pcu, _field),               \
        .field_length = sizeof(((struct ims_pcu *)NULL)->_field),       \
}

#define IMS_PCU_RO_ATTR(_field)                                         \
                IMS_PCU_ATTR(_field, S_IRUGO)
#define IMS_PCU_RW_ATTR(_field)                                         \
                IMS_PCU_ATTR(_field, S_IRUGO | S_IWUSR)

static IMS_PCU_RW_ATTR(part_number);
static IMS_PCU_RW_ATTR(serial_number);
static IMS_PCU_RW_ATTR(date_of_manufacturing);

static IMS_PCU_RO_ATTR(fw_version);
static IMS_PCU_RO_ATTR(bl_version);
static IMS_PCU_RO_ATTR(reset_reason);

static ssize_t ims_pcu_reset_device(struct device *dev,
                                    struct device_attribute *dattr,
                                    const char *buf, size_t count)
{
        static const u8 reset_byte = 1;
        struct usb_interface *intf = to_usb_interface(dev);
        struct ims_pcu *pcu = usb_get_intfdata(intf);
        int value;
        int error;

        error = kstrtoint(buf, 0, &value);
        if (error)
                return error;

        if (value != 1)
                return -EINVAL;

        dev_info(pcu->dev, "Attempting to reset device\n");

        error = ims_pcu_execute_command(pcu, PCU_RESET, &reset_byte, 1);
        if (error) {
                dev_info(pcu->dev,
                         "Failed to reset device, error: %d\n",
                         error);
                return error;
        }

        return count;
}

static DEVICE_ATTR(reset_device, S_IWUSR, NULL, ims_pcu_reset_device);

static ssize_t ims_pcu_update_firmware_store(struct device *dev,
                                             struct device_attribute *dattr,
                                             const char *buf, size_t count)
{
        struct usb_interface *intf = to_usb_interface(dev);
        struct ims_pcu *pcu = usb_get_intfdata(intf);
        const struct firmware *fw = NULL;
        int value;
        int error;

        error = kstrtoint(buf, 0, &value);
        if (error)
                return error;

        if (value != 1)
                return -EINVAL;

        error = mutex_lock_interruptible(&pcu->cmd_mutex);
        if (error)
                return error;

        error = request_ihex_firmware(&fw, IMS_PCU_FIRMWARE_NAME, pcu->dev);
        if (error) {
                dev_err(pcu->dev, "Failed to request firmware %s, error: %d\n",
                        IMS_PCU_FIRMWARE_NAME, error);
                goto out;
        }

        /*
         * If we are already in bootloader mode we can proceed with
         * flashing the firmware.
         *
         * If we are in application mode, then we need to switch into
         * bootloader mode, which will cause the device to disconnect
         * and reconnect as different device.
         */
        if (pcu->bootloader_mode)
                error = ims_pcu_handle_firmware_update(pcu, fw);
        else
                error = ims_pcu_switch_to_bootloader(pcu);

        release_firmware(fw);

out:
        mutex_unlock(&pcu->cmd_mutex);
        return error ?: count;
}

static DEVICE_ATTR(update_firmware, S_IWUSR,
                   NULL, ims_pcu_update_firmware_store);

static ssize_t
ims_pcu_update_firmware_status_show(struct device *dev,
                                    struct device_attribute *dattr,
                                    char *buf)
{
        struct usb_interface *intf = to_usb_interface(dev);
        struct ims_pcu *pcu = usb_get_intfdata(intf);

        return scnprintf(buf, PAGE_SIZE, "%d\n", pcu->update_firmware_status);
}

static DEVICE_ATTR(update_firmware_status, S_IRUGO,
                   ims_pcu_update_firmware_status_show, NULL);

static struct attribute *ims_pcu_attrs[] = {
        &ims_pcu_attr_part_number.dattr.attr,
        &ims_pcu_attr_serial_number.dattr.attr,
        &ims_pcu_attr_date_of_manufacturing.dattr.attr,
        &ims_pcu_attr_fw_version.dattr.attr,
        &ims_pcu_attr_bl_version.dattr.attr,
        &ims_pcu_attr_reset_reason.dattr.attr,
        &dev_attr_reset_device.attr,
        &dev_attr_update_firmware.attr,
        &dev_attr_update_firmware_status.attr,
        NULL
};

static umode_t ims_pcu_is_attr_visible(struct kobject *kobj,
                                       struct attribute *attr, int n)
{
        struct device *dev = container_of(kobj, struct device, kobj);
        struct usb_interface *intf = to_usb_interface(dev);
        struct ims_pcu *pcu = usb_get_intfdata(intf);
        umode_t mode = attr->mode;

        if (pcu->bootloader_mode) {
                if (attr != &dev_attr_update_firmware_status.attr &&
                    attr != &dev_attr_update_firmware.attr &&
                    attr != &dev_attr_reset_device.attr) {
                        mode = 0;
                }
        } else {
                if (attr == &dev_attr_update_firmware_status.attr)
                        mode = 0;
        }

        return mode;
}

static const struct attribute_group ims_pcu_attr_group = {
        .is_visible     = ims_pcu_is_attr_visible,
        .attrs          = ims_pcu_attrs,
};

/* Support for a separate OFN attribute group */

#define OFN_REG_RESULT_OFFSET   2

static int ims_pcu_read_ofn_config(struct ims_pcu *pcu, u8 addr, u8 *data)
{
        int error;
        s16 result;

        error = ims_pcu_execute_command(pcu, OFN_GET_CONFIG,
                                        &addr, sizeof(addr));
        if (error)
                return error;

        result = (s16)get_unaligned_le16(pcu->cmd_buf + OFN_REG_RESULT_OFFSET);
        if (result < 0)
                return -EIO;

        /* We only need LSB */
        *data = pcu->cmd_buf[OFN_REG_RESULT_OFFSET];
        return 0;
}

static int ims_pcu_write_ofn_config(struct ims_pcu *pcu, u8 addr, u8 data)
{
        u8 buffer[] = { addr, data };
        int error;
        s16 result;

        error = ims_pcu_execute_command(pcu, OFN_SET_CONFIG,
                                        &buffer, sizeof(buffer));
        if (error)
                return error;

        result = (s16)get_unaligned_le16(pcu->cmd_buf + OFN_REG_RESULT_OFFSET);
        if (result < 0)
                return -EIO;

        return 0;
}

static ssize_t ims_pcu_ofn_reg_data_show(struct device *dev,
                                         struct device_attribute *dattr,
                                         char *buf)
{
        struct usb_interface *intf = to_usb_interface(dev);
        struct ims_pcu *pcu = usb_get_intfdata(intf);
        int error;
        u8 data;

        mutex_lock(&pcu->cmd_mutex);
        error = ims_pcu_read_ofn_config(pcu, pcu->ofn_reg_addr, &data);
        mutex_unlock(&pcu->cmd_mutex);

        if (error)
                return error;

        return scnprintf(buf, PAGE_SIZE, "%x\n", data);
}

static ssize_t ims_pcu_ofn_reg_data_store(struct device *dev,
                                          struct device_attribute *dattr,
                                          const char *buf, size_t count)
{
        struct usb_interface *intf = to_usb_interface(dev);
        struct ims_pcu *pcu = usb_get_intfdata(intf);
        int error;
        u8 value;

        error = kstrtou8(buf, 0, &value);
        if (error)
                return error;

        mutex_lock(&pcu->cmd_mutex);
        error = ims_pcu_write_ofn_config(pcu, pcu->ofn_reg_addr, value);
        mutex_unlock(&pcu->cmd_mutex);

        return error ?: count;
}

static DEVICE_ATTR(reg_data, S_IRUGO | S_IWUSR,
                   ims_pcu_ofn_reg_data_show, ims_pcu_ofn_reg_data_store);

static ssize_t ims_pcu_ofn_reg_addr_show(struct device *dev,
                                         struct device_attribute *dattr,
                                         char *buf)
{
        struct usb_interface *intf = to_usb_interface(dev);
        struct ims_pcu *pcu = usb_get_intfdata(intf);
        int error;

        mutex_lock(&pcu->cmd_mutex);
        error = scnprintf(buf, PAGE_SIZE, "%x\n", pcu->ofn_reg_addr);
        mutex_unlock(&pcu->cmd_mutex);

        return error;
}

static ssize_t ims_pcu_ofn_reg_addr_store(struct device *dev,
                                          struct device_attribute *dattr,
                                          const char *buf, size_t count)
{
        struct usb_interface *intf = to_usb_interface(dev);
        struct ims_pcu *pcu = usb_get_intfdata(intf);
        int error;
        u8 value;

        error = kstrtou8(buf, 0, &value);
        if (error)
                return error;

        mutex_lock(&pcu->cmd_mutex);
        pcu->ofn_reg_addr = value;
        mutex_unlock(&pcu->cmd_mutex);

        return count;
}

static DEVICE_ATTR(reg_addr, S_IRUGO | S_IWUSR,
                   ims_pcu_ofn_reg_addr_show, ims_pcu_ofn_reg_addr_store);

struct ims_pcu_ofn_bit_attribute {
        struct device_attribute dattr;
        u8 addr;
        u8 nr;
};

static ssize_t ims_pcu_ofn_bit_show(struct device *dev,
                                    struct device_attribute *dattr,
                                    char *buf)
{
        struct usb_interface *intf = to_usb_interface(dev);
        struct ims_pcu *pcu = usb_get_intfdata(intf);
        struct ims_pcu_ofn_bit_attribute *attr =
                container_of(dattr, struct ims_pcu_ofn_bit_attribute, dattr);
        int error;
        u8 data;

        mutex_lock(&pcu->cmd_mutex);
        error = ims_pcu_read_ofn_config(pcu, attr->addr, &data);
        mutex_unlock(&pcu->cmd_mutex);

        if (error)
                return error;

        return scnprintf(buf, PAGE_SIZE, "%d\n", !!(data & (1 << attr->nr)));
}

static ssize_t ims_pcu_ofn_bit_store(struct device *dev,
                                     struct device_attribute *dattr,
                                     const char *buf, size_t count)
{
        struct usb_interface *intf = to_usb_interface(dev);
        struct ims_pcu *pcu = usb_get_intfdata(intf);
        struct ims_pcu_ofn_bit_attribute *attr =
                container_of(dattr, struct ims_pcu_ofn_bit_attribute, dattr);
        int error;
        int value;
        u8 data;

        error = kstrtoint(buf, 0, &value);
        if (error)
                return error;

        if (value > 1)
                return -EINVAL;

        mutex_lock(&pcu->cmd_mutex);

        error = ims_pcu_read_ofn_config(pcu, attr->addr, &data);
        if (!error) {
                if (value)
                        data |= 1U << attr->nr;
                else
                        data &= ~(1U << attr->nr);

                error = ims_pcu_write_ofn_config(pcu, attr->addr, data);
        }

        mutex_unlock(&pcu->cmd_mutex);

        return error ?: count;
}

#define IMS_PCU_OFN_BIT_ATTR(_field, _addr, _nr)                        \
struct ims_pcu_ofn_bit_attribute ims_pcu_ofn_attr_##_field = {          \
        .dattr = __ATTR(_field, S_IWUSR | S_IRUGO,                      \
                        ims_pcu_ofn_bit_show, ims_pcu_ofn_bit_store),   \
        .addr = _addr,                                                  \
        .nr = _nr,                                                      \
}

static IMS_PCU_OFN_BIT_ATTR(engine_enable,   0x60, 7);
static IMS_PCU_OFN_BIT_ATTR(speed_enable,    0x60, 6);
static IMS_PCU_OFN_BIT_ATTR(assert_enable,   0x60, 5);
static IMS_PCU_OFN_BIT_ATTR(xyquant_enable,  0x60, 4);
static IMS_PCU_OFN_BIT_ATTR(xyscale_enable,  0x60, 1);

static IMS_PCU_OFN_BIT_ATTR(scale_x2,        0x63, 6);
static IMS_PCU_OFN_BIT_ATTR(scale_y2,        0x63, 7);

static struct attribute *ims_pcu_ofn_attrs[] = {
        &dev_attr_reg_data.attr,
        &dev_attr_reg_addr.attr,
        &ims_pcu_ofn_attr_engine_enable.dattr.attr,
        &ims_pcu_ofn_attr_speed_enable.dattr.attr,
        &ims_pcu_ofn_attr_assert_enable.dattr.attr,
        &ims_pcu_ofn_attr_xyquant_enable.dattr.attr,
        &ims_pcu_ofn_attr_xyscale_enable.dattr.attr,
        &ims_pcu_ofn_attr_scale_x2.dattr.attr,
        &ims_pcu_ofn_attr_scale_y2.dattr.attr,
        NULL
};

static const struct attribute_group ims_pcu_ofn_attr_group = {
        .name   = "ofn",
        .attrs  = ims_pcu_ofn_attrs,
};

static void ims_pcu_irq(struct urb *urb)
{
        struct ims_pcu *pcu = urb->context;
        int retval, status;

        status = urb->status;

        switch (status) {
        case 0:
                /* success */
                break;
        case -ECONNRESET:
        case -ENOENT:
        case -ESHUTDOWN:
                /* this urb is terminated, clean up */
                dev_dbg(pcu->dev, "%s - urb shutting down with status: %d\n",
                        __func__, status);
                return;
        default:
                dev_dbg(pcu->dev, "%s - nonzero urb status received: %d\n",
                        __func__, status);
                goto exit;
        }

        dev_dbg(pcu->dev, "%s: received %d: %*ph\n", __func__,
                urb->actual_length, urb->actual_length, pcu->urb_in_buf);

        if (urb == pcu->urb_in)
                ims_pcu_process_data(pcu, urb);

exit:
        retval = usb_submit_urb(urb, GFP_ATOMIC);
        if (retval && retval != -ENODEV)
                dev_err(pcu->dev, "%s - usb_submit_urb failed with result %d\n",
                        __func__, retval);
}

static int ims_pcu_buffers_alloc(struct ims_pcu *pcu)
{
        int error;

        pcu->urb_in_buf = usb_alloc_coherent(pcu->udev, pcu->max_in_size,
                                             GFP_KERNEL, &pcu->read_dma);
        if (!pcu->urb_in_buf) {
                dev_err(pcu->dev,
                        "Failed to allocate memory for read buffer\n");
                return -ENOMEM;
        }

        pcu->urb_in = usb_alloc_urb(0, GFP_KERNEL);
        if (!pcu->urb_in) {
                dev_err(pcu->dev, "Failed to allocate input URB\n");
                error = -ENOMEM;
                goto err_free_urb_in_buf;
        }

        pcu->urb_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
        pcu->urb_in->transfer_dma = pcu->read_dma;

        usb_fill_bulk_urb(pcu->urb_in, pcu->udev,
                          usb_rcvbulkpipe(pcu->udev,
                                          pcu->ep_in->bEndpointAddress),
                          pcu->urb_in_buf, pcu->max_in_size,
                          ims_pcu_irq, pcu);

        /*
         * We are using usb_bulk_msg() for sending so there is no point
         * in allocating memory with usb_alloc_coherent().
         */
        pcu->urb_out_buf = kmalloc(pcu->max_out_size, GFP_KERNEL);
        if (!pcu->urb_out_buf) {
                dev_err(pcu->dev, "Failed to allocate memory for write buffer\n");
                error = -ENOMEM;
                goto err_free_in_urb;
        }

        pcu->urb_ctrl_buf = usb_alloc_coherent(pcu->udev, pcu->max_ctrl_size,
                                               GFP_KERNEL, &pcu->ctrl_dma);
        if (!pcu->urb_ctrl_buf) {
                dev_err(pcu->dev,
                        "Failed to allocate memory for read buffer\n");
                error = -ENOMEM;
                goto err_free_urb_out_buf;
        }

        pcu->urb_ctrl = usb_alloc_urb(0, GFP_KERNEL);
        if (!pcu->urb_ctrl) {
                dev_err(pcu->dev, "Failed to allocate input URB\n");
                error = -ENOMEM;
                goto err_free_urb_ctrl_buf;
        }

        pcu->urb_ctrl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
        pcu->urb_ctrl->transfer_dma = pcu->ctrl_dma;

        usb_fill_int_urb(pcu->urb_ctrl, pcu->udev,
                          usb_rcvintpipe(pcu->udev,
                                         pcu->ep_ctrl->bEndpointAddress),
                          pcu->urb_ctrl_buf, pcu->max_ctrl_size,
                          ims_pcu_irq, pcu, pcu->ep_ctrl->bInterval);

        return 0;

err_free_urb_ctrl_buf:
        usb_free_coherent(pcu->udev, pcu->max_ctrl_size,
                          pcu->urb_ctrl_buf, pcu->ctrl_dma);
err_free_urb_out_buf:
        kfree(pcu->urb_out_buf);
err_free_in_urb:
        usb_free_urb(pcu->urb_in);
err_free_urb_in_buf:
        usb_free_coherent(pcu->udev, pcu->max_in_size,
                          pcu->urb_in_buf, pcu->read_dma);
        return error;
}

static void ims_pcu_buffers_free(struct ims_pcu *pcu)
{
        usb_kill_urb(pcu->urb_in);
        usb_free_urb(pcu->urb_in);

        usb_free_coherent(pcu->udev, pcu->max_out_size,
                          pcu->urb_in_buf, pcu->read_dma);

        kfree(pcu->urb_out_buf);

        usb_kill_urb(pcu->urb_ctrl);
        usb_free_urb(pcu->urb_ctrl);

        usb_free_coherent(pcu->udev, pcu->max_ctrl_size,
                          pcu->urb_ctrl_buf, pcu->ctrl_dma);
}

static const struct usb_cdc_union_desc *
ims_pcu_get_cdc_union_desc(struct usb_interface *intf)
{
        const void *buf = intf->altsetting->extra;
        size_t buflen = intf->altsetting->extralen;
        struct usb_cdc_union_desc *union_desc;

        if (!buf) {
                dev_err(&intf->dev, "Missing descriptor data\n");
                return NULL;
        }

        if (!buflen) {
                dev_err(&intf->dev, "Zero length descriptor\n");
                return NULL;
        }

        while (buflen >= sizeof(*union_desc)) {
                union_desc = (struct usb_cdc_union_desc *)buf;

                if (union_desc->bLength > buflen) {
                        dev_err(&intf->dev, "Too large descriptor\n");
                        return NULL;
                }

                if (union_desc->bDescriptorType == USB_DT_CS_INTERFACE &&
                    union_desc->bDescriptorSubType == USB_CDC_UNION_TYPE) {
                        dev_dbg(&intf->dev, "Found union header\n");

                        if (union_desc->bLength >= sizeof(*union_desc))
                                return union_desc;

                        dev_err(&intf->dev,
                                "Union descriptor too short (%d vs %zd)\n",
                                union_desc->bLength, sizeof(*union_desc));
                        return NULL;
                }

                buflen -= union_desc->bLength;
                buf += union_desc->bLength;
        }

        dev_err(&intf->dev, "Missing CDC union descriptor\n");
        return NULL;
}

static int ims_pcu_parse_cdc_data(struct usb_interface *intf, struct ims_pcu *pcu)
{
        const struct usb_cdc_union_desc *union_desc;
        struct usb_host_interface *alt;

        union_desc = ims_pcu_get_cdc_union_desc(intf);
        if (!union_desc)
                return -EINVAL;

        pcu->ctrl_intf = usb_ifnum_to_if(pcu->udev,
                                         union_desc->bMasterInterface0);
        if (!pcu->ctrl_intf)
                return -EINVAL;

        alt = pcu->ctrl_intf->cur_altsetting;

        if (alt->desc.bNumEndpoints < 1)
                return -ENODEV;

        pcu->ep_ctrl = &alt->endpoint[0].desc;
        pcu->max_ctrl_size = usb_endpoint_maxp(pcu->ep_ctrl);

        pcu->data_intf = usb_ifnum_to_if(pcu->udev,
                                         union_desc->bSlaveInterface0);
        if (!pcu->data_intf)
                return -EINVAL;

        alt = pcu->data_intf->cur_altsetting;
        if (alt->desc.bNumEndpoints != 2) {
                dev_err(pcu->dev,
                        "Incorrect number of endpoints on data interface (%d)\n",
                        alt->desc.bNumEndpoints);
                return -EINVAL;
        }

        pcu->ep_out = &alt->endpoint[0].desc;
        if (!usb_endpoint_is_bulk_out(pcu->ep_out)) {
                dev_err(pcu->dev,
                        "First endpoint on data interface is not BULK OUT\n");
                return -EINVAL;
        }

        pcu->max_out_size = usb_endpoint_maxp(pcu->ep_out);
        if (pcu->max_out_size < 8) {
                dev_err(pcu->dev,
                        "Max OUT packet size is too small (%zd)\n",
                        pcu->max_out_size);
                return -EINVAL;
        }

        pcu->ep_in = &alt->endpoint[1].desc;
        if (!usb_endpoint_is_bulk_in(pcu->ep_in)) {
                dev_err(pcu->dev,
                        "Second endpoint on data interface is not BULK IN\n");
                return -EINVAL;
        }

        pcu->max_in_size = usb_endpoint_maxp(pcu->ep_in);
        if (pcu->max_in_size < 8) {
                dev_err(pcu->dev,
                        "Max IN packet size is too small (%zd)\n",
                        pcu->max_in_size);
                return -EINVAL;
        }

        return 0;
}

static int ims_pcu_start_io(struct ims_pcu *pcu)
{
        int error;

        error = usb_submit_urb(pcu->urb_ctrl, GFP_KERNEL);
        if (error) {
                dev_err(pcu->dev,
                        "Failed to start control IO - usb_submit_urb failed with result: %d\n",
                        error);
                return -EIO;
        }

        error = usb_submit_urb(pcu->urb_in, GFP_KERNEL);
        if (error) {
                dev_err(pcu->dev,
                        "Failed to start IO - usb_submit_urb failed with result: %d\n",
                        error);
                usb_kill_urb(pcu->urb_ctrl);
                return -EIO;
        }

        return 0;
}

static void ims_pcu_stop_io(struct ims_pcu *pcu)
{
        usb_kill_urb(pcu->urb_in);
        usb_kill_urb(pcu->urb_ctrl);
}

static int ims_pcu_line_setup(struct ims_pcu *pcu)
{
        struct usb_host_interface *interface = pcu->ctrl_intf->cur_altsetting;
        struct usb_cdc_line_coding *line = (void *)pcu->cmd_buf;
        int error;

        memset(line, 0, sizeof(*line));
        line->dwDTERate = cpu_to_le32(57600);
        line->bDataBits = 8;

        error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
                                USB_CDC_REQ_SET_LINE_CODING,
                                USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                                0, interface->desc.bInterfaceNumber,
                                line, sizeof(struct usb_cdc_line_coding),
                                5000);
        if (error < 0) {
                dev_err(pcu->dev, "Failed to set line coding, error: %d\n",
                        error);
                return error;
        }

        error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
                                USB_CDC_REQ_SET_CONTROL_LINE_STATE,
                                USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                                0x03, interface->desc.bInterfaceNumber,
                                NULL, 0, 5000);
        if (error < 0) {
                dev_err(pcu->dev, "Failed to set line state, error: %d\n",
                        error);
                return error;
        }

        return 0;
}

static int ims_pcu_get_device_info(struct ims_pcu *pcu)
{
        int error;

        error = ims_pcu_get_info(pcu);
        if (error)
                return error;

        error = ims_pcu_execute_query(pcu, GET_FW_VERSION);
        if (error) {
                dev_err(pcu->dev,
                        "GET_FW_VERSION command failed, error: %d\n", error);
                return error;
        }

        snprintf(pcu->fw_version, sizeof(pcu->fw_version),
                 "%02d%02d%02d%02d.%c%c",
                 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5],
                 pcu->cmd_buf[6], pcu->cmd_buf[7]);

        error = ims_pcu_execute_query(pcu, GET_BL_VERSION);
        if (error) {
                dev_err(pcu->dev,
                        "GET_BL_VERSION command failed, error: %d\n", error);
                return error;
        }

        snprintf(pcu->bl_version, sizeof(pcu->bl_version),
                 "%02d%02d%02d%02d.%c%c",
                 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5],
                 pcu->cmd_buf[6], pcu->cmd_buf[7]);

        error = ims_pcu_execute_query(pcu, RESET_REASON);
        if (error) {
                dev_err(pcu->dev,
                        "RESET_REASON command failed, error: %d\n", error);
                return error;
        }

        snprintf(pcu->reset_reason, sizeof(pcu->reset_reason),
                 "%02x", pcu->cmd_buf[IMS_PCU_DATA_OFFSET]);

        dev_dbg(pcu->dev,
                "P/N: %s, MD: %s, S/N: %s, FW: %s, BL: %s, RR: %s\n",
                pcu->part_number,
                pcu->date_of_manufacturing,
                pcu->serial_number,
                pcu->fw_version,
                pcu->bl_version,
                pcu->reset_reason);

        return 0;
}

static int ims_pcu_identify_type(struct ims_pcu *pcu, u8 *device_id)
{
        int error;

        error = ims_pcu_execute_query(pcu, GET_DEVICE_ID);
        if (error) {
                dev_err(pcu->dev,
                        "GET_DEVICE_ID command failed, error: %d\n", error);
                return error;
        }

        *device_id = pcu->cmd_buf[IMS_PCU_DATA_OFFSET];
        dev_dbg(pcu->dev, "Detected device ID: %d\n", *device_id);

        return 0;
}

static int ims_pcu_init_application_mode(struct ims_pcu *pcu)
{
        static atomic_t device_no = ATOMIC_INIT(-1);

        const struct ims_pcu_device_info *info;
        int error;

        error = ims_pcu_get_device_info(pcu);
        if (error) {
                /* Device does not respond to basic queries, hopeless */
                return error;
        }

        error = ims_pcu_identify_type(pcu, &pcu->device_id);
        if (error) {
                dev_err(pcu->dev,
                        "Failed to identify device, error: %d\n", error);
                /*
                 * Do not signal error, but do not create input nor
                 * backlight devices either, let userspace figure this
                 * out (flash a new firmware?).
                 */
                return 0;
        }

        if (pcu->device_id >= ARRAY_SIZE(ims_pcu_device_info) ||
            !ims_pcu_device_info[pcu->device_id].keymap) {
                dev_err(pcu->dev, "Device ID %d is not valid\n", pcu->device_id);
                /* Same as above, punt to userspace */
                return 0;
        }

        /* Device appears to be operable, complete initialization */
        pcu->device_no = atomic_inc_return(&device_no);

        /*
         * PCU-B devices, both GEN_1 and GEN_2 do not have OFN sensor
         */
        if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID) {
                error = sysfs_create_group(&pcu->dev->kobj,
                                           &ims_pcu_ofn_attr_group);
                if (error)
                        return error;
        }

        error = ims_pcu_setup_backlight(pcu);
        if (error)
                return error;

        info = &ims_pcu_device_info[pcu->device_id];
        error = ims_pcu_setup_buttons(pcu, info->keymap, info->keymap_len);
        if (error)
                goto err_destroy_backlight;

        if (info->has_gamepad) {
                error = ims_pcu_setup_gamepad(pcu);
                if (error)
                        goto err_destroy_buttons;
        }

        pcu->setup_complete = true;

        return 0;

err_destroy_buttons:
        ims_pcu_destroy_buttons(pcu);
err_destroy_backlight:
        ims_pcu_destroy_backlight(pcu);
        return error;
}

static void ims_pcu_destroy_application_mode(struct ims_pcu *pcu)
{
        if (pcu->setup_complete) {
                pcu->setup_complete = false;
                mb(); /* make sure flag setting is not reordered */

                if (pcu->gamepad)
                        ims_pcu_destroy_gamepad(pcu);
                ims_pcu_destroy_buttons(pcu);
                ims_pcu_destroy_backlight(pcu);

                if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID)
                        sysfs_remove_group(&pcu->dev->kobj,
                                           &ims_pcu_ofn_attr_group);
        }
}

static int ims_pcu_init_bootloader_mode(struct ims_pcu *pcu)
{
        int error;

        error = ims_pcu_execute_bl_command(pcu, QUERY_DEVICE, NULL, 0,
                                           IMS_PCU_CMD_RESPONSE_TIMEOUT);
        if (error) {
                dev_err(pcu->dev, "Bootloader does not respond, aborting\n");
                return error;
        }

        pcu->fw_start_addr =
                get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 11]);
        pcu->fw_end_addr =
                get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 15]);

        dev_info(pcu->dev,
                 "Device is in bootloader mode (addr 0x%08x-0x%08x), requesting firmware\n",
                 pcu->fw_start_addr, pcu->fw_end_addr);

        error = request_firmware_nowait(THIS_MODULE, true,
                                        IMS_PCU_FIRMWARE_NAME,
                                        pcu->dev, GFP_KERNEL, pcu,
                                        ims_pcu_process_async_firmware);
        if (error) {
                /* This error is not fatal, let userspace have another chance */
                complete(&pcu->async_firmware_done);
        }

        return 0;
}

static void ims_pcu_destroy_bootloader_mode(struct ims_pcu *pcu)
{
        /* Make sure our initial firmware request has completed */
        wait_for_completion(&pcu->async_firmware_done);
}

#define IMS_PCU_APPLICATION_MODE        0
#define IMS_PCU_BOOTLOADER_MODE         1

static struct usb_driver ims_pcu_driver;

static int ims_pcu_probe(struct usb_interface *intf,

                         const struct usb_device_id *id)
{
        struct usb_device *udev = interface_to_usbdev(intf);
        struct ims_pcu *pcu;
        int error;

        pcu = kzalloc(sizeof(struct ims_pcu), GFP_KERNEL);
        if (!pcu)
                return -ENOMEM;

        pcu->dev = &intf->dev;
        pcu->udev = udev;
        pcu->bootloader_mode = id->driver_info == IMS_PCU_BOOTLOADER_MODE;
        mutex_init(&pcu->cmd_mutex);
        init_completion(&pcu->cmd_done);
        init_completion(&pcu->async_firmware_done);

        error = ims_pcu_parse_cdc_data(intf, pcu);
        if (error)
                goto err_free_mem;

        error = usb_driver_claim_interface(&ims_pcu_driver,
                                           pcu->data_intf, pcu);
        if (error) {
                dev_err(&intf->dev,
                        "Unable to claim corresponding data interface: %d\n",
                        error);
                goto err_free_mem;
        }

        usb_set_intfdata(pcu->ctrl_intf, pcu);
        usb_set_intfdata(pcu->data_intf, pcu);

        error = ims_pcu_buffers_alloc(pcu);
        if (error)
                goto err_unclaim_intf;

        error = ims_pcu_start_io(pcu);
        if (error)
                goto err_free_buffers;

        error = ims_pcu_line_setup(pcu);
        if (error)
                goto err_stop_io;

        error = sysfs_create_group(&intf->dev.kobj, &ims_pcu_attr_group);
        if (error)
                goto err_stop_io;

        error = pcu->bootloader_mode ?
                        ims_pcu_init_bootloader_mode(pcu) :
                        ims_pcu_init_application_mode(pcu);
        if (error)
                goto err_remove_sysfs;

        return 0;

err_remove_sysfs:
        sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group);
err_stop_io:
        ims_pcu_stop_io(pcu);
err_free_buffers:
        ims_pcu_buffers_free(pcu);
err_unclaim_intf:
        usb_driver_release_interface(&ims_pcu_driver, pcu->data_intf);
err_free_mem:
        kfree(pcu);
        return error;
}

static void ims_pcu_disconnect(struct usb_interface *intf)
{
        struct ims_pcu *pcu = usb_get_intfdata(intf);
        struct usb_host_interface *alt = intf->cur_altsetting;

        usb_set_intfdata(intf, NULL);

        /*
         * See if we are dealing with control or data interface. The cleanup
         * happens when we unbind primary (control) interface.
         */
        if (alt->desc.bInterfaceClass != USB_CLASS_COMM)
                return;

        sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group);

        ims_pcu_stop_io(pcu);

        if (pcu->bootloader_mode)
                ims_pcu_destroy_bootloader_mode(pcu);
        else
                ims_pcu_destroy_application_mode(pcu);

        ims_pcu_buffers_free(pcu);
        kfree(pcu);
}

#ifdef CONFIG_PM
static int ims_pcu_suspend(struct usb_interface *intf,
                           pm_message_t message)
{
        struct ims_pcu *pcu = usb_get_intfdata(intf);
        struct usb_host_interface *alt = intf->cur_altsetting;

        if (alt->desc.bInterfaceClass == USB_CLASS_COMM)
                ims_pcu_stop_io(pcu);

        return 0;
}

static int ims_pcu_resume(struct usb_interface *intf)
{
        struct ims_pcu *pcu = usb_get_intfdata(intf);
        struct usb_host_interface *alt = intf->cur_altsetting;
        int retval = 0;

        if (alt->desc.bInterfaceClass == USB_CLASS_COMM) {
                retval = ims_pcu_start_io(pcu);
                if (retval == 0)
                        retval = ims_pcu_line_setup(pcu);
        }

        return retval;
}
#endif

static const struct usb_device_id ims_pcu_id_table[] = {
        {
                USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0082,
                                        USB_CLASS_COMM,
                                        USB_CDC_SUBCLASS_ACM,
                                        USB_CDC_ACM_PROTO_AT_V25TER),
                .driver_info = IMS_PCU_APPLICATION_MODE,
        },
        {
                USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0083,
                                        USB_CLASS_COMM,
                                        USB_CDC_SUBCLASS_ACM,
                                        USB_CDC_ACM_PROTO_AT_V25TER),
                .driver_info = IMS_PCU_BOOTLOADER_MODE,
        },
        { }
};

static struct usb_driver ims_pcu_driver = {
        .name                   = "ims_pcu",
        .id_table               = ims_pcu_id_table,
        .probe                  = ims_pcu_probe,
        .disconnect             = ims_pcu_disconnect,
#ifdef CONFIG_PM
        .suspend                = ims_pcu_suspend,
        .resume                 = ims_pcu_resume,
        .reset_resume           = ims_pcu_resume,
#endif
};

module_usb_driver(ims_pcu_driver);

MODULE_DESCRIPTION("IMS Passenger Control Unit driver");
MODULE_AUTHOR("Dmitry Torokhov <dmitry.torokhov@gmail.com>");
MODULE_LICENSE("GPL");