[linux-2.6-block.git] / drivers / mfd / dm355evm_msp.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * dm355evm_msp.c - driver for MSP430 firmware on DM355EVM board
 *
 * Copyright (C) 2008 David Brownell
 */

#include <linux/init.h>
#include <linux/mutex.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <linux/module.h>
#include <linux/err.h>
#include <linux/gpio.h>
#include <linux/leds.h>
#include <linux/i2c.h>
#include <linux/mfd/dm355evm_msp.h>


/*
 * The DM355 is a DaVinci chip with video support but no C64+ DSP.  Its
 * EVM board has an MSP430 programmed with firmware for various board
 * support functions.  This driver exposes some of them directly, and
 * supports other drivers (e.g. RTC, input) for more complex access.
 *
 * Because this firmware is entirely board-specific, this file embeds
 * knowledge that would be passed as platform_data in a generic driver.
 *
 * This driver was tested with firmware revision A4.
 */

#if IS_ENABLED(CONFIG_INPUT_DM355EVM)
#define msp_has_keyboard()	true
#else
#define msp_has_keyboard()	false
#endif

#if IS_ENABLED(CONFIG_LEDS_GPIO)
#define msp_has_leds()		true
#else
#define msp_has_leds()		false
#endif

#if IS_ENABLED(CONFIG_RTC_DRV_DM355EVM)
#define msp_has_rtc()		true
#else
#define msp_has_rtc()		false
#endif

#if IS_ENABLED(CONFIG_VIDEO_TVP514X)
#define msp_has_tvp()		true
#else
#define msp_has_tvp()		false
#endif


/*----------------------------------------------------------------------*/

/* REVISIT for paranoia's sake, retry reads/writes on error */

static struct i2c_client *msp430;

/**
 * dm355evm_msp_write - Writes a register in dm355evm_msp
 * @value: the value to be written
 * @reg: register address
 *
 * Returns result of operation - 0 is success, else negative errno
 */
int dm355evm_msp_write(u8 value, u8 reg)
{
	return i2c_smbus_write_byte_data(msp430, reg, value);
}
EXPORT_SYMBOL(dm355evm_msp_write);

/**
 * dm355evm_msp_read - Reads a register from dm355evm_msp
 * @reg: register address
 *
 * Returns result of operation - value, or negative errno
 */
int dm355evm_msp_read(u8 reg)
{
	return i2c_smbus_read_byte_data(msp430, reg);
}
EXPORT_SYMBOL(dm355evm_msp_read);

/*----------------------------------------------------------------------*/

/*
 * Many of the msp430 pins are just used as fixed-direction GPIOs.
 * We could export a few more of them this way, if we wanted.
 */
#define MSP_GPIO(bit, reg)	((DM355EVM_MSP_ ## reg) << 3 | (bit))

static const u8 msp_gpios[] = {
	/* eight leds */
	MSP_GPIO(0, LED), MSP_GPIO(1, LED),
	MSP_GPIO(2, LED), MSP_GPIO(3, LED),
	MSP_GPIO(4, LED), MSP_GPIO(5, LED),
	MSP_GPIO(6, LED), MSP_GPIO(7, LED),
	/* SW6 and the NTSC/nPAL jumper */
	MSP_GPIO(0, SWITCH1), MSP_GPIO(1, SWITCH1),
	MSP_GPIO(2, SWITCH1), MSP_GPIO(3, SWITCH1),
	MSP_GPIO(4, SWITCH1),
	/* switches on MMC/SD sockets */
	/*
	 * Note: EVMDM355_ECP_VA4.pdf suggests that Bit 2 and 4 should be
	 * checked for card detection. However on the EVM bit 1 and 3 gives
	 * this status, for 0 and 1 instance respectively. The pdf also
	 * suggests that Bit 1 and 3 should be checked for write protection.
	 * However on the EVM bit 2 and 4 gives this status,for 0 and 1
	 * instance respectively.
	 */
	MSP_GPIO(2, SDMMC), MSP_GPIO(1, SDMMC),	/* mmc0 WP, nCD */
	MSP_GPIO(4, SDMMC), MSP_GPIO(3, SDMMC),	/* mmc1 WP, nCD */
};

