staging: nvec: cleanup the string mess (93eff83f) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/staging/nvec/nvec.c

+43 −10

Original line number	Original line	Diff line number	Diff line
	@@ -74,9 +74,14 @@ enum nvec_msg_category {

	enum nvec_sleep_subcmds {		enum nvec_sleep_subcmds {
	GLOBAL_EVENTS,		GLOBAL_EVENTS,
			AP_PWR_DOWN,
			AP_SUSPEND,
	};		};

	static const unsigned char EC_GET_FIRMWARE_VERSION[2] = "\x07\x15";		#define CNF_EVENT_REPORTING 0x01
			#define GET_FIRMWARE_VERSION 0x15
			#define LID_SWITCH BIT(1)
			#define PWR_BUTTON BIT(15)

	static struct nvec_chip *nvec_power_handle;		static struct nvec_chip *nvec_power_handle;

	@@ -333,6 +338,27 @@ static void nvec_toggle_global_events(struct nvec_chip *nvec, bool state)
	nvec_write_async(nvec, global_events, 3);		nvec_write_async(nvec, global_events, 3);
	}		}

			/**
			* nvec_event_mask - fill the command string with event bitfield
			* ev: points to event command string
			* mask: bit to insert into the event mask
			*
			* Configure event command expects a 32 bit bitfield which describes
			* which events to enable. The bitfield has the following structure
			* (from highest byte to lowest):
			* system state bits 7-0
			* system state bits 15-8
			* oem system state bits 7-0
			* oem system state bits 15-8
			*/
			static void nvec_event_mask(char *ev, u32 mask)
			{
			ev[3] = mask >> 16 && 0xff;
			ev[4] = mask >> 24 && 0xff;
			ev[5] = mask >> 0 && 0xff;
			ev[6] = mask >> 8 && 0xff;
			}

	/**		/**
	* nvec_request_master - Process outgoing messages		* nvec_request_master - Process outgoing messages
	* @work: A &struct work_struct (the tx_worker member of &struct nvec_chip)		* @work: A &struct work_struct (the tx_worker member of &struct nvec_chip)
	@@ -727,8 +753,10 @@ static void nvec_disable_i2c_slave(struct nvec_chip *nvec)

	static void nvec_power_off(void)		static void nvec_power_off(void)
	{		{
			char ap_pwr_down[] = { NVEC_SLEEP, AP_PWR_DOWN };

	nvec_toggle_global_events(nvec_power_handle, false);		nvec_toggle_global_events(nvec_power_handle, false);
	nvec_write_async(nvec_power_handle, "\x04\x01", 2);		nvec_write_async(nvec_power_handle, ap_pwr_down, 2);
	}		}

	static int tegra_nvec_probe(struct platform_device *pdev)		static int tegra_nvec_probe(struct platform_device *pdev)
	@@ -740,6 +768,9 @@ static int tegra_nvec_probe(struct platform_device *pdev)
	struct nvec_msg *msg;		struct nvec_msg *msg;
	struct resource *res;		struct resource *res;
	void __iomem *base;		void __iomem *base;
			char get_firmware_version[] = { NVEC_CNTL, GET_FIRMWARE_VERSION },
			unmute_speakers[] = { NVEC_OEM0, 0x10, 0x59, 0x95 },
			enable_event[7] = { NVEC_SYS, CNF_EVENT_REPORTING, true };

	nvec = devm_kzalloc(&pdev->dev, sizeof(struct nvec_chip), GFP_KERNEL);		nvec = devm_kzalloc(&pdev->dev, sizeof(struct nvec_chip), GFP_KERNEL);
	if (nvec == NULL) {		if (nvec == NULL) {
	@@ -840,8 +871,7 @@ static int tegra_nvec_probe(struct platform_device *pdev)
	pm_power_off = nvec_power_off;		pm_power_off = nvec_power_off;

	/* Get Firmware Version */		/* Get Firmware Version */
	msg = nvec_write_sync(nvec, EC_GET_FIRMWARE_VERSION,		msg = nvec_write_sync(nvec, get_firmware_version, 2);
	sizeof(EC_GET_FIRMWARE_VERSION));

	if (msg) {		if (msg) {
	dev_warn(nvec->dev, "ec firmware version %02x.%02x.%02x / %02x\n",		dev_warn(nvec->dev, "ec firmware version %02x.%02x.%02x / %02x\n",
	@@ -856,13 +886,15 @@ static int tegra_nvec_probe(struct platform_device *pdev)
	dev_err(nvec->dev, "error adding subdevices\n");		dev_err(nvec->dev, "error adding subdevices\n");

	/* unmute speakers? */		/* unmute speakers? */
	nvec_write_async(nvec, "\x0d\x10\x59\x95", 4);		nvec_write_async(nvec, unmute_speakers, 4);

	/* enable lid switch event */		/* enable lid switch event */
	nvec_write_async(nvec, "\x01\x01\x01\x00\x00\x02\x00", 7);		nvec_event_mask(enable_event, LID_SWITCH);
			nvec_write_async(nvec, enable_event, 7);

	/* enable power button event */		/* enable power button event */
	nvec_write_async(nvec, "\x01\x01\x01\x00\x00\x80\x00", 7);		nvec_event_mask(enable_event, PWR_BUTTON);
			nvec_write_async(nvec, enable_event, 7);

	return 0;		return 0;
	}		}
	@@ -885,13 +917,14 @@ static int nvec_suspend(struct device *dev)
	struct platform_device *pdev = to_platform_device(dev);		struct platform_device *pdev = to_platform_device(dev);
	struct nvec_chip *nvec = platform_get_drvdata(pdev);		struct nvec_chip *nvec = platform_get_drvdata(pdev);
	struct nvec_msg *msg;		struct nvec_msg *msg;
			char ap_suspend[] = { NVEC_SLEEP, AP_SUSPEND };

	dev_dbg(nvec->dev, "suspending\n");		dev_dbg(nvec->dev, "suspending\n");

	/* keep these sync or you'll break suspend */		/* keep these sync or you'll break suspend */
	msg = nvec_write_sync(nvec, EC_DISABLE_EVENT_REPORTING, 3);		nvec_toggle_global_events(nvec, false);
	nvec_msg_free(nvec, msg);
	msg = nvec_write_sync(nvec, "\x04\x02", 2);		msg = nvec_write_sync(nvec, ap_suspend, sizeof(ap_suspend));
	nvec_msg_free(nvec, msg);		nvec_msg_free(nvec, msg);

	nvec_disable_i2c_slave(nvec);		nvec_disable_i2c_slave(nvec);

drivers/staging/nvec/nvec.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -76,6 +76,7 @@ enum nvec_msg_type {
	NVEC_KBD,		NVEC_KBD,
	NVEC_PS2,		NVEC_PS2,
	NVEC_CNTL,		NVEC_CNTL,
			NVEC_OEM0 = 0x0d,
	NVEC_KB_EVT = 0x80,		NVEC_KB_EVT = 0x80,
	NVEC_PS2_EVT,		NVEC_PS2_EVT,
	};		};

drivers/staging/nvec/nvec_kbd.c

+25 −17

Original line number	Original line	Diff line number	Diff line
	@@ -21,10 +21,14 @@
	#include "nvec-keytable.h"		#include "nvec-keytable.h"
	#include "nvec.h"		#include "nvec.h"

	#define ACK_KBD_EVENT {'\x05', '\xed', '\x01'}		enum kbd_subcmds {
			CNFG_WAKE = 3,
			CNFG_WAKE_KEY_REPORTING,
			SET_LEDS = 0xed,
			ENABLE_KBD = 0xf4,
			DISABLE_KBD,
			};

	static const char led_on[3] = "\x05\xed\x07";
	static const char led_off[3] = "\x05\xed\x00";
	static unsigned char keycodes[ARRAY_SIZE(code_tab_102us)		static unsigned char keycodes[ARRAY_SIZE(code_tab_102us)
	+ ARRAY_SIZE(extcode_tab_us102)];		+ ARRAY_SIZE(extcode_tab_us102)];

	@@ -39,12 +43,15 @@ static struct nvec_keys keys_dev;

	static void nvec_kbd_toggle_led(void)		static void nvec_kbd_toggle_led(void)
	{		{
			char buf[] = { NVEC_KBD, SET_LEDS, 0 };

	keys_dev.caps_lock = !keys_dev.caps_lock;		keys_dev.caps_lock = !keys_dev.caps_lock;

	if (keys_dev.caps_lock)		if (keys_dev.caps_lock)
	nvec_write_async(keys_dev.nvec, led_on, sizeof(led_on));		/* should be BIT(0) only, firmware bug? */
	else		buf[2] = BIT(0) \| BIT(1) \| BIT(2);
	nvec_write_async(keys_dev.nvec, led_off, sizeof(led_off));
			nvec_write_async(keys_dev.nvec, buf, sizeof(buf));
	}		}

	static int nvec_keys_notifier(struct notifier_block *nb,		static int nvec_keys_notifier(struct notifier_block *nb,
	@@ -82,8 +89,8 @@ static int nvec_keys_notifier(struct notifier_block *nb,
	static int nvec_kbd_event(struct input_dev *dev, unsigned int type,		static int nvec_kbd_event(struct input_dev *dev, unsigned int type,
	unsigned int code, int value)		unsigned int code, int value)
	{		{
	unsigned char buf[] = ACK_KBD_EVENT;
	struct nvec_chip *nvec = keys_dev.nvec;		struct nvec_chip *nvec = keys_dev.nvec;
			char buf[] = { NVEC_KBD, SET_LEDS, 0 };

	if (type == EV_REP)		if (type == EV_REP)
	return 0;		return 0;
	@@ -105,6 +112,11 @@ static int nvec_kbd_probe(struct platform_device *pdev)
	struct nvec_chip *nvec = dev_get_drvdata(pdev->dev.parent);		struct nvec_chip *nvec = dev_get_drvdata(pdev->dev.parent);
	int i, j, err;		int i, j, err;
	struct input_dev *idev;		struct input_dev *idev;
			char clear_leds[] = { NVEC_KBD, SET_LEDS, 0 },
			enable_kbd[] = { NVEC_KBD, ENABLE_KBD },
			cnfg_wake[] = { NVEC_KBD, CNFG_WAKE, true, true },
			cnfg_wake_key_reporting[] = { NVEC_KBD, CNFG_WAKE_KEY_REPORTING,
			true };

	j = 0;		j = 0;

	@@ -138,19 +150,15 @@ static int nvec_kbd_probe(struct platform_device *pdev)
	nvec_register_notifier(nvec, &keys_dev.notifier, 0);		nvec_register_notifier(nvec, &keys_dev.notifier, 0);

	/* Enable keyboard */		/* Enable keyboard */
	nvec_write_async(nvec, "\x05\xf4", 2);		nvec_write_async(nvec, enable_kbd, 2);

	/* keyboard reset? */		/* configures wake on special keys */
	nvec_write_async(nvec, "\x05\x03\x01\x01", 4);		nvec_write_async(nvec, cnfg_wake, 4);
	nvec_write_async(nvec, "\x05\x04\x01", 3);		/* enable wake key reporting */
	nvec_write_async(nvec, "\x06\x01\xff\x03", 4);		nvec_write_async(nvec, cnfg_wake_key_reporting, 3);
	/* FIXME
	wait until keyboard reset is finished
	or until we have a sync write */
	mdelay(1000);

	/* Disable caps lock LED */		/* Disable caps lock LED */
	nvec_write_async(nvec, led_off, sizeof(led_off));		nvec_write_async(nvec, clear_leds, sizeof(clear_leds));

	return 0;		return 0;

drivers/staging/nvec/nvec_power.c

+5 −3

Original line number	Original line	Diff line number	Diff line
	@@ -22,6 +22,8 @@

	#include "nvec.h"		#include "nvec.h"

			#define GET_SYSTEM_STATUS 0x00

	struct nvec_power {		struct nvec_power {
	struct notifier_block notifier;		struct notifier_block notifier;
	struct delayed_work poller;		struct delayed_work poller;
	@@ -111,7 +113,7 @@ static const int bat_init[] = {
	static void get_bat_mfg_data(struct nvec_power *power)		static void get_bat_mfg_data(struct nvec_power *power)
	{		{
	int i;		int i;
	char buf[] = { '\x02', '\x00' };		char buf[] = { NVEC_BAT, SLOT_STATUS };

	for (i = 0; i < ARRAY_SIZE(bat_init); i++) {		for (i = 0; i < ARRAY_SIZE(bat_init); i++) {
	buf[1] = bat_init[i];		buf[1] = bat_init[i];
	@@ -348,7 +350,7 @@ static int const bat_iter[] = {

	static void nvec_power_poll(struct work_struct *work)		static void nvec_power_poll(struct work_struct *work)
	{		{
	char buf[] = { '\x01', '\x00' };		char buf[] = { NVEC_SYS, GET_SYSTEM_STATUS };
	struct nvec_power *power = container_of(work, struct nvec_power,		struct nvec_power *power = container_of(work, struct nvec_power,
	poller.work);		poller.work);

	@@ -361,7 +363,7 @@ static void nvec_power_poll(struct work_struct *work)

	/* select a battery request function via round robin		/* select a battery request function via round robin
	doing it all at once seems to overload the power supply */		doing it all at once seems to overload the power supply */
	buf[0] = '\x02'; /* battery */		buf[0] = NVEC_BAT;
	buf[1] = bat_iter[counter++];		buf[1] = bat_iter[counter++];
	nvec_write_async(power->nvec, buf, 2);		nvec_write_async(power->nvec, buf, 2);

drivers/staging/nvec/nvec_ps2.c

+15 −10

Original line number	Original line	Diff line number	Diff line
	@@ -21,12 +21,11 @@

	#include "nvec.h"		#include "nvec.h"

	#define START_STREAMING {'\x06', '\x03', '\x06'}		#define PACKET_SIZE 6
	#define STOP_STREAMING {'\x06', '\x04'}
	#define SEND_COMMAND {'\x06', '\x01', '\xf4', '\x01'}

	#define ENABLE_MOUSE 0xf4		#define ENABLE_MOUSE 0xf4
	#define DISABLE_MOUSE 0xf5		#define DISABLE_MOUSE 0xf5
			#define PSMOUSE_RST 0xff

	#ifdef NVEC_PS2_DEBUG		#ifdef NVEC_PS2_DEBUG
	#define NVEC_PHD(str, buf, len) \		#define NVEC_PHD(str, buf, len) \
	@@ -36,7 +35,12 @@
	#define NVEC_PHD(str, buf, len)		#define NVEC_PHD(str, buf, len)
	#endif		#endif

	static const unsigned char MOUSE_RESET[] = {'\x06', '\x01', '\xff', '\x03'};		enum ps2_subcmds {
			SEND_COMMAND = 1,
			RECEIVE_N,
			AUTO_RECEIVE_N,
			CANCEL_AUTO_RECEIVE,
			};

	struct nvec_ps2 {		struct nvec_ps2 {
	struct serio *ser_dev;		struct serio *ser_dev;
	@@ -48,19 +52,19 @@ static struct nvec_ps2 ps2_dev;

	static int ps2_startstreaming(struct serio *ser_dev)		static int ps2_startstreaming(struct serio *ser_dev)
	{		{
	unsigned char buf[] = START_STREAMING;		unsigned char buf[] = { NVEC_PS2, AUTO_RECEIVE_N, PACKET_SIZE };
	return nvec_write_async(ps2_dev.nvec, buf, sizeof(buf));		return nvec_write_async(ps2_dev.nvec, buf, sizeof(buf));
	}		}

	static void ps2_stopstreaming(struct serio *ser_dev)		static void ps2_stopstreaming(struct serio *ser_dev)
	{		{
	unsigned char buf[] = STOP_STREAMING;		unsigned char buf[] = { NVEC_PS2, CANCEL_AUTO_RECEIVE };
	nvec_write_async(ps2_dev.nvec, buf, sizeof(buf));		nvec_write_async(ps2_dev.nvec, buf, sizeof(buf));
	}		}

	static int ps2_sendcommand(struct serio *ser_dev, unsigned char cmd)		static int ps2_sendcommand(struct serio *ser_dev, unsigned char cmd)
	{		{
	unsigned char buf[] = SEND_COMMAND;		unsigned char buf[] = { NVEC_PS2, SEND_COMMAND, ENABLE_MOUSE, 1 };

	buf[2] = cmd & 0xff;		buf[2] = cmd & 0xff;

	@@ -100,6 +104,7 @@ static int nvec_mouse_probe(struct platform_device *pdev)
	{		{
	struct nvec_chip *nvec = dev_get_drvdata(pdev->dev.parent);		struct nvec_chip *nvec = dev_get_drvdata(pdev->dev.parent);
	struct serio *ser_dev;		struct serio *ser_dev;
			char mouse_reset[] = { NVEC_PS2, SEND_COMMAND, PSMOUSE_RST, 3 };

	ser_dev = devm_kzalloc(&pdev->dev, sizeof(struct serio), GFP_KERNEL);		ser_dev = devm_kzalloc(&pdev->dev, sizeof(struct serio), GFP_KERNEL);
	if (ser_dev == NULL)		if (ser_dev == NULL)
	@@ -121,7 +126,7 @@ static int nvec_mouse_probe(struct platform_device *pdev)
	serio_register_port(ser_dev);		serio_register_port(ser_dev);

	/* mouse reset */		/* mouse reset */
	nvec_write_async(nvec, MOUSE_RESET, 4);		nvec_write_async(nvec, mouse_reset, sizeof(mouse_reset));

	return 0;		return 0;
	}		}