projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge git://git.infradead.org/users/eparis/audit
[deliverable/linux.git] / arch / arm / mach-ep93xx / core.c
1 /*
2 * arch/arm/mach-ep93xx/core.c
3 * Core routines for Cirrus EP93xx chips.
4 *
5 * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
6 * Copyright (C) 2007 Herbert Valerio Riedel <hvr@gnu.org>
7 *
8 * Thanks go to Michael Burian and Ray Lehtiniemi for their key
9 * role in the ep93xx linux community.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or (at
14 * your option) any later version.
15 */
16
17 #define pr_fmt(fmt) "ep93xx " KBUILD_MODNAME ": " fmt
18
19 #include <linux/kernel.h>
20 #include <linux/init.h>
21 #include <linux/platform_device.h>
22 #include <linux/interrupt.h>
23 #include <linux/dma-mapping.h>
24 #include <linux/timex.h>
25 #include <linux/irq.h>
26 #include <linux/io.h>
27 #include <linux/gpio.h>
28 #include <linux/leds.h>
29 #include <linux/termios.h>
30 #include <linux/amba/bus.h>
31 #include <linux/amba/serial.h>
32 #include <linux/mtd/physmap.h>
33 #include <linux/i2c.h>
34 #include <linux/i2c-gpio.h>
35 #include <linux/spi/spi.h>
36 #include <linux/export.h>
37 #include <linux/irqchip/arm-vic.h>
38 #include <linux/reboot.h>
39 #include <linux/usb/ohci_pdriver.h>
40
41 #include <mach/hardware.h>
42 #include <linux/platform_data/video-ep93xx.h>
43 #include <linux/platform_data/keypad-ep93xx.h>
44 #include <linux/platform_data/spi-ep93xx.h>
45 #include <mach/gpio-ep93xx.h>
46
47 #include <asm/mach/map.h>
48 #include <asm/mach/time.h>
49
50 #include "soc.h"
51
52 /*************************************************************************
53 * Static I/O mappings that are needed for all EP93xx platforms
54 *************************************************************************/
55 static struct map_desc ep93xx_io_desc[] __initdata = {
56 {
57 .virtual = EP93XX_AHB_VIRT_BASE,
58 .pfn = __phys_to_pfn(EP93XX_AHB_PHYS_BASE),
59 .length = EP93XX_AHB_SIZE,
60 .type = MT_DEVICE,
61 }, {
62 .virtual = EP93XX_APB_VIRT_BASE,
63 .pfn = __phys_to_pfn(EP93XX_APB_PHYS_BASE),
64 .length = EP93XX_APB_SIZE,
65 .type = MT_DEVICE,
66 },
67 };
68
69 void __init ep93xx_map_io(void)
70 {
71 iotable_init(ep93xx_io_desc, ARRAY_SIZE(ep93xx_io_desc));
72 }
73
74
75 /*************************************************************************
76 * Timer handling for EP93xx
77 *************************************************************************
78 * The ep93xx has four internal timers. Timers 1, 2 (both 16 bit) and
79 * 3 (32 bit) count down at 508 kHz, are self-reloading, and can generate
80 * an interrupt on underflow. Timer 4 (40 bit) counts down at 983.04 kHz,
81 * is free-running, and can't generate interrupts.
82 *
83 * The 508 kHz timers are ideal for use for the timer interrupt, as the
84 * most common values of HZ divide 508 kHz nicely. We pick one of the 16
85 * bit timers (timer 1) since we don't need more than 16 bits of reload
86 * value as long as HZ >= 8.
87 *
88 * The higher clock rate of timer 4 makes it a better choice than the
89 * other timers for use in gettimeoffset(), while the fact that it can't
90 * generate interrupts means we don't have to worry about not being able
91 * to use this timer for something else. We also use timer 4 for keeping
92 * track of lost jiffies.
93 */
94 #define EP93XX_TIMER_REG(x) (EP93XX_TIMER_BASE + (x))
95 #define EP93XX_TIMER1_LOAD EP93XX_TIMER_REG(0x00)
96 #define EP93XX_TIMER1_VALUE EP93XX_TIMER_REG(0x04)
97 #define EP93XX_TIMER1_CONTROL EP93XX_TIMER_REG(0x08)
98 #define EP93XX_TIMER123_CONTROL_ENABLE (1 << 7)
99 #define EP93XX_TIMER123_CONTROL_MODE (1 << 6)
100 #define EP93XX_TIMER123_CONTROL_CLKSEL (1 << 3)
101 #define EP93XX_TIMER1_CLEAR EP93XX_TIMER_REG(0x0c)
102 #define EP93XX_TIMER2_LOAD EP93XX_TIMER_REG(0x20)
103 #define EP93XX_TIMER2_VALUE EP93XX_TIMER_REG(0x24)
104 #define EP93XX_TIMER2_CONTROL EP93XX_TIMER_REG(0x28)
105 #define EP93XX_TIMER2_CLEAR EP93XX_TIMER_REG(0x2c)
106 #define EP93XX_TIMER4_VALUE_LOW EP93XX_TIMER_REG(0x60)
107 #define EP93XX_TIMER4_VALUE_HIGH EP93XX_TIMER_REG(0x64)
108 #define EP93XX_TIMER4_VALUE_HIGH_ENABLE (1 << 8)
109 #define EP93XX_TIMER3_LOAD EP93XX_TIMER_REG(0x80)
110 #define EP93XX_TIMER3_VALUE EP93XX_TIMER_REG(0x84)
111 #define EP93XX_TIMER3_CONTROL EP93XX_TIMER_REG(0x88)
112 #define EP93XX_TIMER3_CLEAR EP93XX_TIMER_REG(0x8c)
113
114 #define EP93XX_TIMER123_CLOCK 508469
115 #define EP93XX_TIMER4_CLOCK 983040
116
117 #define TIMER1_RELOAD ((EP93XX_TIMER123_CLOCK / HZ) - 1)
118 #define TIMER4_TICKS_PER_JIFFY DIV_ROUND_CLOSEST(CLOCK_TICK_RATE, HZ)
119
120 static unsigned int last_jiffy_time;
121
122 static irqreturn_t ep93xx_timer_interrupt(int irq, void *dev_id)
123 {
124 /* Writing any value clears the timer interrupt */
125 __raw_writel(1, EP93XX_TIMER1_CLEAR);
126
127 /* Recover lost jiffies */
128 while ((signed long)
129 (__raw_readl(EP93XX_TIMER4_VALUE_LOW) - last_jiffy_time)
130 >= TIMER4_TICKS_PER_JIFFY) {
131 last_jiffy_time += TIMER4_TICKS_PER_JIFFY;
132 timer_tick();
133 }
134
135 return IRQ_HANDLED;
136 }
137
138 static struct irqaction ep93xx_timer_irq = {
139 .name = "ep93xx timer",
140 .flags = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL,
141 .handler = ep93xx_timer_interrupt,
142 };
143
144 static u32 ep93xx_gettimeoffset(void)
145 {
146 int offset;
147
148 offset = __raw_readl(EP93XX_TIMER4_VALUE_LOW) - last_jiffy_time;
149
150 /*
151 * Timer 4 is based on a 983.04 kHz reference clock,
152 * so dividing by 983040 gives the fraction of a second,
153 * so dividing by 0.983040 converts to uS.
154 * Refactor the calculation to avoid overflow.
155 * Finally, multiply by 1000 to give nS.
156 */
157 return (offset + (53 * offset / 3072)) * 1000;
158 }
159
160 void __init ep93xx_timer_init(void)
161 {
162 u32 tmode = EP93XX_TIMER123_CONTROL_MODE |
163 EP93XX_TIMER123_CONTROL_CLKSEL;
164
165 arch_gettimeoffset = ep93xx_gettimeoffset;
166
167 /* Enable periodic HZ timer. */
168 __raw_writel(tmode, EP93XX_TIMER1_CONTROL);
169 __raw_writel(TIMER1_RELOAD, EP93XX_TIMER1_LOAD);
170 __raw_writel(tmode | EP93XX_TIMER123_CONTROL_ENABLE,
171 EP93XX_TIMER1_CONTROL);
172
173 /* Enable lost jiffy timer. */
174 __raw_writel(EP93XX_TIMER4_VALUE_HIGH_ENABLE,
175 EP93XX_TIMER4_VALUE_HIGH);
176
177 setup_irq(IRQ_EP93XX_TIMER1, &ep93xx_timer_irq);
178 }
179
180
181 /*************************************************************************
182 * EP93xx IRQ handling
183 *************************************************************************/
184 void __init ep93xx_init_irq(void)
185 {
186 vic_init(EP93XX_VIC1_BASE, 0, EP93XX_VIC1_VALID_IRQ_MASK, 0);
187 vic_init(EP93XX_VIC2_BASE, 32, EP93XX_VIC2_VALID_IRQ_MASK, 0);
188 }
189
190
191 /*************************************************************************
192 * EP93xx System Controller Software Locked register handling
193 *************************************************************************/
194
195 /*
196 * syscon_swlock prevents anything else from writing to the syscon
197 * block while a software locked register is being written.
198 */
199 static DEFINE_SPINLOCK(syscon_swlock);
200
201 void ep93xx_syscon_swlocked_write(unsigned int val, void __iomem *reg)
202 {
203 unsigned long flags;
204
205 spin_lock_irqsave(&syscon_swlock, flags);
206
207 __raw_writel(0xaa, EP93XX_SYSCON_SWLOCK);
208 __raw_writel(val, reg);
209
210 spin_unlock_irqrestore(&syscon_swlock, flags);
211 }
212
213 void ep93xx_devcfg_set_clear(unsigned int set_bits, unsigned int clear_bits)
214 {
215 unsigned long flags;
216 unsigned int val;
217
218 spin_lock_irqsave(&syscon_swlock, flags);
219
220 val = __raw_readl(EP93XX_SYSCON_DEVCFG);
221 val &= ~clear_bits;
222 val |= set_bits;
223 __raw_writel(0xaa, EP93XX_SYSCON_SWLOCK);
224 __raw_writel(val, EP93XX_SYSCON_DEVCFG);
225
226 spin_unlock_irqrestore(&syscon_swlock, flags);
227 }
228
229 /**
230 * ep93xx_chip_revision() - returns the EP93xx chip revision
231 *
232 * See <mach/platform.h> for more information.
233 */
234 unsigned int ep93xx_chip_revision(void)
235 {
236 unsigned int v;
237
238 v = __raw_readl(EP93XX_SYSCON_SYSCFG);
239 v &= EP93XX_SYSCON_SYSCFG_REV_MASK;
240 v >>= EP93XX_SYSCON_SYSCFG_REV_SHIFT;
241 return v;
242 }
243
244 /*************************************************************************
245 * EP93xx GPIO
246 *************************************************************************/
247 static struct resource ep93xx_gpio_resource[] = {
248 DEFINE_RES_MEM(EP93XX_GPIO_PHYS_BASE, 0xcc),
249 };
250
251 static struct platform_device ep93xx_gpio_device = {
252 .name = "gpio-ep93xx",
253 .id = -1,
254 .num_resources = ARRAY_SIZE(ep93xx_gpio_resource),
255 .resource = ep93xx_gpio_resource,
256 };
257
258 /*************************************************************************
259 * EP93xx peripheral handling
260 *************************************************************************/
261 #define EP93XX_UART_MCR_OFFSET (0x0100)
262
263 static void ep93xx_uart_set_mctrl(struct amba_device *dev,
264 void __iomem *base, unsigned int mctrl)
265 {
266 unsigned int mcr;
267
268 mcr = 0;
269 if (mctrl & TIOCM_RTS)
270 mcr |= 2;
271 if (mctrl & TIOCM_DTR)
272 mcr |= 1;
273
274 __raw_writel(mcr, base + EP93XX_UART_MCR_OFFSET);
275 }
276
277 static struct amba_pl010_data ep93xx_uart_data = {
278 .set_mctrl = ep93xx_uart_set_mctrl,
279 };
280
281 static AMBA_APB_DEVICE(uart1, "apb:uart1", 0x00041010, EP93XX_UART1_PHYS_BASE,
282 { IRQ_EP93XX_UART1 }, &ep93xx_uart_data);
283
284 static AMBA_APB_DEVICE(uart2, "apb:uart2", 0x00041010, EP93XX_UART2_PHYS_BASE,
285 { IRQ_EP93XX_UART2 }, NULL);
286
287 static AMBA_APB_DEVICE(uart3, "apb:uart3", 0x00041010, EP93XX_UART3_PHYS_BASE,
288 { IRQ_EP93XX_UART3 }, &ep93xx_uart_data);
289
290 static struct resource ep93xx_rtc_resource[] = {
291 DEFINE_RES_MEM(EP93XX_RTC_PHYS_BASE, 0x10c),
292 };
293
294 static struct platform_device ep93xx_rtc_device = {
295 .name = "ep93xx-rtc",
296 .id = -1,
297 .num_resources = ARRAY_SIZE(ep93xx_rtc_resource),
298 .resource = ep93xx_rtc_resource,
299 };
300
301 /*************************************************************************
302 * EP93xx OHCI USB Host
303 *************************************************************************/
304
305 static struct clk *ep93xx_ohci_host_clock;
306
307 static int ep93xx_ohci_power_on(struct platform_device *pdev)
308 {
309 if (!ep93xx_ohci_host_clock) {
310 ep93xx_ohci_host_clock = devm_clk_get(&pdev->dev, NULL);
311 if (IS_ERR(ep93xx_ohci_host_clock))
312 return PTR_ERR(ep93xx_ohci_host_clock);
313 }
314
315 return clk_enable(ep93xx_ohci_host_clock);
316 }
317
318 static void ep93xx_ohci_power_off(struct platform_device *pdev)
319 {
320 clk_disable(ep93xx_ohci_host_clock);
321 }
322
323 static struct usb_ohci_pdata ep93xx_ohci_pdata = {
324 .power_on = ep93xx_ohci_power_on,
325 .power_off = ep93xx_ohci_power_off,
326 .power_suspend = ep93xx_ohci_power_off,
327 };
328
329 static struct resource ep93xx_ohci_resources[] = {
330 DEFINE_RES_MEM(EP93XX_USB_PHYS_BASE, 0x1000),
331 DEFINE_RES_IRQ(IRQ_EP93XX_USB),
332 };
333
334 static u64 ep93xx_ohci_dma_mask = DMA_BIT_MASK(32);
335
336 static struct platform_device ep93xx_ohci_device = {
337 .name = "ohci-platform",
338 .id = -1,
339 .num_resources = ARRAY_SIZE(ep93xx_ohci_resources),
340 .resource = ep93xx_ohci_resources,
341 .dev = {
342 .dma_mask = &ep93xx_ohci_dma_mask,
343 .coherent_dma_mask = DMA_BIT_MASK(32),
344 .platform_data = &ep93xx_ohci_pdata,
345 },
346 };
347
348 /*************************************************************************
349 * EP93xx physmap'ed flash
350 *************************************************************************/
351 static struct physmap_flash_data ep93xx_flash_data;
352
353 static struct resource ep93xx_flash_resource = {
354 .flags = IORESOURCE_MEM,
355 };
356
357 static struct platform_device ep93xx_flash = {
358 .name = "physmap-flash",
359 .id = 0,
360 .dev = {
361 .platform_data = &ep93xx_flash_data,
362 },
363 .num_resources = 1,
364 .resource = &ep93xx_flash_resource,
365 };
366
367 /**
368 * ep93xx_register_flash() - Register the external flash device.
369 * @width: bank width in octets
370 * @start: resource start address
371 * @size: resource size
372 */
373 void __init ep93xx_register_flash(unsigned int width,
374 resource_size_t start, resource_size_t size)
375 {
376 ep93xx_flash_data.width = width;
377
378 ep93xx_flash_resource.start = start;
379 ep93xx_flash_resource.end = start + size - 1;
380
381 platform_device_register(&ep93xx_flash);
382 }
383
384
385 /*************************************************************************
386 * EP93xx ethernet peripheral handling
387 *************************************************************************/
388 static struct ep93xx_eth_data ep93xx_eth_data;
389
390 static struct resource ep93xx_eth_resource[] = {
391 DEFINE_RES_MEM(EP93XX_ETHERNET_PHYS_BASE, 0x10000),
392 DEFINE_RES_IRQ(IRQ_EP93XX_ETHERNET),
393 };
394
395 static u64 ep93xx_eth_dma_mask = DMA_BIT_MASK(32);
396
397 static struct platform_device ep93xx_eth_device = {
398 .name = "ep93xx-eth",
399 .id = -1,
400 .dev = {
401 .platform_data = &ep93xx_eth_data,
402 .coherent_dma_mask = DMA_BIT_MASK(32),
403 .dma_mask = &ep93xx_eth_dma_mask,
404 },
405 .num_resources = ARRAY_SIZE(ep93xx_eth_resource),
406 .resource = ep93xx_eth_resource,
407 };
408
409 /**
410 * ep93xx_register_eth - Register the built-in ethernet platform device.
411 * @data: platform specific ethernet configuration (__initdata)
412 * @copy_addr: flag indicating that the MAC address should be copied
413 * from the IndAd registers (as programmed by the bootloader)
414 */
415 void __init ep93xx_register_eth(struct ep93xx_eth_data *data, int copy_addr)
416 {
417 if (copy_addr)
418 memcpy_fromio(data->dev_addr, EP93XX_ETHERNET_BASE + 0x50, 6);
419
420 ep93xx_eth_data = *data;
421 platform_device_register(&ep93xx_eth_device);
422 }
423
424
425 /*************************************************************************
426 * EP93xx i2c peripheral handling
427 *************************************************************************/
428 static struct i2c_gpio_platform_data ep93xx_i2c_data;
429
430 static struct platform_device ep93xx_i2c_device = {
431 .name = "i2c-gpio",
432 .id = 0,
433 .dev = {
434 .platform_data = &ep93xx_i2c_data,
435 },
436 };
437
438 /**
439 * ep93xx_register_i2c - Register the i2c platform device.
440 * @data: platform specific i2c-gpio configuration (__initdata)
441 * @devices: platform specific i2c bus device information (__initdata)
442 * @num: the number of devices on the i2c bus
443 */
444 void __init ep93xx_register_i2c(struct i2c_gpio_platform_data *data,
445 struct i2c_board_info *devices, int num)
446 {
447 /*
448 * Set the EEPROM interface pin drive type control.
449 * Defines the driver type for the EECLK and EEDAT pins as either
450 * open drain, which will require an external pull-up, or a normal
451 * CMOS driver.
452 */
453 if (data->sda_is_open_drain && data->sda_pin != EP93XX_GPIO_LINE_EEDAT)
454 pr_warning("sda != EEDAT, open drain has no effect\n");
455 if (data->scl_is_open_drain && data->scl_pin != EP93XX_GPIO_LINE_EECLK)
456 pr_warning("scl != EECLK, open drain has no effect\n");
457
458 __raw_writel((data->sda_is_open_drain << 1) |
459 (data->scl_is_open_drain << 0),
460 EP93XX_GPIO_EEDRIVE);
461
462 ep93xx_i2c_data = *data;
463 i2c_register_board_info(0, devices, num);
464 platform_device_register(&ep93xx_i2c_device);
465 }
466
467 /*************************************************************************
468 * EP93xx SPI peripheral handling
469 *************************************************************************/
470 static struct ep93xx_spi_info ep93xx_spi_master_data;
471
472 static struct resource ep93xx_spi_resources[] = {
473 DEFINE_RES_MEM(EP93XX_SPI_PHYS_BASE, 0x18),
474 DEFINE_RES_IRQ(IRQ_EP93XX_SSP),
475 };
476
477 static u64 ep93xx_spi_dma_mask = DMA_BIT_MASK(32);
478
479 static struct platform_device ep93xx_spi_device = {
480 .name = "ep93xx-spi",
481 .id = 0,
482 .dev = {
483 .platform_data = &ep93xx_spi_master_data,
484 .coherent_dma_mask = DMA_BIT_MASK(32),
485 .dma_mask = &ep93xx_spi_dma_mask,
486 },
487 .num_resources = ARRAY_SIZE(ep93xx_spi_resources),
488 .resource = ep93xx_spi_resources,
489 };
490
491 /**
492 * ep93xx_register_spi() - registers spi platform device
493 * @info: ep93xx board specific spi master info (__initdata)
494 * @devices: SPI devices to register (__initdata)
495 * @num: number of SPI devices to register
496 *
497 * This function registers platform device for the EP93xx SPI controller and
498 * also makes sure that SPI pins are muxed so that I2S is not using those pins.
499 */
500 void __init ep93xx_register_spi(struct ep93xx_spi_info *info,
501 struct spi_board_info *devices, int num)
502 {
503 /*
504 * When SPI is used, we need to make sure that I2S is muxed off from
505 * SPI pins.
506 */
507 ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_I2SONSSP);
508
509 ep93xx_spi_master_data = *info;
510 spi_register_board_info(devices, num);
511 platform_device_register(&ep93xx_spi_device);
512 }
513
514 /*************************************************************************
515 * EP93xx LEDs
516 *************************************************************************/
517 static const struct gpio_led ep93xx_led_pins[] __initconst = {
518 {
519 .name = "platform:grled",
520 .gpio = EP93XX_GPIO_LINE_GRLED,
521 }, {
522 .name = "platform:rdled",
523 .gpio = EP93XX_GPIO_LINE_RDLED,
524 },
525 };
526
527 static const struct gpio_led_platform_data ep93xx_led_data __initconst = {
528 .num_leds = ARRAY_SIZE(ep93xx_led_pins),
529 .leds = ep93xx_led_pins,
530 };
531
532 /*************************************************************************
533 * EP93xx pwm peripheral handling
534 *************************************************************************/
535 static struct resource ep93xx_pwm0_resource[] = {
536 DEFINE_RES_MEM(EP93XX_PWM_PHYS_BASE, 0x10),
537 };
538
539 static struct platform_device ep93xx_pwm0_device = {
540 .name = "ep93xx-pwm",
541 .id = 0,
542 .num_resources = ARRAY_SIZE(ep93xx_pwm0_resource),
543 .resource = ep93xx_pwm0_resource,
544 };
545
546 static struct resource ep93xx_pwm1_resource[] = {
547 DEFINE_RES_MEM(EP93XX_PWM_PHYS_BASE + 0x20, 0x10),
548 };
549
550 static struct platform_device ep93xx_pwm1_device = {
551 .name = "ep93xx-pwm",
552 .id = 1,
553 .num_resources = ARRAY_SIZE(ep93xx_pwm1_resource),
554 .resource = ep93xx_pwm1_resource,
555 };
556
557 void __init ep93xx_register_pwm(int pwm0, int pwm1)
558 {
559 if (pwm0)
560 platform_device_register(&ep93xx_pwm0_device);
561
562 /* NOTE: EP9307 does not have PWMOUT1 (pin EGPIO14) */
563 if (pwm1)
564 platform_device_register(&ep93xx_pwm1_device);
565 }
566
567 int ep93xx_pwm_acquire_gpio(struct platform_device *pdev)
568 {
569 int err;
570
571 if (pdev->id == 0) {
572 err = 0;
573 } else if (pdev->id == 1) {
574 err = gpio_request(EP93XX_GPIO_LINE_EGPIO14,
575 dev_name(&pdev->dev));
576 if (err)
577 return err;
578 err = gpio_direction_output(EP93XX_GPIO_LINE_EGPIO14, 0);
579 if (err)
580 goto fail;
581
582 /* PWM 1 output on EGPIO[14] */
583 ep93xx_devcfg_set_bits(EP93XX_SYSCON_DEVCFG_PONG);
584 } else {
585 err = -ENODEV;
586 }
587
588 return err;
589
590 fail:
591 gpio_free(EP93XX_GPIO_LINE_EGPIO14);
592 return err;
593 }
594 EXPORT_SYMBOL(ep93xx_pwm_acquire_gpio);
595
596 void ep93xx_pwm_release_gpio(struct platform_device *pdev)
597 {
598 if (pdev->id == 1) {
599 gpio_direction_input(EP93XX_GPIO_LINE_EGPIO14);
600 gpio_free(EP93XX_GPIO_LINE_EGPIO14);
601
602 /* EGPIO[14] used for GPIO */
603 ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_PONG);
604 }
605 }
606 EXPORT_SYMBOL(ep93xx_pwm_release_gpio);
607
608
609 /*************************************************************************
610 * EP93xx video peripheral handling
611 *************************************************************************/
612 static struct ep93xxfb_mach_info ep93xxfb_data;
613
614 static struct resource ep93xx_fb_resource[] = {
615 DEFINE_RES_MEM(EP93XX_RASTER_PHYS_BASE, 0x800),
616 };
617
618 static struct platform_device ep93xx_fb_device = {
619 .name = "ep93xx-fb",
620 .id = -1,
621 .dev = {
622 .platform_data = &ep93xxfb_data,
623 .coherent_dma_mask = DMA_BIT_MASK(32),
624 .dma_mask = &ep93xx_fb_device.dev.coherent_dma_mask,
625 },
626 .num_resources = ARRAY_SIZE(ep93xx_fb_resource),
627 .resource = ep93xx_fb_resource,
628 };
629
630 /* The backlight use a single register in the framebuffer's register space */
631 #define EP93XX_RASTER_REG_BRIGHTNESS 0x20
632
633 static struct resource ep93xx_bl_resources[] = {
634 DEFINE_RES_MEM(EP93XX_RASTER_PHYS_BASE +
635 EP93XX_RASTER_REG_BRIGHTNESS, 0x04),
636 };
637
638 static struct platform_device ep93xx_bl_device = {
639 .name = "ep93xx-bl",
640 .id = -1,
641 .num_resources = ARRAY_SIZE(ep93xx_bl_resources),
642 .resource = ep93xx_bl_resources,
643 };
644
645 /**
646 * ep93xx_register_fb - Register the framebuffer platform device.
647 * @data: platform specific framebuffer configuration (__initdata)
648 */
649 void __init ep93xx_register_fb(struct ep93xxfb_mach_info *data)
650 {
651 ep93xxfb_data = *data;
652 platform_device_register(&ep93xx_fb_device);
653 platform_device_register(&ep93xx_bl_device);
654 }
655
656
657 /*************************************************************************
658 * EP93xx matrix keypad peripheral handling
659 *************************************************************************/
660 static struct ep93xx_keypad_platform_data ep93xx_keypad_data;
661
662 static struct resource ep93xx_keypad_resource[] = {
663 DEFINE_RES_MEM(EP93XX_KEY_MATRIX_PHYS_BASE, 0x0c),
664 DEFINE_RES_IRQ(IRQ_EP93XX_KEY),
665 };
666
667 static struct platform_device ep93xx_keypad_device = {
668 .name = "ep93xx-keypad",
669 .id = -1,
670 .dev = {
671 .platform_data = &ep93xx_keypad_data,
672 },
673 .num_resources = ARRAY_SIZE(ep93xx_keypad_resource),
674 .resource = ep93xx_keypad_resource,
675 };
676
677 /**
678 * ep93xx_register_keypad - Register the keypad platform device.
679 * @data: platform specific keypad configuration (__initdata)
680 */
681 void __init ep93xx_register_keypad(struct ep93xx_keypad_platform_data *data)
682 {
683 ep93xx_keypad_data = *data;
684 platform_device_register(&ep93xx_keypad_device);
685 }
686
687 int ep93xx_keypad_acquire_gpio(struct platform_device *pdev)
688 {
689 int err;
690 int i;
691
692 for (i = 0; i < 8; i++) {
693 err = gpio_request(EP93XX_GPIO_LINE_C(i), dev_name(&pdev->dev));
694 if (err)
695 goto fail_gpio_c;
696 err = gpio_request(EP93XX_GPIO_LINE_D(i), dev_name(&pdev->dev));
697 if (err)
698 goto fail_gpio_d;
699 }
700
701 /* Enable the keypad controller; GPIO ports C and D used for keypad */
702 ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_KEYS |
703 EP93XX_SYSCON_DEVCFG_GONK);
704
705 return 0;
706
707 fail_gpio_d:
708 gpio_free(EP93XX_GPIO_LINE_C(i));
709 fail_gpio_c:
710 for (--i; i >= 0; --i) {
711 gpio_free(EP93XX_GPIO_LINE_C(i));
712 gpio_free(EP93XX_GPIO_LINE_D(i));
713 }
714 return err;
715 }
716 EXPORT_SYMBOL(ep93xx_keypad_acquire_gpio);
717
718 void ep93xx_keypad_release_gpio(struct platform_device *pdev)
719 {
720 int i;
721
722 for (i = 0; i < 8; i++) {
723 gpio_free(EP93XX_GPIO_LINE_C(i));
724 gpio_free(EP93XX_GPIO_LINE_D(i));
725 }
726
727 /* Disable the keypad controller; GPIO ports C and D used for GPIO */
728 ep93xx_devcfg_set_bits(EP93XX_SYSCON_DEVCFG_KEYS |
729 EP93XX_SYSCON_DEVCFG_GONK);
730 }
731 EXPORT_SYMBOL(ep93xx_keypad_release_gpio);
732
733 /*************************************************************************
734 * EP93xx I2S audio peripheral handling
735 *************************************************************************/
736 static struct resource ep93xx_i2s_resource[] = {
737 DEFINE_RES_MEM(EP93XX_I2S_PHYS_BASE, 0x100),
738 };
739
740 static struct platform_device ep93xx_i2s_device = {
741 .name = "ep93xx-i2s",
742 .id = -1,
743 .num_resources = ARRAY_SIZE(ep93xx_i2s_resource),
744 .resource = ep93xx_i2s_resource,
745 };
746
747 static struct platform_device ep93xx_pcm_device = {
748 .name = "ep93xx-pcm-audio",
749 .id = -1,
750 };
751
752 void __init ep93xx_register_i2s(void)
753 {
754 platform_device_register(&ep93xx_i2s_device);
755 platform_device_register(&ep93xx_pcm_device);
756 }
757
758 #define EP93XX_SYSCON_DEVCFG_I2S_MASK (EP93XX_SYSCON_DEVCFG_I2SONSSP | \
759 EP93XX_SYSCON_DEVCFG_I2SONAC97)
760
761 #define EP93XX_I2SCLKDIV_MASK (EP93XX_SYSCON_I2SCLKDIV_ORIDE | \
762 EP93XX_SYSCON_I2SCLKDIV_SPOL)
763
764 int ep93xx_i2s_acquire(void)
765 {
766 unsigned val;
767
768 ep93xx_devcfg_set_clear(EP93XX_SYSCON_DEVCFG_I2SONAC97,
769 EP93XX_SYSCON_DEVCFG_I2S_MASK);
770
771 /*
772 * This is potentially racy with the clock api for i2s_mclk, sclk and
773 * lrclk. Since the i2s driver is the only user of those clocks we
774 * rely on it to prevent parallel use of this function and the
775 * clock api for the i2s clocks.
776 */
777 val = __raw_readl(EP93XX_SYSCON_I2SCLKDIV);
778 val &= ~EP93XX_I2SCLKDIV_MASK;
779 val |= EP93XX_SYSCON_I2SCLKDIV_ORIDE | EP93XX_SYSCON_I2SCLKDIV_SPOL;
780 ep93xx_syscon_swlocked_write(val, EP93XX_SYSCON_I2SCLKDIV);
781
782 return 0;
783 }
784 EXPORT_SYMBOL(ep93xx_i2s_acquire);
785
786 void ep93xx_i2s_release(void)
787 {
788 ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_I2S_MASK);
789 }
790 EXPORT_SYMBOL(ep93xx_i2s_release);
791
792 /*************************************************************************
793 * EP93xx AC97 audio peripheral handling
794 *************************************************************************/
795 static struct resource ep93xx_ac97_resources[] = {
796 DEFINE_RES_MEM(EP93XX_AAC_PHYS_BASE, 0xac),
797 DEFINE_RES_IRQ(IRQ_EP93XX_AACINTR),
798 };
799
800 static struct platform_device ep93xx_ac97_device = {
801 .name = "ep93xx-ac97",
802 .id = -1,
803 .num_resources = ARRAY_SIZE(ep93xx_ac97_resources),
804 .resource = ep93xx_ac97_resources,
805 };
806
807 void __init ep93xx_register_ac97(void)
808 {
809 /*
810 * Make sure that the AC97 pins are not used by I2S.
811 */
812 ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_I2SONAC97);
813
814 platform_device_register(&ep93xx_ac97_device);
815 platform_device_register(&ep93xx_pcm_device);
816 }
817
818 /*************************************************************************
819 * EP93xx Watchdog
820 *************************************************************************/
821 static struct resource ep93xx_wdt_resources[] = {
822 DEFINE_RES_MEM(EP93XX_WATCHDOG_PHYS_BASE, 0x08),
823 };
824
825 static struct platform_device ep93xx_wdt_device = {
826 .name = "ep93xx-wdt",
827 .id = -1,
828 .num_resources = ARRAY_SIZE(ep93xx_wdt_resources),
829 .resource = ep93xx_wdt_resources,
830 };
831
832 /*************************************************************************
833 * EP93xx IDE
834 *************************************************************************/
835 static struct resource ep93xx_ide_resources[] = {
836 DEFINE_RES_MEM(EP93XX_IDE_PHYS_BASE, 0x38),
837 DEFINE_RES_IRQ(IRQ_EP93XX_EXT3),
838 };
839
840 static struct platform_device ep93xx_ide_device = {
841 .name = "ep93xx-ide",
842 .id = -1,
843 .dev = {
844 .dma_mask = &ep93xx_ide_device.dev.coherent_dma_mask,
845 .coherent_dma_mask = DMA_BIT_MASK(32),
846 },
847 .num_resources = ARRAY_SIZE(ep93xx_ide_resources),
848 .resource = ep93xx_ide_resources,
849 };
850
851 void __init ep93xx_register_ide(void)
852 {
853 platform_device_register(&ep93xx_ide_device);
854 }
855
856 int ep93xx_ide_acquire_gpio(struct platform_device *pdev)
857 {
858 int err;
859 int i;
860
861 err = gpio_request(EP93XX_GPIO_LINE_EGPIO2, dev_name(&pdev->dev));
862 if (err)
863 return err;
864 err = gpio_request(EP93XX_GPIO_LINE_EGPIO15, dev_name(&pdev->dev));
865 if (err)
866 goto fail_egpio15;
867 for (i = 2; i < 8; i++) {
868 err = gpio_request(EP93XX_GPIO_LINE_E(i), dev_name(&pdev->dev));
869 if (err)
870 goto fail_gpio_e;
871 }
872 for (i = 4; i < 8; i++) {
873 err = gpio_request(EP93XX_GPIO_LINE_G(i), dev_name(&pdev->dev));
874 if (err)
875 goto fail_gpio_g;
876 }
877 for (i = 0; i < 8; i++) {
878 err = gpio_request(EP93XX_GPIO_LINE_H(i), dev_name(&pdev->dev));
879 if (err)
880 goto fail_gpio_h;
881 }
882
883 /* GPIO ports E[7:2], G[7:4] and H used by IDE */
884 ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_EONIDE |
885 EP93XX_SYSCON_DEVCFG_GONIDE |
886 EP93XX_SYSCON_DEVCFG_HONIDE);
887 return 0;
888
889 fail_gpio_h:
890 for (--i; i >= 0; --i)
891 gpio_free(EP93XX_GPIO_LINE_H(i));
892 i = 8;
893 fail_gpio_g:
894 for (--i; i >= 4; --i)
895 gpio_free(EP93XX_GPIO_LINE_G(i));
896 i = 8;
897 fail_gpio_e:
898 for (--i; i >= 2; --i)
899 gpio_free(EP93XX_GPIO_LINE_E(i));
900 gpio_free(EP93XX_GPIO_LINE_EGPIO15);
901 fail_egpio15:
902 gpio_free(EP93XX_GPIO_LINE_EGPIO2);
903 return err;
904 }
905 EXPORT_SYMBOL(ep93xx_ide_acquire_gpio);
906
907 void ep93xx_ide_release_gpio(struct platform_device *pdev)
908 {
909 int i;
910
911 for (i = 2; i < 8; i++)
912 gpio_free(EP93XX_GPIO_LINE_E(i));
913 for (i = 4; i < 8; i++)
914 gpio_free(EP93XX_GPIO_LINE_G(i));
915 for (i = 0; i < 8; i++)
916 gpio_free(EP93XX_GPIO_LINE_H(i));
917 gpio_free(EP93XX_GPIO_LINE_EGPIO15);
918 gpio_free(EP93XX_GPIO_LINE_EGPIO2);
919
920
921 /* GPIO ports E[7:2], G[7:4] and H used by GPIO */
922 ep93xx_devcfg_set_bits(EP93XX_SYSCON_DEVCFG_EONIDE |
923 EP93XX_SYSCON_DEVCFG_GONIDE |
924 EP93XX_SYSCON_DEVCFG_HONIDE);
925 }
926 EXPORT_SYMBOL(ep93xx_ide_release_gpio);
927
928 void __init ep93xx_init_devices(void)
929 {
930 /* Disallow access to MaverickCrunch initially */
931 ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_CPENA);
932
933 /* Default all ports to GPIO */
934 ep93xx_devcfg_set_bits(EP93XX_SYSCON_DEVCFG_KEYS |
935 EP93XX_SYSCON_DEVCFG_GONK |
936 EP93XX_SYSCON_DEVCFG_EONIDE |
937 EP93XX_SYSCON_DEVCFG_GONIDE |
938 EP93XX_SYSCON_DEVCFG_HONIDE);
939
940 /* Get the GPIO working early, other devices need it */
941 platform_device_register(&ep93xx_gpio_device);
942
943 amba_device_register(&uart1_device, &iomem_resource);
944 amba_device_register(&uart2_device, &iomem_resource);
945 amba_device_register(&uart3_device, &iomem_resource);
946
947 platform_device_register(&ep93xx_rtc_device);
948 platform_device_register(&ep93xx_ohci_device);
949 platform_device_register(&ep93xx_wdt_device);
950
951 gpio_led_register_device(-1, &ep93xx_led_data);
952 }
953
954 void ep93xx_restart(enum reboot_mode mode, const char *cmd)
955 {
956 /*
957 * Set then clear the SWRST bit to initiate a software reset
958 */
959 ep93xx_devcfg_set_bits(EP93XX_SYSCON_DEVCFG_SWRST);
960 ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_SWRST);
961
962 while (1)
963 ;
964 }
965
966 void __init ep93xx_init_late(void)
967 {
968 crunch_init();
969 }
Linux kernel - Deliverables
This page took 0.052364 seconds and 5 git commands to generate.