#define MSP_GPIO_REG(offset)	(msp_gpios[(offset)] >> 3)
#define MSP_GPIO_MASK(offset)	BIT(msp_gpios[(offset)] & 0x07)

static int msp_gpio_in(struct gpio_chip *chip, unsigned offset)
{
	switch (MSP_GPIO_REG(offset)) {
	case DM355EVM_MSP_SWITCH1:
	case DM355EVM_MSP_SWITCH2:
	case DM355EVM_MSP_SDMMC:
		return 0;
	default:
		return -EINVAL;
	}
}

static u8 msp_led_cache;

static int msp_gpio_get(struct gpio_chip *chip, unsigned offset)
{
	int reg, status;

	reg = MSP_GPIO_REG(offset);
	status = dm355evm_msp_read(reg);
	if (status < 0)
		return status;
	if (reg == DM355EVM_MSP_LED)
		msp_led_cache = status;
	return !!(status & MSP_GPIO_MASK(offset));
}

static int msp_gpio_out(struct gpio_chip *chip, unsigned offset, int value)
{
	int mask, bits;

	/* NOTE:  there are some other signals that could be
	 * packaged as output GPIOs, but they aren't as useful
	 * as the LEDs ... so for now we don't.
	 */
	if (MSP_GPIO_REG(offset) != DM355EVM_MSP_LED)
		return -EINVAL;

	mask = MSP_GPIO_MASK(offset);
	bits = msp_led_cache;

	bits &= ~mask;
	if (value)
		bits |= mask;
	msp_led_cache = bits;

	return dm355evm_msp_write(bits, DM355EVM_MSP_LED);
}

static void msp_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
{
	msp_gpio_out(chip, offset, value);
}

static struct gpio_chip dm355evm_msp_gpio = {
	.label			= "dm355evm_msp",
	.owner			= THIS_MODULE,
	.direction_input	= msp_gpio_in,
	.get			= msp_gpio_get,
	.direction_output	= msp_gpio_out,
	.set			= msp_gpio_set,
	.base			= -EINVAL,		/* dynamic assignment */
	.ngpio			= ARRAY_SIZE(msp_gpios),
	.can_sleep		= true,
};

/*----------------------------------------------------------------------*/

static struct device *add_child(struct i2c_client *client, const char *name,
		void *pdata, unsigned pdata_len,
		bool can_wakeup, int irq)
{
	struct platform_device	*pdev;
	int			status;

	pdev = platform_device_alloc(name, -1);
	if (!pdev)
		return ERR_PTR(-ENOMEM);

	device_init_wakeup(&pdev->dev, can_wakeup);
	pdev->dev.parent = &client->dev;

	if (pdata) {
		status = platform_device_add_data(pdev, pdata, pdata_len);
		if (status < 0) {
			dev_dbg(&pdev->dev, "can't add platform_data\n");
			goto put_device;
		}
	}

	if (irq) {
		struct resource r = {
			.start = irq,
			.flags = IORESOURCE_IRQ,
		};

		status = platform_device_add_resources(pdev, &r, 1);
		if (status < 0) {
			dev_dbg(&pdev->dev, "can't add irq\n");
			goto put_device;
		}
	}

	status = platform_device_add(pdev);
	if (status)
		goto put_device;

	return &pdev->dev;

put_device:
	platform_device_put(pdev);
	dev_err(&client->dev, "failed to add device %s\n", name);
	return ERR_PTR(status);
}

