1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Linux driver for digital TV devices equipped with B2C2 FlexcopII(b)/III |
4 | * flexcop-sram.c - functions for controlling the SRAM |
5 | * see flexcop.c for copyright information |
6 | */ |
7 | #include "flexcop.h" |
8 | |
9 | static void flexcop_sram_set_chip(struct flexcop_device *fc, |
10 | flexcop_sram_type_t type) |
11 | { |
12 | flexcop_set_ibi_value(wan_ctrl_reg_71c, sram_chip, type); |
13 | } |
14 | |
15 | int flexcop_sram_init(struct flexcop_device *fc) |
16 | { |
17 | switch (fc->rev) { |
18 | case FLEXCOP_II: |
19 | case FLEXCOP_IIB: |
20 | flexcop_sram_set_chip(fc, type: FC_SRAM_1_32KB); |
21 | break; |
22 | case FLEXCOP_III: |
23 | flexcop_sram_set_chip(fc, type: FC_SRAM_1_48KB); |
24 | break; |
25 | default: |
26 | return -EINVAL; |
27 | } |
28 | return 0; |
29 | } |
30 | |
31 | int flexcop_sram_set_dest(struct flexcop_device *fc, flexcop_sram_dest_t dest, |
32 | flexcop_sram_dest_target_t target) |
33 | { |
34 | flexcop_ibi_value v; |
35 | v = fc->read_ibi_reg(fc, sram_dest_reg_714); |
36 | |
37 | if (fc->rev != FLEXCOP_III && target == FC_SRAM_DEST_TARGET_FC3_CA) { |
38 | err("SRAM destination target to available on FlexCopII(b)\n" ); |
39 | return -EINVAL; |
40 | } |
41 | deb_sram("sram dest: %x target: %x\n" , dest, target); |
42 | |
43 | if (dest & FC_SRAM_DEST_NET) |
44 | v.sram_dest_reg_714.NET_Dest = target; |
45 | if (dest & FC_SRAM_DEST_CAI) |
46 | v.sram_dest_reg_714.CAI_Dest = target; |
47 | if (dest & FC_SRAM_DEST_CAO) |
48 | v.sram_dest_reg_714.CAO_Dest = target; |
49 | if (dest & FC_SRAM_DEST_MEDIA) |
50 | v.sram_dest_reg_714.MEDIA_Dest = target; |
51 | |
52 | fc->write_ibi_reg(fc,sram_dest_reg_714,v); |
53 | udelay(1000); /* TODO delay really necessary */ |
54 | |
55 | return 0; |
56 | } |
57 | EXPORT_SYMBOL(flexcop_sram_set_dest); |
58 | |
59 | void flexcop_wan_set_speed(struct flexcop_device *fc, flexcop_wan_speed_t s) |
60 | { |
61 | flexcop_set_ibi_value(wan_ctrl_reg_71c,wan_speed_sig,s); |
62 | } |
63 | EXPORT_SYMBOL(flexcop_wan_set_speed); |
64 | |
65 | void flexcop_sram_ctrl(struct flexcop_device *fc, int usb_wan, int sramdma, int maximumfill) |
66 | { |
67 | flexcop_ibi_value v = fc->read_ibi_reg(fc,sram_dest_reg_714); |
68 | v.sram_dest_reg_714.ctrl_usb_wan = usb_wan; |
69 | v.sram_dest_reg_714.ctrl_sramdma = sramdma; |
70 | v.sram_dest_reg_714.ctrl_maximumfill = maximumfill; |
71 | fc->write_ibi_reg(fc,sram_dest_reg_714,v); |
72 | } |
73 | EXPORT_SYMBOL(flexcop_sram_ctrl); |
74 | |
75 | #if 0 |
76 | static void flexcop_sram_write(struct adapter *adapter, u32 bank, u32 addr, u8 *buf, u32 len) |
77 | { |
78 | int i, retries; |
79 | u32 command; |
80 | |
81 | for (i = 0; i < len; i++) { |
82 | command = bank | addr | 0x04000000 | (*buf << 0x10); |
83 | |
84 | retries = 2; |
85 | |
86 | while (((read_reg_dw(adapter, 0x700) & 0x80000000) != 0) && (retries > 0)) { |
87 | mdelay(1); |
88 | retries--; |
89 | } |
90 | |
91 | if (retries == 0) |
92 | printk("%s: SRAM timeout\n" , __func__); |
93 | |
94 | write_reg_dw(adapter, 0x700, command); |
95 | |
96 | buf++; |
97 | addr++; |
98 | } |
99 | } |
100 | |
101 | static void flex_sram_read(struct adapter *adapter, u32 bank, u32 addr, u8 *buf, u32 len) |
102 | { |
103 | int i, retries; |
104 | u32 command, value; |
105 | |
106 | for (i = 0; i < len; i++) { |
107 | command = bank | addr | 0x04008000; |
108 | |
109 | retries = 10000; |
110 | |
111 | while (((read_reg_dw(adapter, 0x700) & 0x80000000) != 0) && (retries > 0)) { |
112 | mdelay(1); |
113 | retries--; |
114 | } |
115 | |
116 | if (retries == 0) |
117 | printk("%s: SRAM timeout\n" , __func__); |
118 | |
119 | write_reg_dw(adapter, 0x700, command); |
120 | |
121 | retries = 10000; |
122 | |
123 | while (((read_reg_dw(adapter, 0x700) & 0x80000000) != 0) && (retries > 0)) { |
124 | mdelay(1); |
125 | retries--; |
126 | } |
127 | |
128 | if (retries == 0) |
129 | printk("%s: SRAM timeout\n" , __func__); |
130 | |
131 | value = read_reg_dw(adapter, 0x700) >> 0x10; |
132 | |
133 | *buf = (value & 0xff); |
134 | |
135 | addr++; |
136 | buf++; |
137 | } |
138 | } |
139 | |
140 | static void sram_write_chunk(struct adapter *adapter, u32 addr, u8 *buf, u16 len) |
141 | { |
142 | u32 bank; |
143 | |
144 | bank = 0; |
145 | |
146 | if (adapter->dw_sram_type == 0x20000) { |
147 | bank = (addr & 0x18000) << 0x0d; |
148 | } |
149 | |
150 | if (adapter->dw_sram_type == 0x00000) { |
151 | if ((addr >> 0x0f) == 0) |
152 | bank = 0x20000000; |
153 | else |
154 | bank = 0x10000000; |
155 | } |
156 | flex_sram_write(adapter, bank, addr & 0x7fff, buf, len); |
157 | } |
158 | |
159 | static void sram_read_chunk(struct adapter *adapter, u32 addr, u8 *buf, u16 len) |
160 | { |
161 | u32 bank; |
162 | bank = 0; |
163 | |
164 | if (adapter->dw_sram_type == 0x20000) { |
165 | bank = (addr & 0x18000) << 0x0d; |
166 | } |
167 | |
168 | if (adapter->dw_sram_type == 0x00000) { |
169 | if ((addr >> 0x0f) == 0) |
170 | bank = 0x20000000; |
171 | else |
172 | bank = 0x10000000; |
173 | } |
174 | flex_sram_read(adapter, bank, addr & 0x7fff, buf, len); |
175 | } |
176 | |
177 | static void sram_read(struct adapter *adapter, u32 addr, u8 *buf, u32 len) |
178 | { |
179 | u32 length; |
180 | while (len != 0) { |
181 | length = len; |
182 | /* check if the address range belongs to the same |
183 | * 32K memory chip. If not, the data is read |
184 | * from one chip at a time */ |
185 | if ((addr >> 0x0f) != ((addr + len - 1) >> 0x0f)) { |
186 | length = (((addr >> 0x0f) + 1) << 0x0f) - addr; |
187 | } |
188 | |
189 | sram_read_chunk(adapter, addr, buf, length); |
190 | addr = addr + length; |
191 | buf = buf + length; |
192 | len = len - length; |
193 | } |
194 | } |
195 | |
196 | static void sram_write(struct adapter *adapter, u32 addr, u8 *buf, u32 len) |
197 | { |
198 | u32 length; |
199 | while (len != 0) { |
200 | length = len; |
201 | |
202 | /* check if the address range belongs to the same |
203 | * 32K memory chip. If not, the data is |
204 | * written to one chip at a time */ |
205 | if ((addr >> 0x0f) != ((addr + len - 1) >> 0x0f)) { |
206 | length = (((addr >> 0x0f) + 1) << 0x0f) - addr; |
207 | } |
208 | |
209 | sram_write_chunk(adapter, addr, buf, length); |
210 | addr = addr + length; |
211 | buf = buf + length; |
212 | len = len - length; |
213 | } |
214 | } |
215 | |
216 | static void sram_set_size(struct adapter *adapter, u32 mask) |
217 | { |
218 | write_reg_dw(adapter, 0x71c, |
219 | (mask | (~0x30000 & read_reg_dw(adapter, 0x71c)))); |
220 | } |
221 | |
222 | static void sram_init(struct adapter *adapter) |
223 | { |
224 | u32 tmp; |
225 | tmp = read_reg_dw(adapter, 0x71c); |
226 | write_reg_dw(adapter, 0x71c, 1); |
227 | |
228 | if (read_reg_dw(adapter, 0x71c) != 0) { |
229 | write_reg_dw(adapter, 0x71c, tmp); |
230 | adapter->dw_sram_type = tmp & 0x30000; |
231 | ddprintk("%s: dw_sram_type = %x\n" , __func__, adapter->dw_sram_type); |
232 | } else { |
233 | adapter->dw_sram_type = 0x10000; |
234 | ddprintk("%s: dw_sram_type = %x\n" , __func__, adapter->dw_sram_type); |
235 | } |
236 | } |
237 | |
238 | static int sram_test_location(struct adapter *adapter, u32 mask, u32 addr) |
239 | { |
240 | u8 tmp1, tmp2; |
241 | dprintk("%s: mask = %x, addr = %x\n" , __func__, mask, addr); |
242 | |
243 | sram_set_size(adapter, mask); |
244 | sram_init(adapter); |
245 | |
246 | tmp2 = 0xa5; |
247 | tmp1 = 0x4f; |
248 | |
249 | sram_write(adapter, addr, &tmp2, 1); |
250 | sram_write(adapter, addr + 4, &tmp1, 1); |
251 | |
252 | tmp2 = 0; |
253 | mdelay(20); |
254 | |
255 | sram_read(adapter, addr, &tmp2, 1); |
256 | sram_read(adapter, addr, &tmp2, 1); |
257 | |
258 | dprintk("%s: wrote 0xa5, read 0x%2x\n" , __func__, tmp2); |
259 | |
260 | if (tmp2 != 0xa5) |
261 | return 0; |
262 | |
263 | tmp2 = 0x5a; |
264 | tmp1 = 0xf4; |
265 | |
266 | sram_write(adapter, addr, &tmp2, 1); |
267 | sram_write(adapter, addr + 4, &tmp1, 1); |
268 | |
269 | tmp2 = 0; |
270 | mdelay(20); |
271 | |
272 | sram_read(adapter, addr, &tmp2, 1); |
273 | sram_read(adapter, addr, &tmp2, 1); |
274 | |
275 | dprintk("%s: wrote 0x5a, read 0x%2x\n" , __func__, tmp2); |
276 | |
277 | if (tmp2 != 0x5a) |
278 | return 0; |
279 | return 1; |
280 | } |
281 | |
282 | static u32 sram_length(struct adapter *adapter) |
283 | { |
284 | if (adapter->dw_sram_type == 0x10000) |
285 | return 32768; /* 32K */ |
286 | if (adapter->dw_sram_type == 0x00000) |
287 | return 65536; /* 64K */ |
288 | if (adapter->dw_sram_type == 0x20000) |
289 | return 131072; /* 128K */ |
290 | return 32768; /* 32K */ |
291 | } |
292 | |
293 | /* FlexcopII can work with 32K, 64K or 128K of external SRAM memory. |
294 | - for 128K there are 4x32K chips at bank 0,1,2,3. |
295 | - for 64K there are 2x32K chips at bank 1,2. |
296 | - for 32K there is one 32K chip at bank 0. |
297 | |
298 | FlexCop works only with one bank at a time. The bank is selected |
299 | by bits 28-29 of the 0x700 register. |
300 | |
301 | bank 0 covers addresses 0x00000-0x07fff |
302 | bank 1 covers addresses 0x08000-0x0ffff |
303 | bank 2 covers addresses 0x10000-0x17fff |
304 | bank 3 covers addresses 0x18000-0x1ffff */ |
305 | |
306 | static int flexcop_sram_detect(struct flexcop_device *fc) |
307 | { |
308 | flexcop_ibi_value r208, r71c_0, vr71c_1; |
309 | r208 = fc->read_ibi_reg(fc, ctrl_208); |
310 | fc->write_ibi_reg(fc, ctrl_208, ibi_zero); |
311 | |
312 | r71c_0 = fc->read_ibi_reg(fc, wan_ctrl_reg_71c); |
313 | write_reg_dw(adapter, 0x71c, 1); |
314 | tmp3 = read_reg_dw(adapter, 0x71c); |
315 | dprintk("%s: tmp3 = %x\n" , __func__, tmp3); |
316 | write_reg_dw(adapter, 0x71c, tmp2); |
317 | |
318 | // check for internal SRAM ??? |
319 | tmp3--; |
320 | if (tmp3 != 0) { |
321 | sram_set_size(adapter, 0x10000); |
322 | sram_init(adapter); |
323 | write_reg_dw(adapter, 0x208, tmp); |
324 | dprintk("%s: sram size = 32K\n" , __func__); |
325 | return 32; |
326 | } |
327 | |
328 | if (sram_test_location(adapter, 0x20000, 0x18000) != 0) { |
329 | sram_set_size(adapter, 0x20000); |
330 | sram_init(adapter); |
331 | write_reg_dw(adapter, 0x208, tmp); |
332 | dprintk("%s: sram size = 128K\n" , __func__); |
333 | return 128; |
334 | } |
335 | |
336 | if (sram_test_location(adapter, 0x00000, 0x10000) != 0) { |
337 | sram_set_size(adapter, 0x00000); |
338 | sram_init(adapter); |
339 | write_reg_dw(adapter, 0x208, tmp); |
340 | dprintk("%s: sram size = 64K\n" , __func__); |
341 | return 64; |
342 | } |
343 | |
344 | if (sram_test_location(adapter, 0x10000, 0x00000) != 0) { |
345 | sram_set_size(adapter, 0x10000); |
346 | sram_init(adapter); |
347 | write_reg_dw(adapter, 0x208, tmp); |
348 | dprintk("%s: sram size = 32K\n" , __func__); |
349 | return 32; |
350 | } |
351 | |
352 | sram_set_size(adapter, 0x10000); |
353 | sram_init(adapter); |
354 | write_reg_dw(adapter, 0x208, tmp); |
355 | dprintk("%s: SRAM detection failed. Set to 32K \n" , __func__); |
356 | return 0; |
357 | } |
358 | |
359 | static void sll_detect_sram_size(struct adapter *adapter) |
360 | { |
361 | sram_detect_for_flex2(adapter); |
362 | } |
363 | |
364 | #endif |
365 | |