1 | /* |
2 | * Broadcom specific AMBA |
3 | * Core ops |
4 | * |
5 | * Licensed under the GNU/GPL. See COPYING for details. |
6 | */ |
7 | |
8 | #include "bcma_private.h" |
9 | #include <linux/export.h> |
10 | #include <linux/bcma/bcma.h> |
11 | |
12 | static bool bcma_core_wait_value(struct bcma_device *core, u16 reg, u32 mask, |
13 | u32 value, int timeout) |
14 | { |
15 | unsigned long deadline = jiffies + timeout; |
16 | u32 val; |
17 | |
18 | do { |
19 | val = bcma_aread32(core, offset: reg); |
20 | if ((val & mask) == value) |
21 | return true; |
22 | cpu_relax(); |
23 | udelay(10); |
24 | } while (!time_after_eq(jiffies, deadline)); |
25 | |
26 | bcma_warn(core->bus, "Timeout waiting for register 0x%04X!\n" , reg); |
27 | |
28 | return false; |
29 | } |
30 | |
31 | bool bcma_core_is_enabled(struct bcma_device *core) |
32 | { |
33 | if ((bcma_aread32(core, BCMA_IOCTL) & (BCMA_IOCTL_CLK | BCMA_IOCTL_FGC)) |
34 | != BCMA_IOCTL_CLK) |
35 | return false; |
36 | if (bcma_aread32(core, BCMA_RESET_CTL) & BCMA_RESET_CTL_RESET) |
37 | return false; |
38 | return true; |
39 | } |
40 | EXPORT_SYMBOL_GPL(bcma_core_is_enabled); |
41 | |
42 | void bcma_core_disable(struct bcma_device *core, u32 flags) |
43 | { |
44 | if (bcma_aread32(core, BCMA_RESET_CTL) & BCMA_RESET_CTL_RESET) |
45 | return; |
46 | |
47 | bcma_core_wait_value(core, BCMA_RESET_ST, mask: ~0, value: 0, timeout: 300); |
48 | |
49 | bcma_awrite32(core, BCMA_RESET_CTL, BCMA_RESET_CTL_RESET); |
50 | bcma_aread32(core, BCMA_RESET_CTL); |
51 | udelay(1); |
52 | |
53 | bcma_awrite32(core, BCMA_IOCTL, value: flags); |
54 | bcma_aread32(core, BCMA_IOCTL); |
55 | udelay(10); |
56 | } |
57 | EXPORT_SYMBOL_GPL(bcma_core_disable); |
58 | |
59 | int bcma_core_enable(struct bcma_device *core, u32 flags) |
60 | { |
61 | bcma_core_disable(core, flags); |
62 | |
63 | bcma_awrite32(core, BCMA_IOCTL, value: (BCMA_IOCTL_CLK | BCMA_IOCTL_FGC | flags)); |
64 | bcma_aread32(core, BCMA_IOCTL); |
65 | |
66 | bcma_awrite32(core, BCMA_RESET_CTL, value: 0); |
67 | bcma_aread32(core, BCMA_RESET_CTL); |
68 | udelay(1); |
69 | |
70 | bcma_awrite32(core, BCMA_IOCTL, value: (BCMA_IOCTL_CLK | flags)); |
71 | bcma_aread32(core, BCMA_IOCTL); |
72 | udelay(1); |
73 | |
74 | return 0; |
75 | } |
76 | EXPORT_SYMBOL_GPL(bcma_core_enable); |
77 | |
78 | void bcma_core_set_clockmode(struct bcma_device *core, |
79 | enum bcma_clkmode clkmode) |
80 | { |
81 | u16 i; |
82 | |
83 | WARN_ON(core->id.id != BCMA_CORE_CHIPCOMMON && |
84 | core->id.id != BCMA_CORE_PCIE && |
85 | core->id.id != BCMA_CORE_80211); |
86 | |
87 | switch (clkmode) { |
88 | case BCMA_CLKMODE_FAST: |
89 | bcma_set32(cc: core, BCMA_CLKCTLST, BCMA_CLKCTLST_FORCEHT); |
90 | usleep_range(min: 64, max: 300); |
91 | for (i = 0; i < 1500; i++) { |
92 | if (bcma_read32(core, BCMA_CLKCTLST) & |
93 | BCMA_CLKCTLST_HAVEHT) { |
94 | i = 0; |
95 | break; |
96 | } |
97 | udelay(10); |
98 | } |
99 | if (i) |
100 | bcma_err(core->bus, "HT force timeout\n" ); |
101 | break; |
102 | case BCMA_CLKMODE_DYNAMIC: |
103 | bcma_set32(cc: core, BCMA_CLKCTLST, set: ~BCMA_CLKCTLST_FORCEHT); |
104 | break; |
105 | } |
106 | } |
107 | EXPORT_SYMBOL_GPL(bcma_core_set_clockmode); |
108 | |
109 | void bcma_core_pll_ctl(struct bcma_device *core, u32 req, u32 status, bool on) |
110 | { |
111 | u16 i; |
112 | |
113 | WARN_ON(req & ~BCMA_CLKCTLST_EXTRESREQ); |
114 | WARN_ON(status & ~BCMA_CLKCTLST_EXTRESST); |
115 | |
116 | if (on) { |
117 | bcma_set32(cc: core, BCMA_CLKCTLST, set: req); |
118 | for (i = 0; i < 10000; i++) { |
119 | if ((bcma_read32(core, BCMA_CLKCTLST) & status) == |
120 | status) { |
121 | i = 0; |
122 | break; |
123 | } |
124 | udelay(10); |
125 | } |
126 | if (i) |
127 | bcma_err(core->bus, "PLL enable timeout\n" ); |
128 | } else { |
129 | /* |
130 | * Mask the PLL but don't wait for it to be disabled. PLL may be |
131 | * shared between cores and will be still up if there is another |
132 | * core using it. |
133 | */ |
134 | bcma_mask32(cc: core, BCMA_CLKCTLST, mask: ~req); |
135 | bcma_read32(core, BCMA_CLKCTLST); |
136 | } |
137 | } |
138 | EXPORT_SYMBOL_GPL(bcma_core_pll_ctl); |
139 | |
140 | u32 bcma_core_dma_translation(struct bcma_device *core) |
141 | { |
142 | switch (core->bus->hosttype) { |
143 | case BCMA_HOSTTYPE_SOC: |
144 | return 0; |
145 | case BCMA_HOSTTYPE_PCI: |
146 | if (bcma_aread32(core, BCMA_IOST) & BCMA_IOST_DMA64) |
147 | return BCMA_DMA_TRANSLATION_DMA64_CMT; |
148 | else |
149 | return BCMA_DMA_TRANSLATION_DMA32_CMT; |
150 | default: |
151 | bcma_err(core->bus, "DMA translation unknown for host %d\n" , |
152 | core->bus->hosttype); |
153 | } |
154 | return BCMA_DMA_TRANSLATION_NONE; |
155 | } |
156 | EXPORT_SYMBOL(bcma_core_dma_translation); |
157 | |