static int add_children(struct i2c_client *client)
{
	static const struct {
		int offset;
		char *label;
	} config_inputs[] = {
		/* 8 == right after the LEDs */
		{ 8 + 0, "sw6_1", },
		{ 8 + 1, "sw6_2", },
		{ 8 + 2, "sw6_3", },
		{ 8 + 3, "sw6_4", },
		{ 8 + 4, "NTSC/nPAL", },
	};

	struct device	*child;
	int		status;
	int		i;

	/* GPIO-ish stuff */
	dm355evm_msp_gpio.parent = &client->dev;
	status = gpiochip_add_data(&dm355evm_msp_gpio, NULL);
	if (status < 0)
		return status;

	/* LED output */
	if (msp_has_leds()) {
#define GPIO_LED(l)	.name = l, .active_low = true
		static struct gpio_led evm_leds[] = {
			{ GPIO_LED("dm355evm::ds14"),
				.default_trigger = "heartbeat", },
			{ GPIO_LED("dm355evm::ds15"),
				.default_trigger = "mmc0", },
			{ GPIO_LED("dm355evm::ds16"),
				/* could also be a CE-ATA drive */
				.default_trigger = "mmc1", },
			{ GPIO_LED("dm355evm::ds17"),
				.default_trigger = "nand-disk", },
			{ GPIO_LED("dm355evm::ds18"), },
			{ GPIO_LED("dm355evm::ds19"), },
			{ GPIO_LED("dm355evm::ds20"), },
			{ GPIO_LED("dm355evm::ds21"), },
		};
#undef GPIO_LED

		struct gpio_led_platform_data evm_led_data = {
			.num_leds	= ARRAY_SIZE(evm_leds),
			.leds		= evm_leds,
		};

		for (i = 0; i < ARRAY_SIZE(evm_leds); i++)
			evm_leds[i].gpio = i + dm355evm_msp_gpio.base;

		/* NOTE:  these are the only fully programmable LEDs
		 * on the board, since GPIO-61/ds22 (and many signals
		 * going to DC7) must be used for AEMIF address lines
		 * unless the top 1 GB of NAND is unused...
		 */
		child = add_child(client, "leds-gpio",
				&evm_led_data, sizeof(evm_led_data),
				false, 0);
		if (IS_ERR(child))
			return PTR_ERR(child);
	}

	/* configuration inputs */
	for (i = 0; i < ARRAY_SIZE(config_inputs); i++) {
		int gpio = dm355evm_msp_gpio.base + config_inputs[i].offset;

		gpio_request_one(gpio, GPIOF_IN, config_inputs[i].label);

		/* make it easy for userspace to see these */
		gpio_export(gpio, false);
	}

	/* MMC/SD inputs -- right after the last config input */
	if (dev_get_platdata(&client->dev)) {
		void (*mmcsd_setup)(unsigned) = dev_get_platdata(&client->dev);

		mmcsd_setup(dm355evm_msp_gpio.base + 8 + 5);
	}

	/* RTC is a 32 bit counter, no alarm */
	if (msp_has_rtc()) {
		child = add_child(client, "rtc-dm355evm",
				NULL, 0, false, 0);
		if (IS_ERR(child))
			return PTR_ERR(child);
	}

	/* input from buttons and IR remote (uses the IRQ) */
	if (msp_has_keyboard()) {
		child = add_child(client, "dm355evm_keys",
				NULL, 0, true, client->irq);
		if (IS_ERR(child))
			return PTR_ERR(child);
	}

	return 0;
}

/*----------------------------------------------------------------------*/

static void dm355evm_command(unsigned command)
{
	int status;

	status = dm355evm_msp_write(command, DM355EVM_MSP_COMMAND);
	if (status < 0)
		dev_err(&msp430->dev, "command %d failure %d\n",
				command, status);
}

static void dm355evm_power_off(void)
{
	dm355evm_command(MSP_COMMAND_POWEROFF);
}

static int dm355evm_msp_remove(struct i2c_client *client)
{
	pm_power_off = NULL;
	msp430 = NULL;
	return 0;
}

