Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 93eff83f authored by Marc Dietrich's avatar Marc Dietrich Committed by Greg Kroah-Hartman
Browse files

staging: nvec: cleanup the string mess 



Replace the various command strings by named constants.

Signed-off-by: default avatarMarc Dietrich <marvin24@gmx.de>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 85a90528

drivers/staging/nvec/nvec.c

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


enum nvec_sleep_subcmds {

	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;
@@ -333,6 +338,27 @@ static void nvec_toggle_global_events(struct nvec_chip *nvec, bool state) 
	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

 * @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)

{

	char ap_pwr_down[] = { NVEC_SLEEP, AP_PWR_DOWN };



	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)
@@ -740,6 +768,9 @@ static int tegra_nvec_probe(struct platform_device *pdev) 
	struct nvec_msg *msg;

	struct resource *res;

	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);

	if (nvec == NULL) {
@@ -840,8 +871,7 @@ static int tegra_nvec_probe(struct platform_device *pdev) 
	pm_power_off = nvec_power_off;



	/* Get Firmware Version */

	msg = nvec_write_sync(nvec, EC_GET_FIRMWARE_VERSION,

		sizeof(EC_GET_FIRMWARE_VERSION));

	msg = nvec_write_sync(nvec, get_firmware_version, 2);



	if (msg) {

		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");



	/* unmute speakers? */

	nvec_write_async(nvec, "\x0d\x10\x59\x95", 4);

	nvec_write_async(nvec, unmute_speakers, 4);



	/* 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 */

	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;

}
@@ -885,13 +917,14 @@ static int nvec_suspend(struct device *dev) 
	struct platform_device *pdev = to_platform_device(dev);

	struct nvec_chip *nvec = platform_get_drvdata(pdev);

	struct nvec_msg *msg;

	char ap_suspend[] = { NVEC_SLEEP, AP_SUSPEND };



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



	/* keep these sync or you'll break suspend */

	msg = nvec_write_sync(nvec, EC_DISABLE_EVENT_REPORTING, 3);

	nvec_msg_free(nvec, msg);

	msg = nvec_write_sync(nvec, "\x04\x02", 2);

	nvec_toggle_global_events(nvec, false);



	msg = nvec_write_sync(nvec, ap_suspend, sizeof(ap_suspend));

	nvec_msg_free(nvec, msg);



	nvec_disable_i2c_slave(nvec);

drivers/staging/nvec/nvec.h

+1 −0
Original line number Diff line number Diff line
@@ -76,6 +76,7 @@ enum nvec_msg_type { 
	NVEC_KBD,

	NVEC_PS2,

	NVEC_CNTL,

	NVEC_OEM0 = 0x0d,

	NVEC_KB_EVT = 0x80,

	NVEC_PS2_EVT,

};

drivers/staging/nvec/nvec_kbd.c

+25 −17
Original line number Diff line number Diff line
@@ -21,10 +21,14 @@ 
#include "nvec-keytable.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)

			      + ARRAY_SIZE(extcode_tab_us102)];
@@ -39,12 +43,15 @@ static struct nvec_keys keys_dev; 


static void nvec_kbd_toggle_led(void)

{

	char buf[] = { NVEC_KBD, SET_LEDS, 0 };



	keys_dev.caps_lock = !keys_dev.caps_lock;



	if (keys_dev.caps_lock)

		nvec_write_async(keys_dev.nvec, led_on, sizeof(led_on));

	else

		nvec_write_async(keys_dev.nvec, led_off, sizeof(led_off));

		/* should be BIT(0) only, firmware bug? */

		buf[2] = BIT(0) | BIT(1) | BIT(2);



	nvec_write_async(keys_dev.nvec, buf, sizeof(buf));

}



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,

			  unsigned int code, int value)

{

	unsigned char buf[] = ACK_KBD_EVENT;

	struct nvec_chip *nvec = keys_dev.nvec;

	char buf[] = { NVEC_KBD, SET_LEDS, 0 };



	if (type == EV_REP)

		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);

	int i, j, err;

	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;
@@ -138,19 +150,15 @@ static int nvec_kbd_probe(struct platform_device *pdev) 
	nvec_register_notifier(nvec, &keys_dev.notifier, 0);



	/* Enable keyboard */

	nvec_write_async(nvec, "\x05\xf4", 2);

	nvec_write_async(nvec, enable_kbd, 2);



	/* keyboard reset? */

	nvec_write_async(nvec, "\x05\x03\x01\x01", 4);

	nvec_write_async(nvec, "\x05\x04\x01", 3);

	nvec_write_async(nvec, "\x06\x01\xff\x03", 4);

/*	FIXME

	wait until keyboard reset is finished

	or until we have a sync write */

	mdelay(1000);

	/* configures wake on special keys */

	nvec_write_async(nvec, cnfg_wake, 4);

	/* enable wake key reporting */

	nvec_write_async(nvec, cnfg_wake_key_reporting, 3);



	/* Disable caps lock LED */

	nvec_write_async(nvec, led_off, sizeof(led_off));

	nvec_write_async(nvec, clear_leds, sizeof(clear_leds));



	return 0;

drivers/staging/nvec/nvec_power.c

+5 −3
Original line number Diff line number Diff line
@@ -22,6 +22,8 @@ 


#include "nvec.h"



#define GET_SYSTEM_STATUS 0x00



struct nvec_power {

	struct notifier_block notifier;

	struct delayed_work poller;
@@ -111,7 +113,7 @@ static const int bat_init[] = { 
static void get_bat_mfg_data(struct nvec_power *power)

{

	int i;

	char buf[] = { '\x02', '\x00' };

	char buf[] = { NVEC_BAT, SLOT_STATUS };



	for (i = 0; i < ARRAY_SIZE(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)

{

	char buf[] = { '\x01', '\x00' };

	char buf[] = { NVEC_SYS, GET_SYSTEM_STATUS };

	struct nvec_power *power = container_of(work, struct nvec_power,

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


/* select a battery request function via round robin

   doing it all at once seems to overload the power supply */

	buf[0] = '\x02';	/* battery */

	buf[0] = NVEC_BAT;

	buf[1] = bat_iter[counter++];

	nvec_write_async(power->nvec, buf, 2);

drivers/staging/nvec/nvec_ps2.c

+15 −10
Original line number Diff line number Diff line
@@ -21,12 +21,11 @@ 


#include "nvec.h"



#define START_STREAMING	{'\x06', '\x03', '\x06'}

#define STOP_STREAMING	{'\x06', '\x04'}

#define SEND_COMMAND	{'\x06', '\x01', '\xf4', '\x01'}

#define PACKET_SIZE	6



#define ENABLE_MOUSE	0xf4

#define DISABLE_MOUSE	0xf5

#define PSMOUSE_RST	0xff



#ifdef NVEC_PS2_DEBUG

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

#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 serio *ser_dev;
@@ -48,19 +52,19 @@ static struct nvec_ps2 ps2_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));

}



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));

}



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;
@@ -100,6 +104,7 @@ static int nvec_mouse_probe(struct platform_device *pdev) 
{

	struct nvec_chip *nvec = dev_get_drvdata(pdev->dev.parent);

	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);

	if (ser_dev == NULL)
@@ -121,7 +126,7 @@ static int nvec_mouse_probe(struct platform_device *pdev) 
	serio_register_port(ser_dev);



	/* mouse reset */

	nvec_write_async(nvec, MOUSE_RESET, 4);

	nvec_write_async(nvec, mouse_reset, sizeof(mouse_reset));



	return 0;

}