History

ARM: ep93xx: delete all boardfiles

Delete the ep93xx board files.

Nikita Shubin committed 2 years ago

Commit e5ef5741 parent a63222915 files · +0 −3669Browse files

Unified · Split

15 files
  1. arch/arm/mach-ep93xx/clock.c +0 −733
  2. arch/arm/mach-ep93xx/core.c +0 −955
  3. arch/arm/mach-ep93xx/dma.c +0 −114
  4. arch/arm/mach-ep93xx/edb93xx.c +0 −368
  5. arch/arm/mach-ep93xx/ep93xx-regs.h +0 −38
  6. arch/arm/mach-ep93xx/gpio-ep93xx.h +0 −111
  7. arch/arm/mach-ep93xx/hardware.h +0 −25
  8. arch/arm/mach-ep93xx/irqs.h +0 −76
  9. arch/arm/mach-ep93xx/platform.h +0 −42
  10. arch/arm/mach-ep93xx/soc.h +0 −212
  11. arch/arm/mach-ep93xx/timer-ep93xx.c +0 −143
  12. arch/arm/mach-ep93xx/ts72xx.c +0 −422
  13. arch/arm/mach-ep93xx/ts72xx.h +0 −94
  14. arch/arm/mach-ep93xx/vision_ep9307.c +0 −321
  15. include/linux/platform_data/spi-ep93xx.h +0 −15
