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−
28−static DEFINE_SPINLOCK(clk_lock);
29−
30−static char fclk_divisors[] = { 1, 2, 4, 8, 16, 1, 1, 1 };
31−static char hclk_divisors[] = { 1, 2, 4, 5, 6, 8, 16, 32 };
32−static char pclk_divisors[] = { 1, 2, 4, 8 };
33−
34−static char adc_divisors[] = { 16, 4 };
35−static char sclk_divisors[] = { 2, 4 };
36−static char lrclk_divisors[] = { 32, 64, 128 };
37−
38−static 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− */
47−static 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−
60−struct 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−
74−static 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−
82−static 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−
102−static 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−
120−static 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−
126−static 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−
159−static 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−
173−static 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−
202−static bool is_best(unsigned long rate, unsigned long now,
203− unsigned long best)
204−{
205− return abs(rate - now) < abs(rate - best);
206−}
207−
208−static 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−
259−static 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−
274−static 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−
313−static 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−
324−static 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−
355−static 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−
368−static 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−
393−static 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−
414−static 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−
423−static 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−
463−struct ep93xx_gate {
464− unsigned int bit;
465− const char *dev_id;
466− const char *con_id;
467−};
468−
469−static 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−
475−static 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−
501−static 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−
516−static 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−
537−static 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−}
733−postcore_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− *************************************************************************/
57−static 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−
71−void __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− *************************************************************************/
79−void __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− */
94−static DEFINE_SPINLOCK(syscon_swlock);
95−
96−void 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−
108−void 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− */
129−unsigned 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−}
138−EXPORT_SYMBOL_GPL(ep93xx_chip_revision);
139−
140−/*************************************************************************
141− * EP93xx GPIO
142− *************************************************************************/
143−/* port A */
144−static 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−
151−static 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 */
159−static 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−
166−static 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 */
174−static 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−
179−static 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 */
187−static 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−
192−static 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 */
200−static 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−
205−static 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 */
213−static 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−
227−static 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 */
235−static 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−
240−static 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−
247−static 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−
262−static 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−
276−static struct amba_pl010_data ep93xx_uart_data = {
277− .set_mctrl = ep93xx_uart_set_mctrl,
278−};
279−
280−static AMBA_APB_DEVICE(uart1, "apb:uart1", 0x00041010, EP93XX_UART1_PHYS_BASE,
281− { IRQ_EP93XX_UART1 }, &ep93xx_uart_data);
282−
283−static AMBA_APB_DEVICE(uart2, "apb:uart2", 0x00041010, EP93XX_UART2_PHYS_BASE,
284− { IRQ_EP93XX_UART2 }, NULL);
285−
286−static AMBA_APB_DEVICE(uart3, "apb:uart3", 0x00041010, EP93XX_UART3_PHYS_BASE,
287− { IRQ_EP93XX_UART3 }, &ep93xx_uart_data);
288−
289−static struct resource ep93xx_rtc_resource[] = {
290− DEFINE_RES_MEM(EP93XX_RTC_PHYS_BASE, 0x10c),
291−};
292−
293−static 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−
304−static struct clk *ep93xx_ohci_host_clock;
305−
306−static 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−
317−static void ep93xx_ohci_power_off(struct platform_device *pdev)
318−{
319− clk_disable(ep93xx_ohci_host_clock);
320−}
321−
322−static 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−
328−static struct resource ep93xx_ohci_resources[] = {
329− DEFINE_RES_MEM(EP93XX_USB_PHYS_BASE, 0x1000),
330− DEFINE_RES_IRQ(IRQ_EP93XX_USB),
331−};
332−
333−static u64 ep93xx_ohci_dma_mask = DMA_BIT_MASK(32);
334−
335−static 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− *************************************************************************/
350−static struct physmap_flash_data ep93xx_flash_data;
351−
352−static struct resource ep93xx_flash_resource = {
353− .flags = IORESOURCE_MEM,
354−};
355−
356−static 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− */
372−void __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− *************************************************************************/
387−static struct ep93xx_eth_data ep93xx_eth_data;
388−
389−static struct resource ep93xx_eth_resource[] = {
390− DEFINE_RES_MEM(EP93XX_ETHERNET_PHYS_BASE, 0x10000),
391− DEFINE_RES_IRQ(IRQ_EP93XX_ETHERNET),
392−};
393−
394−static u64 ep93xx_eth_dma_mask = DMA_BIT_MASK(32);
395−
396−static 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− */
414−void __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 */
429−static 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−
441−static 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− */
454−void __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− *************************************************************************/
475−static struct ep93xx_spi_info ep93xx_spi_master_data;
476−
477−static struct resource ep93xx_spi_resources[] = {
478− DEFINE_RES_MEM(EP93XX_SPI_PHYS_BASE, 0x18),
479− DEFINE_RES_IRQ(IRQ_EP93XX_SSP),
480−};
481−
482−static u64 ep93xx_spi_dma_mask = DMA_BIT_MASK(32);
483−
484−static 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− */
505−void __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− *************************************************************************/
522−static const struct gpio_led ep93xx_led_pins[] __initconst = {
523− {
524− .name = "platform:grled",
525− }, {
526− .name = "platform:rdled",
527− },
528−};
529−
530−static 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−
535−static 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− *************************************************************************/
548−static struct resource ep93xx_pwm0_resource[] = {
549− DEFINE_RES_MEM(EP93XX_PWM_PHYS_BASE, 0x10),
550−};
551−
552−static 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−
559−static struct resource ep93xx_pwm1_resource[] = {
560− DEFINE_RES_MEM(EP93XX_PWM_PHYS_BASE + 0x20, 0x10),
561−};
562−
563−static 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−
570−void __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− *************************************************************************/
583−static struct ep93xxfb_mach_info ep93xxfb_data;
584−
585−static struct resource ep93xx_fb_resource[] = {
586− DEFINE_RES_MEM(EP93XX_RASTER_PHYS_BASE, 0x800),
587−};
588−
589−static 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−
604−static struct resource ep93xx_bl_resources[] = {
605− DEFINE_RES_MEM(EP93XX_RASTER_PHYS_BASE +
606− EP93XX_RASTER_REG_BRIGHTNESS, 0x04),
607−};
608−
609−static 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− */
620−void __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− *************************************************************************/
631−static struct ep93xx_keypad_platform_data ep93xx_keypad_data;
632−
633−static struct resource ep93xx_keypad_resource[] = {
634− DEFINE_RES_MEM(EP93XX_KEY_MATRIX_PHYS_BASE, 0x0c),
635− DEFINE_RES_IRQ(IRQ_EP93XX_KEY),
636−};
637−
638−static 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− */
652−void __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− *************************************************************************/
661−static struct resource ep93xx_i2s_resource[] = {
662− DEFINE_RES_MEM(EP93XX_I2S_PHYS_BASE, 0x100),
663− DEFINE_RES_IRQ(IRQ_EP93XX_SAI),
664−};
665−
666−static 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−
673−static struct platform_device ep93xx_pcm_device = {
674− .name = "ep93xx-pcm-audio",
675− .id = -1,
676−};
677−
678−void __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−
690−int 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−}
710−EXPORT_SYMBOL(ep93xx_i2s_acquire);
711−
712−void ep93xx_i2s_release(void)
713−{
714− ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_I2S_MASK);
715−}
716−EXPORT_SYMBOL(ep93xx_i2s_release);
717−
718−/*************************************************************************
719− * EP93xx AC97 audio peripheral handling
720− *************************************************************************/
721−static struct resource ep93xx_ac97_resources[] = {
722− DEFINE_RES_MEM(EP93XX_AAC_PHYS_BASE, 0xac),
723− DEFINE_RES_IRQ(IRQ_EP93XX_AACINTR),
724−};
725−
726−static 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−
733−void __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− *************************************************************************/
747−static struct resource ep93xx_wdt_resources[] = {
748− DEFINE_RES_MEM(EP93XX_WATCHDOG_PHYS_BASE, 0x08),
749−};
750−
751−static 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− *************************************************************************/
761−static struct resource ep93xx_ide_resources[] = {
762− DEFINE_RES_MEM(EP93XX_IDE_PHYS_BASE, 0x38),
763− DEFINE_RES_IRQ(IRQ_EP93XX_EXT3),
764−};
765−
766−static 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−
777−void __init ep93xx_register_ide(void)
778−{
779− platform_device_register(&ep93xx_ide_device);
780−}
781−
782−/*************************************************************************
783− * EP93xx ADC
784− *************************************************************************/
785−static struct resource ep93xx_adc_resources[] = {
786− DEFINE_RES_MEM(EP93XX_ADC_PHYS_BASE, 0x28),
787− DEFINE_RES_IRQ(IRQ_EP93XX_TOUCH),
788−};
789−
790−static 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−
797−void __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−
831−static char ep93xx_soc_id[33];
832−
833−static 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−
861−static 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−
881−static const char __init *ep93xx_get_machine_name(void)
882−{
883− return kasprintf(GFP_KERNEL,"%s", machine_desc->name);
884−}
885−
886−static 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−
910−struct 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−
945−void 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− */
47−static 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−
60−static 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−
65−static u64 ep93xx_dma_m2p_mask = DMA_BIT_MASK(32);
66−
67−static 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− */
86−static 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−
91−static 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−
96−static u64 ep93xx_dma_m2m_mask = DMA_BIT_MASK(32);
97−
98−static 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−
108−static 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−}
114−arch_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−
42−static 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−
52−static struct ep93xx_eth_data __initdata edb93xx_eth_data = {
53− .phy_id = 1,
54−};
55−
56−
57−/*************************************************************************
58− * EDB93xx i2c peripheral handling
59− *************************************************************************/
60−
61−static struct i2c_board_info __initdata edb93xxa_i2c_board_info[] = {
62− {
63− I2C_BOARD_INFO("isl1208", 0x6f),
64− },
65−};
66−
67−static struct i2c_board_info __initdata edb93xx_i2c_board_info[] = {
68− {
69− I2C_BOARD_INFO("ds1337", 0x68),
70− },
71−};
72−
73−static 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− *************************************************************************/
90−static struct cs4271_platform_data edb93xx_cs4271_data = {
91− /* Intentionally left blank */
92−};
93−
94−static 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−
105−static 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−
113−static struct ep93xx_spi_info edb93xx_spi_info __initdata = {
114− /* Intentionally left blank */
115−};
116−
117−static 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−
125−static 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−
133−static 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−
141−static 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− *************************************************************************/
159−static struct platform_device edb93xx_audio_device = {
160− .name = "edb93xx-audio",
161− .id = -1,
162−};
163−
164−static 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−
171−static 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− *************************************************************************/
183−static 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− *************************************************************************/
202−static struct ep93xxfb_mach_info __initdata edb93xxfb_info = {
203− .flags = 0,
204−};
205−
206−static 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−
214−static 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− *************************************************************************/
231−static 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−
242−static void __init edb93xx_register_ide(void)
243−{
244− if (!edb93xx_has_ide())
245− return;
246−
247− ep93xx_register_ide();
248−}
249−
250−
251−static 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
267−MACHINE_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,
276−MACHINE_END
277−#endif
278−
279−#ifdef CONFIG_MACH_EDB9302
280−MACHINE_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,
289−MACHINE_END
290−#endif
291−
292−#ifdef CONFIG_MACH_EDB9302A
293−MACHINE_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,
302−MACHINE_END
303−#endif
304−
305−#ifdef CONFIG_MACH_EDB9307
306−MACHINE_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,
315−MACHINE_END
316−#endif
317−
318−#ifdef CONFIG_MACH_EDB9307A
319−MACHINE_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,
328−MACHINE_END
329−#endif
330−
331−#ifdef CONFIG_MACH_EDB9312
332−MACHINE_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,
341−MACHINE_END
342−#endif
343−
344−#ifdef CONFIG_MACH_EDB9315
345−MACHINE_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,
354−MACHINE_END
355−#endif
356−
357−#ifdef CONFIG_MACH_EDB9315A
358−MACHINE_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,
367−MACHINE_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−
11−struct device;
12−struct i2c_board_info;
13−struct spi_board_info;
14−struct platform_device;
15−struct ep93xxfb_mach_info;
16−struct ep93xx_keypad_platform_data;
17−struct ep93xx_spi_info;
18−
19−void ep93xx_map_io(void);
20−void ep93xx_init_irq(void);
21−
22−void ep93xx_register_flash(unsigned int width,
23− resource_size_t start, resource_size_t size);
24−
25−void ep93xx_register_eth(struct ep93xx_eth_data *data, int copy_addr);
26−void ep93xx_register_i2c(struct i2c_board_info *devices, int num);
27−void ep93xx_register_spi(struct ep93xx_spi_info *info,
28− struct spi_board_info *devices, int num);
29−void ep93xx_register_fb(struct ep93xxfb_mach_info *data);
30−void ep93xx_register_pwm(int pwm0, int pwm1);
31−void ep93xx_register_keypad(struct ep93xx_keypad_platform_data *data);
32−void ep93xx_register_i2s(void);
33−void ep93xx_register_ac97(void);
34−void ep93xx_register_ide(void);
35−void ep93xx_register_adc(void);
36−
37−struct device *ep93xx_init_devices(void);
38−extern void ep93xx_timer_init(void);
39−
40−void 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 */
199−void ep93xx_syscon_swlocked_write(unsigned int val, void __iomem *reg);
200−void ep93xx_devcfg_set_clear(unsigned int set_bits, unsigned int clear_bits);
201−
202−static inline void ep93xx_devcfg_set_bits(unsigned int bits)
203−{
204− ep93xx_devcfg_set_clear(bits, 0x00);
205−}
206−
207−static 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−
55−static 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−
64−static 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−
73−static 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−
91−static 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−
99−static 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−
109−static 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−
121−void __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− *************************************************************************/
36−static 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−
60−static 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−
73−static 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−
94−static 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−
106−static 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−
125−static 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−
137−static 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−
145−static 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−
153−static 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−
178−static 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−
183−static 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−
196−static 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−
201−static 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− *************************************************************************/
211−static 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
221−static 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−
241−static 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− *************************************************************************/
252−static 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− */
268−static 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−
276−static 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−
288−static 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−
296−static 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− *************************************************************************/
308−static 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−
317−static 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−
326−static struct ep93xx_spi_info ts72xx_spi_info __initdata = {
327− /* Intentionally left blank */
328−};
329−
330−static 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−
349−MACHINE_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,
358−MACHINE_END
359−
360−/*************************************************************************
361− * EP93xx I2S audio peripheral handling
362− *************************************************************************/
363−static 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−
368−static 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− *************************************************************************/
378−static 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−
395−static 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−
413−MACHINE_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,
422−MACHINE_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−
52−static inline int ts72xx_model(void)
53−{
54− return __raw_readb(TS72XX_MODEL_VIRT_BASE) & TS72XX_MODEL_MASK;
55−}
56−
57−static inline int board_is_ts7200(void)
58−{
59− return ts72xx_model() == TS72XX_MODEL_TS7200;
60−}
61−
62−static inline int board_is_ts7250(void)
63−{
64− return ts72xx_model() == TS72XX_MODEL_TS7250;
65−}
66−
67−static inline int board_is_ts7260(void)
68−{
69− return ts72xx_model() == TS72XX_MODEL_TS7260;
70−}
71−
72−static inline int board_is_ts7300(void)
73−{
74− return ts72xx_model() == TS72XX_MODEL_TS7300;
75−}
76−
77−static inline int board_is_ts7400(void)
78−{
79− return ts72xx_model() == TS72XX_MODEL_TS7400;
80−}
81−
82−static inline int is_max197_installed(void)
83−{
84− return !!(__raw_readb(TS72XX_OPTIONS_VIRT_BASE) &
85− TS72XX_OPTIONS_MAX197);
86−}
87−
88−static 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−
47−static 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−
56−static 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− *************************************************************************/
66−static 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−
75−static 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−
91−static void vision_lcd_teardown(struct platform_device *pdev)
92−{
93− gpio_free(VISION_LCD_ENABLE);
94−}
95−
96−static 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−
104−static 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−
120−static struct pca953x_platform_data pca953x_74_gpio_data = {
121− .gpio_base = PCA9539_74_GPIO_BASE,
122− .irq_base = EP93XX_BOARD_IRQ(0),
123−};
124−
125−static struct pca953x_platform_data pca953x_75_gpio_data = {
126− .gpio_base = PCA9539_75_GPIO_BASE,
127− .irq_base = -1,
128−};
129−
130−static struct pca953x_platform_data pca953x_76_gpio_data = {
131− .gpio_base = PCA9539_76_GPIO_BASE,
132− .irq_base = -1,
133−};
134−
135−static 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−
144−static 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− *************************************************************************/
166−static struct cs4271_platform_data vision_cs4271_data = {
167− /* Intentionally left blank */
168−};
169−
170−/*************************************************************************
171− * SPI Flash
172− *************************************************************************/
173−static 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−
189−static 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− *************************************************************************/
198−static 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−
205−static 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− *************************************************************************/
219−static 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−
244−static 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−
253−static 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−
263−static struct ep93xx_spi_info vision_spi_master __initdata = {
264− .use_dma = 1,
265−};
266−
267−/*************************************************************************
268− * I2S Audio
269− *************************************************************************/
270−static struct platform_device vision_audio_device = {
271− .name = "edb93xx-audio",
272− .id = -1,
273−};
274−
275−static 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− *************************************************************************/
284−static 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−
312−MACHINE_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,
321−MACHINE_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−
5−struct spi_device;
6−
7−/**
8− * struct ep93xx_spi_info - EP93xx specific SPI descriptor
9− * @use_dma: use DMA for the transfers
10− */
11−struct 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