PageRenderTime 6ms CodeModel.GetById 3ms app.highlight 113ms RepoModel.GetById 2ms app.codeStats 0ms

/drivers/input/misc/ims-pcu.c

http://github.com/torvalds/linux
C | 2150 lines | 1661 code | 409 blank | 80 comment | 181 complexity | ddb71d4331a6c39065364efe0b6beb6d MD5 | raw file

Large files files are truncated, but you can click here to view the full file

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

Large files files are truncated, but you can click here to view the full file