2 * GPMC support functions
4 * Copyright (C) 2005-2006 Nokia Corporation
8 * Copyright (C) 2009 Texas Instruments
9 * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
17 #include <linux/irq.h>
18 #include <linux/kernel.h>
19 #include <linux/init.h>
20 #include <linux/err.h>
21 #include <linux/clk.h>
22 #include <linux/ioport.h>
23 #include <linux/spinlock.h>
25 #include <linux/module.h>
26 #include <linux/interrupt.h>
27 #include <linux/platform_device.h>
29 #include <linux/platform_data/mtd-nand-omap2.h>
31 #include <asm/mach-types.h>
32 #include <plat/gpmc.h>
35 #include <plat/gpmc.h>
36 #include <plat/sdrc.h>
37 #include <plat/omap_device.h>
42 #define DEVICE_NAME "omap-gpmc"
44 /* GPMC register offsets */
45 #define GPMC_REVISION 0x00
46 #define GPMC_SYSCONFIG 0x10
47 #define GPMC_SYSSTATUS 0x14
48 #define GPMC_IRQSTATUS 0x18
49 #define GPMC_IRQENABLE 0x1c
50 #define GPMC_TIMEOUT_CONTROL 0x40
51 #define GPMC_ERR_ADDRESS 0x44
52 #define GPMC_ERR_TYPE 0x48
53 #define GPMC_CONFIG 0x50
54 #define GPMC_STATUS 0x54
55 #define GPMC_PREFETCH_CONFIG1 0x1e0
56 #define GPMC_PREFETCH_CONFIG2 0x1e4
57 #define GPMC_PREFETCH_CONTROL 0x1ec
58 #define GPMC_PREFETCH_STATUS 0x1f0
59 #define GPMC_ECC_CONFIG 0x1f4
60 #define GPMC_ECC_CONTROL 0x1f8
61 #define GPMC_ECC_SIZE_CONFIG 0x1fc
62 #define GPMC_ECC1_RESULT 0x200
63 #define GPMC_ECC_BCH_RESULT_0 0x240 /* not available on OMAP2 */
64 #define GPMC_ECC_BCH_RESULT_1 0x244 /* not available on OMAP2 */
65 #define GPMC_ECC_BCH_RESULT_2 0x248 /* not available on OMAP2 */
66 #define GPMC_ECC_BCH_RESULT_3 0x24c /* not available on OMAP2 */
68 /* GPMC ECC control settings */
69 #define GPMC_ECC_CTRL_ECCCLEAR 0x100
70 #define GPMC_ECC_CTRL_ECCDISABLE 0x000
71 #define GPMC_ECC_CTRL_ECCREG1 0x001
72 #define GPMC_ECC_CTRL_ECCREG2 0x002
73 #define GPMC_ECC_CTRL_ECCREG3 0x003
74 #define GPMC_ECC_CTRL_ECCREG4 0x004
75 #define GPMC_ECC_CTRL_ECCREG5 0x005
76 #define GPMC_ECC_CTRL_ECCREG6 0x006
77 #define GPMC_ECC_CTRL_ECCREG7 0x007
78 #define GPMC_ECC_CTRL_ECCREG8 0x008
79 #define GPMC_ECC_CTRL_ECCREG9 0x009
81 #define GPMC_CS0_OFFSET 0x60
82 #define GPMC_CS_SIZE 0x30
83 #define GPMC_BCH_SIZE 0x10
85 #define GPMC_MEM_START 0x00000000
86 #define GPMC_MEM_END 0x3FFFFFFF
87 #define BOOT_ROM_SPACE 0x100000 /* 1MB */
89 #define GPMC_CHUNK_SHIFT 24 /* 16 MB */
90 #define GPMC_SECTION_SHIFT 28 /* 128 MB */
92 #define CS_NUM_SHIFT 24
93 #define ENABLE_PREFETCH (0x1 << 7)
94 #define DMA_MPU_MODE 2
96 #define GPMC_REVISION_MAJOR(l) ((l >> 4) & 0xf)
97 #define GPMC_REVISION_MINOR(l) (l & 0xf)
99 #define GPMC_HAS_WR_ACCESS 0x1
100 #define GPMC_HAS_WR_DATA_MUX_BUS 0x2
102 /* XXX: Only NAND irq has been considered,currently these are the only ones used
104 #define GPMC_NR_IRQ 2
106 struct gpmc_client_irq
{
111 /* Structure to save gpmc cs context */
112 struct gpmc_cs_config
{
124 * Structure to save/restore gpmc context
125 * to support core off on OMAP3
127 struct omap3_gpmc_regs
{
132 u32 prefetch_config1
;
133 u32 prefetch_config2
;
134 u32 prefetch_control
;
135 struct gpmc_cs_config cs_context
[GPMC_CS_NUM
];
138 static struct gpmc_client_irq gpmc_client_irq
[GPMC_NR_IRQ
];
139 static struct irq_chip gpmc_irq_chip
;
140 static unsigned gpmc_irq_start
;
142 static struct resource gpmc_mem_root
;
143 static struct resource gpmc_cs_mem
[GPMC_CS_NUM
];
144 static DEFINE_SPINLOCK(gpmc_mem_lock
);
145 static unsigned int gpmc_cs_map
; /* flag for cs which are initialized */
146 static struct device
*gpmc_dev
;
148 static resource_size_t phys_base
, mem_size
;
149 static unsigned gpmc_capability
;
150 static void __iomem
*gpmc_base
;
152 static struct clk
*gpmc_l3_clk
;
154 static irqreturn_t
gpmc_handle_irq(int irq
, void *dev
);
156 static void gpmc_write_reg(int idx
, u32 val
)
158 __raw_writel(val
, gpmc_base
+ idx
);
161 static u32
gpmc_read_reg(int idx
)
163 return __raw_readl(gpmc_base
+ idx
);
166 void gpmc_cs_write_reg(int cs
, int idx
, u32 val
)
168 void __iomem
*reg_addr
;
170 reg_addr
= gpmc_base
+ GPMC_CS0_OFFSET
+ (cs
* GPMC_CS_SIZE
) + idx
;
171 __raw_writel(val
, reg_addr
);
174 u32
gpmc_cs_read_reg(int cs
, int idx
)
176 void __iomem
*reg_addr
;
178 reg_addr
= gpmc_base
+ GPMC_CS0_OFFSET
+ (cs
* GPMC_CS_SIZE
) + idx
;
179 return __raw_readl(reg_addr
);
182 /* TODO: Add support for gpmc_fck to clock framework and use it */
183 unsigned long gpmc_get_fclk_period(void)
185 unsigned long rate
= clk_get_rate(gpmc_l3_clk
);
188 printk(KERN_WARNING
"gpmc_l3_clk not enabled\n");
193 rate
= 1000000000 / rate
; /* In picoseconds */
198 unsigned int gpmc_ns_to_ticks(unsigned int time_ns
)
200 unsigned long tick_ps
;
202 /* Calculate in picosecs to yield more exact results */
203 tick_ps
= gpmc_get_fclk_period();
205 return (time_ns
* 1000 + tick_ps
- 1) / tick_ps
;
208 unsigned int gpmc_ps_to_ticks(unsigned int time_ps
)
210 unsigned long tick_ps
;
212 /* Calculate in picosecs to yield more exact results */
213 tick_ps
= gpmc_get_fclk_period();
215 return (time_ps
+ tick_ps
- 1) / tick_ps
;
218 unsigned int gpmc_ticks_to_ns(unsigned int ticks
)
220 return ticks
* gpmc_get_fclk_period() / 1000;
223 unsigned int gpmc_round_ns_to_ticks(unsigned int time_ns
)
225 unsigned long ticks
= gpmc_ns_to_ticks(time_ns
);
227 return ticks
* gpmc_get_fclk_period() / 1000;
231 static int set_gpmc_timing_reg(int cs
, int reg
, int st_bit
, int end_bit
,
232 int time
, const char *name
)
234 static int set_gpmc_timing_reg(int cs
, int reg
, int st_bit
, int end_bit
,
239 int ticks
, mask
, nr_bits
;
244 ticks
= gpmc_ns_to_ticks(time
);
245 nr_bits
= end_bit
- st_bit
+ 1;
246 if (ticks
>= 1 << nr_bits
) {
248 printk(KERN_INFO
"GPMC CS%d: %-10s* %3d ns, %3d ticks >= %d\n",
249 cs
, name
, time
, ticks
, 1 << nr_bits
);
254 mask
= (1 << nr_bits
) - 1;
255 l
= gpmc_cs_read_reg(cs
, reg
);
258 "GPMC CS%d: %-10s: %3d ticks, %3lu ns (was %3i ticks) %3d ns\n",
259 cs
, name
, ticks
, gpmc_get_fclk_period() * ticks
/ 1000,
260 (l
>> st_bit
) & mask
, time
);
262 l
&= ~(mask
<< st_bit
);
263 l
|= ticks
<< st_bit
;
264 gpmc_cs_write_reg(cs
, reg
, l
);
270 #define GPMC_SET_ONE(reg, st, end, field) \
271 if (set_gpmc_timing_reg(cs, (reg), (st), (end), \
272 t->field, #field) < 0) \
275 #define GPMC_SET_ONE(reg, st, end, field) \
276 if (set_gpmc_timing_reg(cs, (reg), (st), (end), t->field) < 0) \
280 int gpmc_calc_divider(unsigned int sync_clk
)
285 l
= sync_clk
+ (gpmc_get_fclk_period() - 1);
286 div
= l
/ gpmc_get_fclk_period();
295 int gpmc_cs_set_timings(int cs
, const struct gpmc_timings
*t
)
300 div
= gpmc_calc_divider(t
->sync_clk
);
304 GPMC_SET_ONE(GPMC_CS_CONFIG2
, 0, 3, cs_on
);
305 GPMC_SET_ONE(GPMC_CS_CONFIG2
, 8, 12, cs_rd_off
);
306 GPMC_SET_ONE(GPMC_CS_CONFIG2
, 16, 20, cs_wr_off
);
308 GPMC_SET_ONE(GPMC_CS_CONFIG3
, 0, 3, adv_on
);
309 GPMC_SET_ONE(GPMC_CS_CONFIG3
, 8, 12, adv_rd_off
);
310 GPMC_SET_ONE(GPMC_CS_CONFIG3
, 16, 20, adv_wr_off
);
312 GPMC_SET_ONE(GPMC_CS_CONFIG4
, 0, 3, oe_on
);
313 GPMC_SET_ONE(GPMC_CS_CONFIG4
, 8, 12, oe_off
);
314 GPMC_SET_ONE(GPMC_CS_CONFIG4
, 16, 19, we_on
);
315 GPMC_SET_ONE(GPMC_CS_CONFIG4
, 24, 28, we_off
);
317 GPMC_SET_ONE(GPMC_CS_CONFIG5
, 0, 4, rd_cycle
);
318 GPMC_SET_ONE(GPMC_CS_CONFIG5
, 8, 12, wr_cycle
);
319 GPMC_SET_ONE(GPMC_CS_CONFIG5
, 16, 20, access
);
321 GPMC_SET_ONE(GPMC_CS_CONFIG5
, 24, 27, page_burst_access
);
323 if (gpmc_capability
& GPMC_HAS_WR_DATA_MUX_BUS
)
324 GPMC_SET_ONE(GPMC_CS_CONFIG6
, 16, 19, wr_data_mux_bus
);
325 if (gpmc_capability
& GPMC_HAS_WR_ACCESS
)
326 GPMC_SET_ONE(GPMC_CS_CONFIG6
, 24, 28, wr_access
);
328 /* caller is expected to have initialized CONFIG1 to cover
329 * at least sync vs async
331 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG1
);
332 if (l
& (GPMC_CONFIG1_READTYPE_SYNC
| GPMC_CONFIG1_WRITETYPE_SYNC
)) {
334 printk(KERN_INFO
"GPMC CS%d CLK period is %lu ns (div %d)\n",
335 cs
, (div
* gpmc_get_fclk_period()) / 1000, div
);
339 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG1
, l
);
345 static void gpmc_cs_enable_mem(int cs
, u32 base
, u32 size
)
350 mask
= (1 << GPMC_SECTION_SHIFT
) - size
;
351 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG7
);
353 l
= (base
>> GPMC_CHUNK_SHIFT
) & 0x3f;
355 l
|= ((mask
>> GPMC_CHUNK_SHIFT
) & 0x0f) << 8;
356 l
|= GPMC_CONFIG7_CSVALID
;
357 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG7
, l
);
360 static void gpmc_cs_disable_mem(int cs
)
364 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG7
);
365 l
&= ~GPMC_CONFIG7_CSVALID
;
366 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG7
, l
);
369 static void gpmc_cs_get_memconf(int cs
, u32
*base
, u32
*size
)
374 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG7
);
375 *base
= (l
& 0x3f) << GPMC_CHUNK_SHIFT
;
376 mask
= (l
>> 8) & 0x0f;
377 *size
= (1 << GPMC_SECTION_SHIFT
) - (mask
<< GPMC_CHUNK_SHIFT
);
380 static int gpmc_cs_mem_enabled(int cs
)
384 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG7
);
385 return l
& GPMC_CONFIG7_CSVALID
;
388 int gpmc_cs_set_reserved(int cs
, int reserved
)
390 if (cs
> GPMC_CS_NUM
)
393 gpmc_cs_map
&= ~(1 << cs
);
394 gpmc_cs_map
|= (reserved
? 1 : 0) << cs
;
399 int gpmc_cs_reserved(int cs
)
401 if (cs
> GPMC_CS_NUM
)
404 return gpmc_cs_map
& (1 << cs
);
407 static unsigned long gpmc_mem_align(unsigned long size
)
411 size
= (size
- 1) >> (GPMC_CHUNK_SHIFT
- 1);
412 order
= GPMC_CHUNK_SHIFT
- 1;
421 static int gpmc_cs_insert_mem(int cs
, unsigned long base
, unsigned long size
)
423 struct resource
*res
= &gpmc_cs_mem
[cs
];
426 size
= gpmc_mem_align(size
);
427 spin_lock(&gpmc_mem_lock
);
429 res
->end
= base
+ size
- 1;
430 r
= request_resource(&gpmc_mem_root
, res
);
431 spin_unlock(&gpmc_mem_lock
);
436 static int gpmc_cs_delete_mem(int cs
)
438 struct resource
*res
= &gpmc_cs_mem
[cs
];
441 spin_lock(&gpmc_mem_lock
);
442 r
= release_resource(&gpmc_cs_mem
[cs
]);
445 spin_unlock(&gpmc_mem_lock
);
450 int gpmc_cs_request(int cs
, unsigned long size
, unsigned long *base
)
452 struct resource
*res
= &gpmc_cs_mem
[cs
];
455 if (cs
> GPMC_CS_NUM
)
458 size
= gpmc_mem_align(size
);
459 if (size
> (1 << GPMC_SECTION_SHIFT
))
462 spin_lock(&gpmc_mem_lock
);
463 if (gpmc_cs_reserved(cs
)) {
467 if (gpmc_cs_mem_enabled(cs
))
468 r
= adjust_resource(res
, res
->start
& ~(size
- 1), size
);
470 r
= allocate_resource(&gpmc_mem_root
, res
, size
, 0, ~0,
475 gpmc_cs_enable_mem(cs
, res
->start
, resource_size(res
));
477 gpmc_cs_set_reserved(cs
, 1);
479 spin_unlock(&gpmc_mem_lock
);
482 EXPORT_SYMBOL(gpmc_cs_request
);
484 void gpmc_cs_free(int cs
)
486 spin_lock(&gpmc_mem_lock
);
487 if (cs
>= GPMC_CS_NUM
|| cs
< 0 || !gpmc_cs_reserved(cs
)) {
488 printk(KERN_ERR
"Trying to free non-reserved GPMC CS%d\n", cs
);
490 spin_unlock(&gpmc_mem_lock
);
493 gpmc_cs_disable_mem(cs
);
494 release_resource(&gpmc_cs_mem
[cs
]);
495 gpmc_cs_set_reserved(cs
, 0);
496 spin_unlock(&gpmc_mem_lock
);
498 EXPORT_SYMBOL(gpmc_cs_free
);
501 * gpmc_cs_configure - write request to configure gpmc
502 * @cs: chip select number
504 * @wval: value to write
505 * @return status of the operation
507 int gpmc_cs_configure(int cs
, int cmd
, int wval
)
513 case GPMC_ENABLE_IRQ
:
514 gpmc_write_reg(GPMC_IRQENABLE
, wval
);
517 case GPMC_SET_IRQ_STATUS
:
518 gpmc_write_reg(GPMC_IRQSTATUS
, wval
);
522 regval
= gpmc_read_reg(GPMC_CONFIG
);
524 regval
&= ~GPMC_CONFIG_WRITEPROTECT
; /* WP is ON */
526 regval
|= GPMC_CONFIG_WRITEPROTECT
; /* WP is OFF */
527 gpmc_write_reg(GPMC_CONFIG
, regval
);
530 case GPMC_CONFIG_RDY_BSY
:
531 regval
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG1
);
533 regval
|= WR_RD_PIN_MONITORING
;
535 regval
&= ~WR_RD_PIN_MONITORING
;
536 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG1
, regval
);
539 case GPMC_CONFIG_DEV_SIZE
:
540 regval
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG1
);
542 /* clear 2 target bits */
543 regval
&= ~GPMC_CONFIG1_DEVICESIZE(3);
545 /* set the proper value */
546 regval
|= GPMC_CONFIG1_DEVICESIZE(wval
);
548 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG1
, regval
);
551 case GPMC_CONFIG_DEV_TYPE
:
552 regval
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG1
);
553 regval
|= GPMC_CONFIG1_DEVICETYPE(wval
);
554 if (wval
== GPMC_DEVICETYPE_NOR
)
555 regval
|= GPMC_CONFIG1_MUXADDDATA
;
556 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG1
, regval
);
560 printk(KERN_ERR
"gpmc_configure_cs: Not supported\n");
566 EXPORT_SYMBOL(gpmc_cs_configure
);
568 void gpmc_update_nand_reg(struct gpmc_nand_regs
*reg
, int cs
)
572 reg
->gpmc_status
= gpmc_base
+ GPMC_STATUS
;
573 reg
->gpmc_nand_command
= gpmc_base
+ GPMC_CS0_OFFSET
+
574 GPMC_CS_NAND_COMMAND
+ GPMC_CS_SIZE
* cs
;
575 reg
->gpmc_nand_address
= gpmc_base
+ GPMC_CS0_OFFSET
+
576 GPMC_CS_NAND_ADDRESS
+ GPMC_CS_SIZE
* cs
;
577 reg
->gpmc_nand_data
= gpmc_base
+ GPMC_CS0_OFFSET
+
578 GPMC_CS_NAND_DATA
+ GPMC_CS_SIZE
* cs
;
579 reg
->gpmc_prefetch_config1
= gpmc_base
+ GPMC_PREFETCH_CONFIG1
;
580 reg
->gpmc_prefetch_config2
= gpmc_base
+ GPMC_PREFETCH_CONFIG2
;
581 reg
->gpmc_prefetch_control
= gpmc_base
+ GPMC_PREFETCH_CONTROL
;
582 reg
->gpmc_prefetch_status
= gpmc_base
+ GPMC_PREFETCH_STATUS
;
583 reg
->gpmc_ecc_config
= gpmc_base
+ GPMC_ECC_CONFIG
;
584 reg
->gpmc_ecc_control
= gpmc_base
+ GPMC_ECC_CONTROL
;
585 reg
->gpmc_ecc_size_config
= gpmc_base
+ GPMC_ECC_SIZE_CONFIG
;
586 reg
->gpmc_ecc1_result
= gpmc_base
+ GPMC_ECC1_RESULT
;
588 for (i
= 0; i
< GPMC_BCH_NUM_REMAINDER
; i
++) {
589 reg
->gpmc_bch_result0
[i
] = gpmc_base
+ GPMC_ECC_BCH_RESULT_0
+
591 reg
->gpmc_bch_result1
[i
] = gpmc_base
+ GPMC_ECC_BCH_RESULT_1
+
593 reg
->gpmc_bch_result2
[i
] = gpmc_base
+ GPMC_ECC_BCH_RESULT_2
+
595 reg
->gpmc_bch_result3
[i
] = gpmc_base
+ GPMC_ECC_BCH_RESULT_3
+
600 int gpmc_get_client_irq(unsigned irq_config
)
604 if (hweight32(irq_config
) > 1)
607 for (i
= 0; i
< GPMC_NR_IRQ
; i
++)
608 if (gpmc_client_irq
[i
].bitmask
& irq_config
)
609 return gpmc_client_irq
[i
].irq
;
614 static int gpmc_irq_endis(unsigned irq
, bool endis
)
619 for (i
= 0; i
< GPMC_NR_IRQ
; i
++)
620 if (irq
== gpmc_client_irq
[i
].irq
) {
621 regval
= gpmc_read_reg(GPMC_IRQENABLE
);
623 regval
|= gpmc_client_irq
[i
].bitmask
;
625 regval
&= ~gpmc_client_irq
[i
].bitmask
;
626 gpmc_write_reg(GPMC_IRQENABLE
, regval
);
633 static void gpmc_irq_disable(struct irq_data
*p
)
635 gpmc_irq_endis(p
->irq
, false);
638 static void gpmc_irq_enable(struct irq_data
*p
)
640 gpmc_irq_endis(p
->irq
, true);
643 static void gpmc_irq_noop(struct irq_data
*data
) { }
645 static unsigned int gpmc_irq_noop_ret(struct irq_data
*data
) { return 0; }
647 static int gpmc_setup_irq(void)
655 gpmc_irq_start
= irq_alloc_descs(-1, 0, GPMC_NR_IRQ
, 0);
656 if (IS_ERR_VALUE(gpmc_irq_start
)) {
657 pr_err("irq_alloc_descs failed\n");
658 return gpmc_irq_start
;
661 gpmc_irq_chip
.name
= "gpmc";
662 gpmc_irq_chip
.irq_startup
= gpmc_irq_noop_ret
;
663 gpmc_irq_chip
.irq_enable
= gpmc_irq_enable
;
664 gpmc_irq_chip
.irq_disable
= gpmc_irq_disable
;
665 gpmc_irq_chip
.irq_shutdown
= gpmc_irq_noop
;
666 gpmc_irq_chip
.irq_ack
= gpmc_irq_noop
;
667 gpmc_irq_chip
.irq_mask
= gpmc_irq_noop
;
668 gpmc_irq_chip
.irq_unmask
= gpmc_irq_noop
;
670 gpmc_client_irq
[0].bitmask
= GPMC_IRQ_FIFOEVENTENABLE
;
671 gpmc_client_irq
[1].bitmask
= GPMC_IRQ_COUNT_EVENT
;
673 for (i
= 0; i
< GPMC_NR_IRQ
; i
++) {
674 gpmc_client_irq
[i
].irq
= gpmc_irq_start
+ i
;
675 irq_set_chip_and_handler(gpmc_client_irq
[i
].irq
,
676 &gpmc_irq_chip
, handle_simple_irq
);
677 set_irq_flags(gpmc_client_irq
[i
].irq
,
678 IRQF_VALID
| IRQF_NOAUTOEN
);
681 /* Disable interrupts */
682 gpmc_write_reg(GPMC_IRQENABLE
, 0);
684 /* clear interrupts */
685 regval
= gpmc_read_reg(GPMC_IRQSTATUS
);
686 gpmc_write_reg(GPMC_IRQSTATUS
, regval
);
688 return request_irq(gpmc_irq
, gpmc_handle_irq
, 0, "gpmc", NULL
);
691 static __devexit
int gpmc_free_irq(void)
696 free_irq(gpmc_irq
, NULL
);
698 for (i
= 0; i
< GPMC_NR_IRQ
; i
++) {
699 irq_set_handler(gpmc_client_irq
[i
].irq
, NULL
);
700 irq_set_chip(gpmc_client_irq
[i
].irq
, &no_irq_chip
);
701 irq_modify_status(gpmc_client_irq
[i
].irq
, 0, 0);
704 irq_free_descs(gpmc_irq_start
, GPMC_NR_IRQ
);
709 static void __devexit
gpmc_mem_exit(void)
713 for (cs
= 0; cs
< GPMC_CS_NUM
; cs
++) {
714 if (!gpmc_cs_mem_enabled(cs
))
716 gpmc_cs_delete_mem(cs
);
721 static void __devinit
gpmc_mem_init(void)
724 unsigned long boot_rom_space
= 0;
726 /* never allocate the first page, to facilitate bug detection;
727 * even if we didn't boot from ROM.
729 boot_rom_space
= BOOT_ROM_SPACE
;
730 /* In apollon the CS0 is mapped as 0x0000 0000 */
731 if (machine_is_omap_apollon())
733 gpmc_mem_root
.start
= GPMC_MEM_START
+ boot_rom_space
;
734 gpmc_mem_root
.end
= GPMC_MEM_END
;
736 /* Reserve all regions that has been set up by bootloader */
737 for (cs
= 0; cs
< GPMC_CS_NUM
; cs
++) {
740 if (!gpmc_cs_mem_enabled(cs
))
742 gpmc_cs_get_memconf(cs
, &base
, &size
);
743 if (gpmc_cs_insert_mem(cs
, base
, size
) < 0)
748 static __devinit
int gpmc_probe(struct platform_device
*pdev
)
751 struct resource
*res
;
753 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
757 phys_base
= res
->start
;
758 mem_size
= resource_size(res
);
760 gpmc_base
= devm_request_and_ioremap(&pdev
->dev
, res
);
762 dev_err(&pdev
->dev
, "error: request memory / ioremap\n");
763 return -EADDRNOTAVAIL
;
766 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
768 dev_warn(&pdev
->dev
, "Failed to get resource: irq\n");
770 gpmc_irq
= res
->start
;
772 gpmc_l3_clk
= clk_get(&pdev
->dev
, "fck");
773 if (IS_ERR(gpmc_l3_clk
)) {
774 dev_err(&pdev
->dev
, "error: clk_get\n");
776 return PTR_ERR(gpmc_l3_clk
);
779 clk_prepare_enable(gpmc_l3_clk
);
781 gpmc_dev
= &pdev
->dev
;
783 l
= gpmc_read_reg(GPMC_REVISION
);
784 if (GPMC_REVISION_MAJOR(l
) > 0x4)
785 gpmc_capability
= GPMC_HAS_WR_ACCESS
| GPMC_HAS_WR_DATA_MUX_BUS
;
786 dev_info(gpmc_dev
, "GPMC revision %d.%d\n", GPMC_REVISION_MAJOR(l
),
787 GPMC_REVISION_MINOR(l
));
791 if (IS_ERR_VALUE(gpmc_setup_irq()))
792 dev_warn(gpmc_dev
, "gpmc_setup_irq failed\n");
797 static __devexit
int gpmc_remove(struct platform_device
*pdev
)
805 static struct platform_driver gpmc_driver
= {
807 .remove
= __devexit_p(gpmc_remove
),
810 .owner
= THIS_MODULE
,
814 static __init
int gpmc_init(void)
816 return platform_driver_register(&gpmc_driver
);
819 static __exit
void gpmc_exit(void)
821 platform_driver_unregister(&gpmc_driver
);
825 postcore_initcall(gpmc_init
);
826 module_exit(gpmc_exit
);
828 static int __init
omap_gpmc_init(void)
830 struct omap_hwmod
*oh
;
831 struct platform_device
*pdev
;
832 char *oh_name
= "gpmc";
834 oh
= omap_hwmod_lookup(oh_name
);
836 pr_err("Could not look up %s\n", oh_name
);
840 pdev
= omap_device_build(DEVICE_NAME
, -1, oh
, NULL
, 0, NULL
, 0, 0);
841 WARN(IS_ERR(pdev
), "could not build omap_device for %s\n", oh_name
);
843 return IS_ERR(pdev
) ? PTR_ERR(pdev
) : 0;
845 postcore_initcall(omap_gpmc_init
);
847 static irqreturn_t
gpmc_handle_irq(int irq
, void *dev
)
852 regval
= gpmc_read_reg(GPMC_IRQSTATUS
);
857 for (i
= 0; i
< GPMC_NR_IRQ
; i
++)
858 if (regval
& gpmc_client_irq
[i
].bitmask
)
859 generic_handle_irq(gpmc_client_irq
[i
].irq
);
861 gpmc_write_reg(GPMC_IRQSTATUS
, regval
);
866 #ifdef CONFIG_ARCH_OMAP3
867 static struct omap3_gpmc_regs gpmc_context
;
869 void omap3_gpmc_save_context(void)
873 gpmc_context
.sysconfig
= gpmc_read_reg(GPMC_SYSCONFIG
);
874 gpmc_context
.irqenable
= gpmc_read_reg(GPMC_IRQENABLE
);
875 gpmc_context
.timeout_ctrl
= gpmc_read_reg(GPMC_TIMEOUT_CONTROL
);
876 gpmc_context
.config
= gpmc_read_reg(GPMC_CONFIG
);
877 gpmc_context
.prefetch_config1
= gpmc_read_reg(GPMC_PREFETCH_CONFIG1
);
878 gpmc_context
.prefetch_config2
= gpmc_read_reg(GPMC_PREFETCH_CONFIG2
);
879 gpmc_context
.prefetch_control
= gpmc_read_reg(GPMC_PREFETCH_CONTROL
);
880 for (i
= 0; i
< GPMC_CS_NUM
; i
++) {
881 gpmc_context
.cs_context
[i
].is_valid
= gpmc_cs_mem_enabled(i
);
882 if (gpmc_context
.cs_context
[i
].is_valid
) {
883 gpmc_context
.cs_context
[i
].config1
=
884 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG1
);
885 gpmc_context
.cs_context
[i
].config2
=
886 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG2
);
887 gpmc_context
.cs_context
[i
].config3
=
888 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG3
);
889 gpmc_context
.cs_context
[i
].config4
=
890 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG4
);
891 gpmc_context
.cs_context
[i
].config5
=
892 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG5
);
893 gpmc_context
.cs_context
[i
].config6
=
894 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG6
);
895 gpmc_context
.cs_context
[i
].config7
=
896 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG7
);
901 void omap3_gpmc_restore_context(void)
905 gpmc_write_reg(GPMC_SYSCONFIG
, gpmc_context
.sysconfig
);
906 gpmc_write_reg(GPMC_IRQENABLE
, gpmc_context
.irqenable
);
907 gpmc_write_reg(GPMC_TIMEOUT_CONTROL
, gpmc_context
.timeout_ctrl
);
908 gpmc_write_reg(GPMC_CONFIG
, gpmc_context
.config
);
909 gpmc_write_reg(GPMC_PREFETCH_CONFIG1
, gpmc_context
.prefetch_config1
);
910 gpmc_write_reg(GPMC_PREFETCH_CONFIG2
, gpmc_context
.prefetch_config2
);
911 gpmc_write_reg(GPMC_PREFETCH_CONTROL
, gpmc_context
.prefetch_control
);
912 for (i
= 0; i
< GPMC_CS_NUM
; i
++) {
913 if (gpmc_context
.cs_context
[i
].is_valid
) {
914 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG1
,
915 gpmc_context
.cs_context
[i
].config1
);
916 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG2
,
917 gpmc_context
.cs_context
[i
].config2
);
918 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG3
,
919 gpmc_context
.cs_context
[i
].config3
);
920 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG4
,
921 gpmc_context
.cs_context
[i
].config4
);
922 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG5
,
923 gpmc_context
.cs_context
[i
].config5
);
924 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG6
,
925 gpmc_context
.cs_context
[i
].config6
);
926 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG7
,
927 gpmc_context
.cs_context
[i
].config7
);
931 #endif /* CONFIG_ARCH_OMAP3 */