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 error ?: 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		goto err_free_urb_out_buf;
1570	}
1571
1572	pcu->urb_ctrl = usb_alloc_urb(0, GFP_KERNEL);
1573	if (!pcu->urb_ctrl) {
1574		dev_err(pcu->dev, "Failed to allocate input URB\n");
1575		error = -ENOMEM;
1576		goto err_free_urb_ctrl_buf;
1577	}
1578
1579	pcu->urb_ctrl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1580	pcu->urb_ctrl->transfer_dma = pcu->ctrl_dma;
1581
1582	usb_fill_int_urb(pcu->urb_ctrl, pcu->udev,
1583			  usb_rcvintpipe(pcu->udev,
1584					 pcu->ep_ctrl->bEndpointAddress),
1585			  pcu->urb_ctrl_buf, pcu->max_ctrl_size,
1586			  ims_pcu_irq, pcu, pcu->ep_ctrl->bInterval);
1587
1588	return 0;
1589
1590err_free_urb_ctrl_buf:
1591	usb_free_coherent(pcu->udev, pcu->max_ctrl_size,
1592			  pcu->urb_ctrl_buf, pcu->ctrl_dma);
1593err_free_urb_out_buf:
1594	kfree(pcu->urb_out_buf);
1595err_free_in_urb:
1596	usb_free_urb(pcu->urb_in);
1597err_free_urb_in_buf:
1598	usb_free_coherent(pcu->udev, pcu->max_in_size,
1599			  pcu->urb_in_buf, pcu->read_dma);
1600	return error;
1601}
1602
1603static void ims_pcu_buffers_free(struct ims_pcu *pcu)
1604{
1605	usb_kill_urb(pcu->urb_in);
1606	usb_free_urb(pcu->urb_in);
1607
1608	usb_free_coherent(pcu->udev, pcu->max_out_size,
1609			  pcu->urb_in_buf, pcu->read_dma);
1610
1611	kfree(pcu->urb_out_buf);
1612
1613	usb_kill_urb(pcu->urb_ctrl);
1614	usb_free_urb(pcu->urb_ctrl);
1615
1616	usb_free_coherent(pcu->udev, pcu->max_ctrl_size,
1617			  pcu->urb_ctrl_buf, pcu->ctrl_dma);
1618}
1619
1620static const struct usb_cdc_union_desc *
1621ims_pcu_get_cdc_union_desc(struct usb_interface *intf)
1622{
1623	const void *buf = intf->altsetting->extra;
1624	size_t buflen = intf->altsetting->extralen;
1625	struct usb_cdc_union_desc *union_desc;
1626
1627	if (!buf) {
1628		dev_err(&intf->dev, "Missing descriptor data\n");
1629		return NULL;
1630	}
1631
1632	if (!buflen) {
1633		dev_err(&intf->dev, "Zero length descriptor\n");
1634		return NULL;
1635	}
1636
1637	while (buflen > 0) {
1638		union_desc = (struct usb_cdc_union_desc *)buf;
1639
 
 
 
 
 
1640		if (union_desc->bDescriptorType == USB_DT_CS_INTERFACE &&
1641		    union_desc->bDescriptorSubType == USB_CDC_UNION_TYPE) {
1642			dev_dbg(&intf->dev, "Found union header\n");
1643			return union_desc;
 
 
 
 
 
 
 
1644		}
1645
1646		buflen -= union_desc->bLength;
1647		buf += union_desc->bLength;
1648	}
1649
1650	dev_err(&intf->dev, "Missing CDC union descriptor\n");
1651	return NULL;
1652}
1653
1654static int ims_pcu_parse_cdc_data(struct usb_interface *intf, struct ims_pcu *pcu)
1655{
1656	const struct usb_cdc_union_desc *union_desc;
1657	struct usb_host_interface *alt;
1658
1659	union_desc = ims_pcu_get_cdc_union_desc(intf);
1660	if (!union_desc)
1661		return -EINVAL;
1662
1663	pcu->ctrl_intf = usb_ifnum_to_if(pcu->udev,
1664					 union_desc->bMasterInterface0);
 
 
1665
1666	alt = pcu->ctrl_intf->cur_altsetting;
 
 
 
 
1667	pcu->ep_ctrl = &alt->endpoint[0].desc;
1668	pcu->max_ctrl_size = usb_endpoint_maxp(pcu->ep_ctrl);
1669
1670	pcu->data_intf = usb_ifnum_to_if(pcu->udev,
1671					 union_desc->bSlaveInterface0);
 
 
1672
1673	alt = pcu->data_intf->cur_altsetting;
1674	if (alt->desc.bNumEndpoints != 2) {
1675		dev_err(pcu->dev,
1676			"Incorrect number of endpoints on data interface (%d)\n",
1677			alt->desc.bNumEndpoints);
1678		return -EINVAL;
1679	}
1680
1681	pcu->ep_out = &alt->endpoint[0].desc;
1682	if (!usb_endpoint_is_bulk_out(pcu->ep_out)) {
1683		dev_err(pcu->dev,
1684			"First endpoint on data interface is not BULK OUT\n");
1685		return -EINVAL;
1686	}
1687
1688	pcu->max_out_size = usb_endpoint_maxp(pcu->ep_out);
1689	if (pcu->max_out_size < 8) {
1690		dev_err(pcu->dev,
1691			"Max OUT packet size is too small (%zd)\n",
1692			pcu->max_out_size);
1693		return -EINVAL;
1694	}
1695
1696	pcu->ep_in = &alt->endpoint[1].desc;
1697	if (!usb_endpoint_is_bulk_in(pcu->ep_in)) {
1698		dev_err(pcu->dev,
1699			"Second endpoint on data interface is not BULK IN\n");
1700		return -EINVAL;
1701	}
1702
1703	pcu->max_in_size = usb_endpoint_maxp(pcu->ep_in);
1704	if (pcu->max_in_size < 8) {
1705		dev_err(pcu->dev,
1706			"Max IN packet size is too small (%zd)\n",
1707			pcu->max_in_size);
1708		return -EINVAL;
1709	}
1710
1711	return 0;
1712}
1713
1714static int ims_pcu_start_io(struct ims_pcu *pcu)
1715{
1716	int error;
1717
1718	error = usb_submit_urb(pcu->urb_ctrl, GFP_KERNEL);
1719	if (error) {
1720		dev_err(pcu->dev,
1721			"Failed to start control IO - usb_submit_urb failed with result: %d\n",
1722			error);
1723		return -EIO;
1724	}
1725
1726	error = usb_submit_urb(pcu->urb_in, GFP_KERNEL);
1727	if (error) {
1728		dev_err(pcu->dev,
1729			"Failed to start IO - usb_submit_urb failed with result: %d\n",
1730			error);
1731		usb_kill_urb(pcu->urb_ctrl);
1732		return -EIO;
1733	}
1734
1735	return 0;
1736}
1737
1738static void ims_pcu_stop_io(struct ims_pcu *pcu)
1739{
1740	usb_kill_urb(pcu->urb_in);
1741	usb_kill_urb(pcu->urb_ctrl);
1742}
1743
1744static int ims_pcu_line_setup(struct ims_pcu *pcu)
1745{
1746	struct usb_host_interface *interface = pcu->ctrl_intf->cur_altsetting;
1747	struct usb_cdc_line_coding *line = (void *)pcu->cmd_buf;
1748	int error;
1749
1750	memset(line, 0, sizeof(*line));
1751	line->dwDTERate = cpu_to_le32(57600);
1752	line->bDataBits = 8;
1753
1754	error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
1755				USB_CDC_REQ_SET_LINE_CODING,
1756				USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1757				0, interface->desc.bInterfaceNumber,
1758				line, sizeof(struct usb_cdc_line_coding),
1759				5000);
1760	if (error < 0) {
1761		dev_err(pcu->dev, "Failed to set line coding, error: %d\n",
1762			error);
1763		return error;
1764	}
1765
1766	error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
1767				USB_CDC_REQ_SET_CONTROL_LINE_STATE,
1768				USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1769				0x03, interface->desc.bInterfaceNumber,
1770				NULL, 0, 5000);
1771	if (error < 0) {
1772		dev_err(pcu->dev, "Failed to set line state, error: %d\n",
1773			error);
1774		return error;
1775	}
1776
1777	return 0;
1778}
1779
1780static int ims_pcu_get_device_info(struct ims_pcu *pcu)
1781{
1782	int error;
1783
1784	error = ims_pcu_get_info(pcu);
1785	if (error)
1786		return error;
1787
1788	error = ims_pcu_execute_query(pcu, GET_FW_VERSION);
1789	if (error) {
1790		dev_err(pcu->dev,
1791			"GET_FW_VERSION command failed, error: %d\n", error);
1792		return error;
1793	}
1794
1795	snprintf(pcu->fw_version, sizeof(pcu->fw_version),
1796		 "%02d%02d%02d%02d.%c%c",
1797		 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5],
1798		 pcu->cmd_buf[6], pcu->cmd_buf[7]);
1799
1800	error = ims_pcu_execute_query(pcu, GET_BL_VERSION);
1801	if (error) {
1802		dev_err(pcu->dev,
1803			"GET_BL_VERSION command failed, error: %d\n", error);
1804		return error;
1805	}
1806
1807	snprintf(pcu->bl_version, sizeof(pcu->bl_version),
1808		 "%02d%02d%02d%02d.%c%c",
1809		 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5],
1810		 pcu->cmd_buf[6], pcu->cmd_buf[7]);
1811
1812	error = ims_pcu_execute_query(pcu, RESET_REASON);
1813	if (error) {
1814		dev_err(pcu->dev,
1815			"RESET_REASON command failed, error: %d\n", error);
1816		return error;
1817	}
1818
1819	snprintf(pcu->reset_reason, sizeof(pcu->reset_reason),
1820		 "%02x", pcu->cmd_buf[IMS_PCU_DATA_OFFSET]);
1821
1822	dev_dbg(pcu->dev,
1823		"P/N: %s, MD: %s, S/N: %s, FW: %s, BL: %s, RR: %s\n",
1824		pcu->part_number,
1825		pcu->date_of_manufacturing,
1826		pcu->serial_number,
1827		pcu->fw_version,
1828		pcu->bl_version,
1829		pcu->reset_reason);
1830
1831	return 0;
1832}
1833
1834static int ims_pcu_identify_type(struct ims_pcu *pcu, u8 *device_id)
1835{
1836	int error;
1837
1838	error = ims_pcu_execute_query(pcu, GET_DEVICE_ID);
1839	if (error) {
1840		dev_err(pcu->dev,
1841			"GET_DEVICE_ID command failed, error: %d\n", error);
1842		return error;
1843	}
1844
1845	*device_id = pcu->cmd_buf[IMS_PCU_DATA_OFFSET];
1846	dev_dbg(pcu->dev, "Detected device ID: %d\n", *device_id);
1847
1848	return 0;
1849}
1850
1851static int ims_pcu_init_application_mode(struct ims_pcu *pcu)
1852{
1853	static atomic_t device_no = ATOMIC_INIT(0);
1854
1855	const struct ims_pcu_device_info *info;
1856	int error;
1857
1858	error = ims_pcu_get_device_info(pcu);
1859	if (error) {
1860		/* Device does not respond to basic queries, hopeless */
1861		return error;
1862	}
1863
1864	error = ims_pcu_identify_type(pcu, &pcu->device_id);
1865	if (error) {
1866		dev_err(pcu->dev,
1867			"Failed to identify device, error: %d\n", error);
1868		/*
1869		 * Do not signal error, but do not create input nor
1870		 * backlight devices either, let userspace figure this
1871		 * out (flash a new firmware?).
1872		 */
1873		return 0;
1874	}
1875
1876	if (pcu->device_id >= ARRAY_SIZE(ims_pcu_device_info) ||
1877	    !ims_pcu_device_info[pcu->device_id].keymap) {
1878		dev_err(pcu->dev, "Device ID %d is not valid\n", pcu->device_id);
1879		/* Same as above, punt to userspace */
1880		return 0;
1881	}
1882
1883	/* Device appears to be operable, complete initialization */
1884	pcu->device_no = atomic_inc_return(&device_no) - 1;
1885
1886	/*
1887	 * PCU-B devices, both GEN_1 and GEN_2 do not have OFN sensor
1888	 */
1889	if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID) {
1890		error = sysfs_create_group(&pcu->dev->kobj,
1891					   &ims_pcu_ofn_attr_group);
1892		if (error)
1893			return error;
1894	}
1895
1896	error = ims_pcu_setup_backlight(pcu);
1897	if (error)
1898		return error;
1899
1900	info = &ims_pcu_device_info[pcu->device_id];
1901	error = ims_pcu_setup_buttons(pcu, info->keymap, info->keymap_len);
1902	if (error)
1903		goto err_destroy_backlight;
1904
1905	if (info->has_gamepad) {
1906		error = ims_pcu_setup_gamepad(pcu);
1907		if (error)
1908			goto err_destroy_buttons;
1909	}
1910
1911	pcu->setup_complete = true;
1912
1913	return 0;
1914
1915err_destroy_buttons:
1916	ims_pcu_destroy_buttons(pcu);
1917err_destroy_backlight:
1918	ims_pcu_destroy_backlight(pcu);
1919	return error;
1920}
1921
1922static void ims_pcu_destroy_application_mode(struct ims_pcu *pcu)
1923{
1924	if (pcu->setup_complete) {
1925		pcu->setup_complete = false;
1926		mb(); /* make sure flag setting is not reordered */
1927
1928		if (pcu->gamepad)
1929			ims_pcu_destroy_gamepad(pcu);
1930		ims_pcu_destroy_buttons(pcu);
1931		ims_pcu_destroy_backlight(pcu);
1932
1933		if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID)
1934			sysfs_remove_group(&pcu->dev->kobj,
1935					   &ims_pcu_ofn_attr_group);
1936	}
1937}
1938
1939static int ims_pcu_init_bootloader_mode(struct ims_pcu *pcu)
1940{
1941	int error;
1942
1943	error = ims_pcu_execute_bl_command(pcu, QUERY_DEVICE, NULL, 0,
1944					   IMS_PCU_CMD_RESPONSE_TIMEOUT);
1945	if (error) {
1946		dev_err(pcu->dev, "Bootloader does not respond, aborting\n");
1947		return error;
1948	}
1949
1950	pcu->fw_start_addr =
1951		get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 11]);
1952	pcu->fw_end_addr =
1953		get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 15]);
1954
1955	dev_info(pcu->dev,
1956		 "Device is in bootloader mode (addr 0x%08x-0x%08x), requesting firmware\n",
1957		 pcu->fw_start_addr, pcu->fw_end_addr);
1958
1959	error = request_firmware_nowait(THIS_MODULE, true,
1960					IMS_PCU_FIRMWARE_NAME,
1961					pcu->dev, GFP_KERNEL, pcu,
1962					ims_pcu_process_async_firmware);
1963	if (error) {
1964		/* This error is not fatal, let userspace have another chance */
1965		complete(&pcu->async_firmware_done);
1966	}
1967
1968	return 0;
1969}
1970
1971static void ims_pcu_destroy_bootloader_mode(struct ims_pcu *pcu)
1972{
1973	/* Make sure our initial firmware request has completed */
1974	wait_for_completion(&pcu->async_firmware_done);
1975}
1976
1977#define IMS_PCU_APPLICATION_MODE	0
1978#define IMS_PCU_BOOTLOADER_MODE		1
1979
1980static struct usb_driver ims_pcu_driver;
1981
1982static int ims_pcu_probe(struct usb_interface *intf,
1983			 const struct usb_device_id *id)
1984{
1985	struct usb_device *udev = interface_to_usbdev(intf);
1986	struct ims_pcu *pcu;
1987	int error;
1988
1989	pcu = kzalloc(sizeof(struct ims_pcu), GFP_KERNEL);
1990	if (!pcu)
1991		return -ENOMEM;
1992
1993	pcu->dev = &intf->dev;
1994	pcu->udev = udev;
1995	pcu->bootloader_mode = id->driver_info == IMS_PCU_BOOTLOADER_MODE;
1996	mutex_init(&pcu->cmd_mutex);
1997	init_completion(&pcu->cmd_done);
1998	init_completion(&pcu->async_firmware_done);
1999
2000	error = ims_pcu_parse_cdc_data(intf, pcu);
2001	if (error)
2002		goto err_free_mem;
2003
2004	error = usb_driver_claim_interface(&ims_pcu_driver,
2005					   pcu->data_intf, pcu);
2006	if (error) {
2007		dev_err(&intf->dev,
2008			"Unable to claim corresponding data interface: %d\n",
2009			error);
2010		goto err_free_mem;
2011	}
2012
2013	usb_set_intfdata(pcu->ctrl_intf, pcu);
2014	usb_set_intfdata(pcu->data_intf, pcu);
2015
2016	error = ims_pcu_buffers_alloc(pcu);
2017	if (error)
2018		goto err_unclaim_intf;
2019
2020	error = ims_pcu_start_io(pcu);
2021	if (error)
2022		goto err_free_buffers;
2023
2024	error = ims_pcu_line_setup(pcu);
2025	if (error)
2026		goto err_stop_io;
2027
2028	error = sysfs_create_group(&intf->dev.kobj, &ims_pcu_attr_group);
2029	if (error)
2030		goto err_stop_io;
2031
2032	error = pcu->bootloader_mode ?
2033			ims_pcu_init_bootloader_mode(pcu) :
2034			ims_pcu_init_application_mode(pcu);
2035	if (error)
2036		goto err_remove_sysfs;
2037
2038	return 0;
2039
2040err_remove_sysfs:
2041	sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group);
2042err_stop_io:
2043	ims_pcu_stop_io(pcu);
2044err_free_buffers:
2045	ims_pcu_buffers_free(pcu);
2046err_unclaim_intf:
2047	usb_driver_release_interface(&ims_pcu_driver, pcu->data_intf);
2048err_free_mem:
2049	kfree(pcu);
2050	return error;
2051}
2052
2053static void ims_pcu_disconnect(struct usb_interface *intf)
2054{
2055	struct ims_pcu *pcu = usb_get_intfdata(intf);
2056	struct usb_host_interface *alt = intf->cur_altsetting;
2057
2058	usb_set_intfdata(intf, NULL);
2059
2060	/*
2061	 * See if we are dealing with control or data interface. The cleanup
2062	 * happens when we unbind primary (control) interface.
2063	 */
2064	if (alt->desc.bInterfaceClass != USB_CLASS_COMM)
2065		return;
2066
2067	sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group);
2068
2069	ims_pcu_stop_io(pcu);
2070
2071	if (pcu->bootloader_mode)
2072		ims_pcu_destroy_bootloader_mode(pcu);
2073	else
2074		ims_pcu_destroy_application_mode(pcu);
2075
2076	ims_pcu_buffers_free(pcu);
2077	kfree(pcu);
2078}
2079
2080#ifdef CONFIG_PM
2081static int ims_pcu_suspend(struct usb_interface *intf,
2082			   pm_message_t message)
2083{
2084	struct ims_pcu *pcu = usb_get_intfdata(intf);
2085	struct usb_host_interface *alt = intf->cur_altsetting;
2086
2087	if (alt->desc.bInterfaceClass == USB_CLASS_COMM)
2088		ims_pcu_stop_io(pcu);
2089
2090	return 0;
2091}
2092
2093static int ims_pcu_resume(struct usb_interface *intf)
2094{
2095	struct ims_pcu *pcu = usb_get_intfdata(intf);
2096	struct usb_host_interface *alt = intf->cur_altsetting;
2097	int retval = 0;
2098
2099	if (alt->desc.bInterfaceClass == USB_CLASS_COMM) {
2100		retval = ims_pcu_start_io(pcu);
2101		if (retval == 0)
2102			retval = ims_pcu_line_setup(pcu);
2103	}
2104
2105	return retval;
2106}
2107#endif
2108
2109static const struct usb_device_id ims_pcu_id_table[] = {
2110	{
2111		USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0082,
2112					USB_CLASS_COMM,
2113					USB_CDC_SUBCLASS_ACM,
2114					USB_CDC_ACM_PROTO_AT_V25TER),
2115		.driver_info = IMS_PCU_APPLICATION_MODE,
2116	},
2117	{
2118		USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0083,
2119					USB_CLASS_COMM,
2120					USB_CDC_SUBCLASS_ACM,
2121					USB_CDC_ACM_PROTO_AT_V25TER),
2122		.driver_info = IMS_PCU_BOOTLOADER_MODE,
2123	},
2124	{ }
2125};
2126
2127static struct usb_driver ims_pcu_driver = {
2128	.name			= "ims_pcu",
2129	.id_table		= ims_pcu_id_table,
2130	.probe			= ims_pcu_probe,
2131	.disconnect		= ims_pcu_disconnect,
2132#ifdef CONFIG_PM
2133	.suspend		= ims_pcu_suspend,
2134	.resume			= ims_pcu_resume,
2135	.reset_resume		= ims_pcu_resume,
2136#endif
2137};
2138
2139module_usb_driver(ims_pcu_driver);
2140
2141MODULE_DESCRIPTION("IMS Passenger Control Unit driver");
2142MODULE_AUTHOR("Dmitry Torokhov <dmitry.torokhov@gmail.com>");
2143MODULE_LICENSE("GPL");