static int
dm355evm_msp_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	int		status;
	const char	*video = msp_has_tvp() ? "TVP5146" : "imager";

	if (msp430)
		return -EBUSY;
	msp430 = client;

	/* display revision status; doubles as sanity check */
	status = dm355evm_msp_read(DM355EVM_MSP_FIRMREV);
	if (status < 0)
		goto fail;
	dev_info(&client->dev, "firmware v.%02X, %s as video-in\n",
			status, video);

	/* mux video input:  either tvp5146 or some external imager */
	status = dm355evm_msp_write(msp_has_tvp() ? 0 : MSP_VIDEO_IMAGER,
			DM355EVM_MSP_VIDEO_IN);
	if (status < 0)
		dev_warn(&client->dev, "error %d muxing %s as video-in\n",
			status, video);

	/* init LED cache, and turn off the LEDs */
	msp_led_cache = 0xff;
	dm355evm_msp_write(msp_led_cache, DM355EVM_MSP_LED);

	/* export capabilities we support */
	status = add_children(client);
	if (status < 0)
		goto fail;

	/* PM hookup */
	pm_power_off = dm355evm_power_off;

	return 0;

fail:
	/* FIXME remove children ... */
	dm355evm_msp_remove(client);
	return status;
}

static const struct i2c_device_id dm355evm_msp_ids[] = {
	{ "dm355evm_msp", 0 },
	{ /* end of list */ },
};
MODULE_DEVICE_TABLE(i2c, dm355evm_msp_ids);

static struct i2c_driver dm355evm_msp_driver = {
	.driver.name	= "dm355evm_msp",
	.id_table	= dm355evm_msp_ids,
	.probe		= dm355evm_msp_probe,
	.remove		= dm355evm_msp_remove,
};

static int __init dm355evm_msp_init(void)
{
	return i2c_add_driver(&dm355evm_msp_driver);
}
subsys_initcall(dm355evm_msp_init);

static void __exit dm355evm_msp_exit(void)
{
	i2c_del_driver(&dm355evm_msp_driver);
}
module_exit(dm355evm_msp_exit);

MODULE_DESCRIPTION("Interface to MSP430 firmware on DM355EVM");
MODULE_LICENSE("GPL");
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
0931a4c6 DB	2	/*
	3	* dm355evm_msp.c - driver for MSP430 firmware on DM355EVM board
	4	*
	5	* Copyright (C) 2008 David Brownell
0931a4c6 DB	6	*/
	7
	8	#include <linux/init.h>
	9	#include <linux/mutex.h>
	10	#include <linux/platform_device.h>
	11	#include <linux/clk.h>
4e36dd33	12	#include <linux/module.h>
0931a4c6 DB	13	#include <linux/err.h>
	14	#include <linux/gpio.h>
	15	#include <linux/leds.h>
	16	#include <linux/i2c.h>
0335a955	17	#include <linux/mfd/dm355evm_msp.h>
0931a4c6 DB	18
	19
	20	/*
	21	* The DM355 is a DaVinci chip with video support but no C64+ DSP. Its
	22	* EVM board has an MSP430 programmed with firmware for various board
	23	* support functions. This driver exposes some of them directly, and
	24	* supports other drivers (e.g. RTC, input) for more complex access.
	25	*
	26	* Because this firmware is entirely board-specific, this file embeds
	27	* knowledge that would be passed as platform_data in a generic driver.
	28	*
	29	* This driver was tested with firmware revision A4.
	30	*/
	31
5eb519f3	32	#if IS_ENABLED(CONFIG_INPUT_DM355EVM)
0931a4c6 DB	33	#define msp_has_keyboard() true
	34	#else
	35	#define msp_has_keyboard() false
	36	#endif
	37
