static void __init gpio_btn(void)
{
int error,error2; int irq; int ret;
orion_gpio_set_valid(GPIO_BTN, GPIO_INPUT_OK);
orion_gpio_set_valid(GPIO_BTN2, GPIO_OUTPUT_OK);
error = gpio_request(GPIO_BTN, "gpio_btn");
error2 = gpio_request(GPIO_BTN2, "gpio_btn2");
if ( error<0 || error2<0 ) { pr_err("gpio_btn: failed to request GPIO %d, error %d; error2 %d \n",GPIO_BTN, error,error2); }
error = gpio_direction_input(GPIO_BTN);
if ( error<0 )
{ pr_err("gpio_btn: failed to configure input for GPIO %d, error %d; error2 %d \n",GPIO_BTN, error,error2); }
irq = gpio_to_irq(GPIO_BTN);
if ( irq < 0)
{ pr_err("gpio_btn: Unable to get irq number for GPIO %d, error %d \n",GPIO_BTN, irq); }
error = request_irq(irq, gpio_btn_handler, IRQF_TRIGGER_FALLING, "gpio_btn", NULL);
if ( error )
{ pr_err("gpio_btn: failed to request_irq for GPIO/irq %d %d \n",GPIO_BTN,irq); }
//platform_device_register(&gpio_dev_btn);
printk("gpio_btn is called sucessfully! the initial value is %d, return value is %d \n",__gpio_get_value(GPIO_BTN),ret);
}
static void __init d2net_init(void)
{
/*
* Setup basic Orion functions. Need to be called early.
*/
orion5x_init();
orion5x_mpp_conf(d2net_mpp_modes);
/*
* Configure peripherals.
*/
orion5x_ehci0_init();
orion5x_eth_init(&d2net_eth_data);
orion5x_i2c_init();
orion5x_uart0_init();
d2net_sata_power_init();
orion5x_sata_init(&d2net_sata_data);
orion5x_setup_dev_boot_win(D2NET_NOR_BOOT_BASE,
D2NET_NOR_BOOT_SIZE);
platform_device_register(&d2net_nor_flash);
platform_device_register(&d2net_gpio_buttons);
d2net_gpio_leds_init();
pr_notice("d2net: Flash write are not yet supported.\n");
i2c_register_board_info(0, d2net_i2c_devices,
ARRAY_SIZE(d2net_i2c_devices));
orion_gpio_set_valid(D2NET_GPIO_INHIBIT_POWER_OFF, 1);
}
void __init mv78xx0_mpp_conf(unsigned int *mpp_list)
{
u32 mpp_ctrl[MPP_NR_REGS];
unsigned int variant_mask;
int i;
variant_mask = mv78xx0_variant();
if (!variant_mask)
return;
/* Initialize gpiolib. */
orion_gpio_init();
printk(KERN_DEBUG "initial MPP regs:");
for (i = 0; i < MPP_NR_REGS; i++) {
mpp_ctrl[i] = readl(MPP_CTRL(i));
printk(" %08x", mpp_ctrl[i]);
}
printk("\n");
while (*mpp_list) {
unsigned int num = MPP_NUM(*mpp_list);
unsigned int sel = MPP_SEL(*mpp_list);
int shift, gpio_mode;
if (num > MPP_MAX) {
printk(KERN_ERR "mv78xx0_mpp_conf: invalid MPP "
"number (%u)\n", num);
continue;
}
if (!(*mpp_list & variant_mask)) {
printk(KERN_WARNING
"mv78xx0_mpp_conf: requested MPP%u config "
"unavailable on this hardware\n", num);
continue;
}
shift = (num & 7) << 2;
mpp_ctrl[num / 8] &= ~(0xf << shift);
mpp_ctrl[num / 8] |= sel << shift;
gpio_mode = 0;
if (*mpp_list & MPP_INPUT_MASK)
gpio_mode |= GPIO_INPUT_OK;
if (*mpp_list & MPP_OUTPUT_MASK)
gpio_mode |= GPIO_OUTPUT_OK;
if (sel != 0)
gpio_mode = 0;
orion_gpio_set_valid(num, gpio_mode);
mpp_list++;
}
printk(KERN_DEBUG " final MPP regs:");
for (i = 0; i < MPP_NR_REGS; i++) {
writel(mpp_ctrl[i], MPP_CTRL(i));
printk(" %08x", mpp_ctrl[i]);
}
printk("\n");
}
void __init orion_mpp_conf(unsigned int *mpp_list, unsigned int variant_mask,
unsigned int mpp_max, void __iomem *dev_bus)
{
unsigned int mpp_nr_regs = (1 + mpp_max/8);
u32 mpp_ctrl[mpp_nr_regs];
int i;
printk(KERN_DEBUG "initial MPP regs:");
for (i = 0; i < mpp_nr_regs; i++) {
mpp_ctrl[i] = readl(mpp_ctrl_addr(i, dev_bus));
printk(" %08x", mpp_ctrl[i]);
}
printk("\n");
for ( ; *mpp_list; mpp_list++) {
unsigned int num = MPP_NUM(*mpp_list);
unsigned int sel = MPP_SEL(*mpp_list);
int shift, gpio_mode;
if (num > mpp_max) {
printk(KERN_ERR "orion_mpp_conf: invalid MPP "
"number (%u)\n", num);
continue;
}
if (variant_mask & !(*mpp_list & variant_mask)) {
printk(KERN_WARNING
"orion_mpp_conf: requested MPP%u config "
"unavailable on this hardware\n", num);
continue;
}
shift = (num & 7) << 2;
mpp_ctrl[num / 8] &= ~(0xf << shift);
mpp_ctrl[num / 8] |= sel << shift;
gpio_mode = 0;
if (*mpp_list & MPP_INPUT_MASK)
gpio_mode |= GPIO_INPUT_OK;
if (*mpp_list & MPP_OUTPUT_MASK)
gpio_mode |= GPIO_OUTPUT_OK;
orion_gpio_set_valid(num, gpio_mode);
}
printk(KERN_DEBUG " final MPP regs:");
for (i = 0; i < mpp_nr_regs; i++) {
writel(mpp_ctrl[i], mpp_ctrl_addr(i, dev_bus));
printk(" %08x", mpp_ctrl[i]);
}
printk("\n");
}
int __init dove_db_b_giga_phy_gpio_setup(void)
{
orion_gpio_set_valid(DOVE_DB_PHY_RST_GPIO, 1);
if (gpio_request(DOVE_DB_PHY_RST_GPIO, "Giga Phy reset gpio") != 0)
pr_err("Dove: failed to setup Giga phy reset GPIO\n");
if (gpio_direction_output(DOVE_DB_PHY_RST_GPIO, 1) != 0) {
printk(KERN_ERR "%s failed to set output pin %d\n", __func__,
DOVE_DB_PHY_RST_GPIO);
gpio_free(DOVE_DB_PHY_RST_GPIO);
return -1;
}
return 0;
}
static void __init d2net_gpio_leds_init(void)
{
int err;
/* Configure GPIO over MPP max number. */
orion_gpio_set_valid(D2NET_GPIO_BLUE_LED_OFF, 1);
/* Configure register blink_ctrl to allow SATA activity LED blinking. */
err = gpio_request(D2NET_GPIO_BLUE_LED_BLINK_CTRL, "blue LED blink");
if (err == 0) {
err = gpio_direction_output(D2NET_GPIO_BLUE_LED_BLINK_CTRL, 1);
if (err)
gpio_free(D2NET_GPIO_BLUE_LED_BLINK_CTRL);
}
if (err)
pr_err("d2net: failed to configure blue LED blink GPIO\n");
platform_device_register(&d2net_gpio_leds);
}
int __init dove_db_ts_gpio_setup(void)
{
orion_gpio_set_valid(DOVE_DB_TS_PEN_GPIO, 1);
if (gpio_request(DOVE_DB_TS_PEN_GPIO, "DOVE_TS_PEN_IRQ") != 0)
pr_err("Dove: failed to setup TS IRQ GPIO\n");
if (gpio_direction_input(DOVE_DB_TS_PEN_GPIO) != 0) {
printk(KERN_ERR "%s failed "
"to set output pin %d\n", __func__,
DOVE_DB_TS_PEN_GPIO);
gpio_free(DOVE_DB_TS_PEN_GPIO);
return -1;
}
//IRQ
set_irq_chip(DOVE_DB_TS_PEN_IRQ, &orion_gpio_irq_chip);
set_irq_handler(DOVE_DB_TS_PEN_IRQ, handle_level_irq);
set_irq_type(DOVE_DB_TS_PEN_IRQ, IRQ_TYPE_LEVEL_LOW);
return 0;
}
static void __init net2big_init(void)
{
/*
* Setup basic Orion functions. Need to be called early.
*/
orion5x_init();
orion5x_mpp_conf(net2big_mpp_modes);
/*
* Configure peripherals.
*/
orion5x_ehci0_init();
orion5x_ehci1_init();
orion5x_eth_init(&net2big_eth_data);
orion5x_i2c_init();
orion5x_uart0_init();
orion5x_xor_init();
net2big_sata_power_init();
orion5x_sata_init(&net2big_sata_data);
orion5x_setup_dev_boot_win(NET2BIG_NOR_BOOT_BASE,
NET2BIG_NOR_BOOT_SIZE);
platform_device_register(&net2big_nor_flash);
platform_device_register(&net2big_gpio_buttons);
net2big_gpio_leds_init();
i2c_register_board_info(0, net2big_i2c_devices,
ARRAY_SIZE(net2big_i2c_devices));
orion_gpio_set_valid(NET2BIG_GPIO_POWER_OFF, 1);
if (gpio_request(NET2BIG_GPIO_POWER_OFF, "power-off") == 0 &&
gpio_direction_output(NET2BIG_GPIO_POWER_OFF, 0) == 0)
pm_power_off = net2big_power_off;
else
pr_err("net2big: failed to configure power-off GPIO\n");
pr_notice("net2big: Flash writing is not yet supported.\n");
}
static void __init rd88f6192_init(void)
{
/*
* Basic setup. Needs to be called early.
*/
kirkwood_init();
orion_gpio_set_valid(RD88F6192_GPIO_USB_VBUS, 1);
if (gpio_request(RD88F6192_GPIO_USB_VBUS, "USB VBUS") != 0 ||
gpio_direction_output(RD88F6192_GPIO_USB_VBUS, 1) != 0)
pr_err("RD-88F6192-NAS: failed to setup USB VBUS GPIO\n");
kirkwood_ehci_init();
kirkwood_ge00_init(&rd88f6192_ge00_data);
kirkwood_sata_init(&rd88f6192_sata_data);
spi_register_board_info(rd88F6192_spi_slave_info,
ARRAY_SIZE(rd88F6192_spi_slave_info));
kirkwood_spi_init();
kirkwood_uart0_init();
}
static void __init d2net_gpio_leds_init(void)
{
/* Configure GPIO over MPP max number. */
orion_gpio_set_valid(D2NET_GPIO_BLUE_LED_OFF, 1);
if (gpio_request(D2NET_GPIO_SATA0_ACT, "LED SATA0 activity") != 0)
return;
if (gpio_direction_output(D2NET_GPIO_SATA0_ACT, 1) != 0)
goto err_free_1;
if (gpio_request(D2NET_GPIO_SATA1_ACT, "LED SATA1 activity") != 0)
goto err_free_1;
if (gpio_direction_output(D2NET_GPIO_SATA1_ACT, 1) != 0)
goto err_free_2;
platform_device_register(&d2net_gpio_leds);
return;
err_free_2:
gpio_free(D2NET_GPIO_SATA1_ACT);
err_free_1:
gpio_free(D2NET_GPIO_SATA0_ACT);
return;
}
static void __init net2big_sata_power_init(void)
{
int err;
/* Configure GPIOs over MPP max number. */
orion_gpio_set_valid(NET2BIG_GPIO_SATA0_POWER, 1);
orion_gpio_set_valid(NET2BIG_GPIO_SATA1_POWER, 1);
err = gpio_request(NET2BIG_GPIO_SATA0_POWER, "SATA0 power status");
if (err == 0) {
err = gpio_direction_input(NET2BIG_GPIO_SATA0_POWER);
if (err)
gpio_free(NET2BIG_GPIO_SATA0_POWER);
}
if (err) {
pr_err("net2big: failed to setup SATA0 power GPIO\n");
return;
}
err = gpio_request(NET2BIG_GPIO_SATA1_POWER, "SATA1 power status");
if (err == 0) {
err = gpio_direction_input(NET2BIG_GPIO_SATA1_POWER);
if (err)
gpio_free(NET2BIG_GPIO_SATA1_POWER);
}
if (err) {
pr_err("net2big: failed to setup SATA1 power GPIO\n");
goto err_free_1;
}
err = gpio_request(NET2BIG_GPIO_SATA_POWER_REQ, "SATA power request");
if (err == 0) {
err = gpio_direction_output(NET2BIG_GPIO_SATA_POWER_REQ, 0);
if (err)
gpio_free(NET2BIG_GPIO_SATA_POWER_REQ);
}
if (err) {
pr_err("net2big: failed to setup SATA power request GPIO\n");
goto err_free_2;
}
if (gpio_get_value(NET2BIG_GPIO_SATA0_POWER) &&
gpio_get_value(NET2BIG_GPIO_SATA1_POWER)) {
return;
}
/*
* SATA power up on both disk is done by pulling high the CPLD power
* request line. The 300ms delay is related to the CPLD clock and is
* needed to be sure that the CPLD has take into account the low line
* status.
*/
msleep(300);
gpio_set_value(NET2BIG_GPIO_SATA_POWER_REQ, 1);
pr_info("net2big: power up SATA hard disks\n");
return;
err_free_2:
gpio_free(NET2BIG_GPIO_SATA1_POWER);
err_free_1:
gpio_free(NET2BIG_GPIO_SATA0_POWER);
return;
}
static void dove_d2plug_gpio_init(u32 rev)
{
int pin;
unsigned long uiReg;
printk(KERN_ERR"dove_d2plug_gpio_init ENTER!\n");
#if 0
orion_gpio_set_valid(0, 1);
if (gpio_request(0, "led0") != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for led0\n");
gpio_direction_output(0,0); /* led0 */
orion_gpio_set_valid(1, 1);
if (gpio_request(1, "led1") != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for led1\n");
gpio_direction_output(1,0); /* led1 */
orion_gpio_set_valid(2, 1);
if (gpio_request(2, "led2") != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for led2\n");
gpio_direction_output(2,0); /* led2 */
#endif //because registered in leds-gpio
if (rev >= DOVE_REV_X0) {
pin = 16;
} else {
pin = 6;
}
#if 0 //for ddr reset
orion_gpio_set_valid(pin, 1);
if (gpio_request(pin, "MPP_DDR_TERM") != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for MPP_DDR_TERM\n");
gpio_direction_output(pin, 1); /* Enable DDR 1.8v */
#endif
#if 1
orion_gpio_set_valid(5, 1); //for pex1 rst
if (gpio_request(5, "pex1-rst") != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for pex1-rst\n");
gpio_direction_input(5); /* pex1-rst */
#endif
orion_gpio_set_valid(7, 1); //for pex0 rst; usb 3.0
if (gpio_request(7, "pex0-rst" ) != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for pex0-rst\n");
gpio_direction_output(7,1); /*PCI-E reset */
orion_gpio_set_valid(8, 1); //for usb pwr;
if (gpio_request(8, "usb-pwr" ) != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for usb-pwr\n");
gpio_direction_output(8,1); /*PCI-E reset */
orion_gpio_set_valid(14, 1);
if (gpio_request(14, "HDMI_CKSW") != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for HDMI_CKSW\n");
else
gpio_direction_output(14, 0); /* Allow HDMI clk */
orion_gpio_set_valid(15, 1);
if (gpio_request(15, "HDMI_CKSWET1") != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for HDMI_CKSWET1\n");
else
gpio_direction_output(15, 1); /* 148.5 MHz for HDMI*/
orion_gpio_set_valid(16, 1);
if (gpio_request(16, "HDMI_CKSWET2") != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for HDMI_CKSWET2\n");
else
gpio_direction_output(16, 0); /* 148.5 MHz for HDMI*/
orion_gpio_set_valid(23, 1);
if (gpio_request(23, "WLAN_PD") != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for WLAN_PD\n");
else
{
gpio_direction_output(23, 0);
mdelay(20);
gpio_direction_output(23, 1); /* WLAN_PD*/
}
/////////////////////////// input part
orion_gpio_set_valid(9, 1);
if (gpio_request(9, "SRD1_CLKREQn") != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for SRD1_CLKREQn\n");
else
gpio_direction_input(9);
#if 0
orion_gpio_set_valid(10, 1);
if (gpio_request(10, "HDMI_INT") != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for HDMI_INT\n");
else
gpio_direction_input(10);
#endif
orion_gpio_set_valid(11, 1);
if (gpio_request(11, "GPIO_RST_SWIN") != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for GPIO_RST_SWIN\n");
else
gpio_direction_input(11);
orion_gpio_set_valid(12, 1);
if (gpio_request(12, "SRD1_WAKEn") != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for SRD1_WAKEn\n");
else
gpio_direction_input(12);
orion_gpio_set_valid(13, 1);
if (gpio_request(13, "USB_OVC") != 0)
printk(KERN_ERR "Dove: failed to setup GPIO for USB_OVC\n");
else
gpio_direction_input(13);
msleep(200);
printk(KERN_ERR"dove_d2plug_gpio_init exit!\n");
}