arch/arm/mach-ep93xx/clock.c+0−733
@@ -1,733 +0,0 @@
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * arch/arm/mach-ep93xx/clock.c
4 * Clock control for Cirrus EP93xx chips.
5 *
6 * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
7 */
8
9#define pr_fmt(fmt) "ep93xx " KBUILD_MODNAME ": " fmt
10
11#include <linux/kernel.h>
12#include <linux/clk.h>
13#include <linux/err.h>
14#include <linux/module.h>
15#include <linux/string.h>
16#include <linux/io.h>
17#include <linux/spinlock.h>
18#include <linux/clkdev.h>
19#include <linux/clk-provider.h>
20#include <linux/soc/cirrus/ep93xx.h>
21
22#include "hardware.h"
23
24#include <asm/div64.h>
25
26#include "soc.h"
27
28static DEFINE_SPINLOCK(clk_lock);
29
30static char fclk_divisors[] = { 1, 2, 4, 8, 16, 1, 1, 1 };
31static char hclk_divisors[] = { 1, 2, 4, 5, 6, 8, 16, 32 };
32static char pclk_divisors[] = { 1, 2, 4, 8 };
33
34static char adc_divisors[] = { 16, 4 };
35static char sclk_divisors[] = { 2, 4 };
36static char lrclk_divisors[] = { 32, 64, 128 };
37
38static const char * const mux_parents[] = {
39 "xtali",
40 "pll1",
41 "pll2"
42};
43
44/*
45 * PLL rate = 14.7456 MHz * (X1FBD + 1) * (X2FBD + 1) / (X2IPD + 1) / 2^PS
46 */
47static unsigned long calc_pll_rate(unsigned long long rate, u32 config_word)
48{
49 int i;
50
51 rate *= ((config_word >> 11) & 0x1f) + 1; /* X1FBD */
52 rate *= ((config_word >> 5) & 0x3f) + 1; /* X2FBD */
53 do_div(rate, (config_word & 0x1f) + 1); /* X2IPD */
54 for (i = 0; i < ((config_word >> 16) & 3); i++) /* PS */
55 rate >>= 1;
56
57 return (unsigned long)rate;
58}
59
60struct clk_psc {
61 struct clk_hw hw;
62 void __iomem *reg;
63 u8 bit_idx;
64 u32 mask;
65 u8 shift;
66 u8 width;
67 char *div;
68 u8 num_div;
69 spinlock_t *lock;
70};
71
72#define to_clk_psc(_hw) container_of(_hw, struct clk_psc, hw)
73
74static int ep93xx_clk_is_enabled(struct clk_hw *hw)
75{
76 struct clk_psc *psc = to_clk_psc(hw);
77 u32 val = readl(psc->reg);
78
79 return (val & BIT(psc->bit_idx)) ? 1 : 0;
80}
81
82static int ep93xx_clk_enable(struct clk_hw *hw)
83{
84 struct clk_psc *psc = to_clk_psc(hw);
85 unsigned long flags = 0;
86 u32 val;
87
88 if (psc->lock)
89 spin_lock_irqsave(psc->lock, flags);
90
91 val = __raw_readl(psc->reg);
92 val |= BIT(psc->bit_idx);
93
94 ep93xx_syscon_swlocked_write(val, psc->reg);
95
96 if (psc->lock)
97 spin_unlock_irqrestore(psc->lock, flags);
98
99 return 0;
100}
101
102static void ep93xx_clk_disable(struct clk_hw *hw)
103{
104 struct clk_psc *psc = to_clk_psc(hw);
105 unsigned long flags = 0;
106 u32 val;
107
108 if (psc->lock)
109 spin_lock_irqsave(psc->lock, flags);
110
111 val = __raw_readl(psc->reg);
112 val &= ~BIT(psc->bit_idx);
113
114 ep93xx_syscon_swlocked_write(val, psc->reg);
115
116 if (psc->lock)
117 spin_unlock_irqrestore(psc->lock, flags);
118}
119
120static const struct clk_ops clk_ep93xx_gate_ops = {
121 .enable = ep93xx_clk_enable,
122 .disable = ep93xx_clk_disable,
123 .is_enabled = ep93xx_clk_is_enabled,
124};
125
126static struct clk_hw *ep93xx_clk_register_gate(const char *name,
127 const char *parent_name,
128 void __iomem *reg,
129 u8 bit_idx)
130{
131 struct clk_init_data init;
132 struct clk_psc *psc;
133 struct clk *clk;
134
135 psc = kzalloc(sizeof(*psc), GFP_KERNEL);
136 if (!psc)
137 return ERR_PTR(-ENOMEM);
138
139 init.name = name;
140 init.ops = &clk_ep93xx_gate_ops;
141 init.flags = CLK_SET_RATE_PARENT;
142 init.parent_names = (parent_name ? &parent_name : NULL);
143 init.num_parents = (parent_name ? 1 : 0);
144
145 psc->reg = reg;
146 psc->bit_idx = bit_idx;
147 psc->hw.init = &init;
148 psc->lock = &clk_lock;
149
150 clk = clk_register(NULL, &psc->hw);
151 if (IS_ERR(clk)) {
152 kfree(psc);
153 return ERR_CAST(clk);
154 }
155
156 return &psc->hw;
157}
158
159static u8 ep93xx_mux_get_parent(struct clk_hw *hw)
160{
161 struct clk_psc *psc = to_clk_psc(hw);
162 u32 val = __raw_readl(psc->reg);
163
164 if (!(val & EP93XX_SYSCON_CLKDIV_ESEL))
165 return 0;
166
167 if (!(val & EP93XX_SYSCON_CLKDIV_PSEL))
168 return 1;
169
170 return 2;
171}
172
173static int ep93xx_mux_set_parent_lock(struct clk_hw *hw, u8 index)
174{
175 struct clk_psc *psc = to_clk_psc(hw);
176 unsigned long flags = 0;
177 u32 val;
178
179 if (index >= ARRAY_SIZE(mux_parents))
180 return -EINVAL;
181
182 if (psc->lock)
183 spin_lock_irqsave(psc->lock, flags);
184
185 val = __raw_readl(psc->reg);
186 val &= ~(EP93XX_SYSCON_CLKDIV_ESEL | EP93XX_SYSCON_CLKDIV_PSEL);
187
188
189 if (index != 0) {
190 val |= EP93XX_SYSCON_CLKDIV_ESEL;
191 val |= (index - 1) ? EP93XX_SYSCON_CLKDIV_PSEL : 0;
192 }
193
194 ep93xx_syscon_swlocked_write(val, psc->reg);
195
196 if (psc->lock)
197 spin_unlock_irqrestore(psc->lock, flags);
198
199 return 0;
200}
201
202static bool is_best(unsigned long rate, unsigned long now,
203 unsigned long best)
204{
205 return abs(rate - now) < abs(rate - best);
206}
207
208static int ep93xx_mux_determine_rate(struct clk_hw *hw,
209 struct clk_rate_request *req)
210{
211 unsigned long rate = req->rate;
212 struct clk *best_parent = NULL;
213 unsigned long __parent_rate;
214 unsigned long best_rate = 0, actual_rate, mclk_rate;
215 unsigned long best_parent_rate;
216 int __div = 0, __pdiv = 0;
217 int i;
218
219 /*
220 * Try the two pll's and the external clock
221 * Because the valid predividers are 2, 2.5 and 3, we multiply
222 * all the clocks by 2 to avoid floating point math.
223 *
224 * This is based on the algorithm in the ep93xx raster guide:
225 * http://be-a-maverick.com/en/pubs/appNote/AN269REV1.pdf
226 *
227 */
228 for (i = 0; i < ARRAY_SIZE(mux_parents); i++) {
229 struct clk *parent = clk_get_sys(mux_parents[i], NULL);
230
231 __parent_rate = clk_get_rate(parent);
232 mclk_rate = __parent_rate * 2;
233
234 /* Try each predivider value */
235 for (__pdiv = 4; __pdiv <= 6; __pdiv++) {
236 __div = mclk_rate / (rate * __pdiv);
237 if (__div < 2 || __div > 127)
238 continue;
239
240 actual_rate = mclk_rate / (__pdiv * __div);
241 if (is_best(rate, actual_rate, best_rate)) {
242 best_rate = actual_rate;
243 best_parent_rate = __parent_rate;
244 best_parent = parent;
245 }
246 }
247 }
248
249 if (!best_parent)
250 return -EINVAL;
251
252 req->best_parent_rate = best_parent_rate;
253 req->best_parent_hw = __clk_get_hw(best_parent);
254 req->rate = best_rate;
255
256 return 0;
257}
258
259static unsigned long ep93xx_ddiv_recalc_rate(struct clk_hw *hw,
260 unsigned long parent_rate)
261{
262 struct clk_psc *psc = to_clk_psc(hw);
263 unsigned long rate = 0;
264 u32 val = __raw_readl(psc->reg);
265 int __pdiv = ((val >> EP93XX_SYSCON_CLKDIV_PDIV_SHIFT) & 0x03);
266 int __div = val & 0x7f;
267
268 if (__div > 0)
269 rate = (parent_rate * 2) / ((__pdiv + 3) * __div);
270
271 return rate;
272}
273
274static int ep93xx_ddiv_set_rate(struct clk_hw *hw, unsigned long rate,
275 unsigned long parent_rate)
276{
277 struct clk_psc *psc = to_clk_psc(hw);
278 int pdiv = 0, div = 0;
279 unsigned long best_rate = 0, actual_rate, mclk_rate;
280 int __div = 0, __pdiv = 0;
281 u32 val;
282
283 mclk_rate = parent_rate * 2;
284
285 for (__pdiv = 4; __pdiv <= 6; __pdiv++) {
286 __div = mclk_rate / (rate * __pdiv);
287 if (__div < 2 || __div > 127)
288 continue;
289
290 actual_rate = mclk_rate / (__pdiv * __div);
291 if (is_best(rate, actual_rate, best_rate)) {
292 pdiv = __pdiv - 3;
293 div = __div;
294 best_rate = actual_rate;
295 }
296 }
297
298 if (!best_rate)
299 return -EINVAL;
300
301 val = __raw_readl(psc->reg);
302
303 /* Clear old dividers */
304 val &= ~0x37f;
305
306 /* Set the new pdiv and div bits for the new clock rate */
307 val |= (pdiv << EP93XX_SYSCON_CLKDIV_PDIV_SHIFT) | div;
308 ep93xx_syscon_swlocked_write(val, psc->reg);
309
310 return 0;
311}
312
313static const struct clk_ops clk_ddiv_ops = {
314 .enable = ep93xx_clk_enable,
315 .disable = ep93xx_clk_disable,
316 .is_enabled = ep93xx_clk_is_enabled,
317 .get_parent = ep93xx_mux_get_parent,
318 .set_parent = ep93xx_mux_set_parent_lock,
319 .determine_rate = ep93xx_mux_determine_rate,
320 .recalc_rate = ep93xx_ddiv_recalc_rate,
321 .set_rate = ep93xx_ddiv_set_rate,
322};
323
324static struct clk_hw *clk_hw_register_ddiv(const char *name,
325 void __iomem *reg,
326 u8 bit_idx)
327{
328 struct clk_init_data init;
329 struct clk_psc *psc;
330 struct clk *clk;
331
332 psc = kzalloc(sizeof(*psc), GFP_KERNEL);
333 if (!psc)
334 return ERR_PTR(-ENOMEM);
335
336 init.name = name;
337 init.ops = &clk_ddiv_ops;
338 init.flags = 0;
339 init.parent_names = mux_parents;
340 init.num_parents = ARRAY_SIZE(mux_parents);
341
342 psc->reg = reg;
343 psc->bit_idx = bit_idx;
344 psc->lock = &clk_lock;
345 psc->hw.init = &init;
346
347 clk = clk_register(NULL, &psc->hw);
348 if (IS_ERR(clk)) {
349 kfree(psc);
350 return ERR_CAST(clk);
351 }
352 return &psc->hw;
353}
354
355static unsigned long ep93xx_div_recalc_rate(struct clk_hw *hw,
356 unsigned long parent_rate)
357{
358 struct clk_psc *psc = to_clk_psc(hw);
359 u32 val = __raw_readl(psc->reg);
360 u8 index = (val & psc->mask) >> psc->shift;
361
362 if (index >= psc->num_div)
363 return 0;
364
365 return DIV_ROUND_UP_ULL(parent_rate, psc->div[index]);
366}
367
368static long ep93xx_div_round_rate(struct clk_hw *hw, unsigned long rate,
369 unsigned long *parent_rate)
370{
371 struct clk_psc *psc = to_clk_psc(hw);
372 unsigned long best = 0, now, maxdiv;
373 int i;
374
375 maxdiv = psc->div[psc->num_div - 1];
376
377 for (i = 0; i < psc->num_div; i++) {
378 if ((rate * psc->div[i]) == *parent_rate)
379 return DIV_ROUND_UP_ULL((u64)*parent_rate, psc->div[i]);
380
381 now = DIV_ROUND_UP_ULL((u64)*parent_rate, psc->div[i]);
382
383 if (is_best(rate, now, best))
384 best = now;
385 }
386
387 if (!best)
388 best = DIV_ROUND_UP_ULL(*parent_rate, maxdiv);
389
390 return best;
391}
392
393static int ep93xx_div_set_rate(struct clk_hw *hw, unsigned long rate,
394 unsigned long parent_rate)
395{
396 struct clk_psc *psc = to_clk_psc(hw);
397 u32 val = __raw_readl(psc->reg) & ~psc->mask;
398 int i;
399
400 for (i = 0; i < psc->num_div; i++)
401 if (rate == parent_rate / psc->div[i]) {
402 val |= i << psc->shift;
403 break;
404 }
405
406 if (i == psc->num_div)
407 return -EINVAL;
408
409 ep93xx_syscon_swlocked_write(val, psc->reg);
410
411 return 0;
412}
413
414static const struct clk_ops ep93xx_div_ops = {
415 .enable = ep93xx_clk_enable,
416 .disable = ep93xx_clk_disable,
417 .is_enabled = ep93xx_clk_is_enabled,
418 .recalc_rate = ep93xx_div_recalc_rate,
419 .round_rate = ep93xx_div_round_rate,
420 .set_rate = ep93xx_div_set_rate,
421};
422
423static struct clk_hw *clk_hw_register_div(const char *name,
424 const char *parent_name,
425 void __iomem *reg,
426 u8 enable_bit,
427 u8 shift,
428 u8 width,
429 char *clk_divisors,
430 u8 num_div)
431{
432 struct clk_init_data init;
433 struct clk_psc *psc;
434 struct clk *clk;
435
436 psc = kzalloc(sizeof(*psc), GFP_KERNEL);
437 if (!psc)
438 return ERR_PTR(-ENOMEM);
439
440 init.name = name;
441 init.ops = &ep93xx_div_ops;
442 init.flags = 0;
443 init.parent_names = (parent_name ? &parent_name : NULL);
444 init.num_parents = 1;
445
446 psc->reg = reg;
447 psc->bit_idx = enable_bit;
448 psc->mask = GENMASK(shift + width - 1, shift);
449 psc->shift = shift;
450 psc->div = clk_divisors;
451 psc->num_div = num_div;
452 psc->lock = &clk_lock;
453 psc->hw.init = &init;
454
455 clk = clk_register(NULL, &psc->hw);
456 if (IS_ERR(clk)) {
457 kfree(psc);
458 return ERR_CAST(clk);
459 }
460 return &psc->hw;
461}
462
463struct ep93xx_gate {
464 unsigned int bit;
465 const char *dev_id;
466 const char *con_id;
467};
468
469static struct ep93xx_gate ep93xx_uarts[] = {
470 {EP93XX_SYSCON_DEVCFG_U1EN, "apb:uart1", NULL},
471 {EP93XX_SYSCON_DEVCFG_U2EN, "apb:uart2", NULL},
472 {EP93XX_SYSCON_DEVCFG_U3EN, "apb:uart3", NULL},
473};
474
475static void __init ep93xx_uart_clock_init(void)
476{
477 unsigned int i;
478 struct clk_hw *hw;
479 u32 value;
480 unsigned int clk_uart_div;
481
482 value = __raw_readl(EP93XX_SYSCON_PWRCNT);
483 if (value & EP93XX_SYSCON_PWRCNT_UARTBAUD)
484 clk_uart_div = 1;
485 else
486 clk_uart_div = 2;
487
488 hw = clk_hw_register_fixed_factor(NULL, "uart", "xtali", 0, 1, clk_uart_div);
489
490 /* parenting uart gate clocks to uart clock */
491 for (i = 0; i < ARRAY_SIZE(ep93xx_uarts); i++) {
492 hw = ep93xx_clk_register_gate(ep93xx_uarts[i].dev_id,
493 "uart",
494 EP93XX_SYSCON_DEVCFG,
495 ep93xx_uarts[i].bit);
496
497 clk_hw_register_clkdev(hw, NULL, ep93xx_uarts[i].dev_id);
498 }
499}
500
501static struct ep93xx_gate ep93xx_dmas[] = {
502 {EP93XX_SYSCON_PWRCNT_DMA_M2P0, NULL, "m2p0"},
503 {EP93XX_SYSCON_PWRCNT_DMA_M2P1, NULL, "m2p1"},
504 {EP93XX_SYSCON_PWRCNT_DMA_M2P2, NULL, "m2p2"},
505 {EP93XX_SYSCON_PWRCNT_DMA_M2P3, NULL, "m2p3"},
506 {EP93XX_SYSCON_PWRCNT_DMA_M2P4, NULL, "m2p4"},
507 {EP93XX_SYSCON_PWRCNT_DMA_M2P5, NULL, "m2p5"},
508 {EP93XX_SYSCON_PWRCNT_DMA_M2P6, NULL, "m2p6"},
509 {EP93XX_SYSCON_PWRCNT_DMA_M2P7, NULL, "m2p7"},
510 {EP93XX_SYSCON_PWRCNT_DMA_M2P8, NULL, "m2p8"},
511 {EP93XX_SYSCON_PWRCNT_DMA_M2P9, NULL, "m2p9"},
512 {EP93XX_SYSCON_PWRCNT_DMA_M2M0, NULL, "m2m0"},
513 {EP93XX_SYSCON_PWRCNT_DMA_M2M1, NULL, "m2m1"},
514};
515
516static void __init ep93xx_dma_clock_init(void)
517{
518 unsigned int i;
519 struct clk_hw *hw;
520 int ret;
521
522 for (i = 0; i < ARRAY_SIZE(ep93xx_dmas); i++) {
523 hw = clk_hw_register_gate(NULL, ep93xx_dmas[i].con_id,
524 "hclk", 0,
525 EP93XX_SYSCON_PWRCNT,
526 ep93xx_dmas[i].bit,
527 0,
528 &clk_lock);
529
530 ret = clk_hw_register_clkdev(hw, ep93xx_dmas[i].con_id, NULL);
531 if (ret)
532 pr_err("%s: failed to register lookup %s\n",
533 __func__, ep93xx_dmas[i].con_id);
534 }
535}
536
537static int __init ep93xx_clock_init(void)
538{
539 u32 value;
540 struct clk_hw *hw;
541 unsigned long clk_pll1_rate;
542 unsigned long clk_f_rate;
543 unsigned long clk_h_rate;
544 unsigned long clk_p_rate;
545 unsigned long clk_pll2_rate;
546 unsigned int clk_f_div;
547 unsigned int clk_h_div;
548 unsigned int clk_p_div;
549 unsigned int clk_usb_div;
550 unsigned long clk_spi_div;
551
552 hw = clk_hw_register_fixed_rate(NULL, "xtali", NULL, 0, EP93XX_EXT_CLK_RATE);
553 clk_hw_register_clkdev(hw, NULL, "xtali");
554
555 /* Determine the bootloader configured pll1 rate */
556 value = __raw_readl(EP93XX_SYSCON_CLKSET1);
557 if (!(value & EP93XX_SYSCON_CLKSET1_NBYP1))
558 clk_pll1_rate = EP93XX_EXT_CLK_RATE;
559 else
560 clk_pll1_rate = calc_pll_rate(EP93XX_EXT_CLK_RATE, value);
561
562 hw = clk_hw_register_fixed_rate(NULL, "pll1", "xtali", 0, clk_pll1_rate);
563 clk_hw_register_clkdev(hw, NULL, "pll1");
564
565 /* Initialize the pll1 derived clocks */
566 clk_f_div = fclk_divisors[(value >> 25) & 0x7];
567 clk_h_div = hclk_divisors[(value >> 20) & 0x7];
568 clk_p_div = pclk_divisors[(value >> 18) & 0x3];
569
570 hw = clk_hw_register_fixed_factor(NULL, "fclk", "pll1", 0, 1, clk_f_div);
571 clk_f_rate = clk_get_rate(hw->clk);
572 hw = clk_hw_register_fixed_factor(NULL, "hclk", "pll1", 0, 1, clk_h_div);
573 clk_h_rate = clk_get_rate(hw->clk);
574 hw = clk_hw_register_fixed_factor(NULL, "pclk", "hclk", 0, 1, clk_p_div);
575 clk_p_rate = clk_get_rate(hw->clk);
576
577 clk_hw_register_clkdev(hw, "apb_pclk", NULL);
578
579 ep93xx_dma_clock_init();
580
581 /* Determine the bootloader configured pll2 rate */
582 value = __raw_readl(EP93XX_SYSCON_CLKSET2);
583 if (!(value & EP93XX_SYSCON_CLKSET2_NBYP2))
584 clk_pll2_rate = EP93XX_EXT_CLK_RATE;
585 else if (value & EP93XX_SYSCON_CLKSET2_PLL2_EN)
586 clk_pll2_rate = calc_pll_rate(EP93XX_EXT_CLK_RATE, value);
587 else
588 clk_pll2_rate = 0;
589
590 hw = clk_hw_register_fixed_rate(NULL, "pll2", "xtali", 0, clk_pll2_rate);
591 clk_hw_register_clkdev(hw, NULL, "pll2");
592
593 /* Initialize the pll2 derived clocks */
594 /*
595 * These four bits set the divide ratio between the PLL2
596 * output and the USB clock.
597 * 0000 - Divide by 1
598 * 0001 - Divide by 2
599 * 0010 - Divide by 3
600 * 0011 - Divide by 4
601 * 0100 - Divide by 5
602 * 0101 - Divide by 6
603 * 0110 - Divide by 7
604 * 0111 - Divide by 8
605 * 1000 - Divide by 9
606 * 1001 - Divide by 10
607 * 1010 - Divide by 11
608 * 1011 - Divide by 12
609 * 1100 - Divide by 13
610 * 1101 - Divide by 14
611 * 1110 - Divide by 15
612 * 1111 - Divide by 1
613 * On power-on-reset these bits are reset to 0000b.
614 */
615 clk_usb_div = (((value >> 28) & 0xf) + 1);
616 hw = clk_hw_register_fixed_factor(NULL, "usb_clk", "pll2", 0, 1, clk_usb_div);
617 hw = clk_hw_register_gate(NULL, "ohci-platform",
618 "usb_clk", 0,
619 EP93XX_SYSCON_PWRCNT,
620 EP93XX_SYSCON_PWRCNT_USH_EN,
621 0,
622 &clk_lock);
623 clk_hw_register_clkdev(hw, NULL, "ohci-platform");
624
625 /*
626 * EP93xx SSP clock rate was doubled in version E2. For more information
627 * see:
628 * http://www.cirrus.com/en/pubs/appNote/AN273REV4.pdf
629 */
630 clk_spi_div = 1;
631 if (ep93xx_chip_revision() < EP93XX_CHIP_REV_E2)
632 clk_spi_div = 2;
633 hw = clk_hw_register_fixed_factor(NULL, "ep93xx-spi.0", "xtali", 0, 1, clk_spi_div);
634 clk_hw_register_clkdev(hw, NULL, "ep93xx-spi.0");
635
636 /* pwm clock */
637 hw = clk_hw_register_fixed_factor(NULL, "pwm_clk", "xtali", 0, 1, 1);
638 clk_hw_register_clkdev(hw, "pwm_clk", NULL);
639
640 pr_info("PLL1 running at %ld MHz, PLL2 at %ld MHz\n",
641 clk_pll1_rate / 1000000, clk_pll2_rate / 1000000);
642 pr_info("FCLK %ld MHz, HCLK %ld MHz, PCLK %ld MHz\n",
643 clk_f_rate / 1000000, clk_h_rate / 1000000,
644 clk_p_rate / 1000000);
645
646 ep93xx_uart_clock_init();
647
648 /* touchscreen/adc clock */
649 hw = clk_hw_register_div("ep93xx-adc",
650 "xtali",
651 EP93XX_SYSCON_KEYTCHCLKDIV,
652 EP93XX_SYSCON_KEYTCHCLKDIV_TSEN,
653 EP93XX_SYSCON_KEYTCHCLKDIV_ADIV,
654 1,
655 adc_divisors,
656 ARRAY_SIZE(adc_divisors));
657
658 clk_hw_register_clkdev(hw, NULL, "ep93xx-adc");
659
660 /* keypad clock */
661 hw = clk_hw_register_div("ep93xx-keypad",
662 "xtali",
663 EP93XX_SYSCON_KEYTCHCLKDIV,
664 EP93XX_SYSCON_KEYTCHCLKDIV_KEN,
665 EP93XX_SYSCON_KEYTCHCLKDIV_KDIV,
666 1,
667 adc_divisors,
668 ARRAY_SIZE(adc_divisors));
669
670 clk_hw_register_clkdev(hw, NULL, "ep93xx-keypad");
671
672 /* On reset PDIV and VDIV is set to zero, while PDIV zero
673 * means clock disable, VDIV shouldn't be zero.
674 * So i set both dividers to minimum.
675 */
676 /* ENA - Enable CLK divider. */
677 /* PDIV - 00 - Disable clock */
678 /* VDIV - at least 2 */
679 /* Check and enable video clk registers */
680 value = __raw_readl(EP93XX_SYSCON_VIDCLKDIV);
681 value |= (1 << EP93XX_SYSCON_CLKDIV_PDIV_SHIFT) | 2;
682 ep93xx_syscon_swlocked_write(value, EP93XX_SYSCON_VIDCLKDIV);
683
684 /* check and enable i2s clk registers */
685 value = __raw_readl(EP93XX_SYSCON_I2SCLKDIV);
686 value |= (1 << EP93XX_SYSCON_CLKDIV_PDIV_SHIFT) | 2;
687 ep93xx_syscon_swlocked_write(value, EP93XX_SYSCON_I2SCLKDIV);
688
689 /* video clk */
690 hw = clk_hw_register_ddiv("ep93xx-fb",
691 EP93XX_SYSCON_VIDCLKDIV,
692 EP93XX_SYSCON_CLKDIV_ENABLE);
693
694 clk_hw_register_clkdev(hw, NULL, "ep93xx-fb");
695
696 /* i2s clk */
697 hw = clk_hw_register_ddiv("mclk",
698 EP93XX_SYSCON_I2SCLKDIV,
699 EP93XX_SYSCON_CLKDIV_ENABLE);
700
701 clk_hw_register_clkdev(hw, "mclk", "ep93xx-i2s");
702
703 /* i2s sclk */
704#define EP93XX_I2SCLKDIV_SDIV_SHIFT 16
705#define EP93XX_I2SCLKDIV_SDIV_WIDTH 1
706 hw = clk_hw_register_div("sclk",
707 "mclk",
708 EP93XX_SYSCON_I2SCLKDIV,
709 EP93XX_SYSCON_I2SCLKDIV_SENA,
710 EP93XX_I2SCLKDIV_SDIV_SHIFT,
711 EP93XX_I2SCLKDIV_SDIV_WIDTH,
712 sclk_divisors,
713 ARRAY_SIZE(sclk_divisors));
714
715 clk_hw_register_clkdev(hw, "sclk", "ep93xx-i2s");
716
717 /* i2s lrclk */
718#define EP93XX_I2SCLKDIV_LRDIV32_SHIFT 17
719#define EP93XX_I2SCLKDIV_LRDIV32_WIDTH 3
720 hw = clk_hw_register_div("lrclk",
721 "sclk",
722 EP93XX_SYSCON_I2SCLKDIV,
723 EP93XX_SYSCON_I2SCLKDIV_SENA,
724 EP93XX_I2SCLKDIV_LRDIV32_SHIFT,
725 EP93XX_I2SCLKDIV_LRDIV32_WIDTH,
726 lrclk_divisors,
727 ARRAY_SIZE(lrclk_divisors));
728
729 clk_hw_register_clkdev(hw, "lrclk", "ep93xx-i2s");
730
731 return 0;
732}
733postcore_initcall(ep93xx_clock_init);
arch/arm/mach-ep93xx/core.c+0−955
@@ -1,955 +0,0 @@
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * arch/arm/mach-ep93xx/core.c
4 * Core routines for Cirrus EP93xx chips.
5 *
6 * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
7 * Copyright (C) 2007 Herbert Valerio Riedel <hvr@gnu.org>
8 *
9 * Thanks go to Michael Burian and Ray Lehtiniemi for their key
10 * role in the ep93xx linux community.
11 */
12
13#define pr_fmt(fmt) "ep93xx " KBUILD_MODNAME ": " fmt
14
15#include <linux/kernel.h>
16#include <linux/init.h>
17#include <linux/platform_device.h>
18#include <linux/interrupt.h>
19#include <linux/dma-mapping.h>
20#include <linux/sys_soc.h>
21#include <linux/irq.h>
22#include <linux/io.h>
23#include <linux/gpio.h>
24#include <linux/leds.h>
25#include <linux/uaccess.h>
26#include <linux/termios.h>
27#include <linux/amba/bus.h>
28#include <linux/amba/serial.h>
29#include <linux/mtd/physmap.h>
30#include <linux/i2c.h>
31#include <linux/gpio/machine.h>
32#include <linux/spi/spi.h>
33#include <linux/export.h>
34#include <linux/irqchip/arm-vic.h>
35#include <linux/reboot.h>
36#include <linux/usb/ohci_pdriver.h>
37#include <linux/random.h>
38#include <linux/ioport.h>
39
40#include "hardware.h"
41#include <linux/platform_data/video-ep93xx.h>
42#include <linux/platform_data/keypad-ep93xx.h>
43#include <linux/platform_data/spi-ep93xx.h>
44#include <linux/soc/cirrus/ep93xx.h>
45
46#include "gpio-ep93xx.h"
47
48#include <asm/mach/arch.h>
49#include <asm/mach/map.h>
50
51#include "soc.h"
52#include "irqs.h"
53
54/*************************************************************************
55 * Static I/O mappings that are needed for all EP93xx platforms
56 *************************************************************************/
57static struct map_desc ep93xx_io_desc[] __initdata = {
58 {
59 .virtual = EP93XX_AHB_VIRT_BASE,
60 .pfn = __phys_to_pfn(EP93XX_AHB_PHYS_BASE),
61 .length = EP93XX_AHB_SIZE,
62 .type = MT_DEVICE,
63 }, {
64 .virtual = EP93XX_APB_VIRT_BASE,
65 .pfn = __phys_to_pfn(EP93XX_APB_PHYS_BASE),
66 .length = EP93XX_APB_SIZE,
67 .type = MT_DEVICE,
68 },
69};
70
71void __init ep93xx_map_io(void)
72{
73 iotable_init(ep93xx_io_desc, ARRAY_SIZE(ep93xx_io_desc));
74}
75
76/*************************************************************************
77 * EP93xx IRQ handling
78 *************************************************************************/
79void __init ep93xx_init_irq(void)
80{
81 vic_init(EP93XX_VIC1_BASE, IRQ_EP93XX_VIC0, EP93XX_VIC1_VALID_IRQ_MASK, 0);
82 vic_init(EP93XX_VIC2_BASE, IRQ_EP93XX_VIC1, EP93XX_VIC2_VALID_IRQ_MASK, 0);
83}
84
85
86/*************************************************************************
87 * EP93xx System Controller Software Locked register handling
88 *************************************************************************/
89
90/*
91 * syscon_swlock prevents anything else from writing to the syscon
92 * block while a software locked register is being written.
93 */
94static DEFINE_SPINLOCK(syscon_swlock);
95
96void ep93xx_syscon_swlocked_write(unsigned int val, void __iomem *reg)
97{
98 unsigned long flags;
99
100 spin_lock_irqsave(&syscon_swlock, flags);
101
102 __raw_writel(0xaa, EP93XX_SYSCON_SWLOCK);
103 __raw_writel(val, reg);
104
105 spin_unlock_irqrestore(&syscon_swlock, flags);
106}
107
108void ep93xx_devcfg_set_clear(unsigned int set_bits, unsigned int clear_bits)
109{
110 unsigned long flags;
111 unsigned int val;
112
113 spin_lock_irqsave(&syscon_swlock, flags);
114
115 val = __raw_readl(EP93XX_SYSCON_DEVCFG);
116 val &= ~clear_bits;
117 val |= set_bits;
118 __raw_writel(0xaa, EP93XX_SYSCON_SWLOCK);
119 __raw_writel(val, EP93XX_SYSCON_DEVCFG);
120
121 spin_unlock_irqrestore(&syscon_swlock, flags);
122}
123
124/**
125 * ep93xx_chip_revision() - returns the EP93xx chip revision
126 *
127 * See "platform.h" for more information.
128 */
129unsigned int ep93xx_chip_revision(void)
130{
131 unsigned int v;
132
133 v = __raw_readl(EP93XX_SYSCON_SYSCFG);
134 v &= EP93XX_SYSCON_SYSCFG_REV_MASK;
135 v >>= EP93XX_SYSCON_SYSCFG_REV_SHIFT;
136 return v;
137}
138EXPORT_SYMBOL_GPL(ep93xx_chip_revision);
139
140/*************************************************************************
141 * EP93xx GPIO
142 *************************************************************************/
143/* port A */
144static struct resource ep93xx_a_gpio_resources[] = {
145 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE, 0x04, "data"),
146 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0x10, 0x04, "dir"),
147 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0x90, 0x1c, "intr"),
148 DEFINE_RES_IRQ(IRQ_EP93XX_GPIO_AB),
149};
150
151static struct platform_device ep93xx_a_gpio = {
152 .name = "gpio-ep93xx",
153 .id = 0,
154 .num_resources = ARRAY_SIZE(ep93xx_a_gpio_resources),
155 .resource = ep93xx_a_gpio_resources,
156};
157
158/* port B */
159static struct resource ep93xx_b_gpio_resources[] = {
160 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0x04, 0x04, "data"),
161 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0x14, 0x04, "dir"),
162 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0xac, 0x1c, "intr"),
163 DEFINE_RES_IRQ(IRQ_EP93XX_GPIO_AB),
164};
165
166static struct platform_device ep93xx_b_gpio = {
167 .name = "gpio-ep93xx",
168 .id = 1,
169 .num_resources = ARRAY_SIZE(ep93xx_b_gpio_resources),
170 .resource = ep93xx_b_gpio_resources,
171};
172
173/* port C */
174static struct resource ep93xx_c_gpio_resources[] = {
175 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0x08, 0x04, "data"),
176 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0x18, 0x04, "dir"),
177};
178
179static struct platform_device ep93xx_c_gpio = {
180 .name = "gpio-ep93xx",
181 .id = 2,
182 .num_resources = ARRAY_SIZE(ep93xx_c_gpio_resources),
183 .resource = ep93xx_c_gpio_resources,
184};
185
186/* port D */
187static struct resource ep93xx_d_gpio_resources[] = {
188 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0x0c, 0x04, "data"),
189 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0x1c, 0x04, "dir"),
190};
191
192static struct platform_device ep93xx_d_gpio = {
193 .name = "gpio-ep93xx",
194 .id = 3,
195 .num_resources = ARRAY_SIZE(ep93xx_d_gpio_resources),
196 .resource = ep93xx_d_gpio_resources,
197};
198
199/* port E */
200static struct resource ep93xx_e_gpio_resources[] = {
201 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0x20, 0x04, "data"),
202 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0x24, 0x04, "dir"),
203};
204
205static struct platform_device ep93xx_e_gpio = {
206 .name = "gpio-ep93xx",
207 .id = 4,
208 .num_resources = ARRAY_SIZE(ep93xx_e_gpio_resources),
209 .resource = ep93xx_e_gpio_resources,
210};
211
212/* port F */
213static struct resource ep93xx_f_gpio_resources[] = {
214 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0x30, 0x04, "data"),
215 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0x34, 0x04, "dir"),
216 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0x4c, 0x1c, "intr"),
217 DEFINE_RES_IRQ(IRQ_EP93XX_GPIO0MUX),
218 DEFINE_RES_IRQ(IRQ_EP93XX_GPIO1MUX),
219 DEFINE_RES_IRQ(IRQ_EP93XX_GPIO2MUX),
220 DEFINE_RES_IRQ(IRQ_EP93XX_GPIO3MUX),
221 DEFINE_RES_IRQ(IRQ_EP93XX_GPIO4MUX),
222 DEFINE_RES_IRQ(IRQ_EP93XX_GPIO5MUX),
223 DEFINE_RES_IRQ(IRQ_EP93XX_GPIO6MUX),
224 DEFINE_RES_IRQ(IRQ_EP93XX_GPIO7MUX),
225};
226
227static struct platform_device ep93xx_f_gpio = {
228 .name = "gpio-ep93xx",
229 .id = 5,
230 .num_resources = ARRAY_SIZE(ep93xx_f_gpio_resources),
231 .resource = ep93xx_f_gpio_resources,
232};
233
234/* port G */
235static struct resource ep93xx_g_gpio_resources[] = {
236 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0x38, 0x04, "data"),
237 DEFINE_RES_MEM_NAMED(EP93XX_GPIO_PHYS_BASE + 0x3c, 0x04, "dir"),
238};
239
240static struct platform_device ep93xx_g_gpio = {
241 .name = "gpio-ep93xx",
242 .id = 6,
243 .num_resources = ARRAY_SIZE(ep93xx_g_gpio_resources),
244 .resource = ep93xx_g_gpio_resources,
245};
246
247static struct platform_device *ep93xx_gpio_device[] __initdata = {
248 &ep93xx_a_gpio,
249 &ep93xx_b_gpio,
250 &ep93xx_c_gpio,
251 &ep93xx_d_gpio,
252 &ep93xx_e_gpio,
253 &ep93xx_f_gpio,
254 &ep93xx_g_gpio,
255};
256
257/*************************************************************************
258 * EP93xx peripheral handling
259 *************************************************************************/
260#define EP93XX_UART_MCR_OFFSET (0x0100)
261
262static void ep93xx_uart_set_mctrl(struct amba_device *dev,
263 void __iomem *base, unsigned int mctrl)
264{
265 unsigned int mcr;
266
267 mcr = 0;
268 if (mctrl & TIOCM_RTS)
269 mcr |= 2;
270 if (mctrl & TIOCM_DTR)
271 mcr |= 1;
272
273 __raw_writel(mcr, base + EP93XX_UART_MCR_OFFSET);
274}
275
276static struct amba_pl010_data ep93xx_uart_data = {
277 .set_mctrl = ep93xx_uart_set_mctrl,
278};
279
280static AMBA_APB_DEVICE(uart1, "apb:uart1", 0x00041010, EP93XX_UART1_PHYS_BASE,
281 { IRQ_EP93XX_UART1 }, &ep93xx_uart_data);
282
283static AMBA_APB_DEVICE(uart2, "apb:uart2", 0x00041010, EP93XX_UART2_PHYS_BASE,
284 { IRQ_EP93XX_UART2 }, NULL);
285
286static AMBA_APB_DEVICE(uart3, "apb:uart3", 0x00041010, EP93XX_UART3_PHYS_BASE,
287 { IRQ_EP93XX_UART3 }, &ep93xx_uart_data);
288
289static struct resource ep93xx_rtc_resource[] = {
290 DEFINE_RES_MEM(EP93XX_RTC_PHYS_BASE, 0x10c),
291};
292
293static struct platform_device ep93xx_rtc_device = {
294 .name = "ep93xx-rtc",
295 .id = -1,
296 .num_resources = ARRAY_SIZE(ep93xx_rtc_resource),
297 .resource = ep93xx_rtc_resource,
298};
299
300/*************************************************************************
301 * EP93xx OHCI USB Host
302 *************************************************************************/
303
304static struct clk *ep93xx_ohci_host_clock;
305
306static int ep93xx_ohci_power_on(struct platform_device *pdev)
307{
308 if (!ep93xx_ohci_host_clock) {
309 ep93xx_ohci_host_clock = devm_clk_get(&pdev->dev, NULL);
310 if (IS_ERR(ep93xx_ohci_host_clock))
311 return PTR_ERR(ep93xx_ohci_host_clock);
312 }
313
314 return clk_prepare_enable(ep93xx_ohci_host_clock);
315}
316
317static void ep93xx_ohci_power_off(struct platform_device *pdev)
318{
319 clk_disable(ep93xx_ohci_host_clock);
320}
321
322static struct usb_ohci_pdata ep93xx_ohci_pdata = {
323 .power_on = ep93xx_ohci_power_on,
324 .power_off = ep93xx_ohci_power_off,
325 .power_suspend = ep93xx_ohci_power_off,
326};
327
328static struct resource ep93xx_ohci_resources[] = {
329 DEFINE_RES_MEM(EP93XX_USB_PHYS_BASE, 0x1000),
330 DEFINE_RES_IRQ(IRQ_EP93XX_USB),
331};
332
333static u64 ep93xx_ohci_dma_mask = DMA_BIT_MASK(32);
334
335static struct platform_device ep93xx_ohci_device = {
336 .name = "ohci-platform",
337 .id = -1,
338 .num_resources = ARRAY_SIZE(ep93xx_ohci_resources),
339 .resource = ep93xx_ohci_resources,
340 .dev = {
341 .dma_mask = &ep93xx_ohci_dma_mask,
342 .coherent_dma_mask = DMA_BIT_MASK(32),
343 .platform_data = &ep93xx_ohci_pdata,
344 },
345};
346
347/*************************************************************************
348 * EP93xx physmap'ed flash
349 *************************************************************************/
350static struct physmap_flash_data ep93xx_flash_data;
351
352static struct resource ep93xx_flash_resource = {
353 .flags = IORESOURCE_MEM,
354};
355
356static struct platform_device ep93xx_flash = {
357 .name = "physmap-flash",
358 .id = 0,
359 .dev = {
360 .platform_data = &ep93xx_flash_data,
361 },
362 .num_resources = 1,
363 .resource = &ep93xx_flash_resource,
364};
365
366/**
367 * ep93xx_register_flash() - Register the external flash device.
368 * @width: bank width in octets
369 * @start: resource start address
370 * @size: resource size
371 */
372void __init ep93xx_register_flash(unsigned int width,
373 resource_size_t start, resource_size_t size)
374{
375 ep93xx_flash_data.width = width;
376
377 ep93xx_flash_resource.start = start;
378 ep93xx_flash_resource.end = start + size - 1;
379
380 platform_device_register(&ep93xx_flash);
381}
382
383
384/*************************************************************************
385 * EP93xx ethernet peripheral handling
386 *************************************************************************/
387static struct ep93xx_eth_data ep93xx_eth_data;
388
389static struct resource ep93xx_eth_resource[] = {
390 DEFINE_RES_MEM(EP93XX_ETHERNET_PHYS_BASE, 0x10000),
391 DEFINE_RES_IRQ(IRQ_EP93XX_ETHERNET),
392};
393
394static u64 ep93xx_eth_dma_mask = DMA_BIT_MASK(32);
395
396static struct platform_device ep93xx_eth_device = {
397 .name = "ep93xx-eth",
398 .id = -1,
399 .dev = {
400 .platform_data = &ep93xx_eth_data,
401 .coherent_dma_mask = DMA_BIT_MASK(32),
402 .dma_mask = &ep93xx_eth_dma_mask,
403 },
404 .num_resources = ARRAY_SIZE(ep93xx_eth_resource),
405 .resource = ep93xx_eth_resource,
406};
407
408/**
409 * ep93xx_register_eth - Register the built-in ethernet platform device.
410 * @data: platform specific ethernet configuration (__initdata)
411 * @copy_addr: flag indicating that the MAC address should be copied
412 * from the IndAd registers (as programmed by the bootloader)
413 */
414void __init ep93xx_register_eth(struct ep93xx_eth_data *data, int copy_addr)
415{
416 if (copy_addr)
417 memcpy_fromio(data->dev_addr, EP93XX_ETHERNET_BASE + 0x50, 6);
418
419 ep93xx_eth_data = *data;
420 platform_device_register(&ep93xx_eth_device);
421}
422
423
424/*************************************************************************
425 * EP93xx i2c peripheral handling
426 *************************************************************************/
427
428/* All EP93xx devices use the same two GPIO pins for I2C bit-banging */
429static struct gpiod_lookup_table ep93xx_i2c_gpiod_table = {
430 .dev_id = "i2c-gpio.0",
431 .table = {
432 /* Use local offsets on gpiochip/port "G" */
433 GPIO_LOOKUP_IDX("gpio-ep93xx.6", 1, NULL, 0,
434 GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN),
435 GPIO_LOOKUP_IDX("gpio-ep93xx.6", 0, NULL, 1,
436 GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN),
437 { }
438 },
439};
440
441static struct platform_device ep93xx_i2c_device = {
442 .name = "i2c-gpio",
443 .id = 0,
444 .dev = {
445 .platform_data = NULL,
446 },
447};
448
449/**
450 * ep93xx_register_i2c - Register the i2c platform device.
451 * @devices: platform specific i2c bus device information (__initdata)
452 * @num: the number of devices on the i2c bus
453 */
454void __init ep93xx_register_i2c(struct i2c_board_info *devices, int num)
455{
456 /*
457 * FIXME: this just sets the two pins as non-opendrain, as no
458 * platforms tries to do that anyway. Flag the applicable lines
459 * as open drain in the GPIO_LOOKUP above and the driver or
460 * gpiolib will handle open drain/open drain emulation as need
461 * be. Right now i2c-gpio emulates open drain which is not
462 * optimal.
463 */
464 __raw_writel((0 << 1) | (0 << 0),
465 EP93XX_GPIO_EEDRIVE);
466
467 i2c_register_board_info(0, devices, num);
468 gpiod_add_lookup_table(&ep93xx_i2c_gpiod_table);
469 platform_device_register(&ep93xx_i2c_device);
470}
471
472/*************************************************************************
473 * EP93xx SPI peripheral handling
474 *************************************************************************/
475static struct ep93xx_spi_info ep93xx_spi_master_data;
476
477static struct resource ep93xx_spi_resources[] = {
478 DEFINE_RES_MEM(EP93XX_SPI_PHYS_BASE, 0x18),
479 DEFINE_RES_IRQ(IRQ_EP93XX_SSP),
480};
481
482static u64 ep93xx_spi_dma_mask = DMA_BIT_MASK(32);
483
484static struct platform_device ep93xx_spi_device = {
485 .name = "ep93xx-spi",
486 .id = 0,
487 .dev = {
488 .platform_data = &ep93xx_spi_master_data,
489 .coherent_dma_mask = DMA_BIT_MASK(32),
490 .dma_mask = &ep93xx_spi_dma_mask,
491 },
492 .num_resources = ARRAY_SIZE(ep93xx_spi_resources),
493 .resource = ep93xx_spi_resources,
494};
495
496/**
497 * ep93xx_register_spi() - registers spi platform device
498 * @info: ep93xx board specific spi master info (__initdata)
499 * @devices: SPI devices to register (__initdata)
500 * @num: number of SPI devices to register
501 *
502 * This function registers platform device for the EP93xx SPI controller and
503 * also makes sure that SPI pins are muxed so that I2S is not using those pins.
504 */
505void __init ep93xx_register_spi(struct ep93xx_spi_info *info,
506 struct spi_board_info *devices, int num)
507{
508 /*
509 * When SPI is used, we need to make sure that I2S is muxed off from
510 * SPI pins.
511 */
512 ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_I2SONSSP);
513
514 ep93xx_spi_master_data = *info;
515 spi_register_board_info(devices, num);
516 platform_device_register(&ep93xx_spi_device);
517}
518
519/*************************************************************************
520 * EP93xx LEDs
521 *************************************************************************/
522static const struct gpio_led ep93xx_led_pins[] __initconst = {
523 {
524 .name = "platform:grled",
525 }, {
526 .name = "platform:rdled",
527 },
528};
529
530static const struct gpio_led_platform_data ep93xx_led_data __initconst = {
531 .num_leds = ARRAY_SIZE(ep93xx_led_pins),
532 .leds = ep93xx_led_pins,
533};
534
535static struct gpiod_lookup_table ep93xx_leds_gpio_table = {
536 .dev_id = "leds-gpio",
537 .table = {
538 /* Use local offsets on gpiochip/port "E" */
539 GPIO_LOOKUP_IDX("gpio-ep93xx.4", 0, NULL, 0, GPIO_ACTIVE_HIGH),
540 GPIO_LOOKUP_IDX("gpio-ep93xx.4", 1, NULL, 1, GPIO_ACTIVE_HIGH),
541 { }
542 },
543};
544
545/*************************************************************************
546 * EP93xx pwm peripheral handling
547 *************************************************************************/
548static struct resource ep93xx_pwm0_resource[] = {
549 DEFINE_RES_MEM(EP93XX_PWM_PHYS_BASE, 0x10),
550};
551
552static struct platform_device ep93xx_pwm0_device = {
553 .name = "ep93xx-pwm",
554 .id = 0,
555 .num_resources = ARRAY_SIZE(ep93xx_pwm0_resource),
556 .resource = ep93xx_pwm0_resource,
557};
558
559static struct resource ep93xx_pwm1_resource[] = {
560 DEFINE_RES_MEM(EP93XX_PWM_PHYS_BASE + 0x20, 0x10),
561};
562
563static struct platform_device ep93xx_pwm1_device = {
564 .name = "ep93xx-pwm",
565 .id = 1,
566 .num_resources = ARRAY_SIZE(ep93xx_pwm1_resource),
567 .resource = ep93xx_pwm1_resource,
568};
569
570void __init ep93xx_register_pwm(int pwm0, int pwm1)
571{
572 if (pwm0)
573 platform_device_register(&ep93xx_pwm0_device);
574
575 /* NOTE: EP9307 does not have PWMOUT1 (pin EGPIO14) */
576 if (pwm1)
577 platform_device_register(&ep93xx_pwm1_device);
578}
579
580/*************************************************************************
581 * EP93xx video peripheral handling
582 *************************************************************************/
583static struct ep93xxfb_mach_info ep93xxfb_data;
584
585static struct resource ep93xx_fb_resource[] = {
586 DEFINE_RES_MEM(EP93XX_RASTER_PHYS_BASE, 0x800),
587};
588
589static struct platform_device ep93xx_fb_device = {
590 .name = "ep93xx-fb",
591 .id = -1,
592 .dev = {
593 .platform_data = &ep93xxfb_data,
594 .coherent_dma_mask = DMA_BIT_MASK(32),
595 .dma_mask = &ep93xx_fb_device.dev.coherent_dma_mask,
596 },
597 .num_resources = ARRAY_SIZE(ep93xx_fb_resource),
598 .resource = ep93xx_fb_resource,
599};
600
601/* The backlight use a single register in the framebuffer's register space */
602#define EP93XX_RASTER_REG_BRIGHTNESS 0x20
603
604static struct resource ep93xx_bl_resources[] = {
605 DEFINE_RES_MEM(EP93XX_RASTER_PHYS_BASE +
606 EP93XX_RASTER_REG_BRIGHTNESS, 0x04),
607};
608
609static struct platform_device ep93xx_bl_device = {
610 .name = "ep93xx-bl",
611 .id = -1,
612 .num_resources = ARRAY_SIZE(ep93xx_bl_resources),
613 .resource = ep93xx_bl_resources,
614};
615
616/**
617 * ep93xx_register_fb - Register the framebuffer platform device.
618 * @data: platform specific framebuffer configuration (__initdata)
619 */
620void __init ep93xx_register_fb(struct ep93xxfb_mach_info *data)
621{
622 ep93xxfb_data = *data;
623 platform_device_register(&ep93xx_fb_device);
624 platform_device_register(&ep93xx_bl_device);
625}
626
627
628/*************************************************************************
629 * EP93xx matrix keypad peripheral handling
630 *************************************************************************/
631static struct ep93xx_keypad_platform_data ep93xx_keypad_data;
632
633static struct resource ep93xx_keypad_resource[] = {
634 DEFINE_RES_MEM(EP93XX_KEY_MATRIX_PHYS_BASE, 0x0c),
635 DEFINE_RES_IRQ(IRQ_EP93XX_KEY),
636};
637
638static struct platform_device ep93xx_keypad_device = {
639 .name = "ep93xx-keypad",
640 .id = -1,
641 .dev = {
642 .platform_data = &ep93xx_keypad_data,
643 },
644 .num_resources = ARRAY_SIZE(ep93xx_keypad_resource),
645 .resource = ep93xx_keypad_resource,
646};
647
648/**
649 * ep93xx_register_keypad - Register the keypad platform device.
650 * @data: platform specific keypad configuration (__initdata)
651 */
652void __init ep93xx_register_keypad(struct ep93xx_keypad_platform_data *data)
653{
654 ep93xx_keypad_data = *data;
655 platform_device_register(&ep93xx_keypad_device);
656}
657
658/*************************************************************************
659 * EP93xx I2S audio peripheral handling
660 *************************************************************************/
661static struct resource ep93xx_i2s_resource[] = {
662 DEFINE_RES_MEM(EP93XX_I2S_PHYS_BASE, 0x100),
663 DEFINE_RES_IRQ(IRQ_EP93XX_SAI),
664};
665
666static struct platform_device ep93xx_i2s_device = {
667 .name = "ep93xx-i2s",
668 .id = -1,
669 .num_resources = ARRAY_SIZE(ep93xx_i2s_resource),
670 .resource = ep93xx_i2s_resource,
671};
672
673static struct platform_device ep93xx_pcm_device = {
674 .name = "ep93xx-pcm-audio",
675 .id = -1,
676};
677
678void __init ep93xx_register_i2s(void)
679{
680 platform_device_register(&ep93xx_i2s_device);
681 platform_device_register(&ep93xx_pcm_device);
682}
683
684#define EP93XX_SYSCON_DEVCFG_I2S_MASK (EP93XX_SYSCON_DEVCFG_I2SONSSP | \
685 EP93XX_SYSCON_DEVCFG_I2SONAC97)
686
687#define EP93XX_I2SCLKDIV_MASK (EP93XX_SYSCON_I2SCLKDIV_ORIDE | \
688 EP93XX_SYSCON_I2SCLKDIV_SPOL)
689
690int ep93xx_i2s_acquire(void)
691{
692 unsigned val;
693
694 ep93xx_devcfg_set_clear(EP93XX_SYSCON_DEVCFG_I2SONAC97,
695 EP93XX_SYSCON_DEVCFG_I2S_MASK);
696
697 /*
698 * This is potentially racy with the clock api for i2s_mclk, sclk and
699 * lrclk. Since the i2s driver is the only user of those clocks we
700 * rely on it to prevent parallel use of this function and the
701 * clock api for the i2s clocks.
702 */
703 val = __raw_readl(EP93XX_SYSCON_I2SCLKDIV);
704 val &= ~EP93XX_I2SCLKDIV_MASK;
705 val |= EP93XX_SYSCON_I2SCLKDIV_ORIDE | EP93XX_SYSCON_I2SCLKDIV_SPOL;
706 ep93xx_syscon_swlocked_write(val, EP93XX_SYSCON_I2SCLKDIV);
707
708 return 0;
709}
710EXPORT_SYMBOL(ep93xx_i2s_acquire);
711
712void ep93xx_i2s_release(void)
713{
714 ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_I2S_MASK);
715}
716EXPORT_SYMBOL(ep93xx_i2s_release);
717
718/*************************************************************************
719 * EP93xx AC97 audio peripheral handling
720 *************************************************************************/
721static struct resource ep93xx_ac97_resources[] = {
722 DEFINE_RES_MEM(EP93XX_AAC_PHYS_BASE, 0xac),
723 DEFINE_RES_IRQ(IRQ_EP93XX_AACINTR),
724};
725
726static struct platform_device ep93xx_ac97_device = {
727 .name = "ep93xx-ac97",
728 .id = -1,
729 .num_resources = ARRAY_SIZE(ep93xx_ac97_resources),
730 .resource = ep93xx_ac97_resources,
731};
732
733void __init ep93xx_register_ac97(void)
734{
735 /*
736 * Make sure that the AC97 pins are not used by I2S.
737 */
738 ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_I2SONAC97);
739
740 platform_device_register(&ep93xx_ac97_device);
741 platform_device_register(&ep93xx_pcm_device);
742}
743
744/*************************************************************************
745 * EP93xx Watchdog
746 *************************************************************************/
747static struct resource ep93xx_wdt_resources[] = {
748 DEFINE_RES_MEM(EP93XX_WATCHDOG_PHYS_BASE, 0x08),
749};
750
751static struct platform_device ep93xx_wdt_device = {
752 .name = "ep93xx-wdt",
753 .id = -1,
754 .num_resources = ARRAY_SIZE(ep93xx_wdt_resources),
755 .resource = ep93xx_wdt_resources,
756};
757
758/*************************************************************************
759 * EP93xx IDE
760 *************************************************************************/
761static struct resource ep93xx_ide_resources[] = {
762 DEFINE_RES_MEM(EP93XX_IDE_PHYS_BASE, 0x38),
763 DEFINE_RES_IRQ(IRQ_EP93XX_EXT3),
764};
765
766static struct platform_device ep93xx_ide_device = {
767 .name = "ep93xx-ide",
768 .id = -1,
769 .dev = {
770 .dma_mask = &ep93xx_ide_device.dev.coherent_dma_mask,
771 .coherent_dma_mask = DMA_BIT_MASK(32),
772 },
773 .num_resources = ARRAY_SIZE(ep93xx_ide_resources),
774 .resource = ep93xx_ide_resources,
775};
776
777void __init ep93xx_register_ide(void)
778{
779 platform_device_register(&ep93xx_ide_device);
780}
781
782/*************************************************************************
783 * EP93xx ADC
784 *************************************************************************/
785static struct resource ep93xx_adc_resources[] = {
786 DEFINE_RES_MEM(EP93XX_ADC_PHYS_BASE, 0x28),
787 DEFINE_RES_IRQ(IRQ_EP93XX_TOUCH),
788};
789
790static struct platform_device ep93xx_adc_device = {
791 .name = "ep93xx-adc",
792 .id = -1,
793 .num_resources = ARRAY_SIZE(ep93xx_adc_resources),
794 .resource = ep93xx_adc_resources,
795};
796
797void __init ep93xx_register_adc(void)
798{
799 /* Power up ADC, deactivate Touch Screen Controller */
800 ep93xx_devcfg_set_clear(EP93XX_SYSCON_DEVCFG_TIN,
801 EP93XX_SYSCON_DEVCFG_ADCPD);
802
803 platform_device_register(&ep93xx_adc_device);
804}
805
806/*************************************************************************
807 * EP93xx Security peripheral
808 *************************************************************************/
809
810/*
811 * The Maverick Key is 256 bits of micro fuses blown at the factory during
812 * manufacturing to uniquely identify a part.
813 *
814 * See: http://arm.cirrus.com/forum/viewtopic.php?t=486&highlight=maverick+key
815 */
816#define EP93XX_SECURITY_REG(x) (EP93XX_SECURITY_BASE + (x))
817#define EP93XX_SECURITY_SECFLG EP93XX_SECURITY_REG(0x2400)
818#define EP93XX_SECURITY_FUSEFLG EP93XX_SECURITY_REG(0x2410)
819#define EP93XX_SECURITY_UNIQID EP93XX_SECURITY_REG(0x2440)
820#define EP93XX_SECURITY_UNIQCHK EP93XX_SECURITY_REG(0x2450)
821#define EP93XX_SECURITY_UNIQVAL EP93XX_SECURITY_REG(0x2460)
822#define EP93XX_SECURITY_SECID1 EP93XX_SECURITY_REG(0x2500)
823#define EP93XX_SECURITY_SECID2 EP93XX_SECURITY_REG(0x2504)
824#define EP93XX_SECURITY_SECCHK1 EP93XX_SECURITY_REG(0x2520)
825#define EP93XX_SECURITY_SECCHK2 EP93XX_SECURITY_REG(0x2524)
826#define EP93XX_SECURITY_UNIQID2 EP93XX_SECURITY_REG(0x2700)
827#define EP93XX_SECURITY_UNIQID3 EP93XX_SECURITY_REG(0x2704)
828#define EP93XX_SECURITY_UNIQID4 EP93XX_SECURITY_REG(0x2708)
829#define EP93XX_SECURITY_UNIQID5 EP93XX_SECURITY_REG(0x270c)
830
831static char ep93xx_soc_id[33];
832
833static const char __init *ep93xx_get_soc_id(void)
834{
835 unsigned int id, id2, id3, id4, id5;
836
837 if (__raw_readl(EP93XX_SECURITY_UNIQVAL) != 1)
838 return "bad Hamming code";
839
840 id = __raw_readl(EP93XX_SECURITY_UNIQID);
841 id2 = __raw_readl(EP93XX_SECURITY_UNIQID2);
842 id3 = __raw_readl(EP93XX_SECURITY_UNIQID3);
843 id4 = __raw_readl(EP93XX_SECURITY_UNIQID4);
844 id5 = __raw_readl(EP93XX_SECURITY_UNIQID5);
845
846 if (id != id2)
847 return "invalid";
848
849 /* Toss the unique ID into the entropy pool */
850 add_device_randomness(&id2, 4);
851 add_device_randomness(&id3, 4);
852 add_device_randomness(&id4, 4);
853 add_device_randomness(&id5, 4);
854
855 snprintf(ep93xx_soc_id, sizeof(ep93xx_soc_id),
856 "%08x%08x%08x%08x", id2, id3, id4, id5);
857
858 return ep93xx_soc_id;
859}
860
861static const char __init *ep93xx_get_soc_rev(void)
862{
863 int rev = ep93xx_chip_revision();
864
865 switch (rev) {
866 case EP93XX_CHIP_REV_D0:
867 return "D0";
868 case EP93XX_CHIP_REV_D1:
869 return "D1";
870 case EP93XX_CHIP_REV_E0:
871 return "E0";
872 case EP93XX_CHIP_REV_E1:
873 return "E1";
874 case EP93XX_CHIP_REV_E2:
875 return "E2";
876 default:
877 return "unknown";
878 }
879}
880
881static const char __init *ep93xx_get_machine_name(void)
882{
883 return kasprintf(GFP_KERNEL,"%s", machine_desc->name);
884}
885
886static struct device __init *ep93xx_init_soc(void)
887{
888 struct soc_device_attribute *soc_dev_attr;
889 struct soc_device *soc_dev;
890
891 soc_dev_attr = kzalloc(sizeof(*soc_dev_attr), GFP_KERNEL);
892 if (!soc_dev_attr)
893 return NULL;
894
895 soc_dev_attr->machine = ep93xx_get_machine_name();
896 soc_dev_attr->family = "Cirrus Logic EP93xx";
897 soc_dev_attr->revision = ep93xx_get_soc_rev();
898 soc_dev_attr->soc_id = ep93xx_get_soc_id();
899
900 soc_dev = soc_device_register(soc_dev_attr);
901 if (IS_ERR(soc_dev)) {
902 kfree(soc_dev_attr->machine);
903 kfree(soc_dev_attr);
904 return NULL;
905 }
906
907 return soc_device_to_device(soc_dev);
908}
909
910struct device __init *ep93xx_init_devices(void)
911{
912 struct device *parent;
913 unsigned int i;
914
915 /* Disallow access to MaverickCrunch initially */
916 ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_CPENA);
917
918 /* Default all ports to GPIO */
919 ep93xx_devcfg_set_bits(EP93XX_SYSCON_DEVCFG_KEYS |
920 EP93XX_SYSCON_DEVCFG_GONK |
921 EP93XX_SYSCON_DEVCFG_EONIDE |
922 EP93XX_SYSCON_DEVCFG_GONIDE |
923 EP93XX_SYSCON_DEVCFG_HONIDE);
924
925 parent = ep93xx_init_soc();
926
927 /* Get the GPIO working early, other devices need it */
928 for (i = 0; i < ARRAY_SIZE(ep93xx_gpio_device); i++)
929 platform_device_register(ep93xx_gpio_device[i]);
930
931 amba_device_register(&uart1_device, &iomem_resource);
932 amba_device_register(&uart2_device, &iomem_resource);
933 amba_device_register(&uart3_device, &iomem_resource);
934
935 platform_device_register(&ep93xx_rtc_device);
936 platform_device_register(&ep93xx_ohci_device);
937 platform_device_register(&ep93xx_wdt_device);
938
939 gpiod_add_lookup_table(&ep93xx_leds_gpio_table);
940 gpio_led_register_device(-1, &ep93xx_led_data);
941
942 return parent;
943}
944
945void ep93xx_restart(enum reboot_mode mode, const char *cmd)
946{
947 /*
948 * Set then clear the SWRST bit to initiate a software reset
949 */
950 ep93xx_devcfg_set_bits(EP93XX_SYSCON_DEVCFG_SWRST);
951 ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_SWRST);
952
953 while (1)
954 ;
955}
arch/arm/mach-ep93xx/dma.c+0−114
@@ -1,114 +0,0 @@
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * arch/arm/mach-ep93xx/dma.c
4 *
5 * Platform support code for the EP93xx dmaengine driver.
6 *
7 * Copyright (C) 2011 Mika Westerberg
8 *
9 * This work is based on the original dma-m2p implementation with
10 * following copyrights:
11 *
12 * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
13 * Copyright (C) 2006 Applied Data Systems
14 * Copyright (C) 2009 Ryan Mallon <rmallon@gmail.com>
15 */
16
17#include <linux/dmaengine.h>
18#include <linux/dma-mapping.h>
19#include <linux/init.h>
20#include <linux/interrupt.h>
21#include <linux/kernel.h>
22#include <linux/platform_device.h>
23
24#include <linux/platform_data/dma-ep93xx.h>
25#include "hardware.h"
26
27#include "soc.h"
28
29#define DMA_CHANNEL(_name, _base, _irq) \
30 { .name = (_name), .base = (_base), .irq = (_irq) }
31
32/*
33 * DMA M2P channels.
34 *
35 * On the EP93xx chip the following peripherals my be allocated to the 10
36 * Memory to Internal Peripheral (M2P) channels (5 transmit + 5 receive).
37 *
38 * I2S contains 3 Tx and 3 Rx DMA Channels
39 * AAC contains 3 Tx and 3 Rx DMA Channels
40 * UART1 contains 1 Tx and 1 Rx DMA Channels
41 * UART2 contains 1 Tx and 1 Rx DMA Channels
42 * UART3 contains 1 Tx and 1 Rx DMA Channels
43 * IrDA contains 1 Tx and 1 Rx DMA Channels
44 *
45 * Registers are mapped statically in ep93xx_map_io().
46 */
47static struct ep93xx_dma_chan_data ep93xx_dma_m2p_channels[] = {
48 DMA_CHANNEL("m2p0", EP93XX_DMA_BASE + 0x0000, IRQ_EP93XX_DMAM2P0),
49 DMA_CHANNEL("m2p1", EP93XX_DMA_BASE + 0x0040, IRQ_EP93XX_DMAM2P1),
50 DMA_CHANNEL("m2p2", EP93XX_DMA_BASE + 0x0080, IRQ_EP93XX_DMAM2P2),
51 DMA_CHANNEL("m2p3", EP93XX_DMA_BASE + 0x00c0, IRQ_EP93XX_DMAM2P3),
52 DMA_CHANNEL("m2p4", EP93XX_DMA_BASE + 0x0240, IRQ_EP93XX_DMAM2P4),
53 DMA_CHANNEL("m2p5", EP93XX_DMA_BASE + 0x0200, IRQ_EP93XX_DMAM2P5),
54 DMA_CHANNEL("m2p6", EP93XX_DMA_BASE + 0x02c0, IRQ_EP93XX_DMAM2P6),
55 DMA_CHANNEL("m2p7", EP93XX_DMA_BASE + 0x0280, IRQ_EP93XX_DMAM2P7),
56 DMA_CHANNEL("m2p8", EP93XX_DMA_BASE + 0x0340, IRQ_EP93XX_DMAM2P8),
57 DMA_CHANNEL("m2p9", EP93XX_DMA_BASE + 0x0300, IRQ_EP93XX_DMAM2P9),
58};
59
60static struct ep93xx_dma_platform_data ep93xx_dma_m2p_data = {
61 .channels = ep93xx_dma_m2p_channels,
62 .num_channels = ARRAY_SIZE(ep93xx_dma_m2p_channels),
63};
64
65static u64 ep93xx_dma_m2p_mask = DMA_BIT_MASK(32);
66
67static struct platform_device ep93xx_dma_m2p_device = {
68 .name = "ep93xx-dma-m2p",
69 .id = -1,
70 .dev = {
71 .platform_data = &ep93xx_dma_m2p_data,
72 .dma_mask = &ep93xx_dma_m2p_mask,
73 .coherent_dma_mask = DMA_BIT_MASK(32),
74 },
75};
76
77/*
78 * DMA M2M channels.
79 *
80 * There are 2 M2M channels which support memcpy/memset and in addition simple
81 * hardware requests from/to SSP and IDE. We do not implement an external
82 * hardware requests.
83 *
84 * Registers are mapped statically in ep93xx_map_io().
85 */
86static struct ep93xx_dma_chan_data ep93xx_dma_m2m_channels[] = {
87 DMA_CHANNEL("m2m0", EP93XX_DMA_BASE + 0x0100, IRQ_EP93XX_DMAM2M0),
88 DMA_CHANNEL("m2m1", EP93XX_DMA_BASE + 0x0140, IRQ_EP93XX_DMAM2M1),
89};
90
91static struct ep93xx_dma_platform_data ep93xx_dma_m2m_data = {
92 .channels = ep93xx_dma_m2m_channels,
93 .num_channels = ARRAY_SIZE(ep93xx_dma_m2m_channels),
94};
95
96static u64 ep93xx_dma_m2m_mask = DMA_BIT_MASK(32);
97
98static struct platform_device ep93xx_dma_m2m_device = {
99 .name = "ep93xx-dma-m2m",
100 .id = -1,
101 .dev = {
102 .platform_data = &ep93xx_dma_m2m_data,
103 .dma_mask = &ep93xx_dma_m2m_mask,
104 .coherent_dma_mask = DMA_BIT_MASK(32),
105 },
106};
107
108static int __init ep93xx_dma_init(void)
109{
110 platform_device_register(&ep93xx_dma_m2p_device);
111 platform_device_register(&ep93xx_dma_m2m_device);
112 return 0;
113}
114arch_initcall(ep93xx_dma_init);
arch/arm/mach-ep93xx/edb93xx.c+0−368
@@ -1,368 +0,0 @@
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * arch/arm/mach-ep93xx/edb93xx.c
4 * Cirrus Logic EDB93xx Development Board support.
5 *
6 * EDB93XX, EDB9301, EDB9307A
7 * Copyright (C) 2008-2009 H Hartley Sweeten <hsweeten@visionengravers.com>
8 *
9 * EDB9302
10 * Copyright (C) 2006 George Kashperko <george@chas.com.ua>
11 *
12 * EDB9302A, EDB9315, EDB9315A
13 * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
14 *
15 * EDB9307
16 * Copyright (C) 2007 Herbert Valerio Riedel <hvr@gnu.org>
17 *
18 * EDB9312
19 * Copyright (C) 2006 Infosys Technologies Limited
20 * Toufeeq Hussain <toufeeq_hussain@infosys.com>
21 */
22
23#include <linux/kernel.h>
24#include <linux/init.h>
25#include <linux/platform_device.h>
26#include <linux/i2c.h>
27#include <linux/spi/spi.h>
28#include <linux/gpio/machine.h>
29
30#include <sound/cs4271.h>
31
32#include "hardware.h"
33#include <linux/platform_data/video-ep93xx.h>
34#include <linux/platform_data/spi-ep93xx.h>
35#include "gpio-ep93xx.h"
36
37#include <asm/mach-types.h>
38#include <asm/mach/arch.h>
39
40#include "soc.h"
41
42static void __init edb93xx_register_flash(void)
43{
44 if (machine_is_edb9307() || machine_is_edb9312() ||
45 machine_is_edb9315()) {
46 ep93xx_register_flash(4, EP93XX_CS6_PHYS_BASE, SZ_32M);
47 } else {
48 ep93xx_register_flash(2, EP93XX_CS6_PHYS_BASE, SZ_16M);
49 }
50}
51
52static struct ep93xx_eth_data __initdata edb93xx_eth_data = {
53 .phy_id = 1,
54};
55
56
57/*************************************************************************
58 * EDB93xx i2c peripheral handling
59 *************************************************************************/
60
61static struct i2c_board_info __initdata edb93xxa_i2c_board_info[] = {
62 {
63 I2C_BOARD_INFO("isl1208", 0x6f),
64 },
65};
66
67static struct i2c_board_info __initdata edb93xx_i2c_board_info[] = {
68 {
69 I2C_BOARD_INFO("ds1337", 0x68),
70 },
71};
72
73static void __init edb93xx_register_i2c(void)
74{
75 if (machine_is_edb9302a() || machine_is_edb9307a() ||
76 machine_is_edb9315a()) {
77 ep93xx_register_i2c(edb93xxa_i2c_board_info,
78 ARRAY_SIZE(edb93xxa_i2c_board_info));
79 } else if (machine_is_edb9302() || machine_is_edb9307()
80 || machine_is_edb9312() || machine_is_edb9315()) {
81 ep93xx_register_i2c(edb93xx_i2c_board_info,
82 ARRAY_SIZE(edb93xx_i2c_board_info));
83 }
84}
85
86
87/*************************************************************************
88 * EDB93xx SPI peripheral handling
89 *************************************************************************/
90static struct cs4271_platform_data edb93xx_cs4271_data = {
91 /* Intentionally left blank */
92};
93
94static struct spi_board_info edb93xx_spi_board_info[] __initdata = {
95 {
96 .modalias = "cs4271",
97 .platform_data = &edb93xx_cs4271_data,
98 .max_speed_hz = 6000000,
99 .bus_num = 0,
100 .chip_select = 0,
101 .mode = SPI_MODE_3,
102 },
103};
104
105static struct gpiod_lookup_table edb93xx_spi_cs_gpio_table = {
106 .dev_id = "spi0",
107 .table = {
108 GPIO_LOOKUP("gpio-ep93xx.0", 6, "cs", GPIO_ACTIVE_LOW),
109 { },
110 },
111};
112
113static struct ep93xx_spi_info edb93xx_spi_info __initdata = {
114 /* Intentionally left blank */
115};
116
117static struct gpiod_lookup_table edb93xx_cs4272_edb9301_gpio_table = {
118 .dev_id = "spi0.0", /* CS0 on SPI0 */
119 .table = {
120 GPIO_LOOKUP("A", 1, "reset", GPIO_ACTIVE_LOW),
121 { },
122 },
123};
124
125static struct gpiod_lookup_table edb93xx_cs4272_edb9302_gpio_table = {
126 .dev_id = "spi0.0", /* CS0 on SPI0 */
127 .table = {
128 GPIO_LOOKUP("H", 2, "reset", GPIO_ACTIVE_LOW),
129 { },
130 },
131};
132
133static struct gpiod_lookup_table edb93xx_cs4272_edb9315_gpio_table = {
134 .dev_id = "spi0.0", /* CS0 on SPI0 */
135 .table = {
136 GPIO_LOOKUP("B", 6, "reset", GPIO_ACTIVE_LOW),
137 { },
138 },
139};
140
141static void __init edb93xx_register_spi(void)
142{
143 if (machine_is_edb9301() || machine_is_edb9302())
144 gpiod_add_lookup_table(&edb93xx_cs4272_edb9301_gpio_table);
145 else if (machine_is_edb9302a() || machine_is_edb9307a())
146 gpiod_add_lookup_table(&edb93xx_cs4272_edb9302_gpio_table);
147 else if (machine_is_edb9315a())
148 gpiod_add_lookup_table(&edb93xx_cs4272_edb9315_gpio_table);
149
150 gpiod_add_lookup_table(&edb93xx_spi_cs_gpio_table);
151 ep93xx_register_spi(&edb93xx_spi_info, edb93xx_spi_board_info,
152 ARRAY_SIZE(edb93xx_spi_board_info));
153}
154
155
156/*************************************************************************
157 * EDB93xx I2S
158 *************************************************************************/
159static struct platform_device edb93xx_audio_device = {
160 .name = "edb93xx-audio",
161 .id = -1,
162};
163
164static int __init edb93xx_has_audio(void)
165{
166 return (machine_is_edb9301() || machine_is_edb9302() ||
167 machine_is_edb9302a() || machine_is_edb9307a() ||
168 machine_is_edb9315a());
169}
170
171static void __init edb93xx_register_i2s(void)
172{
173 if (edb93xx_has_audio()) {
174 ep93xx_register_i2s();
175 platform_device_register(&edb93xx_audio_device);
176 }
177}
178
179
180/*************************************************************************
181 * EDB93xx pwm
182 *************************************************************************/
183static void __init edb93xx_register_pwm(void)
184{
185 if (machine_is_edb9301() ||
186 machine_is_edb9302() || machine_is_edb9302a()) {
187 /* EP9301 and EP9302 only have pwm.1 (EGPIO14) */
188 ep93xx_register_pwm(0, 1);
189 } else if (machine_is_edb9307() || machine_is_edb9307a()) {
190 /* EP9307 only has pwm.0 (PWMOUT) */
191 ep93xx_register_pwm(1, 0);
192 } else {
193 /* EP9312 and EP9315 have both */
194 ep93xx_register_pwm(1, 1);
195 }
196}
197
198
199/*************************************************************************
200 * EDB93xx framebuffer
201 *************************************************************************/
202static struct ep93xxfb_mach_info __initdata edb93xxfb_info = {
203 .flags = 0,
204};
205
206static int __init edb93xx_has_fb(void)
207{
208 /* These platforms have an ep93xx with video capability */
209 return machine_is_edb9307() || machine_is_edb9307a() ||
210 machine_is_edb9312() || machine_is_edb9315() ||
211 machine_is_edb9315a();
212}
213
214static void __init edb93xx_register_fb(void)
215{
216 if (!edb93xx_has_fb())
217 return;
218
219 if (machine_is_edb9307a() || machine_is_edb9315a())
220 edb93xxfb_info.flags |= EP93XXFB_USE_SDCSN0;
221 else
222 edb93xxfb_info.flags |= EP93XXFB_USE_SDCSN3;
223
224 ep93xx_register_fb(&edb93xxfb_info);
225}
226
227
228/*************************************************************************
229 * EDB93xx IDE
230 *************************************************************************/
231static int __init edb93xx_has_ide(void)
232{
233 /*
234 * Although EDB9312 and EDB9315 do have IDE capability, they have
235 * INTRQ line wired as pull-up, which makes using IDE interface
236 * problematic.
237 */
238 return machine_is_edb9312() || machine_is_edb9315() ||
239 machine_is_edb9315a();
240}
241
242static void __init edb93xx_register_ide(void)
243{
244 if (!edb93xx_has_ide())
245 return;
246
247 ep93xx_register_ide();
248}
249
250
251static void __init edb93xx_init_machine(void)
252{
253 ep93xx_init_devices();
254 edb93xx_register_flash();
255 ep93xx_register_eth(&edb93xx_eth_data, 1);
256 edb93xx_register_i2c();
257 edb93xx_register_spi();
258 edb93xx_register_i2s();
259 edb93xx_register_pwm();
260 edb93xx_register_fb();
261 edb93xx_register_ide();
262 ep93xx_register_adc();
263}
264
265
266#ifdef CONFIG_MACH_EDB9301
267MACHINE_START(EDB9301, "Cirrus Logic EDB9301 Evaluation Board")
268 /* Maintainer: H Hartley Sweeten <hsweeten@visionengravers.com> */
269 .atag_offset = 0x100,
270 .nr_irqs = NR_EP93XX_IRQS,
271 .map_io = ep93xx_map_io,
272 .init_irq = ep93xx_init_irq,
273 .init_time = ep93xx_timer_init,
274 .init_machine = edb93xx_init_machine,
275 .restart = ep93xx_restart,
276MACHINE_END
277#endif
278
279#ifdef CONFIG_MACH_EDB9302
280MACHINE_START(EDB9302, "Cirrus Logic EDB9302 Evaluation Board")
281 /* Maintainer: George Kashperko <george@chas.com.ua> */
282 .atag_offset = 0x100,
283 .nr_irqs = NR_EP93XX_IRQS,
284 .map_io = ep93xx_map_io,
285 .init_irq = ep93xx_init_irq,
286 .init_time = ep93xx_timer_init,
287 .init_machine = edb93xx_init_machine,
288 .restart = ep93xx_restart,
289MACHINE_END
290#endif
291
292#ifdef CONFIG_MACH_EDB9302A
293MACHINE_START(EDB9302A, "Cirrus Logic EDB9302A Evaluation Board")
294 /* Maintainer: Lennert Buytenhek <buytenh@wantstofly.org> */
295 .atag_offset = 0x100,
296 .nr_irqs = NR_EP93XX_IRQS,
297 .map_io = ep93xx_map_io,
298 .init_irq = ep93xx_init_irq,
299 .init_time = ep93xx_timer_init,
300 .init_machine = edb93xx_init_machine,
301 .restart = ep93xx_restart,
302MACHINE_END
303#endif
304
305#ifdef CONFIG_MACH_EDB9307
306MACHINE_START(EDB9307, "Cirrus Logic EDB9307 Evaluation Board")
307 /* Maintainer: Herbert Valerio Riedel <hvr@gnu.org> */
308 .atag_offset = 0x100,
309 .nr_irqs = NR_EP93XX_IRQS,
310 .map_io = ep93xx_map_io,
311 .init_irq = ep93xx_init_irq,
312 .init_time = ep93xx_timer_init,
313 .init_machine = edb93xx_init_machine,
314 .restart = ep93xx_restart,
315MACHINE_END
316#endif
317
318#ifdef CONFIG_MACH_EDB9307A
319MACHINE_START(EDB9307A, "Cirrus Logic EDB9307A Evaluation Board")
320 /* Maintainer: H Hartley Sweeten <hsweeten@visionengravers.com> */
321 .atag_offset = 0x100,
322 .nr_irqs = NR_EP93XX_IRQS,
323 .map_io = ep93xx_map_io,
324 .init_irq = ep93xx_init_irq,
325 .init_time = ep93xx_timer_init,
326 .init_machine = edb93xx_init_machine,
327 .restart = ep93xx_restart,
328MACHINE_END
329#endif
330
331#ifdef CONFIG_MACH_EDB9312
332MACHINE_START(EDB9312, "Cirrus Logic EDB9312 Evaluation Board")
333 /* Maintainer: Toufeeq Hussain <toufeeq_hussain@infosys.com> */
334 .atag_offset = 0x100,
335 .nr_irqs = NR_EP93XX_IRQS,
336 .map_io = ep93xx_map_io,
337 .init_irq = ep93xx_init_irq,
338 .init_time = ep93xx_timer_init,
339 .init_machine = edb93xx_init_machine,
340 .restart = ep93xx_restart,
341MACHINE_END
342#endif
343
344#ifdef CONFIG_MACH_EDB9315
345MACHINE_START(EDB9315, "Cirrus Logic EDB9315 Evaluation Board")
346 /* Maintainer: Lennert Buytenhek <buytenh@wantstofly.org> */
347 .atag_offset = 0x100,
348 .nr_irqs = NR_EP93XX_IRQS,
349 .map_io = ep93xx_map_io,
350 .init_irq = ep93xx_init_irq,
351 .init_time = ep93xx_timer_init,
352 .init_machine = edb93xx_init_machine,
353 .restart = ep93xx_restart,
354MACHINE_END
355#endif
356
357#ifdef CONFIG_MACH_EDB9315A
358MACHINE_START(EDB9315A, "Cirrus Logic EDB9315A Evaluation Board")
359 /* Maintainer: Lennert Buytenhek <buytenh@wantstofly.org> */
360 .atag_offset = 0x100,
361 .nr_irqs = NR_EP93XX_IRQS,
362 .map_io = ep93xx_map_io,
363 .init_irq = ep93xx_init_irq,
364 .init_time = ep93xx_timer_init,
365 .init_machine = edb93xx_init_machine,
366 .restart = ep93xx_restart,
367MACHINE_END
368#endif
arch/arm/mach-ep93xx/ep93xx-regs.h+0−38
@@ -1,38 +0,0 @@
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef __ASM_ARCH_EP93XX_REGS_H
3#define __ASM_ARCH_EP93XX_REGS_H
4
5/*
6 * EP93xx linux memory map:
7 *
8 * virt phys size
9 * fe800000 5M per-platform mappings
10 * fed00000 80800000 2M APB
11 * fef00000 80000000 1M AHB
12 */
13
14#define EP93XX_AHB_PHYS_BASE 0x80000000
15#define EP93XX_AHB_VIRT_BASE 0xfef00000
16#define EP93XX_AHB_SIZE 0x00100000
17
18#define EP93XX_AHB_PHYS(x) (EP93XX_AHB_PHYS_BASE + (x))
19#define EP93XX_AHB_IOMEM(x) IOMEM(EP93XX_AHB_VIRT_BASE + (x))
20
21#define EP93XX_APB_PHYS_BASE 0x80800000
22#define EP93XX_APB_VIRT_BASE 0xfed00000
23#define EP93XX_APB_SIZE 0x00200000
24
25#define EP93XX_APB_PHYS(x) (EP93XX_APB_PHYS_BASE + (x))
26#define EP93XX_APB_IOMEM(x) IOMEM(EP93XX_APB_VIRT_BASE + (x))
27
28/* APB UARTs */
29#define EP93XX_UART1_PHYS_BASE EP93XX_APB_PHYS(0x000c0000)
30#define EP93XX_UART1_BASE EP93XX_APB_IOMEM(0x000c0000)
31
32#define EP93XX_UART2_PHYS_BASE EP93XX_APB_PHYS(0x000d0000)
33#define EP93XX_UART2_BASE EP93XX_APB_IOMEM(0x000d0000)
34
35#define EP93XX_UART3_PHYS_BASE EP93XX_APB_PHYS(0x000e0000)
36#define EP93XX_UART3_BASE EP93XX_APB_IOMEM(0x000e0000)
37
38#endif
arch/arm/mach-ep93xx/gpio-ep93xx.h+0−111
@@ -1,111 +0,0 @@
1/* SPDX-License-Identifier: GPL-2.0 */
2/* Include file for the EP93XX GPIO controller machine specifics */
3
4#ifndef __GPIO_EP93XX_H
5#define __GPIO_EP93XX_H
6
7#include "ep93xx-regs.h"
8
9#define EP93XX_GPIO_PHYS_BASE EP93XX_APB_PHYS(0x00040000)
10#define EP93XX_GPIO_BASE EP93XX_APB_IOMEM(0x00040000)
11#define EP93XX_GPIO_REG(x) (EP93XX_GPIO_BASE + (x))
12#define EP93XX_GPIO_F_INT_STATUS EP93XX_GPIO_REG(0x5c)
13#define EP93XX_GPIO_A_INT_STATUS EP93XX_GPIO_REG(0xa0)
14#define EP93XX_GPIO_B_INT_STATUS EP93XX_GPIO_REG(0xbc)
15#define EP93XX_GPIO_EEDRIVE EP93XX_GPIO_REG(0xc8)
16
17/* GPIO port A. */
18#define EP93XX_GPIO_LINE_A(x) ((x) + 0)
19#define EP93XX_GPIO_LINE_EGPIO0 EP93XX_GPIO_LINE_A(0)
20#define EP93XX_GPIO_LINE_EGPIO1 EP93XX_GPIO_LINE_A(1)
21#define EP93XX_GPIO_LINE_EGPIO2 EP93XX_GPIO_LINE_A(2)
22#define EP93XX_GPIO_LINE_EGPIO3 EP93XX_GPIO_LINE_A(3)
23#define EP93XX_GPIO_LINE_EGPIO4 EP93XX_GPIO_LINE_A(4)
24#define EP93XX_GPIO_LINE_EGPIO5 EP93XX_GPIO_LINE_A(5)
25#define EP93XX_GPIO_LINE_EGPIO6 EP93XX_GPIO_LINE_A(6)
26#define EP93XX_GPIO_LINE_EGPIO7 EP93XX_GPIO_LINE_A(7)
27
28/* GPIO port B. */
29#define EP93XX_GPIO_LINE_B(x) ((x) + 8)
30#define EP93XX_GPIO_LINE_EGPIO8 EP93XX_GPIO_LINE_B(0)
31#define EP93XX_GPIO_LINE_EGPIO9 EP93XX_GPIO_LINE_B(1)
32#define EP93XX_GPIO_LINE_EGPIO10 EP93XX_GPIO_LINE_B(2)
33#define EP93XX_GPIO_LINE_EGPIO11 EP93XX_GPIO_LINE_B(3)
34#define EP93XX_GPIO_LINE_EGPIO12 EP93XX_GPIO_LINE_B(4)
35#define EP93XX_GPIO_LINE_EGPIO13 EP93XX_GPIO_LINE_B(5)
36#define EP93XX_GPIO_LINE_EGPIO14 EP93XX_GPIO_LINE_B(6)
37#define EP93XX_GPIO_LINE_EGPIO15 EP93XX_GPIO_LINE_B(7)
38
39/* GPIO port C. */
40#define EP93XX_GPIO_LINE_C(x) ((x) + 40)
41#define EP93XX_GPIO_LINE_ROW0 EP93XX_GPIO_LINE_C(0)
42#define EP93XX_GPIO_LINE_ROW1 EP93XX_GPIO_LINE_C(1)
43#define EP93XX_GPIO_LINE_ROW2 EP93XX_GPIO_LINE_C(2)
44#define EP93XX_GPIO_LINE_ROW3 EP93XX_GPIO_LINE_C(3)
45#define EP93XX_GPIO_LINE_ROW4 EP93XX_GPIO_LINE_C(4)
46#define EP93XX_GPIO_LINE_ROW5 EP93XX_GPIO_LINE_C(5)
47#define EP93XX_GPIO_LINE_ROW6 EP93XX_GPIO_LINE_C(6)
48#define EP93XX_GPIO_LINE_ROW7 EP93XX_GPIO_LINE_C(7)
49
50/* GPIO port D. */
51#define EP93XX_GPIO_LINE_D(x) ((x) + 24)
52#define EP93XX_GPIO_LINE_COL0 EP93XX_GPIO_LINE_D(0)
53#define EP93XX_GPIO_LINE_COL1 EP93XX_GPIO_LINE_D(1)
54#define EP93XX_GPIO_LINE_COL2 EP93XX_GPIO_LINE_D(2)
55#define EP93XX_GPIO_LINE_COL3 EP93XX_GPIO_LINE_D(3)
56#define EP93XX_GPIO_LINE_COL4 EP93XX_GPIO_LINE_D(4)
57#define EP93XX_GPIO_LINE_COL5 EP93XX_GPIO_LINE_D(5)
58#define EP93XX_GPIO_LINE_COL6 EP93XX_GPIO_LINE_D(6)
59#define EP93XX_GPIO_LINE_COL7 EP93XX_GPIO_LINE_D(7)
60
61/* GPIO port E. */
62#define EP93XX_GPIO_LINE_E(x) ((x) + 32)
63#define EP93XX_GPIO_LINE_GRLED EP93XX_GPIO_LINE_E(0)
64#define EP93XX_GPIO_LINE_RDLED EP93XX_GPIO_LINE_E(1)
65#define EP93XX_GPIO_LINE_DIORn EP93XX_GPIO_LINE_E(2)
66#define EP93XX_GPIO_LINE_IDECS1n EP93XX_GPIO_LINE_E(3)
67#define EP93XX_GPIO_LINE_IDECS2n EP93XX_GPIO_LINE_E(4)
68#define EP93XX_GPIO_LINE_IDEDA0 EP93XX_GPIO_LINE_E(5)
69#define EP93XX_GPIO_LINE_IDEDA1 EP93XX_GPIO_LINE_E(6)
70#define EP93XX_GPIO_LINE_IDEDA2 EP93XX_GPIO_LINE_E(7)
71
72/* GPIO port F. */
73#define EP93XX_GPIO_LINE_F(x) ((x) + 16)
74#define EP93XX_GPIO_LINE_WP EP93XX_GPIO_LINE_F(0)
75#define EP93XX_GPIO_LINE_MCCD1 EP93XX_GPIO_LINE_F(1)
76#define EP93XX_GPIO_LINE_MCCD2 EP93XX_GPIO_LINE_F(2)
77#define EP93XX_GPIO_LINE_MCBVD1 EP93XX_GPIO_LINE_F(3)
78#define EP93XX_GPIO_LINE_MCBVD2 EP93XX_GPIO_LINE_F(4)
79#define EP93XX_GPIO_LINE_VS1 EP93XX_GPIO_LINE_F(5)
80#define EP93XX_GPIO_LINE_READY EP93XX_GPIO_LINE_F(6)
81#define EP93XX_GPIO_LINE_VS2 EP93XX_GPIO_LINE_F(7)
82
83/* GPIO port G. */
84#define EP93XX_GPIO_LINE_G(x) ((x) + 48)
85#define EP93XX_GPIO_LINE_EECLK EP93XX_GPIO_LINE_G(0)
86#define EP93XX_GPIO_LINE_EEDAT EP93XX_GPIO_LINE_G(1)
87#define EP93XX_GPIO_LINE_SLA0 EP93XX_GPIO_LINE_G(2)
88#define EP93XX_GPIO_LINE_SLA1 EP93XX_GPIO_LINE_G(3)
89#define EP93XX_GPIO_LINE_DD12 EP93XX_GPIO_LINE_G(4)
90#define EP93XX_GPIO_LINE_DD13 EP93XX_GPIO_LINE_G(5)
91#define EP93XX_GPIO_LINE_DD14 EP93XX_GPIO_LINE_G(6)
92#define EP93XX_GPIO_LINE_DD15 EP93XX_GPIO_LINE_G(7)
93
94/* GPIO port H. */
95#define EP93XX_GPIO_LINE_H(x) ((x) + 56)
96#define EP93XX_GPIO_LINE_DD0 EP93XX_GPIO_LINE_H(0)
97#define EP93XX_GPIO_LINE_DD1 EP93XX_GPIO_LINE_H(1)
98#define EP93XX_GPIO_LINE_DD2 EP93XX_GPIO_LINE_H(2)
99#define EP93XX_GPIO_LINE_DD3 EP93XX_GPIO_LINE_H(3)
100#define EP93XX_GPIO_LINE_DD4 EP93XX_GPIO_LINE_H(4)
101#define EP93XX_GPIO_LINE_DD5 EP93XX_GPIO_LINE_H(5)
102#define EP93XX_GPIO_LINE_DD6 EP93XX_GPIO_LINE_H(6)
103#define EP93XX_GPIO_LINE_DD7 EP93XX_GPIO_LINE_H(7)
104
105/* maximum value for gpio line identifiers */
106#define EP93XX_GPIO_LINE_MAX EP93XX_GPIO_LINE_H(7)
107
108/* maximum value for irq capable line identifiers */
109#define EP93XX_GPIO_LINE_MAX_IRQ EP93XX_GPIO_LINE_F(7)
110
111#endif /* __GPIO_EP93XX_H */
arch/arm/mach-ep93xx/hardware.h+0−25
@@ -1,25 +0,0 @@
1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * arch/arm/mach-ep93xx/include/mach/hardware.h
4 */
5
6#ifndef __ASM_ARCH_HARDWARE_H
7#define __ASM_ARCH_HARDWARE_H
8
9#include "platform.h"
10
11/*
12 * The EP93xx has two external crystal oscillators. To generate the
13 * required high-frequency clocks, the processor uses two phase-locked-
14 * loops (PLLs) to multiply the incoming external clock signal to much
15 * higher frequencies that are then divided down by programmable dividers
16 * to produce the needed clocks. The PLLs operate independently of one
17 * another.
18 */
19#define EP93XX_EXT_CLK_RATE 14745600
20#define EP93XX_EXT_RTC_RATE 32768
21
22#define EP93XX_KEYTCHCLK_DIV4 (EP93XX_EXT_CLK_RATE / 4)
23#define EP93XX_KEYTCHCLK_DIV16 (EP93XX_EXT_CLK_RATE / 16)
24
25#endif
arch/arm/mach-ep93xx/irqs.h+0−76
@@ -1,76 +0,0 @@
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef __ASM_ARCH_IRQS_H
3#define __ASM_ARCH_IRQS_H
4
5#define IRQ_EP93XX_VIC0 1
6
7#define IRQ_EP93XX_COMMRX (IRQ_EP93XX_VIC0 + 2)
8#define IRQ_EP93XX_COMMTX (IRQ_EP93XX_VIC0 + 3)
9#define IRQ_EP93XX_TIMER1 (IRQ_EP93XX_VIC0 + 4)
10#define IRQ_EP93XX_TIMER2 (IRQ_EP93XX_VIC0 + 5)
11#define IRQ_EP93XX_AACINTR (IRQ_EP93XX_VIC0 + 6)
12#define IRQ_EP93XX_DMAM2P0 (IRQ_EP93XX_VIC0 + 7)
13#define IRQ_EP93XX_DMAM2P1 (IRQ_EP93XX_VIC0 + 8)
14#define IRQ_EP93XX_DMAM2P2 (IRQ_EP93XX_VIC0 + 9)
15#define IRQ_EP93XX_DMAM2P3 (IRQ_EP93XX_VIC0 + 10)
16#define IRQ_EP93XX_DMAM2P4 (IRQ_EP93XX_VIC0 + 11)
17#define IRQ_EP93XX_DMAM2P5 (IRQ_EP93XX_VIC0 + 12)
18#define IRQ_EP93XX_DMAM2P6 (IRQ_EP93XX_VIC0 + 13)
19#define IRQ_EP93XX_DMAM2P7 (IRQ_EP93XX_VIC0 + 14)
20#define IRQ_EP93XX_DMAM2P8 (IRQ_EP93XX_VIC0 + 15)
21#define IRQ_EP93XX_DMAM2P9 (IRQ_EP93XX_VIC0 + 16)
22#define IRQ_EP93XX_DMAM2M0 (IRQ_EP93XX_VIC0 + 17)
23#define IRQ_EP93XX_DMAM2M1 (IRQ_EP93XX_VIC0 + 18)
24#define IRQ_EP93XX_GPIO0MUX (IRQ_EP93XX_VIC0 + 19)
25#define IRQ_EP93XX_GPIO1MUX (IRQ_EP93XX_VIC0 + 20)
26#define IRQ_EP93XX_GPIO2MUX (IRQ_EP93XX_VIC0 + 21)
27#define IRQ_EP93XX_GPIO3MUX (IRQ_EP93XX_VIC0 + 22)
28#define IRQ_EP93XX_UART1RX (IRQ_EP93XX_VIC0 + 23)
29#define IRQ_EP93XX_UART1TX (IRQ_EP93XX_VIC0 + 24)
30#define IRQ_EP93XX_UART2RX (IRQ_EP93XX_VIC0 + 25)
31#define IRQ_EP93XX_UART2TX (IRQ_EP93XX_VIC0 + 26)
32#define IRQ_EP93XX_UART3RX (IRQ_EP93XX_VIC0 + 27)
33#define IRQ_EP93XX_UART3TX (IRQ_EP93XX_VIC0 + 28)
34#define IRQ_EP93XX_KEY (IRQ_EP93XX_VIC0 + 29)
35#define IRQ_EP93XX_TOUCH (IRQ_EP93XX_VIC0 + 30)
36#define EP93XX_VIC1_VALID_IRQ_MASK 0x7ffffffc
37
38#define IRQ_EP93XX_VIC1 (IRQ_EP93XX_VIC0 + 32)
39
40#define IRQ_EP93XX_EXT0 (IRQ_EP93XX_VIC1 + 0)
41#define IRQ_EP93XX_EXT1 (IRQ_EP93XX_VIC1 + 1)
42#define IRQ_EP93XX_EXT2 (IRQ_EP93XX_VIC1 + 2)
43#define IRQ_EP93XX_64HZ (IRQ_EP93XX_VIC1 + 3)
44#define IRQ_EP93XX_WATCHDOG (IRQ_EP93XX_VIC1 + 4)
45#define IRQ_EP93XX_RTC (IRQ_EP93XX_VIC1 + 5)
46#define IRQ_EP93XX_IRDA (IRQ_EP93XX_VIC1 + 6)
47#define IRQ_EP93XX_ETHERNET (IRQ_EP93XX_VIC1 + 7)
48#define IRQ_EP93XX_EXT3 (IRQ_EP93XX_VIC1 + 8)
49#define IRQ_EP93XX_PROG (IRQ_EP93XX_VIC1 + 9)
50#define IRQ_EP93XX_1HZ (IRQ_EP93XX_VIC1 + 10)
51#define IRQ_EP93XX_VSYNC (IRQ_EP93XX_VIC1 + 11)
52#define IRQ_EP93XX_VIDEO_FIFO (IRQ_EP93XX_VIC1 + 12)
53#define IRQ_EP93XX_SSP1RX (IRQ_EP93XX_VIC1 + 13)
54#define IRQ_EP93XX_SSP1TX (IRQ_EP93XX_VIC1 + 14)
55#define IRQ_EP93XX_GPIO4MUX (IRQ_EP93XX_VIC1 + 15)
56#define IRQ_EP93XX_GPIO5MUX (IRQ_EP93XX_VIC1 + 16)
57#define IRQ_EP93XX_GPIO6MUX (IRQ_EP93XX_VIC1 + 17)
58#define IRQ_EP93XX_GPIO7MUX (IRQ_EP93XX_VIC1 + 18)
59#define IRQ_EP93XX_TIMER3 (IRQ_EP93XX_VIC1 + 19)
60#define IRQ_EP93XX_UART1 (IRQ_EP93XX_VIC1 + 20)
61#define IRQ_EP93XX_SSP (IRQ_EP93XX_VIC1 + 21)
62#define IRQ_EP93XX_UART2 (IRQ_EP93XX_VIC1 + 22)
63#define IRQ_EP93XX_UART3 (IRQ_EP93XX_VIC1 + 23)
64#define IRQ_EP93XX_USB (IRQ_EP93XX_VIC1 + 24)
65#define IRQ_EP93XX_ETHERNET_PME (IRQ_EP93XX_VIC1 + 25)
66#define IRQ_EP93XX_DSP (IRQ_EP93XX_VIC1 + 26)
67#define IRQ_EP93XX_GPIO_AB (IRQ_EP93XX_VIC1 + 27)
68#define IRQ_EP93XX_SAI (IRQ_EP93XX_VIC1 + 28)
69#define EP93XX_VIC2_VALID_IRQ_MASK 0x1fffffff
70
71#define NR_EP93XX_IRQS (IRQ_EP93XX_VIC1 + 32 + 24)
72
73#define EP93XX_BOARD_IRQ(x) (NR_EP93XX_IRQS + (x))
74#define EP93XX_BOARD_IRQS 32
75
76#endif
arch/arm/mach-ep93xx/platform.h+0−42
@@ -1,42 +0,0 @@
1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * arch/arm/mach-ep93xx/include/mach/platform.h
4 */
5
6#ifndef __ASSEMBLY__
7
8#include <linux/platform_data/eth-ep93xx.h>
9#include <linux/reboot.h>
10
11struct device;
12struct i2c_board_info;
13struct spi_board_info;
14struct platform_device;
15struct ep93xxfb_mach_info;
16struct ep93xx_keypad_platform_data;
17struct ep93xx_spi_info;
18
19void ep93xx_map_io(void);
20void ep93xx_init_irq(void);
21
22void ep93xx_register_flash(unsigned int width,
23 resource_size_t start, resource_size_t size);
24
25void ep93xx_register_eth(struct ep93xx_eth_data *data, int copy_addr);
26void ep93xx_register_i2c(struct i2c_board_info *devices, int num);
27void ep93xx_register_spi(struct ep93xx_spi_info *info,
28 struct spi_board_info *devices, int num);
29void ep93xx_register_fb(struct ep93xxfb_mach_info *data);
30void ep93xx_register_pwm(int pwm0, int pwm1);
31void ep93xx_register_keypad(struct ep93xx_keypad_platform_data *data);
32void ep93xx_register_i2s(void);
33void ep93xx_register_ac97(void);
34void ep93xx_register_ide(void);
35void ep93xx_register_adc(void);
36
37struct device *ep93xx_init_devices(void);
38extern void ep93xx_timer_init(void);
39
40void ep93xx_restart(enum reboot_mode, const char *);
41
42#endif
arch/arm/mach-ep93xx/soc.h+0−212
@@ -1,212 +0,0 @@
1/* SPDX-License-Identifier: GPL-2.0-or-later */
2/*
3 * arch/arm/mach-ep93xx/soc.h
4 *
5 * Copyright (C) 2012 Open Kernel Labs <www.ok-labs.com>
6 * Copyright (C) 2012 Ryan Mallon <rmallon@gmail.com>
7 */
8
9#ifndef _EP93XX_SOC_H
10#define _EP93XX_SOC_H
11
12#include "ep93xx-regs.h"
13#include "irqs.h"
14
15/*
16 * EP93xx Physical Memory Map:
17 *
18 * The ASDO pin is sampled at system reset to select a synchronous or
19 * asynchronous boot configuration. When ASDO is "1" (i.e. pulled-up)
20 * the synchronous boot mode is selected. When ASDO is "0" (i.e
21 * pulled-down) the asynchronous boot mode is selected.
22 *
23 * In synchronous boot mode nSDCE3 is decoded starting at physical address
24 * 0x00000000 and nCS0 is decoded starting at 0xf0000000. For asynchronous
25 * boot mode they are swapped with nCS0 decoded at 0x00000000 ann nSDCE3
26 * decoded at 0xf0000000.
27 *
28 * There is known errata for the EP93xx dealing with External Memory
29 * Configurations. Please refer to "AN273: EP93xx Silicon Rev E Design
30 * Guidelines" for more information. This document can be found at:
31 *
32 * http://www.cirrus.com/en/pubs/appNote/AN273REV4.pdf
33 */
34
35#define EP93XX_CS0_PHYS_BASE_ASYNC 0x00000000 /* ASDO Pin = 0 */
36#define EP93XX_SDCE3_PHYS_BASE_SYNC 0x00000000 /* ASDO Pin = 1 */
37#define EP93XX_CS1_PHYS_BASE 0x10000000
38#define EP93XX_CS2_PHYS_BASE 0x20000000
39#define EP93XX_CS3_PHYS_BASE 0x30000000
40#define EP93XX_PCMCIA_PHYS_BASE 0x40000000
41#define EP93XX_CS6_PHYS_BASE 0x60000000
42#define EP93XX_CS7_PHYS_BASE 0x70000000
43#define EP93XX_SDCE0_PHYS_BASE 0xc0000000
44#define EP93XX_SDCE1_PHYS_BASE 0xd0000000
45#define EP93XX_SDCE2_PHYS_BASE 0xe0000000
46#define EP93XX_SDCE3_PHYS_BASE_ASYNC 0xf0000000 /* ASDO Pin = 0 */
47#define EP93XX_CS0_PHYS_BASE_SYNC 0xf0000000 /* ASDO Pin = 1 */
48
49/* AHB peripherals */
50#define EP93XX_DMA_BASE EP93XX_AHB_IOMEM(0x00000000)
51
52#define EP93XX_ETHERNET_PHYS_BASE EP93XX_AHB_PHYS(0x00010000)
53#define EP93XX_ETHERNET_BASE EP93XX_AHB_IOMEM(0x00010000)
54
55#define EP93XX_USB_PHYS_BASE EP93XX_AHB_PHYS(0x00020000)
56#define EP93XX_USB_BASE EP93XX_AHB_IOMEM(0x00020000)
57
58#define EP93XX_RASTER_PHYS_BASE EP93XX_AHB_PHYS(0x00030000)
59#define EP93XX_RASTER_BASE EP93XX_AHB_IOMEM(0x00030000)
60
61#define EP93XX_GRAPHICS_ACCEL_BASE EP93XX_AHB_IOMEM(0x00040000)
62
63#define EP93XX_SDRAM_CONTROLLER_BASE EP93XX_AHB_IOMEM(0x00060000)
64
65#define EP93XX_PCMCIA_CONTROLLER_BASE EP93XX_AHB_IOMEM(0x00080000)
66
67#define EP93XX_BOOT_ROM_BASE EP93XX_AHB_IOMEM(0x00090000)
68
69#define EP93XX_IDE_PHYS_BASE EP93XX_AHB_PHYS(0x000a0000)
70#define EP93XX_IDE_BASE EP93XX_AHB_IOMEM(0x000a0000)
71
72#define EP93XX_VIC1_BASE EP93XX_AHB_IOMEM(0x000b0000)
73
74#define EP93XX_VIC2_BASE EP93XX_AHB_IOMEM(0x000c0000)
75
76/* APB peripherals */
77#define EP93XX_TIMER_BASE EP93XX_APB_IOMEM(0x00010000)
78
79#define EP93XX_I2S_PHYS_BASE EP93XX_APB_PHYS(0x00020000)
80#define EP93XX_I2S_BASE EP93XX_APB_IOMEM(0x00020000)
81
82#define EP93XX_SECURITY_BASE EP93XX_APB_IOMEM(0x00030000)
83
84#define EP93XX_AAC_PHYS_BASE EP93XX_APB_PHYS(0x00080000)
85#define EP93XX_AAC_BASE EP93XX_APB_IOMEM(0x00080000)
86
87#define EP93XX_SPI_PHYS_BASE EP93XX_APB_PHYS(0x000a0000)
88#define EP93XX_SPI_BASE EP93XX_APB_IOMEM(0x000a0000)
89
90#define EP93XX_IRDA_BASE EP93XX_APB_IOMEM(0x000b0000)
91
92#define EP93XX_KEY_MATRIX_PHYS_BASE EP93XX_APB_PHYS(0x000f0000)
93#define EP93XX_KEY_MATRIX_BASE EP93XX_APB_IOMEM(0x000f0000)
94
95#define EP93XX_ADC_PHYS_BASE EP93XX_APB_PHYS(0x00100000)
96#define EP93XX_ADC_BASE EP93XX_APB_IOMEM(0x00100000)
97#define EP93XX_TOUCHSCREEN_BASE EP93XX_APB_IOMEM(0x00100000)
98
99#define EP93XX_PWM_PHYS_BASE EP93XX_APB_PHYS(0x00110000)
100#define EP93XX_PWM_BASE EP93XX_APB_IOMEM(0x00110000)
101
102#define EP93XX_RTC_PHYS_BASE EP93XX_APB_PHYS(0x00120000)
103#define EP93XX_RTC_BASE EP93XX_APB_IOMEM(0x00120000)
104
105#define EP93XX_WATCHDOG_PHYS_BASE EP93XX_APB_PHYS(0x00140000)
106#define EP93XX_WATCHDOG_BASE EP93XX_APB_IOMEM(0x00140000)
107
108/* System controller */
109#define EP93XX_SYSCON_BASE EP93XX_APB_IOMEM(0x00130000)
110#define EP93XX_SYSCON_REG(x) (EP93XX_SYSCON_BASE + (x))
111#define EP93XX_SYSCON_POWER_STATE EP93XX_SYSCON_REG(0x00)
112#define EP93XX_SYSCON_PWRCNT EP93XX_SYSCON_REG(0x04)
113#define EP93XX_SYSCON_PWRCNT_FIR_EN (1<<31)
114#define EP93XX_SYSCON_PWRCNT_UARTBAUD (1<<29)
115#define EP93XX_SYSCON_PWRCNT_USH_EN 28
116#define EP93XX_SYSCON_PWRCNT_DMA_M2M1 27
117#define EP93XX_SYSCON_PWRCNT_DMA_M2M0 26
118#define EP93XX_SYSCON_PWRCNT_DMA_M2P8 25
119#define EP93XX_SYSCON_PWRCNT_DMA_M2P9 24
120#define EP93XX_SYSCON_PWRCNT_DMA_M2P6 23
121#define EP93XX_SYSCON_PWRCNT_DMA_M2P7 22
122#define EP93XX_SYSCON_PWRCNT_DMA_M2P4 21
123#define EP93XX_SYSCON_PWRCNT_DMA_M2P5 20
124#define EP93XX_SYSCON_PWRCNT_DMA_M2P2 19
125#define EP93XX_SYSCON_PWRCNT_DMA_M2P3 18
126#define EP93XX_SYSCON_PWRCNT_DMA_M2P0 17
127#define EP93XX_SYSCON_PWRCNT_DMA_M2P1 16
128#define EP93XX_SYSCON_HALT EP93XX_SYSCON_REG(0x08)
129#define EP93XX_SYSCON_STANDBY EP93XX_SYSCON_REG(0x0c)
130#define EP93XX_SYSCON_CLKSET1 EP93XX_SYSCON_REG(0x20)
131#define EP93XX_SYSCON_CLKSET1_NBYP1 (1<<23)
132#define EP93XX_SYSCON_CLKSET2 EP93XX_SYSCON_REG(0x24)
133#define EP93XX_SYSCON_CLKSET2_NBYP2 (1<<19)
134#define EP93XX_SYSCON_CLKSET2_PLL2_EN (1<<18)
135#define EP93XX_SYSCON_DEVCFG EP93XX_SYSCON_REG(0x80)
136#define EP93XX_SYSCON_DEVCFG_SWRST (1<<31)
137#define EP93XX_SYSCON_DEVCFG_D1ONG (1<<30)
138#define EP93XX_SYSCON_DEVCFG_D0ONG (1<<29)
139#define EP93XX_SYSCON_DEVCFG_IONU2 (1<<28)
140#define EP93XX_SYSCON_DEVCFG_GONK (1<<27)
141#define EP93XX_SYSCON_DEVCFG_TONG (1<<26)
142#define EP93XX_SYSCON_DEVCFG_MONG (1<<25)
143#define EP93XX_SYSCON_DEVCFG_U3EN 24
144#define EP93XX_SYSCON_DEVCFG_CPENA (1<<23)
145#define EP93XX_SYSCON_DEVCFG_A2ONG (1<<22)
146#define EP93XX_SYSCON_DEVCFG_A1ONG (1<<21)
147#define EP93XX_SYSCON_DEVCFG_U2EN 20
148#define EP93XX_SYSCON_DEVCFG_EXVC (1<<19)
149#define EP93XX_SYSCON_DEVCFG_U1EN 18
150#define EP93XX_SYSCON_DEVCFG_TIN (1<<17)
151#define EP93XX_SYSCON_DEVCFG_HC3IN (1<<15)
152#define EP93XX_SYSCON_DEVCFG_HC3EN (1<<14)
153#define EP93XX_SYSCON_DEVCFG_HC1IN (1<<13)
154#define EP93XX_SYSCON_DEVCFG_HC1EN (1<<12)
155#define EP93XX_SYSCON_DEVCFG_HONIDE (1<<11)
156#define EP93XX_SYSCON_DEVCFG_GONIDE (1<<10)
157#define EP93XX_SYSCON_DEVCFG_PONG (1<<9)
158#define EP93XX_SYSCON_DEVCFG_EONIDE (1<<8)
159#define EP93XX_SYSCON_DEVCFG_I2SONSSP (1<<7)
160#define EP93XX_SYSCON_DEVCFG_I2SONAC97 (1<<6)
161#define EP93XX_SYSCON_DEVCFG_RASONP3 (1<<4)
162#define EP93XX_SYSCON_DEVCFG_RAS (1<<3)
163#define EP93XX_SYSCON_DEVCFG_ADCPD (1<<2)
164#define EP93XX_SYSCON_DEVCFG_KEYS (1<<1)
165#define EP93XX_SYSCON_DEVCFG_SHENA (1<<0)
166#define EP93XX_SYSCON_VIDCLKDIV EP93XX_SYSCON_REG(0x84)
167#define EP93XX_SYSCON_CLKDIV_ENABLE 15
168#define EP93XX_SYSCON_CLKDIV_ESEL (1<<14)
169#define EP93XX_SYSCON_CLKDIV_PSEL (1<<13)
170#define EP93XX_SYSCON_CLKDIV_PDIV_SHIFT 8
171#define EP93XX_SYSCON_I2SCLKDIV EP93XX_SYSCON_REG(0x8c)
172#define EP93XX_SYSCON_I2SCLKDIV_SENA 31
173#define EP93XX_SYSCON_I2SCLKDIV_ORIDE (1<<29)
174#define EP93XX_SYSCON_I2SCLKDIV_SPOL (1<<19)
175#define EP93XX_I2SCLKDIV_SDIV (1 << 16)
176#define EP93XX_I2SCLKDIV_LRDIV32 (0 << 17)
177#define EP93XX_I2SCLKDIV_LRDIV64 (1 << 17)
178#define EP93XX_I2SCLKDIV_LRDIV128 (2 << 17)
179#define EP93XX_I2SCLKDIV_LRDIV_MASK (3 << 17)
180#define EP93XX_SYSCON_KEYTCHCLKDIV EP93XX_SYSCON_REG(0x90)
181#define EP93XX_SYSCON_KEYTCHCLKDIV_TSEN 31
182#define EP93XX_SYSCON_KEYTCHCLKDIV_ADIV 16
183#define EP93XX_SYSCON_KEYTCHCLKDIV_KEN 15
184#define EP93XX_SYSCON_KEYTCHCLKDIV_KDIV (1<<0)
185#define EP93XX_SYSCON_SYSCFG EP93XX_SYSCON_REG(0x9c)
186#define EP93XX_SYSCON_SYSCFG_REV_MASK (0xf0000000)
187#define EP93XX_SYSCON_SYSCFG_REV_SHIFT (28)
188#define EP93XX_SYSCON_SYSCFG_SBOOT (1<<8)
189#define EP93XX_SYSCON_SYSCFG_LCSN7 (1<<7)
190#define EP93XX_SYSCON_SYSCFG_LCSN6 (1<<6)
191#define EP93XX_SYSCON_SYSCFG_LASDO (1<<5)
192#define EP93XX_SYSCON_SYSCFG_LEEDA (1<<4)
193#define EP93XX_SYSCON_SYSCFG_LEECLK (1<<3)
194#define EP93XX_SYSCON_SYSCFG_LCSN2 (1<<1)
195#define EP93XX_SYSCON_SYSCFG_LCSN1 (1<<0)
196#define EP93XX_SYSCON_SWLOCK EP93XX_SYSCON_REG(0xc0)
197
198/* EP93xx System Controller software locked register write */
199void ep93xx_syscon_swlocked_write(unsigned int val, void __iomem *reg);
200void ep93xx_devcfg_set_clear(unsigned int set_bits, unsigned int clear_bits);
201
202static inline void ep93xx_devcfg_set_bits(unsigned int bits)
203{
204 ep93xx_devcfg_set_clear(bits, 0x00);
205}
206
207static inline void ep93xx_devcfg_clear_bits(unsigned int bits)
208{
209 ep93xx_devcfg_set_clear(0x00, bits);
210}
211
212#endif /* _EP93XX_SOC_H */
arch/arm/mach-ep93xx/timer-ep93xx.c+0−143
@@ -1,143 +0,0 @@
1// SPDX-License-Identifier: GPL-2.0
2#include <linux/kernel.h>
3#include <linux/init.h>
4#include <linux/clocksource.h>
5#include <linux/clockchips.h>
6#include <linux/sched_clock.h>
7#include <linux/interrupt.h>
8#include <linux/irq.h>
9#include <linux/io.h>
10#include <asm/mach/time.h>
11#include "soc.h"
12#include "platform.h"
13
14/*************************************************************************
15 * Timer handling for EP93xx
16 *************************************************************************
17 * The ep93xx has four internal timers. Timers 1, 2 (both 16 bit) and
18 * 3 (32 bit) count down at 508 kHz, are self-reloading, and can generate
19 * an interrupt on underflow. Timer 4 (40 bit) counts down at 983.04 kHz,
20 * is free-running, and can't generate interrupts.
21 *
22 * The 508 kHz timers are ideal for use for the timer interrupt, as the
23 * most common values of HZ divide 508 kHz nicely. We pick the 32 bit
24 * timer (timer 3) to get as long sleep intervals as possible when using
25 * CONFIG_NO_HZ.
26 *
27 * The higher clock rate of timer 4 makes it a better choice than the
28 * other timers for use as clock source and for sched_clock(), providing
29 * a stable 40 bit time base.
30 *************************************************************************
31 */
32#define EP93XX_TIMER_REG(x) (EP93XX_TIMER_BASE + (x))
33#define EP93XX_TIMER1_LOAD EP93XX_TIMER_REG(0x00)
34#define EP93XX_TIMER1_VALUE EP93XX_TIMER_REG(0x04)
35#define EP93XX_TIMER1_CONTROL EP93XX_TIMER_REG(0x08)
36#define EP93XX_TIMER123_CONTROL_ENABLE (1 << 7)
37#define EP93XX_TIMER123_CONTROL_MODE (1 << 6)
38#define EP93XX_TIMER123_CONTROL_CLKSEL (1 << 3)
39#define EP93XX_TIMER1_CLEAR EP93XX_TIMER_REG(0x0c)
40#define EP93XX_TIMER2_LOAD EP93XX_TIMER_REG(0x20)
41#define EP93XX_TIMER2_VALUE EP93XX_TIMER_REG(0x24)
42#define EP93XX_TIMER2_CONTROL EP93XX_TIMER_REG(0x28)
43#define EP93XX_TIMER2_CLEAR EP93XX_TIMER_REG(0x2c)
44#define EP93XX_TIMER4_VALUE_LOW EP93XX_TIMER_REG(0x60)
45#define EP93XX_TIMER4_VALUE_HIGH EP93XX_TIMER_REG(0x64)
46#define EP93XX_TIMER4_VALUE_HIGH_ENABLE (1 << 8)
47#define EP93XX_TIMER3_LOAD EP93XX_TIMER_REG(0x80)
48#define EP93XX_TIMER3_VALUE EP93XX_TIMER_REG(0x84)
49#define EP93XX_TIMER3_CONTROL EP93XX_TIMER_REG(0x88)
50#define EP93XX_TIMER3_CLEAR EP93XX_TIMER_REG(0x8c)
51
52#define EP93XX_TIMER123_RATE 508469
53#define EP93XX_TIMER4_RATE 983040
54
55static u64 notrace ep93xx_read_sched_clock(void)
56{
57 u64 ret;
58
59 ret = readl(EP93XX_TIMER4_VALUE_LOW);
60 ret |= ((u64) (readl(EP93XX_TIMER4_VALUE_HIGH) & 0xff) << 32);
61 return ret;
62}
63
64static u64 ep93xx_clocksource_read(struct clocksource *c)
65{
66 u64 ret;
67
68 ret = readl(EP93XX_TIMER4_VALUE_LOW);
69 ret |= ((u64) (readl(EP93XX_TIMER4_VALUE_HIGH) & 0xff) << 32);
70 return (u64) ret;
71}
72
73static int ep93xx_clkevt_set_next_event(unsigned long next,
74 struct clock_event_device *evt)
75{
76 /* Default mode: periodic, off, 508 kHz */
77 u32 tmode = EP93XX_TIMER123_CONTROL_MODE |
78 EP93XX_TIMER123_CONTROL_CLKSEL;
79
80 /* Clear timer */
81 writel(tmode, EP93XX_TIMER3_CONTROL);
82
83 /* Set next event */
84 writel(next, EP93XX_TIMER3_LOAD);
85 writel(tmode | EP93XX_TIMER123_CONTROL_ENABLE,
86 EP93XX_TIMER3_CONTROL);
87 return 0;
88}
89
90
91static int ep93xx_clkevt_shutdown(struct clock_event_device *evt)
92{
93 /* Disable timer */
94 writel(0, EP93XX_TIMER3_CONTROL);
95
96 return 0;
97}
98
99static struct clock_event_device ep93xx_clockevent = {
100 .name = "timer1",
101 .features = CLOCK_EVT_FEAT_ONESHOT,
102 .set_state_shutdown = ep93xx_clkevt_shutdown,
103 .set_state_oneshot = ep93xx_clkevt_shutdown,
104 .tick_resume = ep93xx_clkevt_shutdown,
105 .set_next_event = ep93xx_clkevt_set_next_event,
106 .rating = 300,
107};
108
109static irqreturn_t ep93xx_timer_interrupt(int irq, void *dev_id)
110{
111 struct clock_event_device *evt = dev_id;
112
113 /* Writing any value clears the timer interrupt */
114 writel(1, EP93XX_TIMER3_CLEAR);
115
116 evt->event_handler(evt);
117
118 return IRQ_HANDLED;
119}
120
121void __init ep93xx_timer_init(void)
122{
123 int irq = IRQ_EP93XX_TIMER3;
124 unsigned long flags = IRQF_TIMER | IRQF_IRQPOLL;
125
126 /* Enable and register clocksource and sched_clock on timer 4 */
127 writel(EP93XX_TIMER4_VALUE_HIGH_ENABLE,
128 EP93XX_TIMER4_VALUE_HIGH);
129 clocksource_mmio_init(NULL, "timer4",
130 EP93XX_TIMER4_RATE, 200, 40,
131 ep93xx_clocksource_read);
132 sched_clock_register(ep93xx_read_sched_clock, 40,
133 EP93XX_TIMER4_RATE);
134
135 /* Set up clockevent on timer 3 */
136 if (request_irq(irq, ep93xx_timer_interrupt, flags, "ep93xx timer",
137 &ep93xx_clockevent))
138 pr_err("Failed to request irq %d (ep93xx timer)\n", irq);
139 clockevents_config_and_register(&ep93xx_clockevent,
140 EP93XX_TIMER123_RATE,
141 1,
142 0xffffffffU);
143}
arch/arm/mach-ep93xx/ts72xx.c+0−422
@@ -1,422 +0,0 @@
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * arch/arm/mach-ep93xx/ts72xx.c
4 * Technologic Systems TS72xx SBC support.
5 *
6 * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
7 */
8
9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10
11#include <linux/kernel.h>
12#include <linux/init.h>
13#include <linux/platform_device.h>
14#include <linux/io.h>
15#include <linux/mtd/platnand.h>
16#include <linux/spi/spi.h>
17#include <linux/spi/flash.h>
18#include <linux/spi/mmc_spi.h>
19#include <linux/mmc/host.h>
20#include <linux/platform_data/spi-ep93xx.h>
21#include <linux/gpio/machine.h>
22
23#include "gpio-ep93xx.h"
24#include "hardware.h"
25
26#include <asm/mach-types.h>
27#include <asm/mach/map.h>
28#include <asm/mach/arch.h>
29
30#include "soc.h"
31#include "ts72xx.h"
32
33/*************************************************************************
34 * IO map
35 *************************************************************************/
36static struct map_desc ts72xx_io_desc[] __initdata = {
37 {
38 .virtual = (unsigned long)TS72XX_MODEL_VIRT_BASE,
39 .pfn = __phys_to_pfn(TS72XX_MODEL_PHYS_BASE),
40 .length = TS72XX_MODEL_SIZE,
41 .type = MT_DEVICE,
42 }, {
43 .virtual = (unsigned long)TS72XX_OPTIONS_VIRT_BASE,
44 .pfn = __phys_to_pfn(TS72XX_OPTIONS_PHYS_BASE),
45 .length = TS72XX_OPTIONS_SIZE,
46 .type = MT_DEVICE,
47 }, {
48 .virtual = (unsigned long)TS72XX_OPTIONS2_VIRT_BASE,
49 .pfn = __phys_to_pfn(TS72XX_OPTIONS2_PHYS_BASE),
50 .length = TS72XX_OPTIONS2_SIZE,
51 .type = MT_DEVICE,
52 }, {
53 .virtual = (unsigned long)TS72XX_CPLDVER_VIRT_BASE,
54 .pfn = __phys_to_pfn(TS72XX_CPLDVER_PHYS_BASE),
55 .length = TS72XX_CPLDVER_SIZE,
56 .type = MT_DEVICE,
57 }
58};
59
60static void __init ts72xx_map_io(void)
61{
62 ep93xx_map_io();
63 iotable_init(ts72xx_io_desc, ARRAY_SIZE(ts72xx_io_desc));
64}
65
66
67/*************************************************************************
68 * NAND flash
69 *************************************************************************/
70#define TS72XX_NAND_CONTROL_ADDR_LINE 22 /* 0xN0400000 */
71#define TS72XX_NAND_BUSY_ADDR_LINE 23 /* 0xN0800000 */
72
73static void ts72xx_nand_hwcontrol(struct nand_chip *chip,
74 int cmd, unsigned int ctrl)
75{
76 if (ctrl & NAND_CTRL_CHANGE) {
77 void __iomem *addr = chip->legacy.IO_ADDR_R;
78 unsigned char bits;
79
80 addr += (1 << TS72XX_NAND_CONTROL_ADDR_LINE);
81
82 bits = __raw_readb(addr) & ~0x07;
83 bits |= (ctrl & NAND_NCE) << 2; /* bit 0 -> bit 2 */
84 bits |= (ctrl & NAND_CLE); /* bit 1 -> bit 1 */
85 bits |= (ctrl & NAND_ALE) >> 2; /* bit 2 -> bit 0 */
86
87 __raw_writeb(bits, addr);
88 }
89
90 if (cmd != NAND_CMD_NONE)
91 __raw_writeb(cmd, chip->legacy.IO_ADDR_W);
92}
93
94static int ts72xx_nand_device_ready(struct nand_chip *chip)
95{
96 void __iomem *addr = chip->legacy.IO_ADDR_R;
97
98 addr += (1 << TS72XX_NAND_BUSY_ADDR_LINE);
99
100 return !!(__raw_readb(addr) & 0x20);
101}
102
103#define TS72XX_BOOTROM_PART_SIZE (SZ_16K)
104#define TS72XX_REDBOOT_PART_SIZE (SZ_2M + SZ_1M)
105
106static struct mtd_partition ts72xx_nand_parts[] = {
107 {
108 .name = "TS-BOOTROM",
109 .offset = 0,
110 .size = TS72XX_BOOTROM_PART_SIZE,
111 .mask_flags = MTD_WRITEABLE, /* force read-only */
112 }, {
113 .name = "Linux",
114 .offset = MTDPART_OFS_RETAIN,
115 .size = TS72XX_REDBOOT_PART_SIZE,
116 /* leave so much for last partition */
117 }, {
118 .name = "RedBoot",
119 .offset = MTDPART_OFS_APPEND,
120 .size = MTDPART_SIZ_FULL,
121 .mask_flags = MTD_WRITEABLE, /* force read-only */
122 },
123};
124
125static struct platform_nand_data ts72xx_nand_data = {
126 .chip = {
127 .nr_chips = 1,
128 .chip_offset = 0,
129 .chip_delay = 15,
130 },
131 .ctrl = {
132 .cmd_ctrl = ts72xx_nand_hwcontrol,
133 .dev_ready = ts72xx_nand_device_ready,
134 },
135};
136
137static struct resource ts72xx_nand_resource[] = {
138 {
139 .start = 0, /* filled in later */
140 .end = 0, /* filled in later */
141 .flags = IORESOURCE_MEM,
142 },
143};
144
145static struct platform_device ts72xx_nand_flash = {
146 .name = "gen_nand",
147 .id = -1,
148 .dev.platform_data = &ts72xx_nand_data,
149 .resource = ts72xx_nand_resource,
150 .num_resources = ARRAY_SIZE(ts72xx_nand_resource),
151};
152
153static void __init ts72xx_register_flash(struct mtd_partition *parts, int n,
154 resource_size_t start)
155{
156 /*
157 * TS7200 has NOR flash all other TS72xx board have NAND flash.
158 */
159 if (board_is_ts7200()) {
160 ep93xx_register_flash(2, EP93XX_CS6_PHYS_BASE, SZ_16M);
161 } else {
162 ts72xx_nand_resource[0].start = start;
163 ts72xx_nand_resource[0].end = start + SZ_16M - 1;
164
165 ts72xx_nand_data.chip.partitions = parts;
166 ts72xx_nand_data.chip.nr_partitions = n;
167
168 platform_device_register(&ts72xx_nand_flash);
169 }
170}
171
172/*************************************************************************
173 * RTC M48T86
174 *************************************************************************/
175#define TS72XX_RTC_INDEX_PHYS_BASE (EP93XX_CS1_PHYS_BASE + 0x00800000)
176#define TS72XX_RTC_DATA_PHYS_BASE (EP93XX_CS1_PHYS_BASE + 0x01700000)
177
178static struct resource ts72xx_rtc_resources[] = {
179 DEFINE_RES_MEM(TS72XX_RTC_INDEX_PHYS_BASE, 0x01),
180 DEFINE_RES_MEM(TS72XX_RTC_DATA_PHYS_BASE, 0x01),
181};
182
183static struct platform_device ts72xx_rtc_device = {
184 .name = "rtc-m48t86",
185 .id = -1,
186 .resource = ts72xx_rtc_resources,
187 .num_resources = ARRAY_SIZE(ts72xx_rtc_resources),
188};
189
190/*************************************************************************
191 * Watchdog (in CPLD)
192 *************************************************************************/
193#define TS72XX_WDT_CONTROL_PHYS_BASE (EP93XX_CS2_PHYS_BASE + 0x03800000)
194#define TS72XX_WDT_FEED_PHYS_BASE (EP93XX_CS2_PHYS_BASE + 0x03c00000)
195
196static struct resource ts72xx_wdt_resources[] = {
197 DEFINE_RES_MEM(TS72XX_WDT_CONTROL_PHYS_BASE, 0x01),
198 DEFINE_RES_MEM(TS72XX_WDT_FEED_PHYS_BASE, 0x01),
199};
200
201static struct platform_device ts72xx_wdt_device = {
202 .name = "ts72xx-wdt",
203 .id = -1,
204 .resource = ts72xx_wdt_resources,
205 .num_resources = ARRAY_SIZE(ts72xx_wdt_resources),
206};
207
208/*************************************************************************
209 * ETH
210 *************************************************************************/
211static struct ep93xx_eth_data __initdata ts72xx_eth_data = {
212 .phy_id = 1,
213};
214
215/*************************************************************************
216 * SPI SD/MMC host
217 *************************************************************************/
218#define BK3_EN_SDCARD_PHYS_BASE 0x12400000
219#define BK3_EN_SDCARD_PWR 0x0
220#define BK3_DIS_SDCARD_PWR 0x0C
221static void bk3_mmc_spi_setpower(struct device *dev, unsigned int vdd)
222{
223 void __iomem *pwr_sd = ioremap(BK3_EN_SDCARD_PHYS_BASE, SZ_4K);
224
225 if (!pwr_sd) {
226 pr_err("Failed to enable SD card power!");
227 return;
228 }
229
230 pr_debug("%s: SD card pwr %s VDD:0x%x\n", __func__,
231 !!vdd ? "ON" : "OFF", vdd);
232
233 if (!!vdd)
234 __raw_writeb(BK3_EN_SDCARD_PWR, pwr_sd);
235 else
236 __raw_writeb(BK3_DIS_SDCARD_PWR, pwr_sd);
237
238 iounmap(pwr_sd);
239}
240
241static struct mmc_spi_platform_data bk3_spi_mmc_data = {
242 .detect_delay = 500,
243 .powerup_msecs = 100,
244 .ocr_mask = MMC_VDD_32_33 | MMC_VDD_33_34,
245 .caps = MMC_CAP_NONREMOVABLE,
246 .setpower = bk3_mmc_spi_setpower,
247};
248
249/*************************************************************************
250 * SPI Bus - SD card access
251 *************************************************************************/
252static struct spi_board_info bk3_spi_board_info[] __initdata = {
253 {
254 .modalias = "mmc_spi",
255 .platform_data = &bk3_spi_mmc_data,
256 .max_speed_hz = 7.4E6,
257 .bus_num = 0,
258 .chip_select = 0,
259 .mode = SPI_MODE_0,
260 },
261};
262
263/*
264 * This is a stub -> the FGPIO[3] pin is not connected on the schematic
265 * The all work is performed automatically by !SPI_FRAME (SFRM1) and
266 * goes through CPLD
267 */
268static struct gpiod_lookup_table bk3_spi_cs_gpio_table = {
269 .dev_id = "spi0",
270 .table = {
271 GPIO_LOOKUP("gpio-ep93xx.5", 3, "cs", GPIO_ACTIVE_LOW),
272 { },
273 },
274};
275
276static struct ep93xx_spi_info bk3_spi_master __initdata = {
277 .use_dma = 1,
278};
279
280/*************************************************************************
281 * TS72XX support code
282 *************************************************************************/
283#if IS_ENABLED(CONFIG_FPGA_MGR_TS73XX)
284
285/* Relative to EP93XX_CS1_PHYS_BASE */
286#define TS73XX_FPGA_LOADER_BASE 0x03c00000
287
288static struct resource ts73xx_fpga_resources[] = {
289 {
290 .start = EP93XX_CS1_PHYS_BASE + TS73XX_FPGA_LOADER_BASE,
291 .end = EP93XX_CS1_PHYS_BASE + TS73XX_FPGA_LOADER_BASE + 1,
292 .flags = IORESOURCE_MEM,
293 },
294};
295
296static struct platform_device ts73xx_fpga_device = {
297 .name = "ts73xx-fpga-mgr",
298 .id = -1,
299 .resource = ts73xx_fpga_resources,
300 .num_resources = ARRAY_SIZE(ts73xx_fpga_resources),
301};
302
303#endif
304
305/*************************************************************************
306 * SPI Bus
307 *************************************************************************/
308static struct spi_board_info ts72xx_spi_devices[] __initdata = {
309 {
310 .modalias = "tmp122",
311 .max_speed_hz = 2 * 1000 * 1000,
312 .bus_num = 0,
313 .chip_select = 0,
314 },
315};
316
317static struct gpiod_lookup_table ts72xx_spi_cs_gpio_table = {
318 .dev_id = "spi0",
319 .table = {
320 /* DIO_17 */
321 GPIO_LOOKUP("gpio-ep93xx.5", 2, "cs", GPIO_ACTIVE_LOW),
322 { },
323 },
324};
325
326static struct ep93xx_spi_info ts72xx_spi_info __initdata = {
327 /* Intentionally left blank */
328};
329
330static void __init ts72xx_init_machine(void)
331{
332 ep93xx_init_devices();
333 ts72xx_register_flash(ts72xx_nand_parts, ARRAY_SIZE(ts72xx_nand_parts),
334 is_ts9420_installed() ?
335 EP93XX_CS7_PHYS_BASE : EP93XX_CS6_PHYS_BASE);
336 platform_device_register(&ts72xx_rtc_device);
337 platform_device_register(&ts72xx_wdt_device);
338
339 ep93xx_register_eth(&ts72xx_eth_data, 1);
340#if IS_ENABLED(CONFIG_FPGA_MGR_TS73XX)
341 if (board_is_ts7300())
342 platform_device_register(&ts73xx_fpga_device);
343#endif
344 gpiod_add_lookup_table(&ts72xx_spi_cs_gpio_table);
345 ep93xx_register_spi(&ts72xx_spi_info, ts72xx_spi_devices,
346 ARRAY_SIZE(ts72xx_spi_devices));
347}
348
349MACHINE_START(TS72XX, "Technologic Systems TS-72xx SBC")
350 /* Maintainer: Lennert Buytenhek <buytenh@wantstofly.org> */
351 .atag_offset = 0x100,
352 .nr_irqs = NR_EP93XX_IRQS,
353 .map_io = ts72xx_map_io,
354 .init_irq = ep93xx_init_irq,
355 .init_time = ep93xx_timer_init,
356 .init_machine = ts72xx_init_machine,
357 .restart = ep93xx_restart,
358MACHINE_END
359
360/*************************************************************************
361 * EP93xx I2S audio peripheral handling
362 *************************************************************************/
363static struct resource ep93xx_i2s_resource[] = {
364 DEFINE_RES_MEM(EP93XX_I2S_PHYS_BASE, 0x100),
365 DEFINE_RES_IRQ_NAMED(IRQ_EP93XX_SAI, "spilink i2s slave"),
366};
367
368static struct platform_device ep93xx_i2s_device = {
369 .name = "ep93xx-spilink-i2s",
370 .id = -1,
371 .num_resources = ARRAY_SIZE(ep93xx_i2s_resource),
372 .resource = ep93xx_i2s_resource,
373};
374
375/*************************************************************************
376 * BK3 support code
377 *************************************************************************/
378static struct mtd_partition bk3_nand_parts[] = {
379 {
380 .name = "System",
381 .offset = 0x00000000,
382 .size = 0x01e00000,
383 }, {
384 .name = "Data",
385 .offset = 0x01e00000,
386 .size = 0x05f20000
387 }, {
388 .name = "RedBoot",
389 .offset = 0x07d20000,
390 .size = 0x002e0000,
391 .mask_flags = MTD_WRITEABLE, /* force RO */
392 },
393};
394
395static void __init bk3_init_machine(void)
396{
397 ep93xx_init_devices();
398
399 ts72xx_register_flash(bk3_nand_parts, ARRAY_SIZE(bk3_nand_parts),
400 EP93XX_CS6_PHYS_BASE);
401
402 ep93xx_register_eth(&ts72xx_eth_data, 1);
403
404 gpiod_add_lookup_table(&bk3_spi_cs_gpio_table);
405 ep93xx_register_spi(&bk3_spi_master, bk3_spi_board_info,
406 ARRAY_SIZE(bk3_spi_board_info));
407
408 /* Configure ep93xx's I2S to use AC97 pins */
409 ep93xx_devcfg_set_bits(EP93XX_SYSCON_DEVCFG_I2SONAC97);
410 platform_device_register(&ep93xx_i2s_device);
411}
412
413MACHINE_START(BK3, "Liebherr controller BK3.1")
414 /* Maintainer: Lukasz Majewski <lukma@denx.de> */
415 .atag_offset = 0x100,
416 .nr_irqs = NR_EP93XX_IRQS,
417 .map_io = ts72xx_map_io,
418 .init_irq = ep93xx_init_irq,
419 .init_time = ep93xx_timer_init,
420 .init_machine = bk3_init_machine,
421 .restart = ep93xx_restart,
422MACHINE_END
arch/arm/mach-ep93xx/ts72xx.h+0−94
@@ -1,94 +0,0 @@
1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * arch/arm/mach-ep93xx/include/mach/ts72xx.h
4 */
5
6/*
7 * TS72xx memory map:
8 *
9 * virt phys size
10 * febff000 22000000 4K model number register (bits 0-2)
11 * febfe000 22400000 4K options register
12 * febfd000 22800000 4K options register #2
13 * febfc000 23400000 4K CPLD version register
14 */
15
16#ifndef __TS72XX_H_
17#define __TS72XX_H_
18
19#define TS72XX_MODEL_PHYS_BASE 0x22000000
20#define TS72XX_MODEL_VIRT_BASE IOMEM(0xfebff000)
21#define TS72XX_MODEL_SIZE 0x00001000
22
23#define TS72XX_MODEL_TS7200 0x00
24#define TS72XX_MODEL_TS7250 0x01
25#define TS72XX_MODEL_TS7260 0x02
26#define TS72XX_MODEL_TS7300 0x03
27#define TS72XX_MODEL_TS7400 0x04
28#define TS72XX_MODEL_MASK 0x07
29
30
31#define TS72XX_OPTIONS_PHYS_BASE 0x22400000
32#define TS72XX_OPTIONS_VIRT_BASE IOMEM(0xfebfe000)
33#define TS72XX_OPTIONS_SIZE 0x00001000
34
35#define TS72XX_OPTIONS_COM2_RS485 0x02
36#define TS72XX_OPTIONS_MAX197 0x01
37
38
39#define TS72XX_OPTIONS2_PHYS_BASE 0x22800000
40#define TS72XX_OPTIONS2_VIRT_BASE IOMEM(0xfebfd000)
41#define TS72XX_OPTIONS2_SIZE 0x00001000
42
43#define TS72XX_OPTIONS2_TS9420 0x04
44#define TS72XX_OPTIONS2_TS9420_BOOT 0x02
45
46#define TS72XX_CPLDVER_PHYS_BASE 0x23400000
47#define TS72XX_CPLDVER_VIRT_BASE IOMEM(0xfebfc000)
48#define TS72XX_CPLDVER_SIZE 0x00001000
49
50#ifndef __ASSEMBLY__
51
52static inline int ts72xx_model(void)
53{
54 return __raw_readb(TS72XX_MODEL_VIRT_BASE) & TS72XX_MODEL_MASK;
55}
56
57static inline int board_is_ts7200(void)
58{
59 return ts72xx_model() == TS72XX_MODEL_TS7200;
60}
61
62static inline int board_is_ts7250(void)
63{
64 return ts72xx_model() == TS72XX_MODEL_TS7250;
65}
66
67static inline int board_is_ts7260(void)
68{
69 return ts72xx_model() == TS72XX_MODEL_TS7260;
70}
71
72static inline int board_is_ts7300(void)
73{
74 return ts72xx_model() == TS72XX_MODEL_TS7300;
75}
76
77static inline int board_is_ts7400(void)
78{
79 return ts72xx_model() == TS72XX_MODEL_TS7400;
80}
81
82static inline int is_max197_installed(void)
83{
84 return !!(__raw_readb(TS72XX_OPTIONS_VIRT_BASE) &
85 TS72XX_OPTIONS_MAX197);
86}
87
88static inline int is_ts9420_installed(void)
89{
90 return !!(__raw_readb(TS72XX_OPTIONS2_VIRT_BASE) &
91 TS72XX_OPTIONS2_TS9420);
92}
93#endif
94#endif /* __TS72XX_H_ */
arch/arm/mach-ep93xx/vision_ep9307.c+0−321
@@ -1,321 +0,0 @@
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * arch/arm/mach-ep93xx/vision_ep9307.c
4 * Vision Engraving Systems EP9307 SoM support.
5 *
6 * Copyright (C) 2008-2011 Vision Engraving Systems
7 * H Hartley Sweeten <hsweeten@visionengravers.com>
8 */
9
10#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
12#include <linux/kernel.h>
13#include <linux/init.h>
14#include <linux/platform_device.h>
15#include <linux/irq.h>
16#include <linux/gpio.h>
17#include <linux/gpio/machine.h>
18#include <linux/fb.h>
19#include <linux/io.h>
20#include <linux/mtd/partitions.h>
21#include <linux/i2c.h>
22#include <linux/platform_data/pca953x.h>
23#include <linux/spi/spi.h>
24#include <linux/spi/flash.h>
25#include <linux/spi/mmc_spi.h>
26#include <linux/mmc/host.h>
27
28#include <sound/cs4271.h>
29
30#include "hardware.h"
31#include <linux/platform_data/video-ep93xx.h>
32#include <linux/platform_data/spi-ep93xx.h>
33#include "gpio-ep93xx.h"
34
35#include <asm/mach-types.h>
36#include <asm/mach/map.h>
37#include <asm/mach/arch.h>
38
39#include "soc.h"
40
41/*************************************************************************
42 * Static I/O mappings for the FPGA
43 *************************************************************************/
44#define VISION_PHYS_BASE EP93XX_CS7_PHYS_BASE
45#define VISION_VIRT_BASE 0xfebff000
46
47static struct map_desc vision_io_desc[] __initdata = {
48 {
49 .virtual = VISION_VIRT_BASE,
50 .pfn = __phys_to_pfn(VISION_PHYS_BASE),
51 .length = SZ_4K,
52 .type = MT_DEVICE,
53 },
54};
55
56static void __init vision_map_io(void)
57{
58 ep93xx_map_io();
59
60 iotable_init(vision_io_desc, ARRAY_SIZE(vision_io_desc));
61}
62
63/*************************************************************************
64 * Ethernet
65 *************************************************************************/
66static struct ep93xx_eth_data vision_eth_data __initdata = {
67 .phy_id = 1,
68};
69
70/*************************************************************************
71 * Framebuffer
72 *************************************************************************/
73#define VISION_LCD_ENABLE EP93XX_GPIO_LINE_EGPIO1
74
75static int vision_lcd_setup(struct platform_device *pdev)
76{
77 int err;
78
79 err = gpio_request_one(VISION_LCD_ENABLE, GPIOF_INIT_HIGH,
80 dev_name(&pdev->dev));
81 if (err)
82 return err;
83
84 ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_RAS |
85 EP93XX_SYSCON_DEVCFG_RASONP3 |
86 EP93XX_SYSCON_DEVCFG_EXVC);
87
88 return 0;
89}
90
91static void vision_lcd_teardown(struct platform_device *pdev)
92{
93 gpio_free(VISION_LCD_ENABLE);
94}
95
96static void vision_lcd_blank(int blank_mode, struct fb_info *info)
97{
98 if (blank_mode)
99 gpio_set_value(VISION_LCD_ENABLE, 0);
100 else
101 gpio_set_value(VISION_LCD_ENABLE, 1);
102}
103
104static struct ep93xxfb_mach_info ep93xxfb_info __initdata = {
105 .flags = EP93XXFB_USE_SDCSN0 | EP93XXFB_PCLK_FALLING,
106 .setup = vision_lcd_setup,
107 .teardown = vision_lcd_teardown,
108 .blank = vision_lcd_blank,
109};
110
111
112/*************************************************************************
113 * GPIO Expanders
114 *************************************************************************/
115#define PCA9539_74_GPIO_BASE (EP93XX_GPIO_LINE_MAX + 1)
116#define PCA9539_75_GPIO_BASE (PCA9539_74_GPIO_BASE + 16)
117#define PCA9539_76_GPIO_BASE (PCA9539_75_GPIO_BASE + 16)
118#define PCA9539_77_GPIO_BASE (PCA9539_76_GPIO_BASE + 16)
119
120static struct pca953x_platform_data pca953x_74_gpio_data = {
121 .gpio_base = PCA9539_74_GPIO_BASE,
122 .irq_base = EP93XX_BOARD_IRQ(0),
123};
124
125static struct pca953x_platform_data pca953x_75_gpio_data = {
126 .gpio_base = PCA9539_75_GPIO_BASE,
127 .irq_base = -1,
128};
129
130static struct pca953x_platform_data pca953x_76_gpio_data = {
131 .gpio_base = PCA9539_76_GPIO_BASE,
132 .irq_base = -1,
133};
134
135static struct pca953x_platform_data pca953x_77_gpio_data = {
136 .gpio_base = PCA9539_77_GPIO_BASE,
137 .irq_base = -1,
138};
139
140/*************************************************************************
141 * I2C Bus
142 *************************************************************************/
143
144static struct i2c_board_info vision_i2c_info[] __initdata = {
145 {
146 I2C_BOARD_INFO("isl1208", 0x6f),
147 .irq = IRQ_EP93XX_EXT1,
148 }, {
149 I2C_BOARD_INFO("pca9539", 0x74),
150 .platform_data = &pca953x_74_gpio_data,
151 }, {
152 I2C_BOARD_INFO("pca9539", 0x75),
153 .platform_data = &pca953x_75_gpio_data,
154 }, {
155 I2C_BOARD_INFO("pca9539", 0x76),
156 .platform_data = &pca953x_76_gpio_data,
157 }, {
158 I2C_BOARD_INFO("pca9539", 0x77),
159 .platform_data = &pca953x_77_gpio_data,
160 },
161};
162
163/*************************************************************************
164 * SPI CS4271 Audio Codec
165 *************************************************************************/
166static struct cs4271_platform_data vision_cs4271_data = {
167 /* Intentionally left blank */
168};
169
170/*************************************************************************
171 * SPI Flash
172 *************************************************************************/
173static struct mtd_partition vision_spi_flash_partitions[] = {
174 {
175 .name = "SPI bootstrap",
176 .offset = 0,
177 .size = SZ_4K,
178 }, {
179 .name = "Bootstrap config",
180 .offset = MTDPART_OFS_APPEND,
181 .size = SZ_4K,
182 }, {
183 .name = "System config",
184 .offset = MTDPART_OFS_APPEND,
185 .size = MTDPART_SIZ_FULL,
186 },
187};
188
189static struct flash_platform_data vision_spi_flash_data = {
190 .name = "SPI Flash",
191 .parts = vision_spi_flash_partitions,
192 .nr_parts = ARRAY_SIZE(vision_spi_flash_partitions),
193};
194
195/*************************************************************************
196 * SPI SD/MMC host
197 *************************************************************************/
198static struct mmc_spi_platform_data vision_spi_mmc_data = {
199 .detect_delay = 100,
200 .powerup_msecs = 100,
201 .ocr_mask = MMC_VDD_32_33 | MMC_VDD_33_34,
202 .caps2 = MMC_CAP2_RO_ACTIVE_HIGH,
203};
204
205static struct gpiod_lookup_table vision_spi_mmc_gpio_table = {
206 .dev_id = "mmc_spi.2", /* "mmc_spi @ CS2 */
207 .table = {
208 /* Card detect */
209 GPIO_LOOKUP_IDX("gpio-ep93xx.1", 7, NULL, 0, GPIO_ACTIVE_LOW),
210 /* Write protect */
211 GPIO_LOOKUP_IDX("gpio-ep93xx.5", 0, NULL, 1, GPIO_ACTIVE_HIGH),
212 { },
213 },
214};
215
216/*************************************************************************
217 * SPI Bus
218 *************************************************************************/
219static struct spi_board_info vision_spi_board_info[] __initdata = {
220 {
221 .modalias = "cs4271",
222 .platform_data = &vision_cs4271_data,
223 .max_speed_hz = 6000000,
224 .bus_num = 0,
225 .chip_select = 0,
226 .mode = SPI_MODE_3,
227 }, {
228 .modalias = "sst25l",
229 .platform_data = &vision_spi_flash_data,
230 .max_speed_hz = 20000000,
231 .bus_num = 0,
232 .chip_select = 1,
233 .mode = SPI_MODE_3,
234 }, {
235 .modalias = "mmc_spi",
236 .platform_data = &vision_spi_mmc_data,
237 .max_speed_hz = 20000000,
238 .bus_num = 0,
239 .chip_select = 2,
240 .mode = SPI_MODE_3,
241 },
242};
243
244static struct gpiod_lookup_table vision_spi_cs4271_gpio_table = {
245 .dev_id = "spi0.0", /* cs4271 @ CS0 */
246 .table = {
247 /* RESET */
248 GPIO_LOOKUP_IDX("H", 2, NULL, 0, GPIO_ACTIVE_LOW),
249 { },
250 },
251};
252
253static struct gpiod_lookup_table vision_spi_cs_gpio_table = {
254 .dev_id = "spi0",
255 .table = {
256 GPIO_LOOKUP_IDX("gpio-ep93xx.0", 6, "cs", 0, GPIO_ACTIVE_LOW),
257 GPIO_LOOKUP_IDX("gpio-ep93xx.0", 7, "cs", 1, GPIO_ACTIVE_LOW),
258 GPIO_LOOKUP_IDX("gpio-ep93xx.6", 2, "cs", 2, GPIO_ACTIVE_LOW),
259 { },
260 },
261};
262
263static struct ep93xx_spi_info vision_spi_master __initdata = {
264 .use_dma = 1,
265};
266
267/*************************************************************************
268 * I2S Audio
269 *************************************************************************/
270static struct platform_device vision_audio_device = {
271 .name = "edb93xx-audio",
272 .id = -1,
273};
274
275static void __init vision_register_i2s(void)
276{
277 ep93xx_register_i2s();
278 platform_device_register(&vision_audio_device);
279}
280
281/*************************************************************************
282 * Machine Initialization
283 *************************************************************************/
284static void __init vision_init_machine(void)
285{
286 ep93xx_init_devices();
287 ep93xx_register_flash(2, EP93XX_CS6_PHYS_BASE, SZ_64M);
288 ep93xx_register_eth(&vision_eth_data, 1);
289 ep93xx_register_fb(&ep93xxfb_info);
290 ep93xx_register_pwm(1, 0);
291
292 /*
293 * Request the gpio expander's interrupt gpio line now to prevent
294 * the kernel from doing a WARN in gpiolib:gpio_ensure_requested().
295 */
296 if (gpio_request_one(EP93XX_GPIO_LINE_F(7), GPIOF_DIR_IN,
297 "pca9539:74"))
298 pr_warn("cannot request interrupt gpio for pca9539:74\n");
299
300 vision_i2c_info[1].irq = gpio_to_irq(EP93XX_GPIO_LINE_F(7));
301
302 ep93xx_register_i2c(vision_i2c_info,
303 ARRAY_SIZE(vision_i2c_info));
304 gpiod_add_lookup_table(&vision_spi_cs4271_gpio_table);
305 gpiod_add_lookup_table(&vision_spi_mmc_gpio_table);
306 gpiod_add_lookup_table(&vision_spi_cs_gpio_table);
307 ep93xx_register_spi(&vision_spi_master, vision_spi_board_info,
308 ARRAY_SIZE(vision_spi_board_info));
309 vision_register_i2s();
310}
311
312MACHINE_START(VISION_EP9307, "Vision Engraving Systems EP9307")
313 /* Maintainer: H Hartley Sweeten <hsweeten@visionengravers.com> */
314 .atag_offset = 0x100,
315 .nr_irqs = NR_EP93XX_IRQS + EP93XX_BOARD_IRQS,
316 .map_io = vision_map_io,
317 .init_irq = ep93xx_init_irq,
318 .init_time = ep93xx_timer_init,
319 .init_machine = vision_init_machine,
320 .restart = ep93xx_restart,
321MACHINE_END
include/linux/platform_data/spi-ep93xx.h+0−15
@@ -1,15 +0,0 @@
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef __ASM_MACH_EP93XX_SPI_H
3#define __ASM_MACH_EP93XX_SPI_H
4
5struct spi_device;
6
7/**
8 * struct ep93xx_spi_info - EP93xx specific SPI descriptor
9 * @use_dma: use DMA for the transfers
10 */
11struct ep93xx_spi_info {
12 bool use_dma;
13};
14
15#endif /* __ASM_MACH_EP93XX_SPI_H */

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t