5eb519f3	38	#if IS_ENABLED(CONFIG_LEDS_GPIO)
0931a4c6 DB	39	#define msp_has_leds() true
	40	#else
	41	#define msp_has_leds() false
	42	#endif
	43
5eb519f3	44	#if IS_ENABLED(CONFIG_RTC_DRV_DM355EVM)
0931a4c6 DB	45	#define msp_has_rtc() true
	46	#else
	47	#define msp_has_rtc() false
	48	#endif
	49
5eb519f3	50	#if IS_ENABLED(CONFIG_VIDEO_TVP514X)
0931a4c6 DB	51	#define msp_has_tvp() true
	52	#else
	53	#define msp_has_tvp() false
	54	#endif
	55
	56
	57	/----------------------------------------------------------------------/
	58
	59	/* REVISIT for paranoia's sake, retry reads/writes on error */
	60
	61	static struct i2c_client *msp430;
	62
	63	/**
	64	* dm355evm_msp_write - Writes a register in dm355evm_msp
	65	* @value: the value to be written
	66	* @reg: register address
	67	*
	68	* Returns result of operation - 0 is success, else negative errno
	69	*/
	70	int dm355evm_msp_write(u8 value, u8 reg)
	71	{
	72	return i2c_smbus_write_byte_data(msp430, reg, value);
	73	}
	74	EXPORT_SYMBOL(dm355evm_msp_write);
	75
	76	/**
	77	* dm355evm_msp_read - Reads a register from dm355evm_msp
	78	* @reg: register address
	79	*
	80	* Returns result of operation - value, or negative errno
	81	*/
	82	int dm355evm_msp_read(u8 reg)
	83	{
	84	return i2c_smbus_read_byte_data(msp430, reg);
	85	}
	86	EXPORT_SYMBOL(dm355evm_msp_read);
	87
	88	/----------------------------------------------------------------------/
	89
	90	/*
	91	* Many of the msp430 pins are just used as fixed-direction GPIOs.
	92	* We could export a few more of them this way, if we wanted.
	93	*/
