2 * linux/arch/arm/mach-pxa/viper.c
4 * Support for the Arcom VIPER SBC.
7 * Created: Feb 03, 2003
8 * Copyright: Arcom Control Systems
10 * Maintained by Marc Zyngier <maz@misterjones.org>
11 * <marc.zyngier@altran.com>
14 * Author: Nicolas Pitre
15 * Created: Jun 15, 2001
16 * Copyright: MontaVista Software Inc.
18 * This program is free software; you can redistribute it and/or modify
19 * it under the terms of the GNU General Public License version 2 as
20 * published by the Free Software Foundation.
23 #include <linux/types.h>
24 #include <linux/memory.h>
25 #include <linux/cpu.h>
26 #include <linux/cpufreq.h>
27 #include <linux/delay.h>
29 #include <linux/init.h>
30 #include <linux/interrupt.h>
31 #include <linux/major.h>
32 #include <linux/module.h>
34 #include <linux/sched.h>
35 #include <linux/gpio.h>
36 #include <linux/i2c-gpio.h>
37 #include <linux/serial_8250.h>
38 #include <linux/smc91x.h>
39 #include <linux/pwm_backlight.h>
40 #include <linux/usb/isp116x.h>
41 #include <linux/mtd/mtd.h>
42 #include <linux/mtd/partitions.h>
43 #include <linux/mtd/physmap.h>
45 #include <mach/pxa25x.h>
46 #include <mach/audio.h>
47 #include <mach/pxafb.h>
49 #include <mach/regs-uart.h>
50 #include <mach/viper.h>
52 #include <asm/setup.h>
53 #include <asm/mach-types.h>
55 #include <asm/sizes.h>
57 #include <asm/mach/arch.h>
58 #include <asm/mach/map.h>
59 #include <asm/mach/irq.h>
64 static unsigned int icr
;
66 static void viper_icr_set_bit(unsigned int bit
)
72 static void viper_icr_clear_bit(unsigned int bit
)
78 /* This function is used from the pcmcia module to reset the CF */
79 void viper_cf_rst(int state
)
82 viper_icr_set_bit(VIPER_ICR_CF_RST
);
84 viper_icr_clear_bit(VIPER_ICR_CF_RST
);
86 EXPORT_SYMBOL(viper_cf_rst
);
89 * The CPLD version register was not present on VIPER boards prior to
90 * v2i1. On v1 boards where the version register is not present we
91 * will just read back the previous value from the databus.
93 * Therefore we do two reads. The first time we write 0 to the
94 * (read-only) register before reading and the second time we write
95 * 0xff first. If the two reads do not match or they read back as 0xff
96 * or 0x00 then we have version 1 hardware.
98 static u8
viper_hw_version(void)
103 local_irq_save(flags
);
107 VIPER_VERSION
= 0xff;
110 v1
= (v1
!= v2
|| v1
== 0xff) ? 0 : v1
;
112 local_irq_restore(flags
);
117 static int viper_cpu_suspend(struct sys_device
*sysdev
, pm_message_t state
)
119 viper_icr_set_bit(VIPER_ICR_R_DIS
);
123 static int viper_cpu_resume(struct sys_device
*sysdev
)
125 viper_icr_clear_bit(VIPER_ICR_R_DIS
);
129 static struct sysdev_driver viper_cpu_sysdev_driver
= {
130 .suspend
= viper_cpu_suspend
,
131 .resume
= viper_cpu_resume
,
134 static unsigned int current_voltage_divisor
;
137 * If force is not true then step from existing to new divisor. If
138 * force is true then jump straight to the new divisor. Stepping is
139 * used because if the jump in voltage is too large, the VCC can dip
140 * too low and the regulator cuts out.
142 * force can be used to initialize the divisor to a know state by
143 * setting the value for the current clock speed, since we are already
144 * running at that speed we know the voltage should be pretty close so
145 * the jump won't be too large
147 static void viper_set_core_cpu_voltage(unsigned long khz
, int force
)
150 unsigned int divisor
= 0;
154 v
= "1.0"; divisor
= 0xfff;
155 } else if (khz
< 300000) {
156 v
= "1.1"; divisor
= 0xde5;
158 v
= "1.3"; divisor
= 0x325;
161 pr_debug("viper: setting CPU core voltage to %sV at %d.%03dMHz\n",
162 v
, (int)khz
/ 1000, (int)khz
% 1000);
170 else if (current_voltage_divisor
< divisor
- STEP
)
171 step
= current_voltage_divisor
+ STEP
;
172 else if (current_voltage_divisor
> divisor
+ STEP
)
173 step
= current_voltage_divisor
- STEP
;
178 gpio_set_value(VIPER_PSU_CLK_GPIO
, 0);
179 gpio_set_value(VIPER_PSU_nCS_LD_GPIO
, 0);
181 for (i
= 1 << 11 ; i
> 0 ; i
>>= 1) {
184 gpio_set_value(VIPER_PSU_DATA_GPIO
, step
& i
);
187 gpio_set_value(VIPER_PSU_CLK_GPIO
, 1);
190 gpio_set_value(VIPER_PSU_CLK_GPIO
, 0);
194 gpio_set_value(VIPER_PSU_nCS_LD_GPIO
, 1);
197 gpio_set_value(VIPER_PSU_nCS_LD_GPIO
, 0);
199 current_voltage_divisor
= step
;
200 } while (current_voltage_divisor
!= divisor
);
203 /* Interrupt handling */
204 static unsigned long viper_irq_enabled_mask
;
205 static const int viper_isa_irqs
[] = { 3, 4, 5, 6, 7, 10, 11, 12, 9, 14, 15 };
206 static const int viper_isa_irq_map
[] = {
207 0, /* ISA irq #0, invalid */
208 0, /* ISA irq #1, invalid */
209 0, /* ISA irq #2, invalid */
210 1 << 0, /* ISA irq #3 */
211 1 << 1, /* ISA irq #4 */
212 1 << 2, /* ISA irq #5 */
213 1 << 3, /* ISA irq #6 */
214 1 << 4, /* ISA irq #7 */
215 0, /* ISA irq #8, invalid */
216 1 << 8, /* ISA irq #9 */
217 1 << 5, /* ISA irq #10 */
218 1 << 6, /* ISA irq #11 */
219 1 << 7, /* ISA irq #12 */
220 0, /* ISA irq #13, invalid */
221 1 << 9, /* ISA irq #14 */
222 1 << 10, /* ISA irq #15 */
225 static inline int viper_irq_to_bitmask(unsigned int irq
)
227 return viper_isa_irq_map
[irq
- PXA_ISA_IRQ(0)];
230 static inline int viper_bit_to_irq(int bit
)
232 return viper_isa_irqs
[bit
] + PXA_ISA_IRQ(0);
235 static void viper_ack_irq(unsigned int irq
)
237 int viper_irq
= viper_irq_to_bitmask(irq
);
239 if (viper_irq
& 0xff)
240 VIPER_LO_IRQ_STATUS
= viper_irq
;
242 VIPER_HI_IRQ_STATUS
= (viper_irq
>> 8);
245 static void viper_mask_irq(unsigned int irq
)
247 viper_irq_enabled_mask
&= ~(viper_irq_to_bitmask(irq
));
250 static void viper_unmask_irq(unsigned int irq
)
252 viper_irq_enabled_mask
|= viper_irq_to_bitmask(irq
);
255 static inline unsigned long viper_irq_pending(void)
257 return (VIPER_HI_IRQ_STATUS
<< 8 | VIPER_LO_IRQ_STATUS
) &
258 viper_irq_enabled_mask
;
261 static void viper_irq_handler(unsigned int irq
, struct irq_desc
*desc
)
263 unsigned long pending
;
265 pending
= viper_irq_pending();
267 /* we're in a chained irq handler,
268 * so ack the interrupt by hand */
269 GEDR(VIPER_CPLD_GPIO
) = GPIO_bit(VIPER_CPLD_GPIO
);
271 if (likely(pending
)) {
272 irq
= viper_bit_to_irq(__ffs(pending
));
273 generic_handle_irq(irq
);
275 pending
= viper_irq_pending();
279 static struct irq_chip viper_irq_chip
= {
281 .ack
= viper_ack_irq
,
282 .mask
= viper_mask_irq
,
283 .unmask
= viper_unmask_irq
286 static void __init
viper_init_irq(void)
294 for (level
= 0; level
< ARRAY_SIZE(viper_isa_irqs
); level
++) {
295 isa_irq
= viper_bit_to_irq(level
);
296 set_irq_chip(isa_irq
, &viper_irq_chip
);
297 set_irq_handler(isa_irq
, handle_edge_irq
);
298 set_irq_flags(isa_irq
, IRQF_VALID
| IRQF_PROBE
);
301 set_irq_chained_handler(gpio_to_irq(VIPER_CPLD_GPIO
),
303 set_irq_type(gpio_to_irq(VIPER_CPLD_GPIO
), IRQ_TYPE_EDGE_BOTH
);
307 static struct pxafb_mode_info fb_mode_info
[] = {
328 static struct pxafb_mach_info fb_info
= {
329 .modes
= fb_mode_info
,
331 .lcd_conn
= LCD_COLOR_TFT_16BPP
| LCD_PCLK_EDGE_FALL
,
334 static int viper_backlight_init(struct device
*dev
)
338 /* GPIO9 and 10 control FB backlight. Initialise to off */
339 ret
= gpio_request(VIPER_BCKLIGHT_EN_GPIO
, "Backlight");
341 goto err_request_bckl
;
343 ret
= gpio_request(VIPER_LCD_EN_GPIO
, "LCD");
345 goto err_request_lcd
;
347 ret
= gpio_direction_output(VIPER_BCKLIGHT_EN_GPIO
, 0);
351 ret
= gpio_direction_output(VIPER_LCD_EN_GPIO
, 0);
358 gpio_free(VIPER_LCD_EN_GPIO
);
360 gpio_free(VIPER_BCKLIGHT_EN_GPIO
);
362 dev_err(dev
, "Failed to setup LCD GPIOs\n");
367 static int viper_backlight_notify(int brightness
)
369 gpio_set_value(VIPER_LCD_EN_GPIO
, !!brightness
);
370 gpio_set_value(VIPER_BCKLIGHT_EN_GPIO
, !!brightness
);
375 static void viper_backlight_exit(struct device
*dev
)
377 gpio_free(VIPER_LCD_EN_GPIO
);
378 gpio_free(VIPER_BCKLIGHT_EN_GPIO
);
381 static struct platform_pwm_backlight_data viper_backlight_data
= {
383 .max_brightness
= 100,
384 .dft_brightness
= 100,
385 .pwm_period_ns
= 1000000,
386 .init
= viper_backlight_init
,
387 .notify
= viper_backlight_notify
,
388 .exit
= viper_backlight_exit
,
391 static struct platform_device viper_backlight_device
= {
392 .name
= "pwm-backlight",
394 .parent
= &pxa25x_device_pwm0
.dev
,
395 .platform_data
= &viper_backlight_data
,
400 static struct resource smc91x_resources
[] = {
402 .name
= "smc91x-regs",
403 .start
= VIPER_ETH_PHYS
+ 0x300,
404 .end
= VIPER_ETH_PHYS
+ 0x30f,
405 .flags
= IORESOURCE_MEM
,
408 .start
= gpio_to_irq(VIPER_ETH_GPIO
),
409 .end
= gpio_to_irq(VIPER_ETH_GPIO
),
410 .flags
= IORESOURCE_IRQ
| IORESOURCE_IRQ_HIGHEDGE
,
413 .name
= "smc91x-data32",
414 .start
= VIPER_ETH_DATA_PHYS
,
415 .end
= VIPER_ETH_DATA_PHYS
+ 3,
416 .flags
= IORESOURCE_MEM
,
420 static struct smc91x_platdata viper_smc91x_info
= {
421 .flags
= SMC91X_USE_16BIT
| SMC91X_NOWAIT
,
422 .leda
= RPC_LED_100_10
,
423 .ledb
= RPC_LED_TX_RX
,
426 static struct platform_device smc91x_device
= {
429 .num_resources
= ARRAY_SIZE(smc91x_resources
),
430 .resource
= smc91x_resources
,
432 .platform_data
= &viper_smc91x_info
,
437 static struct i2c_gpio_platform_data i2c_bus_data
= {
438 .sda_pin
= VIPER_RTC_I2C_SDA_GPIO
,
439 .scl_pin
= VIPER_RTC_I2C_SCL_GPIO
,
444 static struct platform_device i2c_bus_device
= {
446 .id
= 1, /* pxa2xx-i2c is bus 0, so start at 1 */
448 .platform_data
= &i2c_bus_data
,
452 static struct i2c_board_info __initdata viper_i2c_devices
[] = {
454 I2C_BOARD_INFO("ds1338", 0x68),
459 * Serial configuration:
460 * You can either have the standard PXA ports driven by the PXA driver,
461 * or all the ports (PXA + 16850) driven by the 8250 driver.
462 * Choose your poison.
465 static struct resource viper_serial_resources
[] = {
466 #ifndef CONFIG_SERIAL_PXA
470 .flags
= IORESOURCE_MEM
,
475 .flags
= IORESOURCE_MEM
,
480 .flags
= IORESOURCE_MEM
,
483 .start
= VIPER_UARTA_PHYS
,
484 .end
= VIPER_UARTA_PHYS
+ 0xf,
485 .flags
= IORESOURCE_MEM
,
488 .start
= VIPER_UARTB_PHYS
,
489 .end
= VIPER_UARTB_PHYS
+ 0xf,
490 .flags
= IORESOURCE_MEM
,
499 static struct plat_serial8250_port serial_platform_data
[] = {
500 #ifndef CONFIG_SERIAL_PXA
503 .membase
= (void *)&FFUART
,
504 .mapbase
= __PREG(FFUART
),
506 .uartclk
= 921600 * 16,
508 .flags
= UPF_BOOT_AUTOCONF
| UPF_SKIP_TEST
,
512 .membase
= (void *)&BTUART
,
513 .mapbase
= __PREG(BTUART
),
515 .uartclk
= 921600 * 16,
517 .flags
= UPF_BOOT_AUTOCONF
| UPF_SKIP_TEST
,
521 .membase
= (void *)&STUART
,
522 .mapbase
= __PREG(STUART
),
524 .uartclk
= 921600 * 16,
526 .flags
= UPF_BOOT_AUTOCONF
| UPF_SKIP_TEST
,
531 .mapbase
= VIPER_UARTA_PHYS
,
532 .irq
= gpio_to_irq(VIPER_UARTA_GPIO
),
533 .irqflags
= IRQF_TRIGGER_RISING
,
537 .flags
= UPF_BOOT_AUTOCONF
| UPF_IOREMAP
|
541 .mapbase
= VIPER_UARTB_PHYS
,
542 .irq
= gpio_to_irq(VIPER_UARTB_GPIO
),
543 .irqflags
= IRQF_TRIGGER_RISING
,
547 .flags
= UPF_BOOT_AUTOCONF
| UPF_IOREMAP
|
554 static struct platform_device serial_device
= {
555 .name
= "serial8250",
558 .platform_data
= serial_platform_data
,
560 .num_resources
= ARRAY_SIZE(viper_serial_resources
),
561 .resource
= viper_serial_resources
,
565 static void isp116x_delay(struct device
*dev
, int delay
)
570 static struct resource isp116x_resources
[] = {
572 .start
= VIPER_USB_PHYS
+ 0,
573 .end
= VIPER_USB_PHYS
+ 1,
574 .flags
= IORESOURCE_MEM
,
577 .start
= VIPER_USB_PHYS
+ 2,
578 .end
= VIPER_USB_PHYS
+ 3,
579 .flags
= IORESOURCE_MEM
,
582 .start
= gpio_to_irq(VIPER_USB_GPIO
),
583 .end
= gpio_to_irq(VIPER_USB_GPIO
),
584 .flags
= IORESOURCE_IRQ
| IORESOURCE_IRQ_HIGHEDGE
,
588 /* (DataBusWidth16|AnalogOCEnable|DREQOutputPolarity|DownstreamPort15KRSel ) */
589 static struct isp116x_platform_data isp116x_platform_data
= {
590 /* Enable internal resistors on downstream ports */
592 /* On-chip overcurrent protection */
594 /* INT output polarity */
596 /* INT edge or level triggered */
597 .int_edge_triggered
= 0,
599 /* WAKEUP pin connected - NOT SUPPORTED */
600 /* .remote_wakeup_connected = 0, */
601 /* Wakeup by devices on usb bus enabled */
602 .remote_wakeup_enable
= 0,
603 .delay
= isp116x_delay
,
606 static struct platform_device isp116x_device
= {
607 .name
= "isp116x-hcd",
609 .num_resources
= ARRAY_SIZE(isp116x_resources
),
610 .resource
= isp116x_resources
,
612 .platform_data
= &isp116x_platform_data
,
618 static struct resource mtd_resources
[] = {
619 [0] = { /* RedBoot config + filesystem flash */
620 .start
= VIPER_FLASH_PHYS
,
621 .end
= VIPER_FLASH_PHYS
+ SZ_32M
- 1,
622 .flags
= IORESOURCE_MEM
,
624 [1] = { /* Boot flash */
625 .start
= VIPER_BOOT_PHYS
,
626 .end
= VIPER_BOOT_PHYS
+ SZ_1M
- 1,
627 .flags
= IORESOURCE_MEM
,
630 * SRAM size is actually 256KB, 8bits, with a sparse mapping
631 * (each byte is on a 16bit boundary).
633 .start
= _VIPER_SRAM_BASE
,
634 .end
= _VIPER_SRAM_BASE
+ SZ_512K
- 1,
635 .flags
= IORESOURCE_MEM
,
639 static struct mtd_partition viper_boot_flash_partition
= {
643 .mask_flags
= MTD_WRITEABLE
, /* force R/O */
646 static struct physmap_flash_data viper_flash_data
[] = {
654 .parts
= &viper_boot_flash_partition
,
659 static struct platform_device viper_mtd_devices
[] = {
661 .name
= "physmap-flash",
664 .platform_data
= &viper_flash_data
[0],
666 .resource
= &mtd_resources
[0],
670 .name
= "physmap-flash",
673 .platform_data
= &viper_flash_data
[1],
675 .resource
= &mtd_resources
[1],
680 static struct platform_device
*viper_devs
[] __initdata
= {
685 &viper_mtd_devices
[0],
686 &viper_mtd_devices
[1],
687 &viper_backlight_device
,
690 static mfp_cfg_t viper_pin_config
[] __initdata
= {
699 GPIO9_GPIO
, /* VIPER_BCKLIGHT_EN_GPIO */
700 GPIO10_GPIO
, /* VIPER_LCD_EN_GPIO */
703 /* Ethernet PHY Ready */
706 /* Serial shutdown */
707 GPIO12_GPIO
| MFP_LPM_DRIVE_HIGH
, /* VIPER_UART_SHDN_GPIO */
709 /* Compact-Flash / PC104 */
720 GPIO8_GPIO
, /* VIPER_CF_RDY_GPIO */
721 GPIO32_GPIO
, /* VIPER_CF_CD_GPIO */
722 GPIO82_GPIO
, /* VIPER_CF_POWER_GPIO */
724 /* Integrated UPS control */
725 GPIO20_GPIO
, /* VIPER_UPS_GPIO */
727 /* Vcc regulator control */
728 GPIO6_GPIO
, /* VIPER_PSU_DATA_GPIO */
729 GPIO11_GPIO
, /* VIPER_PSU_CLK_GPIO */
730 GPIO19_GPIO
, /* VIPER_PSU_nCS_LD_GPIO */
733 GPIO26_GPIO
, /* VIPER_TPM_I2C_SDA_GPIO */
734 GPIO27_GPIO
, /* VIPER_TPM_I2C_SCL_GPIO */
735 GPIO83_GPIO
, /* VIPER_RTC_I2C_SDA_GPIO */
736 GPIO84_GPIO
, /* VIPER_RTC_I2C_SCL_GPIO */
738 /* PC/104 Interrupt */
739 GPIO1_GPIO
| WAKEUP_ON_EDGE_RISE
, /* VIPER_CPLD_GPIO */
742 static unsigned long viper_tpm
;
744 static int __init
viper_tpm_setup(char *str
)
746 strict_strtoul(str
, 10, &viper_tpm
);
750 __setup("tpm=", viper_tpm_setup
);
752 static void __init
viper_tpm_init(void)
754 struct platform_device
*tpm_device
;
755 struct i2c_gpio_platform_data i2c_tpm_data
= {
756 .sda_pin
= VIPER_TPM_I2C_SDA_GPIO
,
757 .scl_pin
= VIPER_TPM_I2C_SCL_GPIO
,
763 /* Allocate TPM i2c bus if requested */
767 tpm_device
= platform_device_alloc("i2c-gpio", 2);
769 if (!platform_device_add_data(tpm_device
,
771 sizeof(i2c_tpm_data
))) {
772 if (platform_device_add(tpm_device
)) {
773 errstr
= "register TPM i2c bus";
777 errstr
= "allocate TPM i2c bus data";
781 errstr
= "allocate TPM i2c device";
790 pr_err("viper: Couldn't %s, giving up\n", errstr
);
793 static void __init
viper_init_vcore_gpios(void)
795 if (gpio_request(VIPER_PSU_DATA_GPIO
, "PSU data"))
796 goto err_request_data
;
798 if (gpio_request(VIPER_PSU_CLK_GPIO
, "PSU clock"))
799 goto err_request_clk
;
801 if (gpio_request(VIPER_PSU_nCS_LD_GPIO
, "PSU cs"))
804 if (gpio_direction_output(VIPER_PSU_DATA_GPIO
, 0) ||
805 gpio_direction_output(VIPER_PSU_CLK_GPIO
, 0) ||
806 gpio_direction_output(VIPER_PSU_nCS_LD_GPIO
, 0))
809 /* c/should assume redboot set the correct level ??? */
810 viper_set_core_cpu_voltage(get_clk_frequency_khz(0), 1);
815 gpio_free(VIPER_PSU_nCS_LD_GPIO
);
817 gpio_free(VIPER_PSU_CLK_GPIO
);
819 gpio_free(VIPER_PSU_DATA_GPIO
);
821 pr_err("viper: Failed to setup vcore control GPIOs\n");
824 static void __init
viper_init_serial_gpio(void)
826 if (gpio_request(VIPER_UART_SHDN_GPIO
, "UARTs shutdown"))
829 if (gpio_direction_output(VIPER_UART_SHDN_GPIO
, 0))
835 gpio_free(VIPER_UART_SHDN_GPIO
);
837 pr_err("viper: Failed to setup UART shutdown GPIO\n");
840 #ifdef CONFIG_CPU_FREQ
841 static int viper_cpufreq_notifier(struct notifier_block
*nb
,
842 unsigned long val
, void *data
)
844 struct cpufreq_freqs
*freq
= data
;
846 /* TODO: Adjust timings??? */
849 case CPUFREQ_PRECHANGE
:
850 if (freq
->old
< freq
->new) {
851 /* we are getting faster so raise the voltage
852 * before we change freq */
853 viper_set_core_cpu_voltage(freq
->new, 0);
856 case CPUFREQ_POSTCHANGE
:
857 if (freq
->old
> freq
->new) {
858 /* we are slowing down so drop the power
859 * after we change freq */
860 viper_set_core_cpu_voltage(freq
->new, 0);
863 case CPUFREQ_RESUMECHANGE
:
864 viper_set_core_cpu_voltage(freq
->new, 0);
874 static struct notifier_block viper_cpufreq_notifier_block
= {
875 .notifier_call
= viper_cpufreq_notifier
878 static void __init
viper_init_cpufreq(void)
880 if (cpufreq_register_notifier(&viper_cpufreq_notifier_block
,
881 CPUFREQ_TRANSITION_NOTIFIER
))
882 pr_err("viper: Failed to setup cpufreq notifier\n");
885 static inline void viper_init_cpufreq(void) {}
888 static void viper_power_off(void)
890 pr_notice("Shutting off UPS\n");
891 gpio_set_value(VIPER_UPS_GPIO
, 1);
892 /* Spin to death... */
896 static void __init
viper_init(void)
900 pm_power_off
= viper_power_off
;
902 pxa2xx_mfp_config(ARRAY_AND_SIZE(viper_pin_config
));
904 pxa_set_ffuart_info(NULL
);
905 pxa_set_btuart_info(NULL
);
906 pxa_set_stuart_info(NULL
);
908 /* Wake-up serial console */
909 viper_init_serial_gpio();
911 set_pxa_fb_info(&fb_info
);
913 /* v1 hardware cannot use the datacs line */
914 version
= viper_hw_version();
916 smc91x_device
.num_resources
--;
918 pxa_set_i2c_info(NULL
);
919 platform_add_devices(viper_devs
, ARRAY_SIZE(viper_devs
));
921 viper_init_vcore_gpios();
922 viper_init_cpufreq();
924 sysdev_driver_register(&cpu_sysdev_class
, &viper_cpu_sysdev_driver
);
927 pr_info("viper: hardware v%di%d detected. "
928 "CPLD revision %d.\n",
929 VIPER_BOARD_VERSION(version
),
930 VIPER_BOARD_ISSUE(version
),
931 VIPER_CPLD_REVISION(version
));
932 system_rev
= (VIPER_BOARD_VERSION(version
) << 8) |
933 (VIPER_BOARD_ISSUE(version
) << 4) |
934 VIPER_CPLD_REVISION(version
);
936 pr_info("viper: No version register.\n");
939 i2c_register_board_info(1, ARRAY_AND_SIZE(viper_i2c_devices
));
942 pxa_set_ac97_info(NULL
);
945 static struct map_desc viper_io_desc
[] __initdata
= {
947 .virtual = VIPER_CPLD_BASE
,
948 .pfn
= __phys_to_pfn(VIPER_CPLD_PHYS
),
949 .length
= 0x00300000,
953 .virtual = VIPER_PC104IO_BASE
,
954 .pfn
= __phys_to_pfn(0x30000000),
955 .length
= 0x00800000,
960 static void __init
viper_map_io(void)
964 iotable_init(viper_io_desc
, ARRAY_SIZE(viper_io_desc
));
969 MACHINE_START(VIPER
, "Arcom/Eurotech VIPER SBC")
970 /* Maintainer: Marc Zyngier <maz@misterjones.org> */
971 .phys_io
= 0x40000000,
972 .io_pg_offst
= (io_p2v(0x40000000) >> 18) & 0xfffc,
973 .boot_params
= 0xa0000100,
974 .map_io
= viper_map_io
,
975 .init_irq
= viper_init_irq
,
977 .init_machine
= viper_init
,