/* * linux/arch/arm/mach-pxa/viper.c * * Support for the Arcom VIPER SBC. * * Author: Ian Campbell * Created: Feb 03, 2003 * Copyright: Arcom Control Systems * * Maintained by Marc Zyngier * * * Based on lubbock.c: * Author: Nicolas Pitre * Created: Jun 15, 2001 * Copyright: MontaVista Software Inc. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "generic.h" #include "devices.h" static unsigned int icr; static void viper_icr_set_bit(unsigned int bit) { icr |= bit; VIPER_ICR = icr; } static void viper_icr_clear_bit(unsigned int bit) { icr &= ~bit; VIPER_ICR = icr; } /* This function is used from the pcmcia module to reset the CF */ static void viper_cf_reset(int state) { if (state) viper_icr_set_bit(VIPER_ICR_CF_RST); else viper_icr_clear_bit(VIPER_ICR_CF_RST); } static struct arcom_pcmcia_pdata viper_pcmcia_info = { .cd_gpio = VIPER_CF_CD_GPIO, .rdy_gpio = VIPER_CF_RDY_GPIO, .pwr_gpio = VIPER_CF_POWER_GPIO, .reset = viper_cf_reset, }; static struct platform_device viper_pcmcia_device = { .name = "viper-pcmcia", .id = -1, .dev = { .platform_data = &viper_pcmcia_info, }, }; /* * The CPLD version register was not present on VIPER boards prior to * v2i1. On v1 boards where the version register is not present we * will just read back the previous value from the databus. * * Therefore we do two reads. The first time we write 0 to the * (read-only) register before reading and the second time we write * 0xff first. If the two reads do not match or they read back as 0xff * or 0x00 then we have version 1 hardware. */ static u8 viper_hw_version(void) { u8 v1, v2; unsigned long flags; local_irq_save(flags); VIPER_VERSION = 0; v1 = VIPER_VERSION; VIPER_VERSION = 0xff; v2 = VIPER_VERSION; v1 = (v1 != v2 || v1 == 0xff) ? 0 : v1; local_irq_restore(flags); return v1; } /* CPU system core operations. */ static int viper_cpu_suspend(void) { viper_icr_set_bit(VIPER_ICR_R_DIS); return 0; } static void viper_cpu_resume(void) { viper_icr_clear_bit(VIPER_ICR_R_DIS); } static struct syscore_ops viper_cpu_syscore_ops = { .suspend = viper_cpu_suspend, .resume = viper_cpu_resume, }; static unsigned int current_voltage_divisor; /* * If force is not true then step from existing to new divisor. If * force is true then jump straight to the new divisor. Stepping is * used because if the jump in voltage is too large, the VCC can dip * too low and the regulator cuts out. * * force can be used to initialize the divisor to a know state by * setting the value for the current clock speed, since we are already * running at that speed we know the voltage should be pretty close so * the jump won't be too large */ static void viper_set_core_cpu_voltage(unsigned long khz, int force) { int i = 0; unsigned int divisor = 0; const char *v; if (khz < 200000) { v = "1.0"; divisor = 0xfff; } else if (khz < 300000) { v = "1.1"; divisor = 0xde5; } else { v = "1.3"; divisor = 0x325; } pr_debug("viper: setting CPU core voltage to %sV at %d.%03dMHz\n", v, (int)khz / 1000, (int)khz % 1000); #define STEP 0x100 do { int step; if (force) step = divisor; else if (current_voltage_divisor < divisor - STEP) step = current_voltage_divisor + STEP; else if (current_voltage_divisor > divisor + STEP) step = current_voltage_divisor - STEP; else step = divisor; force = 0; gpio_set_value(VIPER_PSU_CLK_GPIO, 0); gpio_set_value(VIPER_PSU_nCS_LD_GPIO, 0); for (i = 1 << 11 ; i > 0 ; i >>= 1) { udelay(1); gpio_set_value(VIPER_PSU_DATA_GPIO, step & i); udelay(1); gpio_set_value(VIPER_PSU_CLK_GPIO, 1); udelay(1); gpio_set_value(VIPER_PSU_CLK_GPIO, 0); } udelay(1); gpio_set_value(VIPER_PSU_nCS_LD_GPIO, 1); udelay(1); gpio_set_value(VIPER_PSU_nCS_LD_GPIO, 0); current_voltage_divisor = step; } while (current_voltage_divisor != divisor); } /* Interrupt handling */ static unsigned long viper_irq_enabled_mask; static const int viper_isa_irqs[] = { 3, 4, 5, 6, 7, 10, 11, 12, 9, 14, 15 }; static const int viper_isa_irq_map[] = { 0, /* ISA irq #0, invalid */ 0, /* ISA irq #1, invalid */ 0, /* ISA irq #2, invalid */ 1 << 0, /* ISA irq #3 */ 1 << 1, /* ISA irq #4 */ 1 << 2, /* ISA irq #5 */ 1 << 3, /* ISA irq #6 */ 1 << 4, /* ISA irq #7 */ 0, /* ISA irq #8, invalid */ 1 << 8, /* ISA irq #9 */ 1 << 5, /* ISA irq #10 */ 1 << 6, /* ISA irq #11 */ 1 << 7, /* ISA irq #12 */ 0, /* ISA irq #13, invalid */ 1 << 9, /* ISA irq #14 */ 1 << 10, /* ISA irq #15 */ }; static inline int viper_irq_to_bitmask(unsigned int irq) { return viper_isa_irq_map[irq - PXA_ISA_IRQ(0)]; } static inline int viper_bit_to_irq(int bit) { return viper_isa_irqs[bit] + PXA_ISA_IRQ(0); } static void viper_ack_irq(struct irq_data *d) { int viper_irq = viper_irq_to_bitmask(d->irq); if (viper_irq & 0xff) VIPER_LO_IRQ_STATUS = viper_irq; else VIPER_HI_IRQ_STATUS = (viper_irq >> 8); } static void viper_mask_irq(struct irq_data *d) { viper_irq_enabled_mask &= ~(viper_irq_to_bitmask(d->irq)); } static void viper_unmask_irq(struct irq_data *d) { viper_irq_enabled_mask |= viper_irq_to_bitmask(d->irq); } static inline unsigned long viper_irq_pending(void) { return (VIPER_HI_IRQ_STATUS << 8 | VIPER_LO_IRQ_STATUS) & viper_irq_enabled_mask; } static void viper_irq_handler(unsigned int irq, struct irq_desc *desc) { unsigned long pending; pending = viper_irq_pending(); do { /* we're in a chained irq handler, * so ack the interrupt by hand */ desc->irq_data.chip->irq_ack(&desc->irq_data); if (likely(pending)) { irq = viper_bit_to_irq(__ffs(pending)); generic_handle_irq(irq); } pending = viper_irq_pending(); } while (pending); } static struct irq_chip viper_irq_chip = { .name = "ISA", .irq_ack = viper_ack_irq, .irq_mask = viper_mask_irq, .irq_unmask = viper_unmask_irq }; static void __init viper_init_irq(void) { int level; int isa_irq; pxa25x_init_irq(); /* setup ISA IRQs */ for (level = 0; level < ARRAY_SIZE(viper_isa_irqs); level++) { isa_irq = viper_bit_to_irq(level); irq_set_chip_and_handler(isa_irq, &viper_irq_chip, handle_edge_irq); set_irq_flags(isa_irq, IRQF_VALID | IRQF_PROBE); } irq_set_chained_handler(gpio_to_irq(VIPER_CPLD_GPIO), viper_irq_handler); irq_set_irq_type(gpio_to_irq(VIPER_CPLD_GPIO), IRQ_TYPE_EDGE_BOTH); } /* Flat Panel */ static struct pxafb_mode_info fb_mode_info[] = { { .pixclock = 157500, .xres = 320, .yres = 240, .bpp = 16, .hsync_len = 63, .left_margin = 7, .right_margin = 13, .vsync_len = 20, .upper_margin = 0, .lower_margin = 0, .sync = 0, }, }; static struct pxafb_mach_info fb_info = { .modes = fb_mode_info, .num_modes = 1, .lcd_conn = LCD_COLOR_TFT_16BPP | LCD_PCLK_EDGE_FALL, }; static int viper_backlight_init(struct device *dev) { int ret; /* GPIO9 and 10 control FB backlight. Initialise to off */ ret = gpio_request(VIPER_BCKLIGHT_EN_GPIO, "Backlight"); if (ret) goto err_request_bckl; ret = gpio_request(VIPER_LCD_EN_GPIO, "LCD"); if (ret) goto err_request_lcd; ret = gpio_direction_output(VIPER_BCKLIGHT_EN_GPIO, 0); if (ret) goto err_dir; ret = gpio_direction_output(VIPER_LCD_EN_GPIO, 0); if (ret) goto err_dir; return 0; err_dir: gpio_free(VIPER_LCD_EN_GPIO); err_request_lcd: gpio_free(VIPER_BCKLIGHT_EN_GPIO); err_request_bckl: dev_err(dev, "Failed to setup LCD GPIOs\n"); return ret; } static int viper_backlight_notify(struct device *dev, int brightness) { gpio_set_value(VIPER_LCD_EN_GPIO, !!brightness); gpio_set_value(VIPER_BCKLIGHT_EN_GPIO, !!brightness); return brightness; } static void viper_backlight_exit(struct device *dev) { gpio_free(VIPER_LCD_EN_GPIO); gpio_free(VIPER_BCKLIGHT_EN_GPIO); } static struct platform_pwm_backlight_data viper_backlight_data = { .pwm_id = 0, .max_brightness = 100, .dft_brightness = 100, .pwm_period_ns = 1000000, .init = viper_backlight_init, .notify = viper_backlight_notify, .exit = viper_backlight_exit, }; static struct platform_device viper_backlight_device = { .name = "pwm-backlight", .dev = { .parent = &pxa25x_device_pwm0.dev, .platform_data = &viper_backlight_data, }, }; /* Ethernet */ static struct resource smc91x_resources[] = { [0] = { .name = "smc91x-regs", .start = VIPER_ETH_PHYS + 0x300, .end = VIPER_ETH_PHYS + 0x30f, .flags = IORESOURCE_MEM, }, [1] = { .start = PXA_GPIO_TO_IRQ(VIPER_ETH_GPIO), .end = PXA_GPIO_TO_IRQ(VIPER_ETH_GPIO), .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE, }, [2] = { .name = "smc91x-data32", .start = VIPER_ETH_DATA_PHYS, .end = VIPER_ETH_DATA_PHYS + 3, .flags = IORESOURCE_MEM, }, }; static struct smc91x_platdata viper_smc91x_info = { .flags = SMC91X_USE_16BIT | SMC91X_NOWAIT, .leda = RPC_LED_100_10, .ledb = RPC_LED_TX_RX, }; static struct platform_device smc91x_device = { .name = "smc91x", .id = -1, .num_resources = ARRAY_SIZE(smc91x_resources), .resource = smc91x_resources, .dev = { .platform_data = &viper_smc91x_info, },