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/of_mtd.h>
30 #include <linux/of_device.h>
31 #include <linux/mtd/nand.h>
33 #include <linux/platform_data/mtd-nand-omap2.h>
35 #include <asm/mach-types.h>
39 #include "omap_device.h"
41 #include "gpmc-nand.h"
42 #include "gpmc-onenand.h"
44 #define DEVICE_NAME "omap-gpmc"
46 /* GPMC register offsets */
47 #define GPMC_REVISION 0x00
48 #define GPMC_SYSCONFIG 0x10
49 #define GPMC_SYSSTATUS 0x14
50 #define GPMC_IRQSTATUS 0x18
51 #define GPMC_IRQENABLE 0x1c
52 #define GPMC_TIMEOUT_CONTROL 0x40
53 #define GPMC_ERR_ADDRESS 0x44
54 #define GPMC_ERR_TYPE 0x48
55 #define GPMC_CONFIG 0x50
56 #define GPMC_STATUS 0x54
57 #define GPMC_PREFETCH_CONFIG1 0x1e0
58 #define GPMC_PREFETCH_CONFIG2 0x1e4
59 #define GPMC_PREFETCH_CONTROL 0x1ec
60 #define GPMC_PREFETCH_STATUS 0x1f0
61 #define GPMC_ECC_CONFIG 0x1f4
62 #define GPMC_ECC_CONTROL 0x1f8
63 #define GPMC_ECC_SIZE_CONFIG 0x1fc
64 #define GPMC_ECC1_RESULT 0x200
65 #define GPMC_ECC_BCH_RESULT_0 0x240 /* not available on OMAP2 */
66 #define GPMC_ECC_BCH_RESULT_1 0x244 /* not available on OMAP2 */
67 #define GPMC_ECC_BCH_RESULT_2 0x248 /* not available on OMAP2 */
68 #define GPMC_ECC_BCH_RESULT_3 0x24c /* not available on OMAP2 */
70 /* GPMC ECC control settings */
71 #define GPMC_ECC_CTRL_ECCCLEAR 0x100
72 #define GPMC_ECC_CTRL_ECCDISABLE 0x000
73 #define GPMC_ECC_CTRL_ECCREG1 0x001
74 #define GPMC_ECC_CTRL_ECCREG2 0x002
75 #define GPMC_ECC_CTRL_ECCREG3 0x003
76 #define GPMC_ECC_CTRL_ECCREG4 0x004
77 #define GPMC_ECC_CTRL_ECCREG5 0x005
78 #define GPMC_ECC_CTRL_ECCREG6 0x006
79 #define GPMC_ECC_CTRL_ECCREG7 0x007
80 #define GPMC_ECC_CTRL_ECCREG8 0x008
81 #define GPMC_ECC_CTRL_ECCREG9 0x009
83 #define GPMC_CONFIG2_CSEXTRADELAY BIT(7)
84 #define GPMC_CONFIG3_ADVEXTRADELAY BIT(7)
85 #define GPMC_CONFIG4_OEEXTRADELAY BIT(7)
86 #define GPMC_CONFIG4_WEEXTRADELAY BIT(23)
87 #define GPMC_CONFIG6_CYCLE2CYCLEDIFFCSEN BIT(6)
88 #define GPMC_CONFIG6_CYCLE2CYCLESAMECSEN BIT(7)
90 #define GPMC_CS0_OFFSET 0x60
91 #define GPMC_CS_SIZE 0x30
92 #define GPMC_BCH_SIZE 0x10
94 #define GPMC_MEM_START 0x00000000
95 #define GPMC_MEM_END 0x3FFFFFFF
96 #define BOOT_ROM_SPACE 0x100000 /* 1MB */
98 #define GPMC_CHUNK_SHIFT 24 /* 16 MB */
99 #define GPMC_SECTION_SHIFT 28 /* 128 MB */
101 #define CS_NUM_SHIFT 24
102 #define ENABLE_PREFETCH (0x1 << 7)
103 #define DMA_MPU_MODE 2
105 #define GPMC_REVISION_MAJOR(l) ((l >> 4) & 0xf)
106 #define GPMC_REVISION_MINOR(l) (l & 0xf)
108 #define GPMC_HAS_WR_ACCESS 0x1
109 #define GPMC_HAS_WR_DATA_MUX_BUS 0x2
111 #define GPMC_NR_WAITPINS 4
113 /* XXX: Only NAND irq has been considered,currently these are the only ones used
115 #define GPMC_NR_IRQ 2
117 struct gpmc_client_irq
{
122 /* Structure to save gpmc cs context */
123 struct gpmc_cs_config
{
135 * Structure to save/restore gpmc context
136 * to support core off on OMAP3
138 struct omap3_gpmc_regs
{
143 u32 prefetch_config1
;
144 u32 prefetch_config2
;
145 u32 prefetch_control
;
146 struct gpmc_cs_config cs_context
[GPMC_CS_NUM
];
149 static struct gpmc_client_irq gpmc_client_irq
[GPMC_NR_IRQ
];
150 static struct irq_chip gpmc_irq_chip
;
151 static unsigned gpmc_irq_start
;
153 static struct resource gpmc_mem_root
;
154 static struct resource gpmc_cs_mem
[GPMC_CS_NUM
];
155 static DEFINE_SPINLOCK(gpmc_mem_lock
);
156 /* Define chip-selects as reserved by default until probe completes */
157 static unsigned int gpmc_cs_map
= ((1 << GPMC_CS_NUM
) - 1);
158 static unsigned int gpmc_nr_waitpins
;
159 static struct device
*gpmc_dev
;
161 static resource_size_t phys_base
, mem_size
;
162 static unsigned gpmc_capability
;
163 static void __iomem
*gpmc_base
;
165 static struct clk
*gpmc_l3_clk
;
167 static irqreturn_t
gpmc_handle_irq(int irq
, void *dev
);
169 static void gpmc_write_reg(int idx
, u32 val
)
171 __raw_writel(val
, gpmc_base
+ idx
);
174 static u32
gpmc_read_reg(int idx
)
176 return __raw_readl(gpmc_base
+ idx
);
179 void gpmc_cs_write_reg(int cs
, int idx
, u32 val
)
181 void __iomem
*reg_addr
;
183 reg_addr
= gpmc_base
+ GPMC_CS0_OFFSET
+ (cs
* GPMC_CS_SIZE
) + idx
;
184 __raw_writel(val
, reg_addr
);
187 static u32
gpmc_cs_read_reg(int cs
, int idx
)
189 void __iomem
*reg_addr
;
191 reg_addr
= gpmc_base
+ GPMC_CS0_OFFSET
+ (cs
* GPMC_CS_SIZE
) + idx
;
192 return __raw_readl(reg_addr
);
195 /* TODO: Add support for gpmc_fck to clock framework and use it */
196 static unsigned long gpmc_get_fclk_period(void)
198 unsigned long rate
= clk_get_rate(gpmc_l3_clk
);
201 printk(KERN_WARNING
"gpmc_l3_clk not enabled\n");
206 rate
= 1000000000 / rate
; /* In picoseconds */
211 static unsigned int gpmc_ns_to_ticks(unsigned int time_ns
)
213 unsigned long tick_ps
;
215 /* Calculate in picosecs to yield more exact results */
216 tick_ps
= gpmc_get_fclk_period();
218 return (time_ns
* 1000 + tick_ps
- 1) / tick_ps
;
221 static unsigned int gpmc_ps_to_ticks(unsigned int time_ps
)
223 unsigned long tick_ps
;
225 /* Calculate in picosecs to yield more exact results */
226 tick_ps
= gpmc_get_fclk_period();
228 return (time_ps
+ tick_ps
- 1) / tick_ps
;
231 unsigned int gpmc_ticks_to_ns(unsigned int ticks
)
233 return ticks
* gpmc_get_fclk_period() / 1000;
236 static unsigned int gpmc_ticks_to_ps(unsigned int ticks
)
238 return ticks
* gpmc_get_fclk_period();
241 static unsigned int gpmc_round_ps_to_ticks(unsigned int time_ps
)
243 unsigned long ticks
= gpmc_ps_to_ticks(time_ps
);
245 return ticks
* gpmc_get_fclk_period();
248 static inline void gpmc_cs_modify_reg(int cs
, int reg
, u32 mask
, bool value
)
252 l
= gpmc_cs_read_reg(cs
, reg
);
257 gpmc_cs_write_reg(cs
, reg
, l
);
260 static void gpmc_cs_bool_timings(int cs
, const struct gpmc_bool_timings
*p
)
262 gpmc_cs_modify_reg(cs
, GPMC_CS_CONFIG1
,
263 GPMC_CONFIG1_TIME_PARA_GRAN
,
264 p
->time_para_granularity
);
265 gpmc_cs_modify_reg(cs
, GPMC_CS_CONFIG2
,
266 GPMC_CONFIG2_CSEXTRADELAY
, p
->cs_extra_delay
);
267 gpmc_cs_modify_reg(cs
, GPMC_CS_CONFIG3
,
268 GPMC_CONFIG3_ADVEXTRADELAY
, p
->adv_extra_delay
);
269 gpmc_cs_modify_reg(cs
, GPMC_CS_CONFIG4
,
270 GPMC_CONFIG4_OEEXTRADELAY
, p
->oe_extra_delay
);
271 gpmc_cs_modify_reg(cs
, GPMC_CS_CONFIG4
,
272 GPMC_CONFIG4_OEEXTRADELAY
, p
->we_extra_delay
);
273 gpmc_cs_modify_reg(cs
, GPMC_CS_CONFIG6
,
274 GPMC_CONFIG6_CYCLE2CYCLESAMECSEN
,
275 p
->cycle2cyclesamecsen
);
276 gpmc_cs_modify_reg(cs
, GPMC_CS_CONFIG6
,
277 GPMC_CONFIG6_CYCLE2CYCLEDIFFCSEN
,
278 p
->cycle2cyclediffcsen
);
282 static int set_gpmc_timing_reg(int cs
, int reg
, int st_bit
, int end_bit
,
283 int time
, const char *name
)
285 static int set_gpmc_timing_reg(int cs
, int reg
, int st_bit
, int end_bit
,
290 int ticks
, mask
, nr_bits
;
295 ticks
= gpmc_ns_to_ticks(time
);
296 nr_bits
= end_bit
- st_bit
+ 1;
297 if (ticks
>= 1 << nr_bits
) {
299 printk(KERN_INFO
"GPMC CS%d: %-10s* %3d ns, %3d ticks >= %d\n",
300 cs
, name
, time
, ticks
, 1 << nr_bits
);
305 mask
= (1 << nr_bits
) - 1;
306 l
= gpmc_cs_read_reg(cs
, reg
);
309 "GPMC CS%d: %-10s: %3d ticks, %3lu ns (was %3i ticks) %3d ns\n",
310 cs
, name
, ticks
, gpmc_get_fclk_period() * ticks
/ 1000,
311 (l
>> st_bit
) & mask
, time
);
313 l
&= ~(mask
<< st_bit
);
314 l
|= ticks
<< st_bit
;
315 gpmc_cs_write_reg(cs
, reg
, l
);
321 #define GPMC_SET_ONE(reg, st, end, field) \
322 if (set_gpmc_timing_reg(cs, (reg), (st), (end), \
323 t->field, #field) < 0) \
326 #define GPMC_SET_ONE(reg, st, end, field) \
327 if (set_gpmc_timing_reg(cs, (reg), (st), (end), t->field) < 0) \
331 int gpmc_calc_divider(unsigned int sync_clk
)
336 l
= sync_clk
+ (gpmc_get_fclk_period() - 1);
337 div
= l
/ gpmc_get_fclk_period();
346 int gpmc_cs_set_timings(int cs
, const struct gpmc_timings
*t
)
351 div
= gpmc_calc_divider(t
->sync_clk
);
355 GPMC_SET_ONE(GPMC_CS_CONFIG2
, 0, 3, cs_on
);
356 GPMC_SET_ONE(GPMC_CS_CONFIG2
, 8, 12, cs_rd_off
);
357 GPMC_SET_ONE(GPMC_CS_CONFIG2
, 16, 20, cs_wr_off
);
359 GPMC_SET_ONE(GPMC_CS_CONFIG3
, 0, 3, adv_on
);
360 GPMC_SET_ONE(GPMC_CS_CONFIG3
, 8, 12, adv_rd_off
);
361 GPMC_SET_ONE(GPMC_CS_CONFIG3
, 16, 20, adv_wr_off
);
363 GPMC_SET_ONE(GPMC_CS_CONFIG4
, 0, 3, oe_on
);
364 GPMC_SET_ONE(GPMC_CS_CONFIG4
, 8, 12, oe_off
);
365 GPMC_SET_ONE(GPMC_CS_CONFIG4
, 16, 19, we_on
);
366 GPMC_SET_ONE(GPMC_CS_CONFIG4
, 24, 28, we_off
);
368 GPMC_SET_ONE(GPMC_CS_CONFIG5
, 0, 4, rd_cycle
);
369 GPMC_SET_ONE(GPMC_CS_CONFIG5
, 8, 12, wr_cycle
);
370 GPMC_SET_ONE(GPMC_CS_CONFIG5
, 16, 20, access
);
372 GPMC_SET_ONE(GPMC_CS_CONFIG5
, 24, 27, page_burst_access
);
374 GPMC_SET_ONE(GPMC_CS_CONFIG6
, 0, 3, bus_turnaround
);
375 GPMC_SET_ONE(GPMC_CS_CONFIG6
, 8, 11, cycle2cycle_delay
);
377 GPMC_SET_ONE(GPMC_CS_CONFIG1
, 18, 19, wait_monitoring
);
378 GPMC_SET_ONE(GPMC_CS_CONFIG1
, 25, 26, clk_activation
);
380 if (gpmc_capability
& GPMC_HAS_WR_DATA_MUX_BUS
)
381 GPMC_SET_ONE(GPMC_CS_CONFIG6
, 16, 19, wr_data_mux_bus
);
382 if (gpmc_capability
& GPMC_HAS_WR_ACCESS
)
383 GPMC_SET_ONE(GPMC_CS_CONFIG6
, 24, 28, wr_access
);
385 /* caller is expected to have initialized CONFIG1 to cover
386 * at least sync vs async
388 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG1
);
389 if (l
& (GPMC_CONFIG1_READTYPE_SYNC
| GPMC_CONFIG1_WRITETYPE_SYNC
)) {
391 printk(KERN_INFO
"GPMC CS%d CLK period is %lu ns (div %d)\n",
392 cs
, (div
* gpmc_get_fclk_period()) / 1000, div
);
396 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG1
, l
);
399 gpmc_cs_bool_timings(cs
, &t
->bool_timings
);
404 static void gpmc_cs_enable_mem(int cs
, u32 base
, u32 size
)
409 mask
= (1 << GPMC_SECTION_SHIFT
) - size
;
410 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG7
);
412 l
= (base
>> GPMC_CHUNK_SHIFT
) & 0x3f;
414 l
|= ((mask
>> GPMC_CHUNK_SHIFT
) & 0x0f) << 8;
415 l
|= GPMC_CONFIG7_CSVALID
;
416 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG7
, l
);
419 static void gpmc_cs_disable_mem(int cs
)
423 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG7
);
424 l
&= ~GPMC_CONFIG7_CSVALID
;
425 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG7
, l
);
428 static void gpmc_cs_get_memconf(int cs
, u32
*base
, u32
*size
)
433 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG7
);
434 *base
= (l
& 0x3f) << GPMC_CHUNK_SHIFT
;
435 mask
= (l
>> 8) & 0x0f;
436 *size
= (1 << GPMC_SECTION_SHIFT
) - (mask
<< GPMC_CHUNK_SHIFT
);
439 static int gpmc_cs_mem_enabled(int cs
)
443 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG7
);
444 return l
& GPMC_CONFIG7_CSVALID
;
447 static void gpmc_cs_set_reserved(int cs
, int reserved
)
449 gpmc_cs_map
&= ~(1 << cs
);
450 gpmc_cs_map
|= (reserved
? 1 : 0) << cs
;
453 static bool gpmc_cs_reserved(int cs
)
455 return gpmc_cs_map
& (1 << cs
);
458 static unsigned long gpmc_mem_align(unsigned long size
)
462 size
= (size
- 1) >> (GPMC_CHUNK_SHIFT
- 1);
463 order
= GPMC_CHUNK_SHIFT
- 1;
472 static int gpmc_cs_insert_mem(int cs
, unsigned long base
, unsigned long size
)
474 struct resource
*res
= &gpmc_cs_mem
[cs
];
477 size
= gpmc_mem_align(size
);
478 spin_lock(&gpmc_mem_lock
);
480 res
->end
= base
+ size
- 1;
481 r
= request_resource(&gpmc_mem_root
, res
);
482 spin_unlock(&gpmc_mem_lock
);
487 static int gpmc_cs_delete_mem(int cs
)
489 struct resource
*res
= &gpmc_cs_mem
[cs
];
492 spin_lock(&gpmc_mem_lock
);
493 r
= release_resource(&gpmc_cs_mem
[cs
]);
496 spin_unlock(&gpmc_mem_lock
);
501 int gpmc_cs_request(int cs
, unsigned long size
, unsigned long *base
)
503 struct resource
*res
= &gpmc_cs_mem
[cs
];
506 if (cs
> GPMC_CS_NUM
)
509 size
= gpmc_mem_align(size
);
510 if (size
> (1 << GPMC_SECTION_SHIFT
))
513 spin_lock(&gpmc_mem_lock
);
514 if (gpmc_cs_reserved(cs
)) {
518 if (gpmc_cs_mem_enabled(cs
))
519 r
= adjust_resource(res
, res
->start
& ~(size
- 1), size
);
521 r
= allocate_resource(&gpmc_mem_root
, res
, size
, 0, ~0,
526 gpmc_cs_enable_mem(cs
, res
->start
, resource_size(res
));
528 gpmc_cs_set_reserved(cs
, 1);
530 spin_unlock(&gpmc_mem_lock
);
533 EXPORT_SYMBOL(gpmc_cs_request
);
535 void gpmc_cs_free(int cs
)
537 spin_lock(&gpmc_mem_lock
);
538 if (cs
>= GPMC_CS_NUM
|| cs
< 0 || !gpmc_cs_reserved(cs
)) {
539 printk(KERN_ERR
"Trying to free non-reserved GPMC CS%d\n", cs
);
541 spin_unlock(&gpmc_mem_lock
);
544 gpmc_cs_disable_mem(cs
);
545 release_resource(&gpmc_cs_mem
[cs
]);
546 gpmc_cs_set_reserved(cs
, 0);
547 spin_unlock(&gpmc_mem_lock
);
549 EXPORT_SYMBOL(gpmc_cs_free
);
552 * gpmc_cs_configure - write request to configure gpmc
553 * @cs: chip select number
555 * @wval: value to write
556 * @return status of the operation
558 int gpmc_cs_configure(int cs
, int cmd
, int wval
)
564 case GPMC_ENABLE_IRQ
:
565 gpmc_write_reg(GPMC_IRQENABLE
, wval
);
568 case GPMC_SET_IRQ_STATUS
:
569 gpmc_write_reg(GPMC_IRQSTATUS
, wval
);
573 regval
= gpmc_read_reg(GPMC_CONFIG
);
575 regval
&= ~GPMC_CONFIG_WRITEPROTECT
; /* WP is ON */
577 regval
|= GPMC_CONFIG_WRITEPROTECT
; /* WP is OFF */
578 gpmc_write_reg(GPMC_CONFIG
, regval
);
581 case GPMC_CONFIG_RDY_BSY
:
582 regval
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG1
);
584 regval
|= WR_RD_PIN_MONITORING
;
586 regval
&= ~WR_RD_PIN_MONITORING
;
587 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG1
, regval
);
590 case GPMC_CONFIG_DEV_SIZE
:
591 regval
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG1
);
593 /* clear 2 target bits */
594 regval
&= ~GPMC_CONFIG1_DEVICESIZE(3);
596 /* set the proper value */
597 regval
|= GPMC_CONFIG1_DEVICESIZE(wval
);
599 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG1
, regval
);
602 case GPMC_CONFIG_DEV_TYPE
:
603 regval
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG1
);
604 /* clear 4 target bits */
605 regval
&= ~(GPMC_CONFIG1_DEVICETYPE(3) |
606 GPMC_CONFIG1_MUXTYPE(3));
607 /* set the proper value */
608 regval
|= GPMC_CONFIG1_DEVICETYPE(wval
);
609 if (wval
== GPMC_DEVICETYPE_NOR
)
610 regval
|= GPMC_CONFIG1_MUXADDDATA
;
611 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG1
, regval
);
615 printk(KERN_ERR
"gpmc_configure_cs: Not supported\n");
621 EXPORT_SYMBOL(gpmc_cs_configure
);
623 void gpmc_update_nand_reg(struct gpmc_nand_regs
*reg
, int cs
)
627 reg
->gpmc_status
= gpmc_base
+ GPMC_STATUS
;
628 reg
->gpmc_nand_command
= gpmc_base
+ GPMC_CS0_OFFSET
+
629 GPMC_CS_NAND_COMMAND
+ GPMC_CS_SIZE
* cs
;
630 reg
->gpmc_nand_address
= gpmc_base
+ GPMC_CS0_OFFSET
+
631 GPMC_CS_NAND_ADDRESS
+ GPMC_CS_SIZE
* cs
;
632 reg
->gpmc_nand_data
= gpmc_base
+ GPMC_CS0_OFFSET
+
633 GPMC_CS_NAND_DATA
+ GPMC_CS_SIZE
* cs
;
634 reg
->gpmc_prefetch_config1
= gpmc_base
+ GPMC_PREFETCH_CONFIG1
;
635 reg
->gpmc_prefetch_config2
= gpmc_base
+ GPMC_PREFETCH_CONFIG2
;
636 reg
->gpmc_prefetch_control
= gpmc_base
+ GPMC_PREFETCH_CONTROL
;
637 reg
->gpmc_prefetch_status
= gpmc_base
+ GPMC_PREFETCH_STATUS
;
638 reg
->gpmc_ecc_config
= gpmc_base
+ GPMC_ECC_CONFIG
;
639 reg
->gpmc_ecc_control
= gpmc_base
+ GPMC_ECC_CONTROL
;
640 reg
->gpmc_ecc_size_config
= gpmc_base
+ GPMC_ECC_SIZE_CONFIG
;
641 reg
->gpmc_ecc1_result
= gpmc_base
+ GPMC_ECC1_RESULT
;
643 for (i
= 0; i
< GPMC_BCH_NUM_REMAINDER
; i
++) {
644 reg
->gpmc_bch_result0
[i
] = gpmc_base
+ GPMC_ECC_BCH_RESULT_0
+
646 reg
->gpmc_bch_result1
[i
] = gpmc_base
+ GPMC_ECC_BCH_RESULT_1
+
648 reg
->gpmc_bch_result2
[i
] = gpmc_base
+ GPMC_ECC_BCH_RESULT_2
+
650 reg
->gpmc_bch_result3
[i
] = gpmc_base
+ GPMC_ECC_BCH_RESULT_3
+
655 int gpmc_get_client_irq(unsigned irq_config
)
659 if (hweight32(irq_config
) > 1)
662 for (i
= 0; i
< GPMC_NR_IRQ
; i
++)
663 if (gpmc_client_irq
[i
].bitmask
& irq_config
)
664 return gpmc_client_irq
[i
].irq
;
669 static int gpmc_irq_endis(unsigned irq
, bool endis
)
674 for (i
= 0; i
< GPMC_NR_IRQ
; i
++)
675 if (irq
== gpmc_client_irq
[i
].irq
) {
676 regval
= gpmc_read_reg(GPMC_IRQENABLE
);
678 regval
|= gpmc_client_irq
[i
].bitmask
;
680 regval
&= ~gpmc_client_irq
[i
].bitmask
;
681 gpmc_write_reg(GPMC_IRQENABLE
, regval
);
688 static void gpmc_irq_disable(struct irq_data
*p
)
690 gpmc_irq_endis(p
->irq
, false);
693 static void gpmc_irq_enable(struct irq_data
*p
)
695 gpmc_irq_endis(p
->irq
, true);
698 static void gpmc_irq_noop(struct irq_data
*data
) { }
700 static unsigned int gpmc_irq_noop_ret(struct irq_data
*data
) { return 0; }
702 static int gpmc_setup_irq(void)
710 gpmc_irq_start
= irq_alloc_descs(-1, 0, GPMC_NR_IRQ
, 0);
711 if (gpmc_irq_start
< 0) {
712 pr_err("irq_alloc_descs failed\n");
713 return gpmc_irq_start
;
716 gpmc_irq_chip
.name
= "gpmc";
717 gpmc_irq_chip
.irq_startup
= gpmc_irq_noop_ret
;
718 gpmc_irq_chip
.irq_enable
= gpmc_irq_enable
;
719 gpmc_irq_chip
.irq_disable
= gpmc_irq_disable
;
720 gpmc_irq_chip
.irq_shutdown
= gpmc_irq_noop
;
721 gpmc_irq_chip
.irq_ack
= gpmc_irq_noop
;
722 gpmc_irq_chip
.irq_mask
= gpmc_irq_noop
;
723 gpmc_irq_chip
.irq_unmask
= gpmc_irq_noop
;
725 gpmc_client_irq
[0].bitmask
= GPMC_IRQ_FIFOEVENTENABLE
;
726 gpmc_client_irq
[1].bitmask
= GPMC_IRQ_COUNT_EVENT
;
728 for (i
= 0; i
< GPMC_NR_IRQ
; i
++) {
729 gpmc_client_irq
[i
].irq
= gpmc_irq_start
+ i
;
730 irq_set_chip_and_handler(gpmc_client_irq
[i
].irq
,
731 &gpmc_irq_chip
, handle_simple_irq
);
732 set_irq_flags(gpmc_client_irq
[i
].irq
,
733 IRQF_VALID
| IRQF_NOAUTOEN
);
736 /* Disable interrupts */
737 gpmc_write_reg(GPMC_IRQENABLE
, 0);
739 /* clear interrupts */
740 regval
= gpmc_read_reg(GPMC_IRQSTATUS
);
741 gpmc_write_reg(GPMC_IRQSTATUS
, regval
);
743 return request_irq(gpmc_irq
, gpmc_handle_irq
, 0, "gpmc", NULL
);
746 static int gpmc_free_irq(void)
751 free_irq(gpmc_irq
, NULL
);
753 for (i
= 0; i
< GPMC_NR_IRQ
; i
++) {
754 irq_set_handler(gpmc_client_irq
[i
].irq
, NULL
);
755 irq_set_chip(gpmc_client_irq
[i
].irq
, &no_irq_chip
);
756 irq_modify_status(gpmc_client_irq
[i
].irq
, 0, 0);
759 irq_free_descs(gpmc_irq_start
, GPMC_NR_IRQ
);
764 static void gpmc_mem_exit(void)
768 for (cs
= 0; cs
< GPMC_CS_NUM
; cs
++) {
769 if (!gpmc_cs_mem_enabled(cs
))
771 gpmc_cs_delete_mem(cs
);
776 static int gpmc_mem_init(void)
779 unsigned long boot_rom_space
= 0;
781 /* never allocate the first page, to facilitate bug detection;
782 * even if we didn't boot from ROM.
784 boot_rom_space
= BOOT_ROM_SPACE
;
785 gpmc_mem_root
.start
= GPMC_MEM_START
+ boot_rom_space
;
786 gpmc_mem_root
.end
= GPMC_MEM_END
;
788 /* Reserve all regions that has been set up by bootloader */
789 for (cs
= 0; cs
< GPMC_CS_NUM
; cs
++) {
792 if (!gpmc_cs_mem_enabled(cs
))
794 gpmc_cs_get_memconf(cs
, &base
, &size
);
795 rc
= gpmc_cs_insert_mem(cs
, base
, size
);
798 if (gpmc_cs_mem_enabled(cs
))
799 gpmc_cs_delete_mem(cs
);
807 static u32
gpmc_round_ps_to_sync_clk(u32 time_ps
, u32 sync_clk
)
812 div
= gpmc_calc_divider(sync_clk
);
813 temp
= gpmc_ps_to_ticks(time_ps
);
814 temp
= (temp
+ div
- 1) / div
;
815 return gpmc_ticks_to_ps(temp
* div
);
818 /* XXX: can the cycles be avoided ? */
819 static int gpmc_calc_sync_read_timings(struct gpmc_timings
*gpmc_t
,
820 struct gpmc_device_timings
*dev_t
,
826 temp
= dev_t
->t_avdp_r
;
827 /* XXX: mux check required ? */
829 /* XXX: t_avdp not to be required for sync, only added for tusb
830 * this indirectly necessitates requirement of t_avdp_r and
831 * t_avdp_w instead of having a single t_avdp
833 temp
= max_t(u32
, temp
, gpmc_t
->clk_activation
+ dev_t
->t_avdh
);
834 temp
= max_t(u32
, gpmc_t
->adv_on
+ gpmc_ticks_to_ps(1), temp
);
836 gpmc_t
->adv_rd_off
= gpmc_round_ps_to_ticks(temp
);
839 temp
= dev_t
->t_oeasu
; /* XXX: remove this ? */
841 temp
= max_t(u32
, temp
, gpmc_t
->clk_activation
+ dev_t
->t_ach
);
842 temp
= max_t(u32
, temp
, gpmc_t
->adv_rd_off
+
843 gpmc_ticks_to_ps(dev_t
->cyc_aavdh_oe
));
845 gpmc_t
->oe_on
= gpmc_round_ps_to_ticks(temp
);
848 /* XXX: any scope for improvement ?, by combining oe_on
849 * and clk_activation, need to check whether
850 * access = clk_activation + round to sync clk ?
852 temp
= max_t(u32
, dev_t
->t_iaa
, dev_t
->cyc_iaa
* gpmc_t
->sync_clk
);
853 temp
+= gpmc_t
->clk_activation
;
855 temp
= max_t(u32
, temp
, gpmc_t
->oe_on
+
856 gpmc_ticks_to_ps(dev_t
->cyc_oe
));
857 gpmc_t
->access
= gpmc_round_ps_to_ticks(temp
);
859 gpmc_t
->oe_off
= gpmc_t
->access
+ gpmc_ticks_to_ps(1);
860 gpmc_t
->cs_rd_off
= gpmc_t
->oe_off
;
863 temp
= max_t(u32
, dev_t
->t_cez_r
, dev_t
->t_oez
);
864 temp
= gpmc_round_ps_to_sync_clk(temp
, gpmc_t
->sync_clk
) +
866 /* XXX: barter t_ce_rdyz with t_cez_r ? */
867 if (dev_t
->t_ce_rdyz
)
868 temp
= max_t(u32
, temp
, gpmc_t
->cs_rd_off
+ dev_t
->t_ce_rdyz
);
869 gpmc_t
->rd_cycle
= gpmc_round_ps_to_ticks(temp
);
874 static int gpmc_calc_sync_write_timings(struct gpmc_timings
*gpmc_t
,
875 struct gpmc_device_timings
*dev_t
,
881 temp
= dev_t
->t_avdp_w
;
883 temp
= max_t(u32
, temp
,
884 gpmc_t
->clk_activation
+ dev_t
->t_avdh
);
885 temp
= max_t(u32
, gpmc_t
->adv_on
+ gpmc_ticks_to_ps(1), temp
);
887 gpmc_t
->adv_wr_off
= gpmc_round_ps_to_ticks(temp
);
889 /* wr_data_mux_bus */
890 temp
= max_t(u32
, dev_t
->t_weasu
,
891 gpmc_t
->clk_activation
+ dev_t
->t_rdyo
);
892 /* XXX: shouldn't mux be kept as a whole for wr_data_mux_bus ?,
893 * and in that case remember to handle we_on properly
896 temp
= max_t(u32
, temp
,
897 gpmc_t
->adv_wr_off
+ dev_t
->t_aavdh
);
898 temp
= max_t(u32
, temp
, gpmc_t
->adv_wr_off
+
899 gpmc_ticks_to_ps(dev_t
->cyc_aavdh_we
));
901 gpmc_t
->wr_data_mux_bus
= gpmc_round_ps_to_ticks(temp
);
904 if (gpmc_capability
& GPMC_HAS_WR_DATA_MUX_BUS
)
905 gpmc_t
->we_on
= gpmc_round_ps_to_ticks(dev_t
->t_weasu
);
907 gpmc_t
->we_on
= gpmc_t
->wr_data_mux_bus
;
910 /* XXX: gpmc_capability check reqd ? , even if not, will not harm */
911 gpmc_t
->wr_access
= gpmc_t
->access
;
914 temp
= gpmc_t
->we_on
+ dev_t
->t_wpl
;
915 temp
= max_t(u32
, temp
,
916 gpmc_t
->wr_access
+ gpmc_ticks_to_ps(1));
917 temp
= max_t(u32
, temp
,
918 gpmc_t
->we_on
+ gpmc_ticks_to_ps(dev_t
->cyc_wpl
));
919 gpmc_t
->we_off
= gpmc_round_ps_to_ticks(temp
);
921 gpmc_t
->cs_wr_off
= gpmc_round_ps_to_ticks(gpmc_t
->we_off
+
925 temp
= gpmc_round_ps_to_sync_clk(dev_t
->t_cez_w
, gpmc_t
->sync_clk
);
926 temp
+= gpmc_t
->wr_access
;
927 /* XXX: barter t_ce_rdyz with t_cez_w ? */
928 if (dev_t
->t_ce_rdyz
)
929 temp
= max_t(u32
, temp
,
930 gpmc_t
->cs_wr_off
+ dev_t
->t_ce_rdyz
);
931 gpmc_t
->wr_cycle
= gpmc_round_ps_to_ticks(temp
);
936 static int gpmc_calc_async_read_timings(struct gpmc_timings
*gpmc_t
,
937 struct gpmc_device_timings
*dev_t
,
943 temp
= dev_t
->t_avdp_r
;
945 temp
= max_t(u32
, gpmc_t
->adv_on
+ gpmc_ticks_to_ps(1), temp
);
946 gpmc_t
->adv_rd_off
= gpmc_round_ps_to_ticks(temp
);
949 temp
= dev_t
->t_oeasu
;
951 temp
= max_t(u32
, temp
,
952 gpmc_t
->adv_rd_off
+ dev_t
->t_aavdh
);
953 gpmc_t
->oe_on
= gpmc_round_ps_to_ticks(temp
);
956 temp
= max_t(u32
, dev_t
->t_iaa
, /* XXX: remove t_iaa in async ? */
957 gpmc_t
->oe_on
+ dev_t
->t_oe
);
958 temp
= max_t(u32
, temp
,
959 gpmc_t
->cs_on
+ dev_t
->t_ce
);
960 temp
= max_t(u32
, temp
,
961 gpmc_t
->adv_on
+ dev_t
->t_aa
);
962 gpmc_t
->access
= gpmc_round_ps_to_ticks(temp
);
964 gpmc_t
->oe_off
= gpmc_t
->access
+ gpmc_ticks_to_ps(1);
965 gpmc_t
->cs_rd_off
= gpmc_t
->oe_off
;
968 temp
= max_t(u32
, dev_t
->t_rd_cycle
,
969 gpmc_t
->cs_rd_off
+ dev_t
->t_cez_r
);
970 temp
= max_t(u32
, temp
, gpmc_t
->oe_off
+ dev_t
->t_oez
);
971 gpmc_t
->rd_cycle
= gpmc_round_ps_to_ticks(temp
);
976 static int gpmc_calc_async_write_timings(struct gpmc_timings
*gpmc_t
,
977 struct gpmc_device_timings
*dev_t
,
983 temp
= dev_t
->t_avdp_w
;
985 temp
= max_t(u32
, gpmc_t
->adv_on
+ gpmc_ticks_to_ps(1), temp
);
986 gpmc_t
->adv_wr_off
= gpmc_round_ps_to_ticks(temp
);
988 /* wr_data_mux_bus */
989 temp
= dev_t
->t_weasu
;
991 temp
= max_t(u32
, temp
, gpmc_t
->adv_wr_off
+ dev_t
->t_aavdh
);
992 temp
= max_t(u32
, temp
, gpmc_t
->adv_wr_off
+
993 gpmc_ticks_to_ps(dev_t
->cyc_aavdh_we
));
995 gpmc_t
->wr_data_mux_bus
= gpmc_round_ps_to_ticks(temp
);
998 if (gpmc_capability
& GPMC_HAS_WR_DATA_MUX_BUS
)
999 gpmc_t
->we_on
= gpmc_round_ps_to_ticks(dev_t
->t_weasu
);
1001 gpmc_t
->we_on
= gpmc_t
->wr_data_mux_bus
;
1004 temp
= gpmc_t
->we_on
+ dev_t
->t_wpl
;
1005 gpmc_t
->we_off
= gpmc_round_ps_to_ticks(temp
);
1007 gpmc_t
->cs_wr_off
= gpmc_round_ps_to_ticks(gpmc_t
->we_off
+
1011 temp
= max_t(u32
, dev_t
->t_wr_cycle
,
1012 gpmc_t
->cs_wr_off
+ dev_t
->t_cez_w
);
1013 gpmc_t
->wr_cycle
= gpmc_round_ps_to_ticks(temp
);
1018 static int gpmc_calc_sync_common_timings(struct gpmc_timings
*gpmc_t
,
1019 struct gpmc_device_timings
*dev_t
)
1023 gpmc_t
->sync_clk
= gpmc_calc_divider(dev_t
->clk
) *
1024 gpmc_get_fclk_period();
1026 gpmc_t
->page_burst_access
= gpmc_round_ps_to_sync_clk(
1030 temp
= max_t(u32
, dev_t
->t_ces
, dev_t
->t_avds
);
1031 gpmc_t
->clk_activation
= gpmc_round_ps_to_ticks(temp
);
1033 if (gpmc_calc_divider(gpmc_t
->sync_clk
) != 1)
1036 if (dev_t
->ce_xdelay
)
1037 gpmc_t
->bool_timings
.cs_extra_delay
= true;
1038 if (dev_t
->avd_xdelay
)
1039 gpmc_t
->bool_timings
.adv_extra_delay
= true;
1040 if (dev_t
->oe_xdelay
)
1041 gpmc_t
->bool_timings
.oe_extra_delay
= true;
1042 if (dev_t
->we_xdelay
)
1043 gpmc_t
->bool_timings
.we_extra_delay
= true;
1048 static int gpmc_calc_common_timings(struct gpmc_timings
*gpmc_t
,
1049 struct gpmc_device_timings
*dev_t
,
1055 gpmc_t
->cs_on
= gpmc_round_ps_to_ticks(dev_t
->t_ceasu
);
1058 temp
= dev_t
->t_avdasu
;
1059 if (dev_t
->t_ce_avd
)
1060 temp
= max_t(u32
, temp
,
1061 gpmc_t
->cs_on
+ dev_t
->t_ce_avd
);
1062 gpmc_t
->adv_on
= gpmc_round_ps_to_ticks(temp
);
1065 gpmc_calc_sync_common_timings(gpmc_t
, dev_t
);
1070 /* TODO: remove this function once all peripherals are confirmed to
1071 * work with generic timing. Simultaneously gpmc_cs_set_timings()
1072 * has to be modified to handle timings in ps instead of ns
1074 static void gpmc_convert_ps_to_ns(struct gpmc_timings
*t
)
1077 t
->cs_rd_off
/= 1000;
1078 t
->cs_wr_off
/= 1000;
1080 t
->adv_rd_off
/= 1000;
1081 t
->adv_wr_off
/= 1000;
1086 t
->page_burst_access
/= 1000;
1088 t
->rd_cycle
/= 1000;
1089 t
->wr_cycle
/= 1000;
1090 t
->bus_turnaround
/= 1000;
1091 t
->cycle2cycle_delay
/= 1000;
1092 t
->wait_monitoring
/= 1000;
1093 t
->clk_activation
/= 1000;
1094 t
->wr_access
/= 1000;
1095 t
->wr_data_mux_bus
/= 1000;
1098 int gpmc_calc_timings(struct gpmc_timings
*gpmc_t
,
1099 struct gpmc_settings
*gpmc_s
,
1100 struct gpmc_device_timings
*dev_t
)
1102 bool mux
= false, sync
= false;
1105 mux
= gpmc_s
->mux_add_data
? true : false;
1106 sync
= (gpmc_s
->sync_read
|| gpmc_s
->sync_write
);
1109 memset(gpmc_t
, 0, sizeof(*gpmc_t
));
1111 gpmc_calc_common_timings(gpmc_t
, dev_t
, sync
);
1113 if (gpmc_s
&& gpmc_s
->sync_read
)
1114 gpmc_calc_sync_read_timings(gpmc_t
, dev_t
, mux
);
1116 gpmc_calc_async_read_timings(gpmc_t
, dev_t
, mux
);
1118 if (gpmc_s
&& gpmc_s
->sync_write
)
1119 gpmc_calc_sync_write_timings(gpmc_t
, dev_t
, mux
);
1121 gpmc_calc_async_write_timings(gpmc_t
, dev_t
, mux
);
1123 /* TODO: remove, see function definition */
1124 gpmc_convert_ps_to_ns(gpmc_t
);
1130 static struct of_device_id gpmc_dt_ids
[] = {
1131 { .compatible
= "ti,omap2420-gpmc" },
1132 { .compatible
= "ti,omap2430-gpmc" },
1133 { .compatible
= "ti,omap3430-gpmc" }, /* omap3430 & omap3630 */
1134 { .compatible
= "ti,omap4430-gpmc" }, /* omap4430 & omap4460 & omap543x */
1135 { .compatible
= "ti,am3352-gpmc" }, /* am335x devices */
1138 MODULE_DEVICE_TABLE(of
, gpmc_dt_ids
);
1140 static void __maybe_unused
gpmc_read_timings_dt(struct device_node
*np
,
1141 struct gpmc_timings
*gpmc_t
)
1145 memset(gpmc_t
, 0, sizeof(*gpmc_t
));
1147 /* minimum clock period for syncronous mode */
1148 if (!of_property_read_u32(np
, "gpmc,sync-clk", &val
))
1149 gpmc_t
->sync_clk
= val
;
1151 /* chip select timtings */
1152 if (!of_property_read_u32(np
, "gpmc,cs-on", &val
))
1153 gpmc_t
->cs_on
= val
;
1155 if (!of_property_read_u32(np
, "gpmc,cs-rd-off", &val
))
1156 gpmc_t
->cs_rd_off
= val
;
1158 if (!of_property_read_u32(np
, "gpmc,cs-wr-off", &val
))
1159 gpmc_t
->cs_wr_off
= val
;
1161 /* ADV signal timings */
1162 if (!of_property_read_u32(np
, "gpmc,adv-on", &val
))
1163 gpmc_t
->adv_on
= val
;
1165 if (!of_property_read_u32(np
, "gpmc,adv-rd-off", &val
))
1166 gpmc_t
->adv_rd_off
= val
;
1168 if (!of_property_read_u32(np
, "gpmc,adv-wr-off", &val
))
1169 gpmc_t
->adv_wr_off
= val
;
1171 /* WE signal timings */
1172 if (!of_property_read_u32(np
, "gpmc,we-on", &val
))
1173 gpmc_t
->we_on
= val
;
1175 if (!of_property_read_u32(np
, "gpmc,we-off", &val
))
1176 gpmc_t
->we_off
= val
;
1178 /* OE signal timings */
1179 if (!of_property_read_u32(np
, "gpmc,oe-on", &val
))
1180 gpmc_t
->oe_on
= val
;
1182 if (!of_property_read_u32(np
, "gpmc,oe-off", &val
))
1183 gpmc_t
->oe_off
= val
;
1185 /* access and cycle timings */
1186 if (!of_property_read_u32(np
, "gpmc,page-burst-access", &val
))
1187 gpmc_t
->page_burst_access
= val
;
1189 if (!of_property_read_u32(np
, "gpmc,access", &val
))
1190 gpmc_t
->access
= val
;
1192 if (!of_property_read_u32(np
, "gpmc,rd-cycle", &val
))
1193 gpmc_t
->rd_cycle
= val
;
1195 if (!of_property_read_u32(np
, "gpmc,wr-cycle", &val
))
1196 gpmc_t
->wr_cycle
= val
;
1198 /* only for OMAP3430 */
1199 if (!of_property_read_u32(np
, "gpmc,wr-access", &val
))
1200 gpmc_t
->wr_access
= val
;
1202 if (!of_property_read_u32(np
, "gpmc,wr-data-mux-bus", &val
))
1203 gpmc_t
->wr_data_mux_bus
= val
;
1206 #ifdef CONFIG_MTD_NAND
1208 static const char * const nand_ecc_opts
[] = {
1209 [OMAP_ECC_HAMMING_CODE_DEFAULT
] = "sw",
1210 [OMAP_ECC_HAMMING_CODE_HW
] = "hw",
1211 [OMAP_ECC_HAMMING_CODE_HW_ROMCODE
] = "hw-romcode",
1212 [OMAP_ECC_BCH4_CODE_HW
] = "bch4",
1213 [OMAP_ECC_BCH8_CODE_HW
] = "bch8",
1216 static int gpmc_probe_nand_child(struct platform_device
*pdev
,
1217 struct device_node
*child
)
1221 struct gpmc_timings gpmc_t
;
1222 struct omap_nand_platform_data
*gpmc_nand_data
;
1224 if (of_property_read_u32(child
, "reg", &val
) < 0) {
1225 dev_err(&pdev
->dev
, "%s has no 'reg' property\n",
1230 gpmc_nand_data
= devm_kzalloc(&pdev
->dev
, sizeof(*gpmc_nand_data
),
1232 if (!gpmc_nand_data
)
1235 gpmc_nand_data
->cs
= val
;
1236 gpmc_nand_data
->of_node
= child
;
1238 if (!of_property_read_string(child
, "ti,nand-ecc-opt", &s
))
1239 for (val
= 0; val
< ARRAY_SIZE(nand_ecc_opts
); val
++)
1240 if (!strcasecmp(s
, nand_ecc_opts
[val
])) {
1241 gpmc_nand_data
->ecc_opt
= val
;
1245 val
= of_get_nand_bus_width(child
);
1247 gpmc_nand_data
->devsize
= NAND_BUSWIDTH_16
;
1249 gpmc_read_timings_dt(child
, &gpmc_t
);
1250 gpmc_nand_init(gpmc_nand_data
, &gpmc_t
);
1255 static int gpmc_probe_nand_child(struct platform_device
*pdev
,
1256 struct device_node
*child
)
1262 #ifdef CONFIG_MTD_ONENAND
1263 static int gpmc_probe_onenand_child(struct platform_device
*pdev
,
1264 struct device_node
*child
)
1267 struct omap_onenand_platform_data
*gpmc_onenand_data
;
1269 if (of_property_read_u32(child
, "reg", &val
) < 0) {
1270 dev_err(&pdev
->dev
, "%s has no 'reg' property\n",
1275 gpmc_onenand_data
= devm_kzalloc(&pdev
->dev
, sizeof(*gpmc_onenand_data
),
1277 if (!gpmc_onenand_data
)
1280 gpmc_onenand_data
->cs
= val
;
1281 gpmc_onenand_data
->of_node
= child
;
1282 gpmc_onenand_data
->dma_channel
= -1;
1284 if (!of_property_read_u32(child
, "dma-channel", &val
))
1285 gpmc_onenand_data
->dma_channel
= val
;
1287 gpmc_onenand_init(gpmc_onenand_data
);
1292 static int gpmc_probe_onenand_child(struct platform_device
*pdev
,
1293 struct device_node
*child
)
1299 static int gpmc_probe_dt(struct platform_device
*pdev
)
1302 struct device_node
*child
;
1303 const struct of_device_id
*of_id
=
1304 of_match_device(gpmc_dt_ids
, &pdev
->dev
);
1309 ret
= of_property_read_u32(pdev
->dev
.of_node
, "gpmc,num-waitpins",
1312 pr_err("%s: number of wait pins not found!\n", __func__
);
1316 for_each_node_by_name(child
, "nand") {
1317 ret
= gpmc_probe_nand_child(pdev
, child
);
1324 for_each_node_by_name(child
, "onenand") {
1325 ret
= gpmc_probe_onenand_child(pdev
, child
);
1334 static int gpmc_probe_dt(struct platform_device
*pdev
)
1340 static int gpmc_probe(struct platform_device
*pdev
)
1344 struct resource
*res
;
1346 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1350 phys_base
= res
->start
;
1351 mem_size
= resource_size(res
);
1353 gpmc_base
= devm_ioremap_resource(&pdev
->dev
, res
);
1354 if (IS_ERR(gpmc_base
))
1355 return PTR_ERR(gpmc_base
);
1357 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
1359 dev_warn(&pdev
->dev
, "Failed to get resource: irq\n");
1361 gpmc_irq
= res
->start
;
1363 gpmc_l3_clk
= clk_get(&pdev
->dev
, "fck");
1364 if (IS_ERR(gpmc_l3_clk
)) {
1365 dev_err(&pdev
->dev
, "error: clk_get\n");
1367 return PTR_ERR(gpmc_l3_clk
);
1370 clk_prepare_enable(gpmc_l3_clk
);
1372 gpmc_dev
= &pdev
->dev
;
1374 l
= gpmc_read_reg(GPMC_REVISION
);
1375 if (GPMC_REVISION_MAJOR(l
) > 0x4)
1376 gpmc_capability
= GPMC_HAS_WR_ACCESS
| GPMC_HAS_WR_DATA_MUX_BUS
;
1377 dev_info(gpmc_dev
, "GPMC revision %d.%d\n", GPMC_REVISION_MAJOR(l
),
1378 GPMC_REVISION_MINOR(l
));
1380 rc
= gpmc_mem_init();
1382 clk_disable_unprepare(gpmc_l3_clk
);
1383 clk_put(gpmc_l3_clk
);
1384 dev_err(gpmc_dev
, "failed to reserve memory\n");
1388 if (gpmc_setup_irq() < 0)
1389 dev_warn(gpmc_dev
, "gpmc_setup_irq failed\n");
1391 /* Now the GPMC is initialised, unreserve the chip-selects */
1394 if (!pdev
->dev
.of_node
)
1395 gpmc_nr_waitpins
= GPMC_NR_WAITPINS
;
1397 rc
= gpmc_probe_dt(pdev
);
1399 clk_disable_unprepare(gpmc_l3_clk
);
1400 clk_put(gpmc_l3_clk
);
1401 dev_err(gpmc_dev
, "failed to probe DT parameters\n");
1408 static int gpmc_remove(struct platform_device
*pdev
)
1416 static struct platform_driver gpmc_driver
= {
1417 .probe
= gpmc_probe
,
1418 .remove
= gpmc_remove
,
1420 .name
= DEVICE_NAME
,
1421 .owner
= THIS_MODULE
,
1422 .of_match_table
= of_match_ptr(gpmc_dt_ids
),
1426 static __init
int gpmc_init(void)
1428 return platform_driver_register(&gpmc_driver
);
1431 static __exit
void gpmc_exit(void)
1433 platform_driver_unregister(&gpmc_driver
);
1437 omap_postcore_initcall(gpmc_init
);
1438 module_exit(gpmc_exit
);
1440 static int __init
omap_gpmc_init(void)
1442 struct omap_hwmod
*oh
;
1443 struct platform_device
*pdev
;
1444 char *oh_name
= "gpmc";
1447 * if the board boots up with a populated DT, do not
1448 * manually add the device from this initcall
1450 if (of_have_populated_dt())
1453 oh
= omap_hwmod_lookup(oh_name
);
1455 pr_err("Could not look up %s\n", oh_name
);
1459 pdev
= omap_device_build(DEVICE_NAME
, -1, oh
, NULL
, 0);
1460 WARN(IS_ERR(pdev
), "could not build omap_device for %s\n", oh_name
);
1462 return IS_ERR(pdev
) ? PTR_ERR(pdev
) : 0;
1464 omap_postcore_initcall(omap_gpmc_init
);
1466 static irqreturn_t
gpmc_handle_irq(int irq
, void *dev
)
1471 regval
= gpmc_read_reg(GPMC_IRQSTATUS
);
1476 for (i
= 0; i
< GPMC_NR_IRQ
; i
++)
1477 if (regval
& gpmc_client_irq
[i
].bitmask
)
1478 generic_handle_irq(gpmc_client_irq
[i
].irq
);
1480 gpmc_write_reg(GPMC_IRQSTATUS
, regval
);
1485 #ifdef CONFIG_ARCH_OMAP3
1486 static struct omap3_gpmc_regs gpmc_context
;
1488 void omap3_gpmc_save_context(void)
1492 gpmc_context
.sysconfig
= gpmc_read_reg(GPMC_SYSCONFIG
);
1493 gpmc_context
.irqenable
= gpmc_read_reg(GPMC_IRQENABLE
);
1494 gpmc_context
.timeout_ctrl
= gpmc_read_reg(GPMC_TIMEOUT_CONTROL
);
1495 gpmc_context
.config
= gpmc_read_reg(GPMC_CONFIG
);
1496 gpmc_context
.prefetch_config1
= gpmc_read_reg(GPMC_PREFETCH_CONFIG1
);
1497 gpmc_context
.prefetch_config2
= gpmc_read_reg(GPMC_PREFETCH_CONFIG2
);
1498 gpmc_context
.prefetch_control
= gpmc_read_reg(GPMC_PREFETCH_CONTROL
);
1499 for (i
= 0; i
< GPMC_CS_NUM
; i
++) {
1500 gpmc_context
.cs_context
[i
].is_valid
= gpmc_cs_mem_enabled(i
);
1501 if (gpmc_context
.cs_context
[i
].is_valid
) {
1502 gpmc_context
.cs_context
[i
].config1
=
1503 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG1
);
1504 gpmc_context
.cs_context
[i
].config2
=
1505 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG2
);
1506 gpmc_context
.cs_context
[i
].config3
=
1507 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG3
);
1508 gpmc_context
.cs_context
[i
].config4
=
1509 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG4
);
1510 gpmc_context
.cs_context
[i
].config5
=
1511 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG5
);
1512 gpmc_context
.cs_context
[i
].config6
=
1513 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG6
);
1514 gpmc_context
.cs_context
[i
].config7
=
1515 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG7
);
1520 void omap3_gpmc_restore_context(void)
1524 gpmc_write_reg(GPMC_SYSCONFIG
, gpmc_context
.sysconfig
);
1525 gpmc_write_reg(GPMC_IRQENABLE
, gpmc_context
.irqenable
);
1526 gpmc_write_reg(GPMC_TIMEOUT_CONTROL
, gpmc_context
.timeout_ctrl
);
1527 gpmc_write_reg(GPMC_CONFIG
, gpmc_context
.config
);
1528 gpmc_write_reg(GPMC_PREFETCH_CONFIG1
, gpmc_context
.prefetch_config1
);
1529 gpmc_write_reg(GPMC_PREFETCH_CONFIG2
, gpmc_context
.prefetch_config2
);
1530 gpmc_write_reg(GPMC_PREFETCH_CONTROL
, gpmc_context
.prefetch_control
);
1531 for (i
= 0; i
< GPMC_CS_NUM
; i
++) {
1532 if (gpmc_context
.cs_context
[i
].is_valid
) {
1533 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG1
,
1534 gpmc_context
.cs_context
[i
].config1
);
1535 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG2
,
1536 gpmc_context
.cs_context
[i
].config2
);
1537 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG3
,
1538 gpmc_context
.cs_context
[i
].config3
);
1539 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG4
,
1540 gpmc_context
.cs_context
[i
].config4
);
1541 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG5
,
1542 gpmc_context
.cs_context
[i
].config5
);
1543 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG6
,
1544 gpmc_context
.cs_context
[i
].config6
);
1545 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG7
,
1546 gpmc_context
.cs_context
[i
].config7
);
1550 #endif /* CONFIG_ARCH_OMAP3 */