mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 19:29:37 +00:00
![Thomas Gleixner](/assets/img/avatar_default.png)
Based on 1 normalized pattern(s): this program is free software you can redistribute it and or modify it under the terms of the gnu general public license as published by the free software foundation either version 2 of the license or at your option any later version extracted by the scancode license scanner the SPDX license identifier GPL-2.0-or-later has been chosen to replace the boilerplate/reference in 3029 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190527070032.746973796@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
431 lines
10 KiB
C
431 lines
10 KiB
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");
|