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.
15 #include <linux/irq.h>
16 #include <linux/kernel.h>
17 #include <linux/init.h>
18 #include <linux/err.h>
19 #include <linux/clk.h>
20 #include <linux/ioport.h>
21 #include <linux/spinlock.h>
23 #include <linux/module.h>
24 #include <linux/interrupt.h>
25 #include <linux/platform_device.h>
27 #include <linux/of_address.h>
28 #include <linux/of_mtd.h>
29 #include <linux/of_device.h>
30 #include <linux/omap-gpmc.h>
31 #include <linux/mtd/nand.h>
32 #include <linux/pm_runtime.h>
34 #include <linux/platform_data/mtd-nand-omap2.h>
35 #include <linux/platform_data/mtd-onenand-omap2.h>
37 #include <asm/mach-types.h>
39 #define DEVICE_NAME "omap-gpmc"
41 /* GPMC register offsets */
42 #define GPMC_REVISION 0x00
43 #define GPMC_SYSCONFIG 0x10
44 #define GPMC_SYSSTATUS 0x14
45 #define GPMC_IRQSTATUS 0x18
46 #define GPMC_IRQENABLE 0x1c
47 #define GPMC_TIMEOUT_CONTROL 0x40
48 #define GPMC_ERR_ADDRESS 0x44
49 #define GPMC_ERR_TYPE 0x48
50 #define GPMC_CONFIG 0x50
51 #define GPMC_STATUS 0x54
52 #define GPMC_PREFETCH_CONFIG1 0x1e0
53 #define GPMC_PREFETCH_CONFIG2 0x1e4
54 #define GPMC_PREFETCH_CONTROL 0x1ec
55 #define GPMC_PREFETCH_STATUS 0x1f0
56 #define GPMC_ECC_CONFIG 0x1f4
57 #define GPMC_ECC_CONTROL 0x1f8
58 #define GPMC_ECC_SIZE_CONFIG 0x1fc
59 #define GPMC_ECC1_RESULT 0x200
60 #define GPMC_ECC_BCH_RESULT_0 0x240 /* not available on OMAP2 */
61 #define GPMC_ECC_BCH_RESULT_1 0x244 /* not available on OMAP2 */
62 #define GPMC_ECC_BCH_RESULT_2 0x248 /* not available on OMAP2 */
63 #define GPMC_ECC_BCH_RESULT_3 0x24c /* not available on OMAP2 */
64 #define GPMC_ECC_BCH_RESULT_4 0x300 /* not available on OMAP2 */
65 #define GPMC_ECC_BCH_RESULT_5 0x304 /* not available on OMAP2 */
66 #define GPMC_ECC_BCH_RESULT_6 0x308 /* 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_CONFIG_LIMITEDADDRESS BIT(1)
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_END 0x3FFFFFFF
96 #define GPMC_CHUNK_SHIFT 24 /* 16 MB */
97 #define GPMC_SECTION_SHIFT 28 /* 128 MB */
99 #define CS_NUM_SHIFT 24
100 #define ENABLE_PREFETCH (0x1 << 7)
101 #define DMA_MPU_MODE 2
103 #define GPMC_REVISION_MAJOR(l) ((l >> 4) & 0xf)
104 #define GPMC_REVISION_MINOR(l) (l & 0xf)
106 #define GPMC_HAS_WR_ACCESS 0x1
107 #define GPMC_HAS_WR_DATA_MUX_BUS 0x2
108 #define GPMC_HAS_MUX_AAD 0x4
110 #define GPMC_NR_WAITPINS 4
112 #define GPMC_CS_CONFIG1 0x00
113 #define GPMC_CS_CONFIG2 0x04
114 #define GPMC_CS_CONFIG3 0x08
115 #define GPMC_CS_CONFIG4 0x0c
116 #define GPMC_CS_CONFIG5 0x10
117 #define GPMC_CS_CONFIG6 0x14
118 #define GPMC_CS_CONFIG7 0x18
119 #define GPMC_CS_NAND_COMMAND 0x1c
120 #define GPMC_CS_NAND_ADDRESS 0x20
121 #define GPMC_CS_NAND_DATA 0x24
123 /* Control Commands */
124 #define GPMC_CONFIG_RDY_BSY 0x00000001
125 #define GPMC_CONFIG_DEV_SIZE 0x00000002
126 #define GPMC_CONFIG_DEV_TYPE 0x00000003
127 #define GPMC_SET_IRQ_STATUS 0x00000004
129 #define GPMC_CONFIG1_WRAPBURST_SUPP (1 << 31)
130 #define GPMC_CONFIG1_READMULTIPLE_SUPP (1 << 30)
131 #define GPMC_CONFIG1_READTYPE_ASYNC (0 << 29)
132 #define GPMC_CONFIG1_READTYPE_SYNC (1 << 29)
133 #define GPMC_CONFIG1_WRITEMULTIPLE_SUPP (1 << 28)
134 #define GPMC_CONFIG1_WRITETYPE_ASYNC (0 << 27)
135 #define GPMC_CONFIG1_WRITETYPE_SYNC (1 << 27)
136 #define GPMC_CONFIG1_CLKACTIVATIONTIME(val) ((val & 3) << 25)
137 #define GPMC_CONFIG1_PAGE_LEN(val) ((val & 3) << 23)
138 #define GPMC_CONFIG1_WAIT_READ_MON (1 << 22)
139 #define GPMC_CONFIG1_WAIT_WRITE_MON (1 << 21)
140 #define GPMC_CONFIG1_WAIT_MON_IIME(val) ((val & 3) << 18)
141 #define GPMC_CONFIG1_WAIT_PIN_SEL(val) ((val & 3) << 16)
142 #define GPMC_CONFIG1_DEVICESIZE(val) ((val & 3) << 12)
143 #define GPMC_CONFIG1_DEVICESIZE_16 GPMC_CONFIG1_DEVICESIZE(1)
144 #define GPMC_CONFIG1_DEVICETYPE(val) ((val & 3) << 10)
145 #define GPMC_CONFIG1_DEVICETYPE_NOR GPMC_CONFIG1_DEVICETYPE(0)
146 #define GPMC_CONFIG1_MUXTYPE(val) ((val & 3) << 8)
147 #define GPMC_CONFIG1_TIME_PARA_GRAN (1 << 4)
148 #define GPMC_CONFIG1_FCLK_DIV(val) (val & 3)
149 #define GPMC_CONFIG1_FCLK_DIV2 (GPMC_CONFIG1_FCLK_DIV(1))
150 #define GPMC_CONFIG1_FCLK_DIV3 (GPMC_CONFIG1_FCLK_DIV(2))
151 #define GPMC_CONFIG1_FCLK_DIV4 (GPMC_CONFIG1_FCLK_DIV(3))
152 #define GPMC_CONFIG7_CSVALID (1 << 6)
154 #define GPMC_CONFIG7_BASEADDRESS_MASK 0x3f
155 #define GPMC_CONFIG7_CSVALID_MASK BIT(6)
156 #define GPMC_CONFIG7_MASKADDRESS_OFFSET 8
157 #define GPMC_CONFIG7_MASKADDRESS_MASK (0xf << GPMC_CONFIG7_MASKADDRESS_OFFSET)
158 /* All CONFIG7 bits except reserved bits */
159 #define GPMC_CONFIG7_MASK (GPMC_CONFIG7_BASEADDRESS_MASK | \
160 GPMC_CONFIG7_CSVALID_MASK | \
161 GPMC_CONFIG7_MASKADDRESS_MASK)
163 #define GPMC_DEVICETYPE_NOR 0
164 #define GPMC_DEVICETYPE_NAND 2
165 #define GPMC_CONFIG_WRITEPROTECT 0x00000010
166 #define WR_RD_PIN_MONITORING 0x00600000
168 #define GPMC_ENABLE_IRQ 0x0000000d
171 #define GPMC_ECC_READ 0 /* Reset Hardware ECC for read */
172 #define GPMC_ECC_WRITE 1 /* Reset Hardware ECC for write */
173 #define GPMC_ECC_READSYN 2 /* Reset before syndrom is read back */
175 /* XXX: Only NAND irq has been considered,currently these are the only ones used
177 #define GPMC_NR_IRQ 2
179 struct gpmc_cs_data
{
182 #define GPMC_CS_RESERVED (1 << 0)
188 struct gpmc_client_irq
{
193 /* Structure to save gpmc cs context */
194 struct gpmc_cs_config
{
206 * Structure to save/restore gpmc context
207 * to support core off on OMAP3
209 struct omap3_gpmc_regs
{
214 u32 prefetch_config1
;
215 u32 prefetch_config2
;
216 u32 prefetch_control
;
217 struct gpmc_cs_config cs_context
[GPMC_CS_NUM
];
220 static struct gpmc_client_irq gpmc_client_irq
[GPMC_NR_IRQ
];
221 static struct irq_chip gpmc_irq_chip
;
222 static int gpmc_irq_start
;
224 static struct resource gpmc_mem_root
;
225 static struct gpmc_cs_data gpmc_cs
[GPMC_CS_NUM
];
226 static DEFINE_SPINLOCK(gpmc_mem_lock
);
227 /* Define chip-selects as reserved by default until probe completes */
228 static unsigned int gpmc_cs_num
= GPMC_CS_NUM
;
229 static unsigned int gpmc_nr_waitpins
;
230 static struct device
*gpmc_dev
;
232 static resource_size_t phys_base
, mem_size
;
233 static unsigned gpmc_capability
;
234 static void __iomem
*gpmc_base
;
236 static struct clk
*gpmc_l3_clk
;
238 static irqreturn_t
gpmc_handle_irq(int irq
, void *dev
);
240 static void gpmc_write_reg(int idx
, u32 val
)
242 writel_relaxed(val
, gpmc_base
+ idx
);
245 static u32
gpmc_read_reg(int idx
)
247 return readl_relaxed(gpmc_base
+ idx
);
250 void gpmc_cs_write_reg(int cs
, int idx
, u32 val
)
252 void __iomem
*reg_addr
;
254 reg_addr
= gpmc_base
+ GPMC_CS0_OFFSET
+ (cs
* GPMC_CS_SIZE
) + idx
;
255 writel_relaxed(val
, reg_addr
);
258 static u32
gpmc_cs_read_reg(int cs
, int idx
)
260 void __iomem
*reg_addr
;
262 reg_addr
= gpmc_base
+ GPMC_CS0_OFFSET
+ (cs
* GPMC_CS_SIZE
) + idx
;
263 return readl_relaxed(reg_addr
);
266 /* TODO: Add support for gpmc_fck to clock framework and use it */
267 static unsigned long gpmc_get_fclk_period(void)
269 unsigned long rate
= clk_get_rate(gpmc_l3_clk
);
272 rate
= 1000000000 / rate
; /* In picoseconds */
277 static unsigned int gpmc_ns_to_ticks(unsigned int time_ns
)
279 unsigned long tick_ps
;
281 /* Calculate in picosecs to yield more exact results */
282 tick_ps
= gpmc_get_fclk_period();
284 return (time_ns
* 1000 + tick_ps
- 1) / tick_ps
;
287 static unsigned int gpmc_ps_to_ticks(unsigned int time_ps
)
289 unsigned long tick_ps
;
291 /* Calculate in picosecs to yield more exact results */
292 tick_ps
= gpmc_get_fclk_period();
294 return (time_ps
+ tick_ps
- 1) / tick_ps
;
297 unsigned int gpmc_ticks_to_ns(unsigned int ticks
)
299 return ticks
* gpmc_get_fclk_period() / 1000;
302 static unsigned int gpmc_ticks_to_ps(unsigned int ticks
)
304 return ticks
* gpmc_get_fclk_period();
307 static unsigned int gpmc_round_ps_to_ticks(unsigned int time_ps
)
309 unsigned long ticks
= gpmc_ps_to_ticks(time_ps
);
311 return ticks
* gpmc_get_fclk_period();
314 static inline void gpmc_cs_modify_reg(int cs
, int reg
, u32 mask
, bool value
)
318 l
= gpmc_cs_read_reg(cs
, reg
);
323 gpmc_cs_write_reg(cs
, reg
, l
);
326 static void gpmc_cs_bool_timings(int cs
, const struct gpmc_bool_timings
*p
)
328 gpmc_cs_modify_reg(cs
, GPMC_CS_CONFIG1
,
329 GPMC_CONFIG1_TIME_PARA_GRAN
,
330 p
->time_para_granularity
);
331 gpmc_cs_modify_reg(cs
, GPMC_CS_CONFIG2
,
332 GPMC_CONFIG2_CSEXTRADELAY
, p
->cs_extra_delay
);
333 gpmc_cs_modify_reg(cs
, GPMC_CS_CONFIG3
,
334 GPMC_CONFIG3_ADVEXTRADELAY
, p
->adv_extra_delay
);
335 gpmc_cs_modify_reg(cs
, GPMC_CS_CONFIG4
,
336 GPMC_CONFIG4_OEEXTRADELAY
, p
->oe_extra_delay
);
337 gpmc_cs_modify_reg(cs
, GPMC_CS_CONFIG4
,
338 GPMC_CONFIG4_OEEXTRADELAY
, p
->we_extra_delay
);
339 gpmc_cs_modify_reg(cs
, GPMC_CS_CONFIG6
,
340 GPMC_CONFIG6_CYCLE2CYCLESAMECSEN
,
341 p
->cycle2cyclesamecsen
);
342 gpmc_cs_modify_reg(cs
, GPMC_CS_CONFIG6
,
343 GPMC_CONFIG6_CYCLE2CYCLEDIFFCSEN
,
344 p
->cycle2cyclediffcsen
);
348 static int get_gpmc_timing_reg(int cs
, int reg
, int st_bit
, int end_bit
,
349 bool raw
, bool noval
, int shift
,
353 int nr_bits
, max_value
, mask
;
355 l
= gpmc_cs_read_reg(cs
, reg
);
356 nr_bits
= end_bit
- st_bit
+ 1;
357 max_value
= (1 << nr_bits
) - 1;
358 mask
= max_value
<< st_bit
;
359 l
= (l
& mask
) >> st_bit
;
362 if (noval
&& (l
== 0))
365 unsigned int time_ns_min
, time_ns
, time_ns_max
;
367 time_ns_min
= gpmc_ticks_to_ns(l
? l
- 1 : 0);
368 time_ns
= gpmc_ticks_to_ns(l
);
369 time_ns_max
= gpmc_ticks_to_ns(l
+ 1 > max_value
?
371 pr_info("gpmc,%s = <%u> (%u - %u ns, %i ticks)\n",
372 name
, time_ns
, time_ns_min
, time_ns_max
, l
);
374 pr_info("gpmc,%s = <%u>\n", name
, l
);
380 #define GPMC_PRINT_CONFIG(cs, config) \
381 pr_info("cs%i %s: 0x%08x\n", cs, #config, \
382 gpmc_cs_read_reg(cs, config))
383 #define GPMC_GET_RAW(reg, st, end, field) \
384 get_gpmc_timing_reg(cs, (reg), (st), (end), 1, 0, 0, field)
385 #define GPMC_GET_RAW_BOOL(reg, st, end, field) \
386 get_gpmc_timing_reg(cs, (reg), (st), (end), 1, 1, 0, field)
387 #define GPMC_GET_RAW_SHIFT(reg, st, end, shift, field) \
388 get_gpmc_timing_reg(cs, (reg), (st), (end), 1, 1, (shift), field)
389 #define GPMC_GET_TICKS(reg, st, end, field) \
390 get_gpmc_timing_reg(cs, (reg), (st), (end), 0, 0, 0, field)
392 static void gpmc_show_regs(int cs
, const char *desc
)
394 pr_info("gpmc cs%i %s:\n", cs
, desc
);
395 GPMC_PRINT_CONFIG(cs
, GPMC_CS_CONFIG1
);
396 GPMC_PRINT_CONFIG(cs
, GPMC_CS_CONFIG2
);
397 GPMC_PRINT_CONFIG(cs
, GPMC_CS_CONFIG3
);
398 GPMC_PRINT_CONFIG(cs
, GPMC_CS_CONFIG4
);
399 GPMC_PRINT_CONFIG(cs
, GPMC_CS_CONFIG5
);
400 GPMC_PRINT_CONFIG(cs
, GPMC_CS_CONFIG6
);
404 * Note that gpmc,wait-pin handing wrongly assumes bit 8 is available,
405 * see commit c9fb809.
407 static void gpmc_cs_show_timings(int cs
, const char *desc
)
409 gpmc_show_regs(cs
, desc
);
411 pr_info("gpmc cs%i access configuration:\n", cs
);
412 GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1
, 4, 4, "time-para-granularity");
413 GPMC_GET_RAW(GPMC_CS_CONFIG1
, 8, 9, "mux-add-data");
414 GPMC_GET_RAW(GPMC_CS_CONFIG1
, 12, 13, "device-width");
415 GPMC_GET_RAW(GPMC_CS_CONFIG1
, 16, 17, "wait-pin");
416 GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1
, 21, 21, "wait-on-write");
417 GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1
, 22, 22, "wait-on-read");
418 GPMC_GET_RAW_SHIFT(GPMC_CS_CONFIG1
, 23, 24, 4, "burst-length");
419 GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1
, 27, 27, "sync-write");
420 GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1
, 28, 28, "burst-write");
421 GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1
, 29, 29, "gpmc,sync-read");
422 GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1
, 30, 30, "burst-read");
423 GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1
, 31, 31, "burst-wrap");
425 GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG2
, 7, 7, "cs-extra-delay");
427 GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG3
, 7, 7, "adv-extra-delay");
429 GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG4
, 23, 23, "we-extra-delay");
430 GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG4
, 7, 7, "oe-extra-delay");
432 GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG6
, 7, 7, "cycle2cycle-samecsen");
433 GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG6
, 6, 6, "cycle2cycle-diffcsen");
435 pr_info("gpmc cs%i timings configuration:\n", cs
);
436 GPMC_GET_TICKS(GPMC_CS_CONFIG2
, 0, 3, "cs-on-ns");
437 GPMC_GET_TICKS(GPMC_CS_CONFIG2
, 8, 12, "cs-rd-off-ns");
438 GPMC_GET_TICKS(GPMC_CS_CONFIG2
, 16, 20, "cs-wr-off-ns");
440 GPMC_GET_TICKS(GPMC_CS_CONFIG3
, 0, 3, "adv-on-ns");
441 GPMC_GET_TICKS(GPMC_CS_CONFIG3
, 8, 12, "adv-rd-off-ns");
442 GPMC_GET_TICKS(GPMC_CS_CONFIG3
, 16, 20, "adv-wr-off-ns");
444 GPMC_GET_TICKS(GPMC_CS_CONFIG4
, 0, 3, "oe-on-ns");
445 GPMC_GET_TICKS(GPMC_CS_CONFIG4
, 8, 12, "oe-off-ns");
446 GPMC_GET_TICKS(GPMC_CS_CONFIG4
, 16, 19, "we-on-ns");
447 GPMC_GET_TICKS(GPMC_CS_CONFIG4
, 24, 28, "we-off-ns");
449 GPMC_GET_TICKS(GPMC_CS_CONFIG5
, 0, 4, "rd-cycle-ns");
450 GPMC_GET_TICKS(GPMC_CS_CONFIG5
, 8, 12, "wr-cycle-ns");
451 GPMC_GET_TICKS(GPMC_CS_CONFIG5
, 16, 20, "access-ns");
453 GPMC_GET_TICKS(GPMC_CS_CONFIG5
, 24, 27, "page-burst-access-ns");
455 GPMC_GET_TICKS(GPMC_CS_CONFIG6
, 0, 3, "bus-turnaround-ns");
456 GPMC_GET_TICKS(GPMC_CS_CONFIG6
, 8, 11, "cycle2cycle-delay-ns");
458 GPMC_GET_TICKS(GPMC_CS_CONFIG1
, 18, 19, "wait-monitoring-ns");
459 GPMC_GET_TICKS(GPMC_CS_CONFIG1
, 25, 26, "clk-activation-ns");
461 GPMC_GET_TICKS(GPMC_CS_CONFIG6
, 16, 19, "wr-data-mux-bus-ns");
462 GPMC_GET_TICKS(GPMC_CS_CONFIG6
, 24, 28, "wr-access-ns");
465 static inline void gpmc_cs_show_timings(int cs
, const char *desc
)
470 static int set_gpmc_timing_reg(int cs
, int reg
, int st_bit
, int end_bit
,
471 int time
, const char *name
)
474 int ticks
, mask
, nr_bits
;
479 ticks
= gpmc_ns_to_ticks(time
);
480 nr_bits
= end_bit
- st_bit
+ 1;
481 mask
= (1 << nr_bits
) - 1;
484 pr_err("%s: GPMC error! CS%d: %s: %d ns, %d ticks > %d\n",
485 __func__
, cs
, name
, time
, ticks
, mask
);
490 l
= gpmc_cs_read_reg(cs
, reg
);
493 "GPMC CS%d: %-10s: %3d ticks, %3lu ns (was %3i ticks) %3d ns\n",
494 cs
, name
, ticks
, gpmc_get_fclk_period() * ticks
/ 1000,
495 (l
>> st_bit
) & mask
, time
);
497 l
&= ~(mask
<< st_bit
);
498 l
|= ticks
<< st_bit
;
499 gpmc_cs_write_reg(cs
, reg
, l
);
504 #define GPMC_SET_ONE(reg, st, end, field) \
505 if (set_gpmc_timing_reg(cs, (reg), (st), (end), \
506 t->field, #field) < 0) \
509 int gpmc_calc_divider(unsigned int sync_clk
)
514 l
= sync_clk
+ (gpmc_get_fclk_period() - 1);
515 div
= l
/ gpmc_get_fclk_period();
524 int gpmc_cs_set_timings(int cs
, const struct gpmc_timings
*t
)
529 gpmc_cs_show_timings(cs
, "before gpmc_cs_set_timings");
530 div
= gpmc_calc_divider(t
->sync_clk
);
534 GPMC_SET_ONE(GPMC_CS_CONFIG2
, 0, 3, cs_on
);
535 GPMC_SET_ONE(GPMC_CS_CONFIG2
, 8, 12, cs_rd_off
);
536 GPMC_SET_ONE(GPMC_CS_CONFIG2
, 16, 20, cs_wr_off
);
538 GPMC_SET_ONE(GPMC_CS_CONFIG3
, 0, 3, adv_on
);
539 GPMC_SET_ONE(GPMC_CS_CONFIG3
, 8, 12, adv_rd_off
);
540 GPMC_SET_ONE(GPMC_CS_CONFIG3
, 16, 20, adv_wr_off
);
542 GPMC_SET_ONE(GPMC_CS_CONFIG4
, 0, 3, oe_on
);
543 GPMC_SET_ONE(GPMC_CS_CONFIG4
, 8, 12, oe_off
);
544 GPMC_SET_ONE(GPMC_CS_CONFIG4
, 16, 19, we_on
);
545 GPMC_SET_ONE(GPMC_CS_CONFIG4
, 24, 28, we_off
);
547 GPMC_SET_ONE(GPMC_CS_CONFIG5
, 0, 4, rd_cycle
);
548 GPMC_SET_ONE(GPMC_CS_CONFIG5
, 8, 12, wr_cycle
);
549 GPMC_SET_ONE(GPMC_CS_CONFIG5
, 16, 20, access
);
551 GPMC_SET_ONE(GPMC_CS_CONFIG5
, 24, 27, page_burst_access
);
553 GPMC_SET_ONE(GPMC_CS_CONFIG6
, 0, 3, bus_turnaround
);
554 GPMC_SET_ONE(GPMC_CS_CONFIG6
, 8, 11, cycle2cycle_delay
);
556 GPMC_SET_ONE(GPMC_CS_CONFIG1
, 18, 19, wait_monitoring
);
557 GPMC_SET_ONE(GPMC_CS_CONFIG1
, 25, 26, clk_activation
);
559 if (gpmc_capability
& GPMC_HAS_WR_DATA_MUX_BUS
)
560 GPMC_SET_ONE(GPMC_CS_CONFIG6
, 16, 19, wr_data_mux_bus
);
561 if (gpmc_capability
& GPMC_HAS_WR_ACCESS
)
562 GPMC_SET_ONE(GPMC_CS_CONFIG6
, 24, 28, wr_access
);
564 /* caller is expected to have initialized CONFIG1 to cover
565 * at least sync vs async
567 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG1
);
568 if (l
& (GPMC_CONFIG1_READTYPE_SYNC
| GPMC_CONFIG1_WRITETYPE_SYNC
)) {
570 printk(KERN_INFO
"GPMC CS%d CLK period is %lu ns (div %d)\n",
571 cs
, (div
* gpmc_get_fclk_period()) / 1000, div
);
575 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG1
, l
);
578 gpmc_cs_bool_timings(cs
, &t
->bool_timings
);
579 gpmc_cs_show_timings(cs
, "after gpmc_cs_set_timings");
584 static int gpmc_cs_set_memconf(int cs
, u32 base
, u32 size
)
590 * Ensure that base address is aligned on a
591 * boundary equal to or greater than size.
593 if (base
& (size
- 1))
596 base
>>= GPMC_CHUNK_SHIFT
;
597 mask
= (1 << GPMC_SECTION_SHIFT
) - size
;
598 mask
>>= GPMC_CHUNK_SHIFT
;
599 mask
<<= GPMC_CONFIG7_MASKADDRESS_OFFSET
;
601 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG7
);
602 l
&= ~GPMC_CONFIG7_MASK
;
603 l
|= base
& GPMC_CONFIG7_BASEADDRESS_MASK
;
604 l
|= mask
& GPMC_CONFIG7_MASKADDRESS_MASK
;
605 l
|= GPMC_CONFIG7_CSVALID
;
606 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG7
, l
);
611 static void gpmc_cs_enable_mem(int cs
)
615 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG7
);
616 l
|= GPMC_CONFIG7_CSVALID
;
617 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG7
, l
);
620 static void gpmc_cs_disable_mem(int cs
)
624 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG7
);
625 l
&= ~GPMC_CONFIG7_CSVALID
;
626 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG7
, l
);
629 static void gpmc_cs_get_memconf(int cs
, u32
*base
, u32
*size
)
634 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG7
);
635 *base
= (l
& 0x3f) << GPMC_CHUNK_SHIFT
;
636 mask
= (l
>> 8) & 0x0f;
637 *size
= (1 << GPMC_SECTION_SHIFT
) - (mask
<< GPMC_CHUNK_SHIFT
);
640 static int gpmc_cs_mem_enabled(int cs
)
644 l
= gpmc_cs_read_reg(cs
, GPMC_CS_CONFIG7
);
645 return l
& GPMC_CONFIG7_CSVALID
;
648 static void gpmc_cs_set_reserved(int cs
, int reserved
)
650 struct gpmc_cs_data
*gpmc
= &gpmc_cs
[cs
];
652 gpmc
->flags
|= GPMC_CS_RESERVED
;
655 static bool gpmc_cs_reserved(int cs
)
657 struct gpmc_cs_data
*gpmc
= &gpmc_cs
[cs
];
659 return gpmc
->flags
& GPMC_CS_RESERVED
;
662 static void gpmc_cs_set_name(int cs
, const char *name
)
664 struct gpmc_cs_data
*gpmc
= &gpmc_cs
[cs
];
669 static const char *gpmc_cs_get_name(int cs
)
671 struct gpmc_cs_data
*gpmc
= &gpmc_cs
[cs
];
676 static unsigned long gpmc_mem_align(unsigned long size
)
680 size
= (size
- 1) >> (GPMC_CHUNK_SHIFT
- 1);
681 order
= GPMC_CHUNK_SHIFT
- 1;
690 static int gpmc_cs_insert_mem(int cs
, unsigned long base
, unsigned long size
)
692 struct gpmc_cs_data
*gpmc
= &gpmc_cs
[cs
];
693 struct resource
*res
= &gpmc
->mem
;
696 size
= gpmc_mem_align(size
);
697 spin_lock(&gpmc_mem_lock
);
699 res
->end
= base
+ size
- 1;
700 r
= request_resource(&gpmc_mem_root
, res
);
701 spin_unlock(&gpmc_mem_lock
);
706 static int gpmc_cs_delete_mem(int cs
)
708 struct gpmc_cs_data
*gpmc
= &gpmc_cs
[cs
];
709 struct resource
*res
= &gpmc
->mem
;
712 spin_lock(&gpmc_mem_lock
);
713 r
= release_resource(res
);
716 spin_unlock(&gpmc_mem_lock
);
722 * gpmc_cs_remap - remaps a chip-select physical base address
723 * @cs: chip-select to remap
724 * @base: physical base address to re-map chip-select to
726 * Re-maps a chip-select to a new physical base address specified by
727 * "base". Returns 0 on success and appropriate negative error code
730 static int gpmc_cs_remap(int cs
, u32 base
)
735 if (cs
> gpmc_cs_num
) {
736 pr_err("%s: requested chip-select is disabled\n", __func__
);
741 * Make sure we ignore any device offsets from the GPMC partition
742 * allocated for the chip select and that the new base confirms
743 * to the GPMC 16MB minimum granularity.
745 base
&= ~(SZ_16M
- 1);
747 gpmc_cs_get_memconf(cs
, &old_base
, &size
);
748 if (base
== old_base
)
751 ret
= gpmc_cs_delete_mem(cs
);
755 ret
= gpmc_cs_insert_mem(cs
, base
, size
);
759 ret
= gpmc_cs_set_memconf(cs
, base
, size
);
764 int gpmc_cs_request(int cs
, unsigned long size
, unsigned long *base
)
766 struct gpmc_cs_data
*gpmc
= &gpmc_cs
[cs
];
767 struct resource
*res
= &gpmc
->mem
;
770 if (cs
> gpmc_cs_num
) {
771 pr_err("%s: requested chip-select is disabled\n", __func__
);
774 size
= gpmc_mem_align(size
);
775 if (size
> (1 << GPMC_SECTION_SHIFT
))
778 spin_lock(&gpmc_mem_lock
);
779 if (gpmc_cs_reserved(cs
)) {
783 if (gpmc_cs_mem_enabled(cs
))
784 r
= adjust_resource(res
, res
->start
& ~(size
- 1), size
);
786 r
= allocate_resource(&gpmc_mem_root
, res
, size
, 0, ~0,
791 /* Disable CS while changing base address and size mask */
792 gpmc_cs_disable_mem(cs
);
794 r
= gpmc_cs_set_memconf(cs
, res
->start
, resource_size(res
));
796 release_resource(res
);
801 gpmc_cs_enable_mem(cs
);
803 gpmc_cs_set_reserved(cs
, 1);
805 spin_unlock(&gpmc_mem_lock
);
808 EXPORT_SYMBOL(gpmc_cs_request
);
810 void gpmc_cs_free(int cs
)
812 struct gpmc_cs_data
*gpmc
= &gpmc_cs
[cs
];
813 struct resource
*res
= &gpmc
->mem
;
815 spin_lock(&gpmc_mem_lock
);
816 if (cs
>= gpmc_cs_num
|| cs
< 0 || !gpmc_cs_reserved(cs
)) {
817 printk(KERN_ERR
"Trying to free non-reserved GPMC CS%d\n", cs
);
819 spin_unlock(&gpmc_mem_lock
);
822 gpmc_cs_disable_mem(cs
);
824 release_resource(res
);
825 gpmc_cs_set_reserved(cs
, 0);
826 spin_unlock(&gpmc_mem_lock
);
828 EXPORT_SYMBOL(gpmc_cs_free
);
831 * gpmc_configure - write request to configure gpmc
833 * @wval: value to write
834 * @return status of the operation
836 int gpmc_configure(int cmd
, int wval
)
841 case GPMC_ENABLE_IRQ
:
842 gpmc_write_reg(GPMC_IRQENABLE
, wval
);
845 case GPMC_SET_IRQ_STATUS
:
846 gpmc_write_reg(GPMC_IRQSTATUS
, wval
);
850 regval
= gpmc_read_reg(GPMC_CONFIG
);
852 regval
&= ~GPMC_CONFIG_WRITEPROTECT
; /* WP is ON */
854 regval
|= GPMC_CONFIG_WRITEPROTECT
; /* WP is OFF */
855 gpmc_write_reg(GPMC_CONFIG
, regval
);
859 pr_err("%s: command not supported\n", __func__
);
865 EXPORT_SYMBOL(gpmc_configure
);
867 void gpmc_update_nand_reg(struct gpmc_nand_regs
*reg
, int cs
)
871 reg
->gpmc_status
= gpmc_base
+ GPMC_STATUS
;
872 reg
->gpmc_nand_command
= gpmc_base
+ GPMC_CS0_OFFSET
+
873 GPMC_CS_NAND_COMMAND
+ GPMC_CS_SIZE
* cs
;
874 reg
->gpmc_nand_address
= gpmc_base
+ GPMC_CS0_OFFSET
+
875 GPMC_CS_NAND_ADDRESS
+ GPMC_CS_SIZE
* cs
;
876 reg
->gpmc_nand_data
= gpmc_base
+ GPMC_CS0_OFFSET
+
877 GPMC_CS_NAND_DATA
+ GPMC_CS_SIZE
* cs
;
878 reg
->gpmc_prefetch_config1
= gpmc_base
+ GPMC_PREFETCH_CONFIG1
;
879 reg
->gpmc_prefetch_config2
= gpmc_base
+ GPMC_PREFETCH_CONFIG2
;
880 reg
->gpmc_prefetch_control
= gpmc_base
+ GPMC_PREFETCH_CONTROL
;
881 reg
->gpmc_prefetch_status
= gpmc_base
+ GPMC_PREFETCH_STATUS
;
882 reg
->gpmc_ecc_config
= gpmc_base
+ GPMC_ECC_CONFIG
;
883 reg
->gpmc_ecc_control
= gpmc_base
+ GPMC_ECC_CONTROL
;
884 reg
->gpmc_ecc_size_config
= gpmc_base
+ GPMC_ECC_SIZE_CONFIG
;
885 reg
->gpmc_ecc1_result
= gpmc_base
+ GPMC_ECC1_RESULT
;
887 for (i
= 0; i
< GPMC_BCH_NUM_REMAINDER
; i
++) {
888 reg
->gpmc_bch_result0
[i
] = gpmc_base
+ GPMC_ECC_BCH_RESULT_0
+
890 reg
->gpmc_bch_result1
[i
] = gpmc_base
+ GPMC_ECC_BCH_RESULT_1
+
892 reg
->gpmc_bch_result2
[i
] = gpmc_base
+ GPMC_ECC_BCH_RESULT_2
+
894 reg
->gpmc_bch_result3
[i
] = gpmc_base
+ GPMC_ECC_BCH_RESULT_3
+
896 reg
->gpmc_bch_result4
[i
] = gpmc_base
+ GPMC_ECC_BCH_RESULT_4
+
898 reg
->gpmc_bch_result5
[i
] = gpmc_base
+ GPMC_ECC_BCH_RESULT_5
+
900 reg
->gpmc_bch_result6
[i
] = gpmc_base
+ GPMC_ECC_BCH_RESULT_6
+
905 int gpmc_get_client_irq(unsigned irq_config
)
909 if (hweight32(irq_config
) > 1)
912 for (i
= 0; i
< GPMC_NR_IRQ
; i
++)
913 if (gpmc_client_irq
[i
].bitmask
& irq_config
)
914 return gpmc_client_irq
[i
].irq
;
919 static int gpmc_irq_endis(unsigned irq
, bool endis
)
924 for (i
= 0; i
< GPMC_NR_IRQ
; i
++)
925 if (irq
== gpmc_client_irq
[i
].irq
) {
926 regval
= gpmc_read_reg(GPMC_IRQENABLE
);
928 regval
|= gpmc_client_irq
[i
].bitmask
;
930 regval
&= ~gpmc_client_irq
[i
].bitmask
;
931 gpmc_write_reg(GPMC_IRQENABLE
, regval
);
938 static void gpmc_irq_disable(struct irq_data
*p
)
940 gpmc_irq_endis(p
->irq
, false);
943 static void gpmc_irq_enable(struct irq_data
*p
)
945 gpmc_irq_endis(p
->irq
, true);
948 static void gpmc_irq_noop(struct irq_data
*data
) { }
950 static unsigned int gpmc_irq_noop_ret(struct irq_data
*data
) { return 0; }
952 static int gpmc_setup_irq(void)
960 gpmc_irq_start
= irq_alloc_descs(-1, 0, GPMC_NR_IRQ
, 0);
961 if (gpmc_irq_start
< 0) {
962 pr_err("irq_alloc_descs failed\n");
963 return gpmc_irq_start
;
966 gpmc_irq_chip
.name
= "gpmc";
967 gpmc_irq_chip
.irq_startup
= gpmc_irq_noop_ret
;
968 gpmc_irq_chip
.irq_enable
= gpmc_irq_enable
;
969 gpmc_irq_chip
.irq_disable
= gpmc_irq_disable
;
970 gpmc_irq_chip
.irq_shutdown
= gpmc_irq_noop
;
971 gpmc_irq_chip
.irq_ack
= gpmc_irq_noop
;
972 gpmc_irq_chip
.irq_mask
= gpmc_irq_noop
;
973 gpmc_irq_chip
.irq_unmask
= gpmc_irq_noop
;
975 gpmc_client_irq
[0].bitmask
= GPMC_IRQ_FIFOEVENTENABLE
;
976 gpmc_client_irq
[1].bitmask
= GPMC_IRQ_COUNT_EVENT
;
978 for (i
= 0; i
< GPMC_NR_IRQ
; i
++) {
979 gpmc_client_irq
[i
].irq
= gpmc_irq_start
+ i
;
980 irq_set_chip_and_handler(gpmc_client_irq
[i
].irq
,
981 &gpmc_irq_chip
, handle_simple_irq
);
982 set_irq_flags(gpmc_client_irq
[i
].irq
,
983 IRQF_VALID
| IRQF_NOAUTOEN
);
986 /* Disable interrupts */
987 gpmc_write_reg(GPMC_IRQENABLE
, 0);
989 /* clear interrupts */
990 regval
= gpmc_read_reg(GPMC_IRQSTATUS
);
991 gpmc_write_reg(GPMC_IRQSTATUS
, regval
);
993 return request_irq(gpmc_irq
, gpmc_handle_irq
, 0, "gpmc", NULL
);
996 static int gpmc_free_irq(void)
1001 free_irq(gpmc_irq
, NULL
);
1003 for (i
= 0; i
< GPMC_NR_IRQ
; i
++) {
1004 irq_set_handler(gpmc_client_irq
[i
].irq
, NULL
);
1005 irq_set_chip(gpmc_client_irq
[i
].irq
, &no_irq_chip
);
1006 irq_modify_status(gpmc_client_irq
[i
].irq
, 0, 0);
1009 irq_free_descs(gpmc_irq_start
, GPMC_NR_IRQ
);
1014 static void gpmc_mem_exit(void)
1018 for (cs
= 0; cs
< gpmc_cs_num
; cs
++) {
1019 if (!gpmc_cs_mem_enabled(cs
))
1021 gpmc_cs_delete_mem(cs
);
1026 static void gpmc_mem_init(void)
1031 * The first 1MB of GPMC address space is typically mapped to
1032 * the internal ROM. Never allocate the first page, to
1033 * facilitate bug detection; even if we didn't boot from ROM.
1035 gpmc_mem_root
.start
= SZ_1M
;
1036 gpmc_mem_root
.end
= GPMC_MEM_END
;
1038 /* Reserve all regions that has been set up by bootloader */
1039 for (cs
= 0; cs
< gpmc_cs_num
; cs
++) {
1042 if (!gpmc_cs_mem_enabled(cs
))
1044 gpmc_cs_get_memconf(cs
, &base
, &size
);
1045 if (gpmc_cs_insert_mem(cs
, base
, size
)) {
1046 pr_warn("%s: disabling cs %d mapped at 0x%x-0x%x\n",
1047 __func__
, cs
, base
, base
+ size
);
1048 gpmc_cs_disable_mem(cs
);
1053 static u32
gpmc_round_ps_to_sync_clk(u32 time_ps
, u32 sync_clk
)
1058 div
= gpmc_calc_divider(sync_clk
);
1059 temp
= gpmc_ps_to_ticks(time_ps
);
1060 temp
= (temp
+ div
- 1) / div
;
1061 return gpmc_ticks_to_ps(temp
* div
);
1064 /* XXX: can the cycles be avoided ? */
1065 static int gpmc_calc_sync_read_timings(struct gpmc_timings
*gpmc_t
,
1066 struct gpmc_device_timings
*dev_t
,
1072 temp
= dev_t
->t_avdp_r
;
1073 /* XXX: mux check required ? */
1075 /* XXX: t_avdp not to be required for sync, only added for tusb
1076 * this indirectly necessitates requirement of t_avdp_r and
1077 * t_avdp_w instead of having a single t_avdp
1079 temp
= max_t(u32
, temp
, gpmc_t
->clk_activation
+ dev_t
->t_avdh
);
1080 temp
= max_t(u32
, gpmc_t
->adv_on
+ gpmc_ticks_to_ps(1), temp
);
1082 gpmc_t
->adv_rd_off
= gpmc_round_ps_to_ticks(temp
);
1085 temp
= dev_t
->t_oeasu
; /* XXX: remove this ? */
1087 temp
= max_t(u32
, temp
, gpmc_t
->clk_activation
+ dev_t
->t_ach
);
1088 temp
= max_t(u32
, temp
, gpmc_t
->adv_rd_off
+
1089 gpmc_ticks_to_ps(dev_t
->cyc_aavdh_oe
));
1091 gpmc_t
->oe_on
= gpmc_round_ps_to_ticks(temp
);
1094 /* XXX: any scope for improvement ?, by combining oe_on
1095 * and clk_activation, need to check whether
1096 * access = clk_activation + round to sync clk ?
1098 temp
= max_t(u32
, dev_t
->t_iaa
, dev_t
->cyc_iaa
* gpmc_t
->sync_clk
);
1099 temp
+= gpmc_t
->clk_activation
;
1101 temp
= max_t(u32
, temp
, gpmc_t
->oe_on
+
1102 gpmc_ticks_to_ps(dev_t
->cyc_oe
));
1103 gpmc_t
->access
= gpmc_round_ps_to_ticks(temp
);
1105 gpmc_t
->oe_off
= gpmc_t
->access
+ gpmc_ticks_to_ps(1);
1106 gpmc_t
->cs_rd_off
= gpmc_t
->oe_off
;
1109 temp
= max_t(u32
, dev_t
->t_cez_r
, dev_t
->t_oez
);
1110 temp
= gpmc_round_ps_to_sync_clk(temp
, gpmc_t
->sync_clk
) +
1112 /* XXX: barter t_ce_rdyz with t_cez_r ? */
1113 if (dev_t
->t_ce_rdyz
)
1114 temp
= max_t(u32
, temp
, gpmc_t
->cs_rd_off
+ dev_t
->t_ce_rdyz
);
1115 gpmc_t
->rd_cycle
= gpmc_round_ps_to_ticks(temp
);
1120 static int gpmc_calc_sync_write_timings(struct gpmc_timings
*gpmc_t
,
1121 struct gpmc_device_timings
*dev_t
,
1127 temp
= dev_t
->t_avdp_w
;
1129 temp
= max_t(u32
, temp
,
1130 gpmc_t
->clk_activation
+ dev_t
->t_avdh
);
1131 temp
= max_t(u32
, gpmc_t
->adv_on
+ gpmc_ticks_to_ps(1), temp
);
1133 gpmc_t
->adv_wr_off
= gpmc_round_ps_to_ticks(temp
);
1135 /* wr_data_mux_bus */
1136 temp
= max_t(u32
, dev_t
->t_weasu
,
1137 gpmc_t
->clk_activation
+ dev_t
->t_rdyo
);
1138 /* XXX: shouldn't mux be kept as a whole for wr_data_mux_bus ?,
1139 * and in that case remember to handle we_on properly
1142 temp
= max_t(u32
, temp
,
1143 gpmc_t
->adv_wr_off
+ dev_t
->t_aavdh
);
1144 temp
= max_t(u32
, temp
, gpmc_t
->adv_wr_off
+
1145 gpmc_ticks_to_ps(dev_t
->cyc_aavdh_we
));
1147 gpmc_t
->wr_data_mux_bus
= gpmc_round_ps_to_ticks(temp
);
1150 if (gpmc_capability
& GPMC_HAS_WR_DATA_MUX_BUS
)
1151 gpmc_t
->we_on
= gpmc_round_ps_to_ticks(dev_t
->t_weasu
);
1153 gpmc_t
->we_on
= gpmc_t
->wr_data_mux_bus
;
1156 /* XXX: gpmc_capability check reqd ? , even if not, will not harm */
1157 gpmc_t
->wr_access
= gpmc_t
->access
;
1160 temp
= gpmc_t
->we_on
+ dev_t
->t_wpl
;
1161 temp
= max_t(u32
, temp
,
1162 gpmc_t
->wr_access
+ gpmc_ticks_to_ps(1));
1163 temp
= max_t(u32
, temp
,
1164 gpmc_t
->we_on
+ gpmc_ticks_to_ps(dev_t
->cyc_wpl
));
1165 gpmc_t
->we_off
= gpmc_round_ps_to_ticks(temp
);
1167 gpmc_t
->cs_wr_off
= gpmc_round_ps_to_ticks(gpmc_t
->we_off
+
1171 temp
= gpmc_round_ps_to_sync_clk(dev_t
->t_cez_w
, gpmc_t
->sync_clk
);
1172 temp
+= gpmc_t
->wr_access
;
1173 /* XXX: barter t_ce_rdyz with t_cez_w ? */
1174 if (dev_t
->t_ce_rdyz
)
1175 temp
= max_t(u32
, temp
,
1176 gpmc_t
->cs_wr_off
+ dev_t
->t_ce_rdyz
);
1177 gpmc_t
->wr_cycle
= gpmc_round_ps_to_ticks(temp
);
1182 static int gpmc_calc_async_read_timings(struct gpmc_timings
*gpmc_t
,
1183 struct gpmc_device_timings
*dev_t
,
1189 temp
= dev_t
->t_avdp_r
;
1191 temp
= max_t(u32
, gpmc_t
->adv_on
+ gpmc_ticks_to_ps(1), temp
);
1192 gpmc_t
->adv_rd_off
= gpmc_round_ps_to_ticks(temp
);
1195 temp
= dev_t
->t_oeasu
;
1197 temp
= max_t(u32
, temp
,
1198 gpmc_t
->adv_rd_off
+ dev_t
->t_aavdh
);
1199 gpmc_t
->oe_on
= gpmc_round_ps_to_ticks(temp
);
1202 temp
= max_t(u32
, dev_t
->t_iaa
, /* XXX: remove t_iaa in async ? */
1203 gpmc_t
->oe_on
+ dev_t
->t_oe
);
1204 temp
= max_t(u32
, temp
,
1205 gpmc_t
->cs_on
+ dev_t
->t_ce
);
1206 temp
= max_t(u32
, temp
,
1207 gpmc_t
->adv_on
+ dev_t
->t_aa
);
1208 gpmc_t
->access
= gpmc_round_ps_to_ticks(temp
);
1210 gpmc_t
->oe_off
= gpmc_t
->access
+ gpmc_ticks_to_ps(1);
1211 gpmc_t
->cs_rd_off
= gpmc_t
->oe_off
;
1214 temp
= max_t(u32
, dev_t
->t_rd_cycle
,
1215 gpmc_t
->cs_rd_off
+ dev_t
->t_cez_r
);
1216 temp
= max_t(u32
, temp
, gpmc_t
->oe_off
+ dev_t
->t_oez
);
1217 gpmc_t
->rd_cycle
= gpmc_round_ps_to_ticks(temp
);
1222 static int gpmc_calc_async_write_timings(struct gpmc_timings
*gpmc_t
,
1223 struct gpmc_device_timings
*dev_t
,
1229 temp
= dev_t
->t_avdp_w
;
1231 temp
= max_t(u32
, gpmc_t
->adv_on
+ gpmc_ticks_to_ps(1), temp
);
1232 gpmc_t
->adv_wr_off
= gpmc_round_ps_to_ticks(temp
);
1234 /* wr_data_mux_bus */
1235 temp
= dev_t
->t_weasu
;
1237 temp
= max_t(u32
, temp
, gpmc_t
->adv_wr_off
+ dev_t
->t_aavdh
);
1238 temp
= max_t(u32
, temp
, gpmc_t
->adv_wr_off
+
1239 gpmc_ticks_to_ps(dev_t
->cyc_aavdh_we
));
1241 gpmc_t
->wr_data_mux_bus
= gpmc_round_ps_to_ticks(temp
);
1244 if (gpmc_capability
& GPMC_HAS_WR_DATA_MUX_BUS
)
1245 gpmc_t
->we_on
= gpmc_round_ps_to_ticks(dev_t
->t_weasu
);
1247 gpmc_t
->we_on
= gpmc_t
->wr_data_mux_bus
;
1250 temp
= gpmc_t
->we_on
+ dev_t
->t_wpl
;
1251 gpmc_t
->we_off
= gpmc_round_ps_to_ticks(temp
);
1253 gpmc_t
->cs_wr_off
= gpmc_round_ps_to_ticks(gpmc_t
->we_off
+
1257 temp
= max_t(u32
, dev_t
->t_wr_cycle
,
1258 gpmc_t
->cs_wr_off
+ dev_t
->t_cez_w
);
1259 gpmc_t
->wr_cycle
= gpmc_round_ps_to_ticks(temp
);
1264 static int gpmc_calc_sync_common_timings(struct gpmc_timings
*gpmc_t
,
1265 struct gpmc_device_timings
*dev_t
)
1269 gpmc_t
->sync_clk
= gpmc_calc_divider(dev_t
->clk
) *
1270 gpmc_get_fclk_period();
1272 gpmc_t
->page_burst_access
= gpmc_round_ps_to_sync_clk(
1276 temp
= max_t(u32
, dev_t
->t_ces
, dev_t
->t_avds
);
1277 gpmc_t
->clk_activation
= gpmc_round_ps_to_ticks(temp
);
1279 if (gpmc_calc_divider(gpmc_t
->sync_clk
) != 1)
1282 if (dev_t
->ce_xdelay
)
1283 gpmc_t
->bool_timings
.cs_extra_delay
= true;
1284 if (dev_t
->avd_xdelay
)
1285 gpmc_t
->bool_timings
.adv_extra_delay
= true;
1286 if (dev_t
->oe_xdelay
)
1287 gpmc_t
->bool_timings
.oe_extra_delay
= true;
1288 if (dev_t
->we_xdelay
)
1289 gpmc_t
->bool_timings
.we_extra_delay
= true;
1294 static int gpmc_calc_common_timings(struct gpmc_timings
*gpmc_t
,
1295 struct gpmc_device_timings
*dev_t
,
1301 gpmc_t
->cs_on
= gpmc_round_ps_to_ticks(dev_t
->t_ceasu
);
1304 temp
= dev_t
->t_avdasu
;
1305 if (dev_t
->t_ce_avd
)
1306 temp
= max_t(u32
, temp
,
1307 gpmc_t
->cs_on
+ dev_t
->t_ce_avd
);
1308 gpmc_t
->adv_on
= gpmc_round_ps_to_ticks(temp
);
1311 gpmc_calc_sync_common_timings(gpmc_t
, dev_t
);
1316 /* TODO: remove this function once all peripherals are confirmed to
1317 * work with generic timing. Simultaneously gpmc_cs_set_timings()
1318 * has to be modified to handle timings in ps instead of ns
1320 static void gpmc_convert_ps_to_ns(struct gpmc_timings
*t
)
1323 t
->cs_rd_off
/= 1000;
1324 t
->cs_wr_off
/= 1000;
1326 t
->adv_rd_off
/= 1000;
1327 t
->adv_wr_off
/= 1000;
1332 t
->page_burst_access
/= 1000;
1334 t
->rd_cycle
/= 1000;
1335 t
->wr_cycle
/= 1000;
1336 t
->bus_turnaround
/= 1000;
1337 t
->cycle2cycle_delay
/= 1000;
1338 t
->wait_monitoring
/= 1000;
1339 t
->clk_activation
/= 1000;
1340 t
->wr_access
/= 1000;
1341 t
->wr_data_mux_bus
/= 1000;
1344 int gpmc_calc_timings(struct gpmc_timings
*gpmc_t
,
1345 struct gpmc_settings
*gpmc_s
,
1346 struct gpmc_device_timings
*dev_t
)
1348 bool mux
= false, sync
= false;
1351 mux
= gpmc_s
->mux_add_data
? true : false;
1352 sync
= (gpmc_s
->sync_read
|| gpmc_s
->sync_write
);
1355 memset(gpmc_t
, 0, sizeof(*gpmc_t
));
1357 gpmc_calc_common_timings(gpmc_t
, dev_t
, sync
);
1359 if (gpmc_s
&& gpmc_s
->sync_read
)
1360 gpmc_calc_sync_read_timings(gpmc_t
, dev_t
, mux
);
1362 gpmc_calc_async_read_timings(gpmc_t
, dev_t
, mux
);
1364 if (gpmc_s
&& gpmc_s
->sync_write
)
1365 gpmc_calc_sync_write_timings(gpmc_t
, dev_t
, mux
);
1367 gpmc_calc_async_write_timings(gpmc_t
, dev_t
, mux
);
1369 /* TODO: remove, see function definition */
1370 gpmc_convert_ps_to_ns(gpmc_t
);
1376 * gpmc_cs_program_settings - programs non-timing related settings
1377 * @cs: GPMC chip-select to program
1378 * @p: pointer to GPMC settings structure
1380 * Programs non-timing related settings for a GPMC chip-select, such as
1381 * bus-width, burst configuration, etc. Function should be called once
1382 * for each chip-select that is being used and must be called before
1383 * calling gpmc_cs_set_timings() as timing parameters in the CONFIG1
1384 * register will be initialised to zero by this function. Returns 0 on
1385 * success and appropriate negative error code on failure.
1387 int gpmc_cs_program_settings(int cs
, struct gpmc_settings
*p
)
1391 if ((!p
->device_width
) || (p
->device_width
> GPMC_DEVWIDTH_16BIT
)) {
1392 pr_err("%s: invalid width %d!", __func__
, p
->device_width
);
1396 /* Address-data multiplexing not supported for NAND devices */
1397 if (p
->device_nand
&& p
->mux_add_data
) {
1398 pr_err("%s: invalid configuration!\n", __func__
);
1402 if ((p
->mux_add_data
> GPMC_MUX_AD
) ||
1403 ((p
->mux_add_data
== GPMC_MUX_AAD
) &&
1404 !(gpmc_capability
& GPMC_HAS_MUX_AAD
))) {
1405 pr_err("%s: invalid multiplex configuration!\n", __func__
);
1409 /* Page/burst mode supports lengths of 4, 8 and 16 bytes */
1410 if (p
->burst_read
|| p
->burst_write
) {
1411 switch (p
->burst_len
) {
1417 pr_err("%s: invalid page/burst-length (%d)\n",
1418 __func__
, p
->burst_len
);
1423 if (p
->wait_pin
> gpmc_nr_waitpins
) {
1424 pr_err("%s: invalid wait-pin (%d)\n", __func__
, p
->wait_pin
);
1428 config1
= GPMC_CONFIG1_DEVICESIZE((p
->device_width
- 1));
1431 config1
|= GPMC_CONFIG1_READTYPE_SYNC
;
1433 config1
|= GPMC_CONFIG1_WRITETYPE_SYNC
;
1434 if (p
->wait_on_read
)
1435 config1
|= GPMC_CONFIG1_WAIT_READ_MON
;
1436 if (p
->wait_on_write
)
1437 config1
|= GPMC_CONFIG1_WAIT_WRITE_MON
;
1438 if (p
->wait_on_read
|| p
->wait_on_write
)
1439 config1
|= GPMC_CONFIG1_WAIT_PIN_SEL(p
->wait_pin
);
1441 config1
|= GPMC_CONFIG1_DEVICETYPE(GPMC_DEVICETYPE_NAND
);
1442 if (p
->mux_add_data
)
1443 config1
|= GPMC_CONFIG1_MUXTYPE(p
->mux_add_data
);
1445 config1
|= GPMC_CONFIG1_READMULTIPLE_SUPP
;
1447 config1
|= GPMC_CONFIG1_WRITEMULTIPLE_SUPP
;
1448 if (p
->burst_read
|| p
->burst_write
) {
1449 config1
|= GPMC_CONFIG1_PAGE_LEN(p
->burst_len
>> 3);
1450 config1
|= p
->burst_wrap
? GPMC_CONFIG1_WRAPBURST_SUPP
: 0;
1453 gpmc_cs_write_reg(cs
, GPMC_CS_CONFIG1
, config1
);
1459 static const struct of_device_id gpmc_dt_ids
[] = {
1460 { .compatible
= "ti,omap2420-gpmc" },
1461 { .compatible
= "ti,omap2430-gpmc" },
1462 { .compatible
= "ti,omap3430-gpmc" }, /* omap3430 & omap3630 */
1463 { .compatible
= "ti,omap4430-gpmc" }, /* omap4430 & omap4460 & omap543x */
1464 { .compatible
= "ti,am3352-gpmc" }, /* am335x devices */
1467 MODULE_DEVICE_TABLE(of
, gpmc_dt_ids
);
1470 * gpmc_read_settings_dt - read gpmc settings from device-tree
1471 * @np: pointer to device-tree node for a gpmc child device
1472 * @p: pointer to gpmc settings structure
1474 * Reads the GPMC settings for a GPMC child device from device-tree and
1475 * stores them in the GPMC settings structure passed. The GPMC settings
1476 * structure is initialised to zero by this function and so any
1477 * previously stored settings will be cleared.
1479 void gpmc_read_settings_dt(struct device_node
*np
, struct gpmc_settings
*p
)
1481 memset(p
, 0, sizeof(struct gpmc_settings
));
1483 p
->sync_read
= of_property_read_bool(np
, "gpmc,sync-read");
1484 p
->sync_write
= of_property_read_bool(np
, "gpmc,sync-write");
1485 of_property_read_u32(np
, "gpmc,device-width", &p
->device_width
);
1486 of_property_read_u32(np
, "gpmc,mux-add-data", &p
->mux_add_data
);
1488 if (!of_property_read_u32(np
, "gpmc,burst-length", &p
->burst_len
)) {
1489 p
->burst_wrap
= of_property_read_bool(np
, "gpmc,burst-wrap");
1490 p
->burst_read
= of_property_read_bool(np
, "gpmc,burst-read");
1491 p
->burst_write
= of_property_read_bool(np
, "gpmc,burst-write");
1492 if (!p
->burst_read
&& !p
->burst_write
)
1493 pr_warn("%s: page/burst-length set but not used!\n",
1497 if (!of_property_read_u32(np
, "gpmc,wait-pin", &p
->wait_pin
)) {
1498 p
->wait_on_read
= of_property_read_bool(np
,
1499 "gpmc,wait-on-read");
1500 p
->wait_on_write
= of_property_read_bool(np
,
1501 "gpmc,wait-on-write");
1502 if (!p
->wait_on_read
&& !p
->wait_on_write
)
1503 pr_debug("%s: rd/wr wait monitoring not enabled!\n",
1508 static void __maybe_unused
gpmc_read_timings_dt(struct device_node
*np
,
1509 struct gpmc_timings
*gpmc_t
)
1511 struct gpmc_bool_timings
*p
;
1516 memset(gpmc_t
, 0, sizeof(*gpmc_t
));
1518 /* minimum clock period for syncronous mode */
1519 of_property_read_u32(np
, "gpmc,sync-clk-ps", &gpmc_t
->sync_clk
);
1521 /* chip select timtings */
1522 of_property_read_u32(np
, "gpmc,cs-on-ns", &gpmc_t
->cs_on
);
1523 of_property_read_u32(np
, "gpmc,cs-rd-off-ns", &gpmc_t
->cs_rd_off
);
1524 of_property_read_u32(np
, "gpmc,cs-wr-off-ns", &gpmc_t
->cs_wr_off
);
1526 /* ADV signal timings */
1527 of_property_read_u32(np
, "gpmc,adv-on-ns", &gpmc_t
->adv_on
);
1528 of_property_read_u32(np
, "gpmc,adv-rd-off-ns", &gpmc_t
->adv_rd_off
);
1529 of_property_read_u32(np
, "gpmc,adv-wr-off-ns", &gpmc_t
->adv_wr_off
);
1531 /* WE signal timings */
1532 of_property_read_u32(np
, "gpmc,we-on-ns", &gpmc_t
->we_on
);
1533 of_property_read_u32(np
, "gpmc,we-off-ns", &gpmc_t
->we_off
);
1535 /* OE signal timings */
1536 of_property_read_u32(np
, "gpmc,oe-on-ns", &gpmc_t
->oe_on
);
1537 of_property_read_u32(np
, "gpmc,oe-off-ns", &gpmc_t
->oe_off
);
1539 /* access and cycle timings */
1540 of_property_read_u32(np
, "gpmc,page-burst-access-ns",
1541 &gpmc_t
->page_burst_access
);
1542 of_property_read_u32(np
, "gpmc,access-ns", &gpmc_t
->access
);
1543 of_property_read_u32(np
, "gpmc,rd-cycle-ns", &gpmc_t
->rd_cycle
);
1544 of_property_read_u32(np
, "gpmc,wr-cycle-ns", &gpmc_t
->wr_cycle
);
1545 of_property_read_u32(np
, "gpmc,bus-turnaround-ns",
1546 &gpmc_t
->bus_turnaround
);
1547 of_property_read_u32(np
, "gpmc,cycle2cycle-delay-ns",
1548 &gpmc_t
->cycle2cycle_delay
);
1549 of_property_read_u32(np
, "gpmc,wait-monitoring-ns",
1550 &gpmc_t
->wait_monitoring
);
1551 of_property_read_u32(np
, "gpmc,clk-activation-ns",
1552 &gpmc_t
->clk_activation
);
1554 /* only applicable to OMAP3+ */
1555 of_property_read_u32(np
, "gpmc,wr-access-ns", &gpmc_t
->wr_access
);
1556 of_property_read_u32(np
, "gpmc,wr-data-mux-bus-ns",
1557 &gpmc_t
->wr_data_mux_bus
);
1559 /* bool timing parameters */
1560 p
= &gpmc_t
->bool_timings
;
1562 p
->cycle2cyclediffcsen
=
1563 of_property_read_bool(np
, "gpmc,cycle2cycle-diffcsen");
1564 p
->cycle2cyclesamecsen
=
1565 of_property_read_bool(np
, "gpmc,cycle2cycle-samecsen");
1566 p
->we_extra_delay
= of_property_read_bool(np
, "gpmc,we-extra-delay");
1567 p
->oe_extra_delay
= of_property_read_bool(np
, "gpmc,oe-extra-delay");
1568 p
->adv_extra_delay
= of_property_read_bool(np
, "gpmc,adv-extra-delay");
1569 p
->cs_extra_delay
= of_property_read_bool(np
, "gpmc,cs-extra-delay");
1570 p
->time_para_granularity
=
1571 of_property_read_bool(np
, "gpmc,time-para-granularity");
1574 #if IS_ENABLED(CONFIG_MTD_NAND)
1576 static const char * const nand_xfer_types
[] = {
1577 [NAND_OMAP_PREFETCH_POLLED
] = "prefetch-polled",
1578 [NAND_OMAP_POLLED
] = "polled",
1579 [NAND_OMAP_PREFETCH_DMA
] = "prefetch-dma",
1580 [NAND_OMAP_PREFETCH_IRQ
] = "prefetch-irq",
1583 static int gpmc_probe_nand_child(struct platform_device
*pdev
,
1584 struct device_node
*child
)
1588 struct gpmc_timings gpmc_t
;
1589 struct omap_nand_platform_data
*gpmc_nand_data
;
1591 if (of_property_read_u32(child
, "reg", &val
) < 0) {
1592 dev_err(&pdev
->dev
, "%s has no 'reg' property\n",
1597 gpmc_nand_data
= devm_kzalloc(&pdev
->dev
, sizeof(*gpmc_nand_data
),
1599 if (!gpmc_nand_data
)
1602 gpmc_nand_data
->cs
= val
;
1603 gpmc_nand_data
->of_node
= child
;
1605 /* Detect availability of ELM module */
1606 gpmc_nand_data
->elm_of_node
= of_parse_phandle(child
, "ti,elm-id", 0);
1607 if (gpmc_nand_data
->elm_of_node
== NULL
)
1608 gpmc_nand_data
->elm_of_node
=
1609 of_parse_phandle(child
, "elm_id", 0);
1611 /* select ecc-scheme for NAND */
1612 if (of_property_read_string(child
, "ti,nand-ecc-opt", &s
)) {
1613 pr_err("%s: ti,nand-ecc-opt not found\n", __func__
);
1617 if (!strcmp(s
, "sw"))
1618 gpmc_nand_data
->ecc_opt
= OMAP_ECC_HAM1_CODE_SW
;
1619 else if (!strcmp(s
, "ham1") ||
1620 !strcmp(s
, "hw") || !strcmp(s
, "hw-romcode"))
1621 gpmc_nand_data
->ecc_opt
=
1622 OMAP_ECC_HAM1_CODE_HW
;
1623 else if (!strcmp(s
, "bch4"))
1624 if (gpmc_nand_data
->elm_of_node
)
1625 gpmc_nand_data
->ecc_opt
=
1626 OMAP_ECC_BCH4_CODE_HW
;
1628 gpmc_nand_data
->ecc_opt
=
1629 OMAP_ECC_BCH4_CODE_HW_DETECTION_SW
;
1630 else if (!strcmp(s
, "bch8"))
1631 if (gpmc_nand_data
->elm_of_node
)
1632 gpmc_nand_data
->ecc_opt
=
1633 OMAP_ECC_BCH8_CODE_HW
;
1635 gpmc_nand_data
->ecc_opt
=
1636 OMAP_ECC_BCH8_CODE_HW_DETECTION_SW
;
1637 else if (!strcmp(s
, "bch16"))
1638 if (gpmc_nand_data
->elm_of_node
)
1639 gpmc_nand_data
->ecc_opt
=
1640 OMAP_ECC_BCH16_CODE_HW
;
1642 pr_err("%s: BCH16 requires ELM support\n", __func__
);
1644 pr_err("%s: ti,nand-ecc-opt invalid value\n", __func__
);
1646 /* select data transfer mode for NAND controller */
1647 if (!of_property_read_string(child
, "ti,nand-xfer-type", &s
))
1648 for (val
= 0; val
< ARRAY_SIZE(nand_xfer_types
); val
++)
1649 if (!strcasecmp(s
, nand_xfer_types
[val
])) {
1650 gpmc_nand_data
->xfer_type
= val
;
1654 gpmc_nand_data
->flash_bbt
= of_get_nand_on_flash_bbt(child
);
1656 val
= of_get_nand_bus_width(child
);
1658 gpmc_nand_data
->devsize
= NAND_BUSWIDTH_16
;
1660 gpmc_read_timings_dt(child
, &gpmc_t
);
1661 gpmc_nand_init(gpmc_nand_data
, &gpmc_t
);
1666 static int gpmc_probe_nand_child(struct platform_device
*pdev
,
1667 struct device_node
*child
)
1673 #if IS_ENABLED(CONFIG_MTD_ONENAND)
1674 static int gpmc_probe_onenand_child(struct platform_device
*pdev
,
1675 struct device_node
*child
)
1678 struct omap_onenand_platform_data
*gpmc_onenand_data
;
1680 if (of_property_read_u32(child
, "reg", &val
) < 0) {
1681 dev_err(&pdev
->dev
, "%s has no 'reg' property\n",
1686 gpmc_onenand_data
= devm_kzalloc(&pdev
->dev
, sizeof(*gpmc_onenand_data
),
1688 if (!gpmc_onenand_data
)
1691 gpmc_onenand_data
->cs
= val
;
1692 gpmc_onenand_data
->of_node
= child
;
1693 gpmc_onenand_data
->dma_channel
= -1;
1695 if (!of_property_read_u32(child
, "dma-channel", &val
))
1696 gpmc_onenand_data
->dma_channel
= val
;
1698 gpmc_onenand_init(gpmc_onenand_data
);
1703 static int gpmc_probe_onenand_child(struct platform_device
*pdev
,
1704 struct device_node
*child
)
1711 * gpmc_probe_generic_child - configures the gpmc for a child device
1712 * @pdev: pointer to gpmc platform device
1713 * @child: pointer to device-tree node for child device
1715 * Allocates and configures a GPMC chip-select for a child device.
1716 * Returns 0 on success and appropriate negative error code on failure.
1718 static int gpmc_probe_generic_child(struct platform_device
*pdev
,
1719 struct device_node
*child
)
1721 struct gpmc_settings gpmc_s
;
1722 struct gpmc_timings gpmc_t
;
1723 struct resource res
;
1729 if (of_property_read_u32(child
, "reg", &cs
) < 0) {
1730 dev_err(&pdev
->dev
, "%s has no 'reg' property\n",
1735 if (of_address_to_resource(child
, 0, &res
) < 0) {
1736 dev_err(&pdev
->dev
, "%s has malformed 'reg' property\n",
1742 * Check if we have multiple instances of the same device
1743 * on a single chip select. If so, use the already initialized
1746 name
= gpmc_cs_get_name(cs
);
1747 if (name
&& child
->name
&& of_node_cmp(child
->name
, name
) == 0)
1750 ret
= gpmc_cs_request(cs
, resource_size(&res
), &base
);
1752 dev_err(&pdev
->dev
, "cannot request GPMC CS %d\n", cs
);
1755 gpmc_cs_set_name(cs
, child
->name
);
1757 gpmc_read_settings_dt(child
, &gpmc_s
);
1758 gpmc_read_timings_dt(child
, &gpmc_t
);
1761 * For some GPMC devices we still need to rely on the bootloader
1762 * timings because the devices can be connected via FPGA.
1763 * REVISIT: Add timing support from slls644g.pdf.
1765 if (!gpmc_t
.cs_rd_off
) {
1766 WARN(1, "enable GPMC debug to configure .dts timings for CS%i\n",
1768 gpmc_cs_show_timings(cs
,
1769 "please add GPMC bootloader timings to .dts");
1773 /* CS must be disabled while making changes to gpmc configuration */
1774 gpmc_cs_disable_mem(cs
);
1777 * FIXME: gpmc_cs_request() will map the CS to an arbitary
1778 * location in the gpmc address space. When booting with
1779 * device-tree we want the NOR flash to be mapped to the
1780 * location specified in the device-tree blob. So remap the
1781 * CS to this location. Once DT migration is complete should
1782 * just make gpmc_cs_request() map a specific address.
1784 ret
= gpmc_cs_remap(cs
, res
.start
);
1786 dev_err(&pdev
->dev
, "cannot remap GPMC CS %d to %pa\n",
1791 ret
= of_property_read_u32(child
, "bank-width", &gpmc_s
.device_width
);
1795 ret
= gpmc_cs_program_settings(cs
, &gpmc_s
);
1799 ret
= gpmc_cs_set_timings(cs
, &gpmc_t
);
1801 dev_err(&pdev
->dev
, "failed to set gpmc timings for: %s\n",
1806 /* Clear limited address i.e. enable A26-A11 */
1807 val
= gpmc_read_reg(GPMC_CONFIG
);
1808 val
&= ~GPMC_CONFIG_LIMITEDADDRESS
;
1809 gpmc_write_reg(GPMC_CONFIG
, val
);
1811 /* Enable CS region */
1812 gpmc_cs_enable_mem(cs
);
1815 if (of_platform_device_create(child
, NULL
, &pdev
->dev
))
1818 dev_err(&pdev
->dev
, "failed to create gpmc child %s\n", child
->name
);
1827 static int gpmc_probe_dt(struct platform_device
*pdev
)
1830 struct device_node
*child
;
1831 const struct of_device_id
*of_id
=
1832 of_match_device(gpmc_dt_ids
, &pdev
->dev
);
1837 ret
= of_property_read_u32(pdev
->dev
.of_node
, "gpmc,num-cs",
1840 pr_err("%s: number of chip-selects not defined\n", __func__
);
1842 } else if (gpmc_cs_num
< 1) {
1843 pr_err("%s: all chip-selects are disabled\n", __func__
);
1845 } else if (gpmc_cs_num
> GPMC_CS_NUM
) {
1846 pr_err("%s: number of supported chip-selects cannot be > %d\n",
1847 __func__
, GPMC_CS_NUM
);
1851 ret
= of_property_read_u32(pdev
->dev
.of_node
, "gpmc,num-waitpins",
1854 pr_err("%s: number of wait pins not found!\n", __func__
);
1858 for_each_available_child_of_node(pdev
->dev
.of_node
, child
) {
1863 if (of_node_cmp(child
->name
, "nand") == 0)
1864 ret
= gpmc_probe_nand_child(pdev
, child
);
1865 else if (of_node_cmp(child
->name
, "onenand") == 0)
1866 ret
= gpmc_probe_onenand_child(pdev
, child
);
1867 else if (of_node_cmp(child
->name
, "ethernet") == 0 ||
1868 of_node_cmp(child
->name
, "nor") == 0 ||
1869 of_node_cmp(child
->name
, "uart") == 0)
1870 ret
= gpmc_probe_generic_child(pdev
, child
);
1872 if (WARN(ret
< 0, "%s: probing gpmc child %s failed\n",
1873 __func__
, child
->full_name
))
1880 static int gpmc_probe_dt(struct platform_device
*pdev
)
1886 static int gpmc_probe(struct platform_device
*pdev
)
1890 struct resource
*res
;
1892 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1896 phys_base
= res
->start
;
1897 mem_size
= resource_size(res
);
1899 gpmc_base
= devm_ioremap_resource(&pdev
->dev
, res
);
1900 if (IS_ERR(gpmc_base
))
1901 return PTR_ERR(gpmc_base
);
1903 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
1905 dev_warn(&pdev
->dev
, "Failed to get resource: irq\n");
1907 gpmc_irq
= res
->start
;
1909 gpmc_l3_clk
= devm_clk_get(&pdev
->dev
, "fck");
1910 if (IS_ERR(gpmc_l3_clk
)) {
1911 dev_err(&pdev
->dev
, "Failed to get GPMC fck\n");
1913 return PTR_ERR(gpmc_l3_clk
);
1916 if (!clk_get_rate(gpmc_l3_clk
)) {
1917 dev_err(&pdev
->dev
, "Invalid GPMC fck clock rate\n");
1921 pm_runtime_enable(&pdev
->dev
);
1922 pm_runtime_get_sync(&pdev
->dev
);
1924 gpmc_dev
= &pdev
->dev
;
1926 l
= gpmc_read_reg(GPMC_REVISION
);
1929 * FIXME: Once device-tree migration is complete the below flags
1930 * should be populated based upon the device-tree compatible
1931 * string. For now just use the IP revision. OMAP3+ devices have
1932 * the wr_access and wr_data_mux_bus register fields. OMAP4+
1933 * devices support the addr-addr-data multiplex protocol.
1935 * GPMC IP revisions:
1938 * - OMAP44xx/54xx/AM335x = 6.0
1940 if (GPMC_REVISION_MAJOR(l
) > 0x4)
1941 gpmc_capability
= GPMC_HAS_WR_ACCESS
| GPMC_HAS_WR_DATA_MUX_BUS
;
1942 if (GPMC_REVISION_MAJOR(l
) > 0x5)
1943 gpmc_capability
|= GPMC_HAS_MUX_AAD
;
1944 dev_info(gpmc_dev
, "GPMC revision %d.%d\n", GPMC_REVISION_MAJOR(l
),
1945 GPMC_REVISION_MINOR(l
));
1949 if (gpmc_setup_irq() < 0)
1950 dev_warn(gpmc_dev
, "gpmc_setup_irq failed\n");
1952 if (!pdev
->dev
.of_node
) {
1953 gpmc_cs_num
= GPMC_CS_NUM
;
1954 gpmc_nr_waitpins
= GPMC_NR_WAITPINS
;
1957 rc
= gpmc_probe_dt(pdev
);
1959 pm_runtime_put_sync(&pdev
->dev
);
1960 dev_err(gpmc_dev
, "failed to probe DT parameters\n");
1967 static int gpmc_remove(struct platform_device
*pdev
)
1971 pm_runtime_put_sync(&pdev
->dev
);
1972 pm_runtime_disable(&pdev
->dev
);
1977 #ifdef CONFIG_PM_SLEEP
1978 static int gpmc_suspend(struct device
*dev
)
1980 omap3_gpmc_save_context();
1981 pm_runtime_put_sync(dev
);
1985 static int gpmc_resume(struct device
*dev
)
1987 pm_runtime_get_sync(dev
);
1988 omap3_gpmc_restore_context();
1993 static SIMPLE_DEV_PM_OPS(gpmc_pm_ops
, gpmc_suspend
, gpmc_resume
);
1995 static struct platform_driver gpmc_driver
= {
1996 .probe
= gpmc_probe
,
1997 .remove
= gpmc_remove
,
1999 .name
= DEVICE_NAME
,
2000 .of_match_table
= of_match_ptr(gpmc_dt_ids
),
2005 static __init
int gpmc_init(void)
2007 return platform_driver_register(&gpmc_driver
);
2010 static __exit
void gpmc_exit(void)
2012 platform_driver_unregister(&gpmc_driver
);
2016 postcore_initcall(gpmc_init
);
2017 module_exit(gpmc_exit
);
2019 static irqreturn_t
gpmc_handle_irq(int irq
, void *dev
)
2024 regval
= gpmc_read_reg(GPMC_IRQSTATUS
);
2029 for (i
= 0; i
< GPMC_NR_IRQ
; i
++)
2030 if (regval
& gpmc_client_irq
[i
].bitmask
)
2031 generic_handle_irq(gpmc_client_irq
[i
].irq
);
2033 gpmc_write_reg(GPMC_IRQSTATUS
, regval
);
2038 static struct omap3_gpmc_regs gpmc_context
;
2040 void omap3_gpmc_save_context(void)
2044 gpmc_context
.sysconfig
= gpmc_read_reg(GPMC_SYSCONFIG
);
2045 gpmc_context
.irqenable
= gpmc_read_reg(GPMC_IRQENABLE
);
2046 gpmc_context
.timeout_ctrl
= gpmc_read_reg(GPMC_TIMEOUT_CONTROL
);
2047 gpmc_context
.config
= gpmc_read_reg(GPMC_CONFIG
);
2048 gpmc_context
.prefetch_config1
= gpmc_read_reg(GPMC_PREFETCH_CONFIG1
);
2049 gpmc_context
.prefetch_config2
= gpmc_read_reg(GPMC_PREFETCH_CONFIG2
);
2050 gpmc_context
.prefetch_control
= gpmc_read_reg(GPMC_PREFETCH_CONTROL
);
2051 for (i
= 0; i
< gpmc_cs_num
; i
++) {
2052 gpmc_context
.cs_context
[i
].is_valid
= gpmc_cs_mem_enabled(i
);
2053 if (gpmc_context
.cs_context
[i
].is_valid
) {
2054 gpmc_context
.cs_context
[i
].config1
=
2055 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG1
);
2056 gpmc_context
.cs_context
[i
].config2
=
2057 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG2
);
2058 gpmc_context
.cs_context
[i
].config3
=
2059 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG3
);
2060 gpmc_context
.cs_context
[i
].config4
=
2061 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG4
);
2062 gpmc_context
.cs_context
[i
].config5
=
2063 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG5
);
2064 gpmc_context
.cs_context
[i
].config6
=
2065 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG6
);
2066 gpmc_context
.cs_context
[i
].config7
=
2067 gpmc_cs_read_reg(i
, GPMC_CS_CONFIG7
);
2072 void omap3_gpmc_restore_context(void)
2076 gpmc_write_reg(GPMC_SYSCONFIG
, gpmc_context
.sysconfig
);
2077 gpmc_write_reg(GPMC_IRQENABLE
, gpmc_context
.irqenable
);
2078 gpmc_write_reg(GPMC_TIMEOUT_CONTROL
, gpmc_context
.timeout_ctrl
);
2079 gpmc_write_reg(GPMC_CONFIG
, gpmc_context
.config
);
2080 gpmc_write_reg(GPMC_PREFETCH_CONFIG1
, gpmc_context
.prefetch_config1
);
2081 gpmc_write_reg(GPMC_PREFETCH_CONFIG2
, gpmc_context
.prefetch_config2
);
2082 gpmc_write_reg(GPMC_PREFETCH_CONTROL
, gpmc_context
.prefetch_control
);
2083 for (i
= 0; i
< gpmc_cs_num
; i
++) {
2084 if (gpmc_context
.cs_context
[i
].is_valid
) {
2085 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG1
,
2086 gpmc_context
.cs_context
[i
].config1
);
2087 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG2
,
2088 gpmc_context
.cs_context
[i
].config2
);
2089 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG3
,
2090 gpmc_context
.cs_context
[i
].config3
);
2091 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG4
,
2092 gpmc_context
.cs_context
[i
].config4
);
2093 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG5
,
2094 gpmc_context
.cs_context
[i
].config5
);
2095 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG6
,
2096 gpmc_context
.cs_context
[i
].config6
);
2097 gpmc_cs_write_reg(i
, GPMC_CS_CONFIG7
,
2098 gpmc_context
.cs_context
[i
].config7
);