016f4219	94	#define MSP_GPIO(bit, reg) ((DM355EVM_MSP_ ## reg) << 3 \| (bit))
0931a4c6 DB	95
	96	static const u8 msp_gpios[] = {
	97	/* eight leds */
	98	MSP_GPIO(0, LED), MSP_GPIO(1, LED),
	99	MSP_GPIO(2, LED), MSP_GPIO(3, LED),
	100	MSP_GPIO(4, LED), MSP_GPIO(5, LED),
	101	MSP_GPIO(6, LED), MSP_GPIO(7, LED),
	102	/* SW6 and the NTSC/nPAL jumper */
	103	MSP_GPIO(0, SWITCH1), MSP_GPIO(1, SWITCH1),
	104	MSP_GPIO(2, SWITCH1), MSP_GPIO(3, SWITCH1),
	105	MSP_GPIO(4, SWITCH1),
d1fdb4f6	106	/* switches on MMC/SD sockets */
89a99e76 VB	107	/*
	108	* Note: EVMDM355_ECP_VA4.pdf suggests that Bit 2 and 4 should be
	109	* checked for card detection. However on the EVM bit 1 and 3 gives
	110	* this status, for 0 and 1 instance respectively. The pdf also
	111	* suggests that Bit 1 and 3 should be checked for write protection.
	112	* However on the EVM bit 2 and 4 gives this status,for 0 and 1
	113	* instance respectively.
	114	*/
	115	MSP_GPIO(2, SDMMC), MSP_GPIO(1, SDMMC), /* mmc0 WP, nCD */
	116	MSP_GPIO(4, SDMMC), MSP_GPIO(3, SDMMC), /* mmc1 WP, nCD */
0931a4c6 DB	117	};
	118
	119	#define MSP_GPIO_REG(offset) (msp_gpios[(offset)] >> 3)
	120	#define MSP_GPIO_MASK(offset) BIT(msp_gpios[(offset)] & 0x07)
	121
	122	static int msp_gpio_in(struct gpio_chip *chip, unsigned offset)
	123	{
	124	switch (MSP_GPIO_REG(offset)) {
	125	case DM355EVM_MSP_SWITCH1:
	126	case DM355EVM_MSP_SWITCH2:
	127	case DM355EVM_MSP_SDMMC:
	128	return 0;
	129	default:
	130	return -EINVAL;
	131	}
	132	}
	133
	134	static u8 msp_led_cache;
	135
	136	static int msp_gpio_get(struct gpio_chip *chip, unsigned offset)
	137	{
	138	int reg, status;
	139
	140	reg = MSP_GPIO_REG(offset);
	141	status = dm355evm_msp_read(reg);
	142	if (status < 0)
	143	return status;
	144	if (reg == DM355EVM_MSP_LED)
	145	msp_led_cache = status;
fe0b4867	146	return !!(status & MSP_GPIO_MASK(offset));
0931a4c6 DB	147	}
	148
	149	static int msp_gpio_out(struct gpio_chip *chip, unsigned offset, int value)
	150	{
	151	int mask, bits;
	152
	153	/* NOTE: there are some other signals that could be
	154	* packaged as output GPIOs, but they aren't as useful
	155	* as the LEDs ... so for now we don't.
	156	*/
	157	if (MSP_GPIO_REG(offset) != DM355EVM_MSP_LED)
	158	return -EINVAL;
	159
	160	mask = MSP_GPIO_MASK(offset);
	161	bits = msp_led_cache;
	162
	163	bits &= ~mask;
	164	if (value)
	165	bits \|= mask;
	166	msp_led_cache = bits;
	167
	168	return dm355evm_msp_write(bits, DM355EVM_MSP_LED);
	169	}
	170
	171	static void msp_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
	172	{
	173	msp_gpio_out(chip, offset, value);
	174	}
	175
	176	static struct gpio_chip dm355evm_msp_gpio = {
	177	.label = "dm355evm_msp",
	178	.owner = THIS_MODULE,
	179	.direction_input = msp_gpio_in,
	180	.get = msp_gpio_get,
	181	.direction_output = msp_gpio_out,
	182	.set = msp_gpio_set,
	183	.base = -EINVAL, /* dynamic assignment */
	184	.ngpio = ARRAY_SIZE(msp_gpios),
	185	.can_sleep = true,
	186	};
	187
	188	/----------------------------------------------------------------------/
	189
	190	static struct device add_child(struct i2c_client client, const char *name,
	191	void *pdata, unsigned pdata_len,
	192	bool can_wakeup, int irq)
	193	{
	194	struct platform_device *pdev;
	195	int status;
	196
	197	pdev = platform_device_alloc(name, -1);
d313cdde ME	198	if (!pdev)
d313cdde ME	199	return ERR_PTR(-ENOMEM);
0931a4c6 DB	200
	201	device_init_wakeup(&pdev->dev, can_wakeup);
	202	pdev->dev.parent = &client->dev;
	203
	204	if (pdata) {
	205	status = platform_device_add_data(pdev, pdata, pdata_len);
	206	if (status < 0) {
	207	dev_dbg(&pdev->dev, "can't add platform_data\n");
29090265	208	goto put_device;
0931a4c6 DB	209	}
	210	}
	211
	212	if (irq) {
	213	struct resource r = {
	214	.start = irq,
	215	.flags = IORESOURCE_IRQ,
	216	};
	217
	218	status = platform_device_add_resources(pdev, &r, 1);
	219	if (status < 0) {
	220	dev_dbg(&pdev->dev, "can't add irq\n");
29090265	221	goto put_device;
0931a4c6 DB	222	}
	223	}
	224
	225	status = platform_device_add(pdev);
29090265 ME	226	if (status)
29090265 ME	227	goto put_device;
0931a4c6	228
0931a4c6	229	return &pdev->dev;
29090265 ME	230
	231	put_device:
	232	platform_device_put(pdev);
	233	dev_err(&client->dev, "failed to add device %s\n", name);
	234	return ERR_PTR(status);
0931a4c6 DB	235	}
	236
	237	static int add_children(struct i2c_client *client)
	238	{
	239	static const struct {
	240	int offset;
	241	char *label;
	242	} config_inputs[] = {
	243	/* 8 == right after the LEDs */
	244	{ 8 + 0, "sw6_1", },
	245	{ 8 + 1, "sw6_2", },
	246	{ 8 + 2, "sw6_3", },
	247	{ 8 + 3, "sw6_4", },
	248	{ 8 + 4, "NTSC/nPAL", },
	249	};
	250
	251	struct device *child;
	252	int status;
	253	int i;
	254
	255	/* GPIO-ish stuff */
58383c78	256	dm355evm_msp_gpio.parent = &client->dev;
4363765c	257	status = gpiochip_add_data(&dm355evm_msp_gpio, NULL);
0931a4c6 DB	258	if (status < 0)
	259	return status;
	260
	261	/* LED output */
	262	if (msp_has_leds()) {
	263	#define GPIO_LED(l) .name = l, .active_low = true
	264	static struct gpio_led evm_leds[] = {
	265	{ GPIO_LED("dm355evm::ds14"),
	266	.default_trigger = "heartbeat", },
	267	{ GPIO_LED("dm355evm::ds15"),
	268	.default_trigger = "mmc0", },
	269	{ GPIO_LED("dm355evm::ds16"),
	270	/* could also be a CE-ATA drive */
	271	.default_trigger = "mmc1", },
	272	{ GPIO_LED("dm355evm::ds17"),
	273	.default_trigger = "nand-disk", },
	274	{ GPIO_LED("dm355evm::ds18"), },
	275	{ GPIO_LED("dm355evm::ds19"), },
	276	{ GPIO_LED("dm355evm::ds20"), },
	277	{ GPIO_LED("dm355evm::ds21"), },
	278	};
	279	#undef GPIO_LED
	280
	281	struct gpio_led_platform_data evm_led_data = {
	282	.num_leds = ARRAY_SIZE(evm_leds),
	283	.leds = evm_leds,
	284	};
	285
	286	for (i = 0; i < ARRAY_SIZE(evm_leds); i++)
	287	evm_leds[i].gpio = i + dm355evm_msp_gpio.base;
	288
	289	/* NOTE: these are the only fully programmable LEDs
	290	* on the board, since GPIO-61/ds22 (and many signals
	291	* going to DC7) must be used for AEMIF address lines
	292	* unless the top 1 GB of NAND is unused...
	293	*/
	294	child = add_child(client, "leds-gpio",
	295	&evm_led_data, sizeof(evm_led_data),
	296	false, 0);
	297	if (IS_ERR(child))
	298	return PTR_ERR(child);
	299	}
	300
	301	/* configuration inputs */
	302	for (i = 0; i < ARRAY_SIZE(config_inputs); i++) {
	303	int gpio = dm355evm_msp_gpio.base + config_inputs[i].offset;
	304
97f2bf51	305	gpio_request_one(gpio, GPIOF_IN, config_inputs[i].label);
0931a4c6 DB	306
	307	/* make it easy for userspace to see these */
	308	gpio_export(gpio, false);
	309	}
	310
d1fdb4f6	311	/* MMC/SD inputs -- right after the last config input */
334a41ce JH	312	if (dev_get_platdata(&client->dev)) {
334a41ce JH	313	void (*mmcsd_setup)(unsigned) = dev_get_platdata(&client->dev);
d1fdb4f6 DB	314
	315	mmcsd_setup(dm355evm_msp_gpio.base + 8 + 5);
	316	}
	317
0931a4c6 DB	318	/* RTC is a 32 bit counter, no alarm */
	319	if (msp_has_rtc()) {
	320	child = add_child(client, "rtc-dm355evm",
	321	NULL, 0, false, 0);
	322	if (IS_ERR(child))
	323	return PTR_ERR(child);
	324	}
	325
	326	/* input from buttons and IR remote (uses the IRQ) */
	327	if (msp_has_keyboard()) {
	328	child = add_child(client, "dm355evm_keys",
	329	NULL, 0, true, client->irq);
	330	if (IS_ERR(child))
	331	return PTR_ERR(child);
	332	}
	333
	334	return 0;
	335	}
	336
	337	/----------------------------------------------------------------------/
	338
	339	static void dm355evm_command(unsigned command)
	340	{
	341	int status;
	342
	343	status = dm355evm_msp_write(command, DM355EVM_MSP_COMMAND);
	344	if (status < 0)
	345	dev_err(&msp430->dev, "command %d failure %d\n",
	346	command, status);
	347	}
	348
	349	static void dm355evm_power_off(void)
	350	{
	351	dm355evm_command(MSP_COMMAND_POWEROFF);
	352	}
	353
	354	static int dm355evm_msp_remove(struct i2c_client *client)
	355	{
	356	pm_power_off = NULL;
	357	msp430 = NULL;
	358	return 0;
	359	}
	360
	361	static int
	362	dm355evm_msp_probe(struct i2c_client client, const struct i2c_device_id id)
	363	{
	364	int status;
	365	const char *video = msp_has_tvp() ? "TVP5146" : "imager";
	366
	367	if (msp430)
	368	return -EBUSY;
	369	msp430 = client;
	370
	371	/* display revision status; doubles as sanity check */
	372	status = dm355evm_msp_read(DM355EVM_MSP_FIRMREV);
	373	if (status < 0)
	374	goto fail;
	375	dev_info(&client->dev, "firmware v.%02X, %s as video-in\n",
	376	status, video);
	377
	378	/* mux video input: either tvp5146 or some external imager */
	379	status = dm355evm_msp_write(msp_has_tvp() ? 0 : MSP_VIDEO_IMAGER,
	380	DM355EVM_MSP_VIDEO_IN);
	381	if (status < 0)
382	dev_warn(&client->dev, "error %d muxing %s as video-in\n",
383	status, video);
384
385	/* init LED cache, and turn off the LEDs */
386	msp_led_cache = 0xff;
387	dm355evm_msp_write(msp_led_cache, DM355EVM_MSP_LED);
388
389	/* export capabilities we support */
390	status = add_children(client);
391	if (status < 0)
392	goto fail;
393
394	/* PM hookup */
395	pm_power_off = dm355evm_power_off;
396
397	return 0;
398
399	fail:
400	/* FIXME remove children ... */
401	dm355evm_msp_remove(client);
402	return status;
403	}
404
405	static const struct i2c_device_id dm355evm_msp_ids[] = {
406	{ "dm355evm_msp", 0 },
407	{ /* end of list */ },
408	};
409	MODULE_DEVICE_TABLE(i2c, dm355evm_msp_ids);
410
411	static struct i2c_driver dm355evm_msp_driver = {
412	.driver.name = "dm355evm_msp",
413	.id_table = dm355evm_msp_ids,
414	.probe = dm355evm_msp_probe,
415	.remove = dm355evm_msp_remove,
416	};
417
418	static int __init dm355evm_msp_init(void)
419	{
420	return i2c_add_driver(&dm355evm_msp_driver);
421	}
422	subsys_initcall(dm355evm_msp_init);
423
424	static void __exit dm355evm_msp_exit(void)
425	{
426	i2c_del_driver(&dm355evm_msp_driver);
427	}
428	module_exit(dm355evm_msp_exit);
429
430	MODULE_DESCRIPTION("Interface to MSP430 firmware on DM355EVM");
431	MODULE_LICENSE("GPL");