1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Device driver for the SYMBIOS/LSILOGIC 53C8XX and 53C1010 family |
4 | * of PCI-SCSI IO processors. |
5 | * |
6 | * Copyright (C) 1999-2001 Gerard Roudier <groudier@free.fr> |
7 | * |
8 | * This driver is derived from the Linux sym53c8xx driver. |
9 | * Copyright (C) 1998-2000 Gerard Roudier |
10 | * |
11 | * The sym53c8xx driver is derived from the ncr53c8xx driver that had been |
12 | * a port of the FreeBSD ncr driver to Linux-1.2.13. |
13 | * |
14 | * The original ncr driver has been written for 386bsd and FreeBSD by |
15 | * Wolfgang Stanglmeier <wolf@cologne.de> |
16 | * Stefan Esser <se@mi.Uni-Koeln.de> |
17 | * Copyright (C) 1994 Wolfgang Stanglmeier |
18 | * |
19 | * Other major contributions: |
20 | * |
21 | * NVRAM detection and reading. |
22 | * Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk> |
23 | * |
24 | *----------------------------------------------------------------------------- |
25 | */ |
26 | |
27 | #include "sym_glue.h" |
28 | #include "sym_nvram.h" |
29 | |
30 | #ifdef SYM_CONF_DEBUG_NVRAM |
31 | static u_char Tekram_boot_delay[7] = {3, 5, 10, 20, 30, 60, 120}; |
32 | #endif |
33 | |
34 | /* |
35 | * Get host setup from NVRAM. |
36 | */ |
37 | void sym_nvram_setup_host(struct Scsi_Host *shost, struct sym_hcb *np, struct sym_nvram *nvram) |
38 | { |
39 | /* |
40 | * Get parity checking, host ID, verbose mode |
41 | * and miscellaneous host flags from NVRAM. |
42 | */ |
43 | switch (nvram->type) { |
44 | case SYM_SYMBIOS_NVRAM: |
45 | if (!(nvram->data.Symbios.flags & SYMBIOS_PARITY_ENABLE)) |
46 | np->rv_scntl0 &= ~0x0a; |
47 | np->myaddr = nvram->data.Symbios.host_id & 0x0f; |
48 | if (nvram->data.Symbios.flags & SYMBIOS_VERBOSE_MSGS) |
49 | np->verbose += 1; |
50 | if (nvram->data.Symbios.flags1 & SYMBIOS_SCAN_HI_LO) |
51 | shost->reverse_ordering = 1; |
52 | if (nvram->data.Symbios.flags2 & SYMBIOS_AVOID_BUS_RESET) |
53 | np->usrflags |= SYM_AVOID_BUS_RESET; |
54 | break; |
55 | case SYM_TEKRAM_NVRAM: |
56 | np->myaddr = nvram->data.Tekram.host_id & 0x0f; |
57 | break; |
58 | #ifdef CONFIG_PARISC |
59 | case SYM_PARISC_PDC: |
60 | if (nvram->data.parisc.host_id != -1) |
61 | np->myaddr = nvram->data.parisc.host_id; |
62 | if (nvram->data.parisc.factor != -1) |
63 | np->minsync = nvram->data.parisc.factor; |
64 | if (nvram->data.parisc.width != -1) |
65 | np->maxwide = nvram->data.parisc.width; |
66 | switch (nvram->data.parisc.mode) { |
67 | case 0: np->scsi_mode = SMODE_SE; break; |
68 | case 1: np->scsi_mode = SMODE_HVD; break; |
69 | case 2: np->scsi_mode = SMODE_LVD; break; |
70 | default: break; |
71 | } |
72 | #endif |
73 | default: |
74 | break; |
75 | } |
76 | } |
77 | |
78 | /* |
79 | * Get target set-up from Symbios format NVRAM. |
80 | */ |
81 | static void |
82 | sym_Symbios_setup_target(struct sym_tcb *tp, int target, Symbios_nvram *nvram) |
83 | { |
84 | Symbios_target *tn = &nvram->target[target]; |
85 | |
86 | if (!(tn->flags & SYMBIOS_QUEUE_TAGS_ENABLED)) |
87 | tp->usrtags = 0; |
88 | if (!(tn->flags & SYMBIOS_DISCONNECT_ENABLE)) |
89 | tp->usrflags &= ~SYM_DISC_ENABLED; |
90 | if (!(tn->flags & SYMBIOS_SCAN_AT_BOOT_TIME)) |
91 | tp->usrflags |= SYM_SCAN_BOOT_DISABLED; |
92 | if (!(tn->flags & SYMBIOS_SCAN_LUNS)) |
93 | tp->usrflags |= SYM_SCAN_LUNS_DISABLED; |
94 | tp->usr_period = (tn->sync_period + 3) / 4; |
95 | tp->usr_width = (tn->bus_width == 0x8) ? 0 : 1; |
96 | } |
97 | |
98 | static const unsigned char Tekram_sync[16] = { |
99 | 25, 31, 37, 43, 50, 62, 75, 125, 12, 15, 18, 21, 6, 7, 9, 10 |
100 | }; |
101 | |
102 | /* |
103 | * Get target set-up from Tekram format NVRAM. |
104 | */ |
105 | static void |
106 | sym_Tekram_setup_target(struct sym_tcb *tp, int target, Tekram_nvram *nvram) |
107 | { |
108 | struct Tekram_target *tn = &nvram->target[target]; |
109 | |
110 | if (tn->flags & TEKRAM_TAGGED_COMMANDS) { |
111 | tp->usrtags = 2 << nvram->max_tags_index; |
112 | } |
113 | |
114 | if (tn->flags & TEKRAM_DISCONNECT_ENABLE) |
115 | tp->usrflags |= SYM_DISC_ENABLED; |
116 | |
117 | if (tn->flags & TEKRAM_SYNC_NEGO) |
118 | tp->usr_period = Tekram_sync[tn->sync_index & 0xf]; |
119 | tp->usr_width = (tn->flags & TEKRAM_WIDE_NEGO) ? 1 : 0; |
120 | } |
121 | |
122 | /* |
123 | * Get target setup from NVRAM. |
124 | */ |
125 | void sym_nvram_setup_target(struct sym_tcb *tp, int target, struct sym_nvram *nvp) |
126 | { |
127 | switch (nvp->type) { |
128 | case SYM_SYMBIOS_NVRAM: |
129 | sym_Symbios_setup_target(tp, target, nvram: &nvp->data.Symbios); |
130 | break; |
131 | case SYM_TEKRAM_NVRAM: |
132 | sym_Tekram_setup_target(tp, target, nvram: &nvp->data.Tekram); |
133 | break; |
134 | default: |
135 | break; |
136 | } |
137 | } |
138 | |
139 | #ifdef SYM_CONF_DEBUG_NVRAM |
140 | /* |
141 | * Dump Symbios format NVRAM for debugging purpose. |
142 | */ |
143 | static void sym_display_Symbios_nvram(struct sym_device *np, Symbios_nvram *nvram) |
144 | { |
145 | int i; |
146 | |
147 | /* display Symbios nvram host data */ |
148 | printf("%s: HOST ID=%d%s%s%s%s%s%s\n" , |
149 | sym_name(np), nvram->host_id & 0x0f, |
150 | (nvram->flags & SYMBIOS_SCAM_ENABLE) ? " SCAM" :"" , |
151 | (nvram->flags & SYMBIOS_PARITY_ENABLE) ? " PARITY" :"" , |
152 | (nvram->flags & SYMBIOS_VERBOSE_MSGS) ? " VERBOSE" :"" , |
153 | (nvram->flags & SYMBIOS_CHS_MAPPING) ? " CHS_ALT" :"" , |
154 | (nvram->flags2 & SYMBIOS_AVOID_BUS_RESET)?" NO_RESET" :"" , |
155 | (nvram->flags1 & SYMBIOS_SCAN_HI_LO) ? " HI_LO" :"" ); |
156 | |
157 | /* display Symbios nvram drive data */ |
158 | for (i = 0 ; i < 15 ; i++) { |
159 | struct Symbios_target *tn = &nvram->target[i]; |
160 | printf("%s-%d:%s%s%s%s WIDTH=%d SYNC=%d TMO=%d\n" , |
161 | sym_name(np), i, |
162 | (tn->flags & SYMBIOS_DISCONNECT_ENABLE) ? " DISC" : "" , |
163 | (tn->flags & SYMBIOS_SCAN_AT_BOOT_TIME) ? " SCAN_BOOT" : "" , |
164 | (tn->flags & SYMBIOS_SCAN_LUNS) ? " SCAN_LUNS" : "" , |
165 | (tn->flags & SYMBIOS_QUEUE_TAGS_ENABLED)? " TCQ" : "" , |
166 | tn->bus_width, |
167 | tn->sync_period / 4, |
168 | tn->timeout); |
169 | } |
170 | } |
171 | |
172 | /* |
173 | * Dump TEKRAM format NVRAM for debugging purpose. |
174 | */ |
175 | static void sym_display_Tekram_nvram(struct sym_device *np, Tekram_nvram *nvram) |
176 | { |
177 | int i, tags, boot_delay; |
178 | char *rem; |
179 | |
180 | /* display Tekram nvram host data */ |
181 | tags = 2 << nvram->max_tags_index; |
182 | boot_delay = 0; |
183 | if (nvram->boot_delay_index < 6) |
184 | boot_delay = Tekram_boot_delay[nvram->boot_delay_index]; |
185 | switch ((nvram->flags & TEKRAM_REMOVABLE_FLAGS) >> 6) { |
186 | default: |
187 | case 0: rem = "" ; break; |
188 | case 1: rem = " REMOVABLE=boot device" ; break; |
189 | case 2: rem = " REMOVABLE=all" ; break; |
190 | } |
191 | |
192 | printf("%s: HOST ID=%d%s%s%s%s%s%s%s%s%s BOOT DELAY=%d tags=%d\n" , |
193 | sym_name(np), nvram->host_id & 0x0f, |
194 | (nvram->flags1 & SYMBIOS_SCAM_ENABLE) ? " SCAM" :"" , |
195 | (nvram->flags & TEKRAM_MORE_THAN_2_DRIVES) ? " >2DRIVES" :"" , |
196 | (nvram->flags & TEKRAM_DRIVES_SUP_1GB) ? " >1GB" :"" , |
197 | (nvram->flags & TEKRAM_RESET_ON_POWER_ON) ? " RESET" :"" , |
198 | (nvram->flags & TEKRAM_ACTIVE_NEGATION) ? " ACT_NEG" :"" , |
199 | (nvram->flags & TEKRAM_IMMEDIATE_SEEK) ? " IMM_SEEK" :"" , |
200 | (nvram->flags & TEKRAM_SCAN_LUNS) ? " SCAN_LUNS" :"" , |
201 | (nvram->flags1 & TEKRAM_F2_F6_ENABLED) ? " F2_F6" :"" , |
202 | rem, boot_delay, tags); |
203 | |
204 | /* display Tekram nvram drive data */ |
205 | for (i = 0; i <= 15; i++) { |
206 | int sync, j; |
207 | struct Tekram_target *tn = &nvram->target[i]; |
208 | j = tn->sync_index & 0xf; |
209 | sync = Tekram_sync[j]; |
210 | printf("%s-%d:%s%s%s%s%s%s PERIOD=%d\n" , |
211 | sym_name(np), i, |
212 | (tn->flags & TEKRAM_PARITY_CHECK) ? " PARITY" : "" , |
213 | (tn->flags & TEKRAM_SYNC_NEGO) ? " SYNC" : "" , |
214 | (tn->flags & TEKRAM_DISCONNECT_ENABLE) ? " DISC" : "" , |
215 | (tn->flags & TEKRAM_START_CMD) ? " START" : "" , |
216 | (tn->flags & TEKRAM_TAGGED_COMMANDS) ? " TCQ" : "" , |
217 | (tn->flags & TEKRAM_WIDE_NEGO) ? " WIDE" : "" , |
218 | sync); |
219 | } |
220 | } |
221 | #else |
222 | static void sym_display_Symbios_nvram(struct sym_device *np, Symbios_nvram *nvram) { (void)np; (void)nvram; } |
223 | static void sym_display_Tekram_nvram(struct sym_device *np, Tekram_nvram *nvram) { (void)np; (void)nvram; } |
224 | #endif /* SYM_CONF_DEBUG_NVRAM */ |
225 | |
226 | |
227 | /* |
228 | * 24C16 EEPROM reading. |
229 | * |
230 | * GPIO0 - data in/data out |
231 | * GPIO1 - clock |
232 | * Symbios NVRAM wiring now also used by Tekram. |
233 | */ |
234 | |
235 | #define SET_BIT 0 |
236 | #define CLR_BIT 1 |
237 | #define SET_CLK 2 |
238 | #define CLR_CLK 3 |
239 | |
240 | /* |
241 | * Set/clear data/clock bit in GPIO0 |
242 | */ |
243 | static void S24C16_set_bit(struct sym_device *np, u_char write_bit, u_char *gpreg, |
244 | int bit_mode) |
245 | { |
246 | udelay(5); |
247 | switch (bit_mode) { |
248 | case SET_BIT: |
249 | *gpreg |= write_bit; |
250 | break; |
251 | case CLR_BIT: |
252 | *gpreg &= 0xfe; |
253 | break; |
254 | case SET_CLK: |
255 | *gpreg |= 0x02; |
256 | break; |
257 | case CLR_CLK: |
258 | *gpreg &= 0xfd; |
259 | break; |
260 | |
261 | } |
262 | OUTB(np, nc_gpreg, *gpreg); |
263 | INB(np, nc_mbox1); |
264 | udelay(5); |
265 | } |
266 | |
267 | /* |
268 | * Send START condition to NVRAM to wake it up. |
269 | */ |
270 | static void S24C16_start(struct sym_device *np, u_char *gpreg) |
271 | { |
272 | S24C16_set_bit(np, write_bit: 1, gpreg, SET_BIT); |
273 | S24C16_set_bit(np, write_bit: 0, gpreg, SET_CLK); |
274 | S24C16_set_bit(np, write_bit: 0, gpreg, CLR_BIT); |
275 | S24C16_set_bit(np, write_bit: 0, gpreg, CLR_CLK); |
276 | } |
277 | |
278 | /* |
279 | * Send STOP condition to NVRAM - puts NVRAM to sleep... ZZzzzz!! |
280 | */ |
281 | static void S24C16_stop(struct sym_device *np, u_char *gpreg) |
282 | { |
283 | S24C16_set_bit(np, write_bit: 0, gpreg, SET_CLK); |
284 | S24C16_set_bit(np, write_bit: 1, gpreg, SET_BIT); |
285 | } |
286 | |
287 | /* |
288 | * Read or write a bit to the NVRAM, |
289 | * read if GPIO0 input else write if GPIO0 output |
290 | */ |
291 | static void S24C16_do_bit(struct sym_device *np, u_char *read_bit, u_char write_bit, |
292 | u_char *gpreg) |
293 | { |
294 | S24C16_set_bit(np, write_bit, gpreg, SET_BIT); |
295 | S24C16_set_bit(np, write_bit: 0, gpreg, SET_CLK); |
296 | if (read_bit) |
297 | *read_bit = INB(np, nc_gpreg); |
298 | S24C16_set_bit(np, write_bit: 0, gpreg, CLR_CLK); |
299 | S24C16_set_bit(np, write_bit: 0, gpreg, CLR_BIT); |
300 | } |
301 | |
302 | /* |
303 | * Output an ACK to the NVRAM after reading, |
304 | * change GPIO0 to output and when done back to an input |
305 | */ |
306 | static void S24C16_write_ack(struct sym_device *np, u_char write_bit, u_char *gpreg, |
307 | u_char *gpcntl) |
308 | { |
309 | OUTB(np, nc_gpcntl, *gpcntl & 0xfe); |
310 | S24C16_do_bit(np, NULL, write_bit, gpreg); |
311 | OUTB(np, nc_gpcntl, *gpcntl); |
312 | } |
313 | |
314 | /* |
315 | * Input an ACK from NVRAM after writing, |
316 | * change GPIO0 to input and when done back to an output |
317 | */ |
318 | static void S24C16_read_ack(struct sym_device *np, u_char *read_bit, u_char *gpreg, |
319 | u_char *gpcntl) |
320 | { |
321 | OUTB(np, nc_gpcntl, *gpcntl | 0x01); |
322 | S24C16_do_bit(np, read_bit, write_bit: 1, gpreg); |
323 | OUTB(np, nc_gpcntl, *gpcntl); |
324 | } |
325 | |
326 | /* |
327 | * WRITE a byte to the NVRAM and then get an ACK to see it was accepted OK, |
328 | * GPIO0 must already be set as an output |
329 | */ |
330 | static void S24C16_write_byte(struct sym_device *np, u_char *ack_data, u_char write_data, |
331 | u_char *gpreg, u_char *gpcntl) |
332 | { |
333 | int x; |
334 | |
335 | for (x = 0; x < 8; x++) |
336 | S24C16_do_bit(np, NULL, write_bit: (write_data >> (7 - x)) & 0x01, gpreg); |
337 | |
338 | S24C16_read_ack(np, read_bit: ack_data, gpreg, gpcntl); |
339 | } |
340 | |
341 | /* |
342 | * READ a byte from the NVRAM and then send an ACK to say we have got it, |
343 | * GPIO0 must already be set as an input |
344 | */ |
345 | static void S24C16_read_byte(struct sym_device *np, u_char *read_data, u_char ack_data, |
346 | u_char *gpreg, u_char *gpcntl) |
347 | { |
348 | int x; |
349 | u_char read_bit; |
350 | |
351 | *read_data = 0; |
352 | for (x = 0; x < 8; x++) { |
353 | S24C16_do_bit(np, read_bit: &read_bit, write_bit: 1, gpreg); |
354 | *read_data |= ((read_bit & 0x01) << (7 - x)); |
355 | } |
356 | |
357 | S24C16_write_ack(np, write_bit: ack_data, gpreg, gpcntl); |
358 | } |
359 | |
360 | #ifdef SYM_CONF_NVRAM_WRITE_SUPPORT |
361 | /* |
362 | * Write 'len' bytes starting at 'offset'. |
363 | */ |
364 | static int sym_write_S24C16_nvram(struct sym_device *np, int offset, |
365 | u_char *data, int len) |
366 | { |
367 | u_char gpcntl, gpreg; |
368 | u_char old_gpcntl, old_gpreg; |
369 | u_char ack_data; |
370 | int x; |
371 | |
372 | /* save current state of GPCNTL and GPREG */ |
373 | old_gpreg = INB(np, nc_gpreg); |
374 | old_gpcntl = INB(np, nc_gpcntl); |
375 | gpcntl = old_gpcntl & 0x1c; |
376 | |
377 | /* set up GPREG & GPCNTL to set GPIO0 and GPIO1 in to known state */ |
378 | OUTB(np, nc_gpreg, old_gpreg); |
379 | OUTB(np, nc_gpcntl, gpcntl); |
380 | |
381 | /* this is to set NVRAM into a known state with GPIO0/1 both low */ |
382 | gpreg = old_gpreg; |
383 | S24C16_set_bit(np, 0, &gpreg, CLR_CLK); |
384 | S24C16_set_bit(np, 0, &gpreg, CLR_BIT); |
385 | |
386 | /* now set NVRAM inactive with GPIO0/1 both high */ |
387 | S24C16_stop(np, &gpreg); |
388 | |
389 | /* NVRAM has to be written in segments of 16 bytes */ |
390 | for (x = 0; x < len ; x += 16) { |
391 | do { |
392 | S24C16_start(np, &gpreg); |
393 | S24C16_write_byte(np, &ack_data, |
394 | 0xa0 | (((offset+x) >> 7) & 0x0e), |
395 | &gpreg, &gpcntl); |
396 | } while (ack_data & 0x01); |
397 | |
398 | S24C16_write_byte(np, &ack_data, (offset+x) & 0xff, |
399 | &gpreg, &gpcntl); |
400 | |
401 | for (y = 0; y < 16; y++) |
402 | S24C16_write_byte(np, &ack_data, data[x+y], |
403 | &gpreg, &gpcntl); |
404 | S24C16_stop(np, &gpreg); |
405 | } |
406 | |
407 | /* return GPIO0/1 to original states after having accessed NVRAM */ |
408 | OUTB(np, nc_gpcntl, old_gpcntl); |
409 | OUTB(np, nc_gpreg, old_gpreg); |
410 | |
411 | return 0; |
412 | } |
413 | #endif /* SYM_CONF_NVRAM_WRITE_SUPPORT */ |
414 | |
415 | /* |
416 | * Read 'len' bytes starting at 'offset'. |
417 | */ |
418 | static int sym_read_S24C16_nvram(struct sym_device *np, int offset, u_char *data, int len) |
419 | { |
420 | u_char gpcntl, gpreg; |
421 | u_char old_gpcntl, old_gpreg; |
422 | u_char ack_data; |
423 | int retv = 1; |
424 | int x; |
425 | |
426 | /* save current state of GPCNTL and GPREG */ |
427 | old_gpreg = INB(np, nc_gpreg); |
428 | old_gpcntl = INB(np, nc_gpcntl); |
429 | gpcntl = old_gpcntl & 0x1c; |
430 | |
431 | /* set up GPREG & GPCNTL to set GPIO0 and GPIO1 in to known state */ |
432 | OUTB(np, nc_gpreg, old_gpreg); |
433 | OUTB(np, nc_gpcntl, gpcntl); |
434 | |
435 | /* this is to set NVRAM into a known state with GPIO0/1 both low */ |
436 | gpreg = old_gpreg; |
437 | S24C16_set_bit(np, write_bit: 0, gpreg: &gpreg, CLR_CLK); |
438 | S24C16_set_bit(np, write_bit: 0, gpreg: &gpreg, CLR_BIT); |
439 | |
440 | /* now set NVRAM inactive with GPIO0/1 both high */ |
441 | S24C16_stop(np, gpreg: &gpreg); |
442 | |
443 | /* activate NVRAM */ |
444 | S24C16_start(np, gpreg: &gpreg); |
445 | |
446 | /* write device code and random address MSB */ |
447 | S24C16_write_byte(np, ack_data: &ack_data, |
448 | write_data: 0xa0 | ((offset >> 7) & 0x0e), gpreg: &gpreg, gpcntl: &gpcntl); |
449 | if (ack_data & 0x01) |
450 | goto out; |
451 | |
452 | /* write random address LSB */ |
453 | S24C16_write_byte(np, ack_data: &ack_data, |
454 | write_data: offset & 0xff, gpreg: &gpreg, gpcntl: &gpcntl); |
455 | if (ack_data & 0x01) |
456 | goto out; |
457 | |
458 | /* regenerate START state to set up for reading */ |
459 | S24C16_start(np, gpreg: &gpreg); |
460 | |
461 | /* rewrite device code and address MSB with read bit set (lsb = 0x01) */ |
462 | S24C16_write_byte(np, ack_data: &ack_data, |
463 | write_data: 0xa1 | ((offset >> 7) & 0x0e), gpreg: &gpreg, gpcntl: &gpcntl); |
464 | if (ack_data & 0x01) |
465 | goto out; |
466 | |
467 | /* now set up GPIO0 for inputting data */ |
468 | gpcntl |= 0x01; |
469 | OUTB(np, nc_gpcntl, gpcntl); |
470 | |
471 | /* input all requested data - only part of total NVRAM */ |
472 | for (x = 0; x < len; x++) |
473 | S24C16_read_byte(np, read_data: &data[x], ack_data: (x == (len-1)), gpreg: &gpreg, gpcntl: &gpcntl); |
474 | |
475 | /* finally put NVRAM back in inactive mode */ |
476 | gpcntl &= 0xfe; |
477 | OUTB(np, nc_gpcntl, gpcntl); |
478 | S24C16_stop(np, gpreg: &gpreg); |
479 | retv = 0; |
480 | out: |
481 | /* return GPIO0/1 to original states after having accessed NVRAM */ |
482 | OUTB(np, nc_gpcntl, old_gpcntl); |
483 | OUTB(np, nc_gpreg, old_gpreg); |
484 | |
485 | return retv; |
486 | } |
487 | |
488 | #undef SET_BIT |
489 | #undef CLR_BIT |
490 | #undef SET_CLK |
491 | #undef CLR_CLK |
492 | |
493 | /* |
494 | * Try reading Symbios NVRAM. |
495 | * Return 0 if OK. |
496 | */ |
497 | static int sym_read_Symbios_nvram(struct sym_device *np, Symbios_nvram *nvram) |
498 | { |
499 | static u_char Symbios_trailer[6] = {0xfe, 0xfe, 0, 0, 0, 0}; |
500 | u_char *data = (u_char *) nvram; |
501 | int len = sizeof(*nvram); |
502 | u_short csum; |
503 | int x; |
504 | |
505 | /* probe the 24c16 and read the SYMBIOS 24c16 area */ |
506 | if (sym_read_S24C16_nvram (np, SYMBIOS_NVRAM_ADDRESS, data, len)) |
507 | return 1; |
508 | |
509 | /* check valid NVRAM signature, verify byte count and checksum */ |
510 | if (nvram->type != 0 || |
511 | memcmp(p: nvram->trailer, q: Symbios_trailer, size: 6) || |
512 | nvram->byte_count != len - 12) |
513 | return 1; |
514 | |
515 | /* verify checksum */ |
516 | for (x = 6, csum = 0; x < len - 6; x++) |
517 | csum += data[x]; |
518 | if (csum != nvram->checksum) |
519 | return 1; |
520 | |
521 | return 0; |
522 | } |
523 | |
524 | /* |
525 | * 93C46 EEPROM reading. |
526 | * |
527 | * GPIO0 - data in |
528 | * GPIO1 - data out |
529 | * GPIO2 - clock |
530 | * GPIO4 - chip select |
531 | * |
532 | * Used by Tekram. |
533 | */ |
534 | |
535 | /* |
536 | * Pulse clock bit in GPIO0 |
537 | */ |
538 | static void T93C46_Clk(struct sym_device *np, u_char *gpreg) |
539 | { |
540 | OUTB(np, nc_gpreg, *gpreg | 0x04); |
541 | INB(np, nc_mbox1); |
542 | udelay(2); |
543 | OUTB(np, nc_gpreg, *gpreg); |
544 | } |
545 | |
546 | /* |
547 | * Read bit from NVRAM |
548 | */ |
549 | static void T93C46_Read_Bit(struct sym_device *np, u_char *read_bit, u_char *gpreg) |
550 | { |
551 | udelay(2); |
552 | T93C46_Clk(np, gpreg); |
553 | *read_bit = INB(np, nc_gpreg); |
554 | } |
555 | |
556 | /* |
557 | * Write bit to GPIO0 |
558 | */ |
559 | static void T93C46_Write_Bit(struct sym_device *np, u_char write_bit, u_char *gpreg) |
560 | { |
561 | if (write_bit & 0x01) |
562 | *gpreg |= 0x02; |
563 | else |
564 | *gpreg &= 0xfd; |
565 | |
566 | *gpreg |= 0x10; |
567 | |
568 | OUTB(np, nc_gpreg, *gpreg); |
569 | INB(np, nc_mbox1); |
570 | udelay(2); |
571 | |
572 | T93C46_Clk(np, gpreg); |
573 | } |
574 | |
575 | /* |
576 | * Send STOP condition to NVRAM - puts NVRAM to sleep... ZZZzzz!! |
577 | */ |
578 | static void T93C46_Stop(struct sym_device *np, u_char *gpreg) |
579 | { |
580 | *gpreg &= 0xef; |
581 | OUTB(np, nc_gpreg, *gpreg); |
582 | INB(np, nc_mbox1); |
583 | udelay(2); |
584 | |
585 | T93C46_Clk(np, gpreg); |
586 | } |
587 | |
588 | /* |
589 | * Send read command and address to NVRAM |
590 | */ |
591 | static void T93C46_Send_Command(struct sym_device *np, u_short write_data, |
592 | u_char *read_bit, u_char *gpreg) |
593 | { |
594 | int x; |
595 | |
596 | /* send 9 bits, start bit (1), command (2), address (6) */ |
597 | for (x = 0; x < 9; x++) |
598 | T93C46_Write_Bit(np, write_bit: (u_char) (write_data >> (8 - x)), gpreg); |
599 | |
600 | *read_bit = INB(np, nc_gpreg); |
601 | } |
602 | |
603 | /* |
604 | * READ 2 bytes from the NVRAM |
605 | */ |
606 | static void T93C46_Read_Word(struct sym_device *np, |
607 | unsigned short *nvram_data, unsigned char *gpreg) |
608 | { |
609 | int x; |
610 | u_char read_bit; |
611 | |
612 | *nvram_data = 0; |
613 | for (x = 0; x < 16; x++) { |
614 | T93C46_Read_Bit(np, read_bit: &read_bit, gpreg); |
615 | |
616 | if (read_bit & 0x01) |
617 | *nvram_data |= (0x01 << (15 - x)); |
618 | else |
619 | *nvram_data &= ~(0x01 << (15 - x)); |
620 | } |
621 | } |
622 | |
623 | /* |
624 | * Read Tekram NvRAM data. |
625 | */ |
626 | static int T93C46_Read_Data(struct sym_device *np, unsigned short *data, |
627 | int len, unsigned char *gpreg) |
628 | { |
629 | int x; |
630 | |
631 | for (x = 0; x < len; x++) { |
632 | unsigned char read_bit; |
633 | /* output read command and address */ |
634 | T93C46_Send_Command(np, write_data: 0x180 | x, read_bit: &read_bit, gpreg); |
635 | if (read_bit & 0x01) |
636 | return 1; /* Bad */ |
637 | T93C46_Read_Word(np, nvram_data: &data[x], gpreg); |
638 | T93C46_Stop(np, gpreg); |
639 | } |
640 | |
641 | return 0; |
642 | } |
643 | |
644 | /* |
645 | * Try reading 93C46 Tekram NVRAM. |
646 | */ |
647 | static int sym_read_T93C46_nvram(struct sym_device *np, Tekram_nvram *nvram) |
648 | { |
649 | u_char gpcntl, gpreg; |
650 | u_char old_gpcntl, old_gpreg; |
651 | int retv; |
652 | |
653 | /* save current state of GPCNTL and GPREG */ |
654 | old_gpreg = INB(np, nc_gpreg); |
655 | old_gpcntl = INB(np, nc_gpcntl); |
656 | |
657 | /* set up GPREG & GPCNTL to set GPIO0/1/2/4 in to known state, 0 in, |
658 | 1/2/4 out */ |
659 | gpreg = old_gpreg & 0xe9; |
660 | OUTB(np, nc_gpreg, gpreg); |
661 | gpcntl = (old_gpcntl & 0xe9) | 0x09; |
662 | OUTB(np, nc_gpcntl, gpcntl); |
663 | |
664 | /* input all of NVRAM, 64 words */ |
665 | retv = T93C46_Read_Data(np, data: (u_short *) nvram, |
666 | len: sizeof(*nvram) / sizeof(short), gpreg: &gpreg); |
667 | |
668 | /* return GPIO0/1/2/4 to original states after having accessed NVRAM */ |
669 | OUTB(np, nc_gpcntl, old_gpcntl); |
670 | OUTB(np, nc_gpreg, old_gpreg); |
671 | |
672 | return retv; |
673 | } |
674 | |
675 | /* |
676 | * Try reading Tekram NVRAM. |
677 | * Return 0 if OK. |
678 | */ |
679 | static int sym_read_Tekram_nvram (struct sym_device *np, Tekram_nvram *nvram) |
680 | { |
681 | u_char *data = (u_char *) nvram; |
682 | int len = sizeof(*nvram); |
683 | u_short csum; |
684 | int x; |
685 | |
686 | switch (np->pdev->device) { |
687 | case PCI_DEVICE_ID_NCR_53C885: |
688 | case PCI_DEVICE_ID_NCR_53C895: |
689 | case PCI_DEVICE_ID_NCR_53C896: |
690 | x = sym_read_S24C16_nvram(np, TEKRAM_24C16_NVRAM_ADDRESS, |
691 | data, len); |
692 | break; |
693 | case PCI_DEVICE_ID_NCR_53C875: |
694 | x = sym_read_S24C16_nvram(np, TEKRAM_24C16_NVRAM_ADDRESS, |
695 | data, len); |
696 | if (!x) |
697 | break; |
698 | fallthrough; |
699 | default: |
700 | x = sym_read_T93C46_nvram(np, nvram); |
701 | break; |
702 | } |
703 | if (x) |
704 | return 1; |
705 | |
706 | /* verify checksum */ |
707 | for (x = 0, csum = 0; x < len - 1; x += 2) |
708 | csum += data[x] + (data[x+1] << 8); |
709 | if (csum != 0x1234) |
710 | return 1; |
711 | |
712 | return 0; |
713 | } |
714 | |
715 | #ifdef CONFIG_PARISC |
716 | /* |
717 | * Host firmware (PDC) keeps a table for altering SCSI capabilities. |
718 | * Many newer machines export one channel of 53c896 chip as SE, 50-pin HD. |
719 | * Also used for Multi-initiator SCSI clusters to set the SCSI Initiator ID. |
720 | */ |
721 | static int sym_read_parisc_pdc(struct sym_device *np, struct pdc_initiator *pdc) |
722 | { |
723 | struct hardware_path hwpath; |
724 | get_pci_node_path(np->pdev, &hwpath); |
725 | if (!pdc_get_initiator(&hwpath, pdc)) |
726 | return 0; |
727 | |
728 | return SYM_PARISC_PDC; |
729 | } |
730 | #else |
731 | static inline int sym_read_parisc_pdc(struct sym_device *np, |
732 | struct pdc_initiator *x) |
733 | { |
734 | return 0; |
735 | } |
736 | #endif |
737 | |
738 | /* |
739 | * Try reading Symbios or Tekram NVRAM |
740 | */ |
741 | int sym_read_nvram(struct sym_device *np, struct sym_nvram *nvp) |
742 | { |
743 | if (!sym_read_Symbios_nvram(np, nvram: &nvp->data.Symbios)) { |
744 | nvp->type = SYM_SYMBIOS_NVRAM; |
745 | sym_display_Symbios_nvram(np, nvram: &nvp->data.Symbios); |
746 | } else if (!sym_read_Tekram_nvram(np, nvram: &nvp->data.Tekram)) { |
747 | nvp->type = SYM_TEKRAM_NVRAM; |
748 | sym_display_Tekram_nvram(np, nvram: &nvp->data.Tekram); |
749 | } else { |
750 | nvp->type = sym_read_parisc_pdc(np, x: &nvp->data.parisc); |
751 | } |
752 | return nvp->type; |
753 | } |
754 | |
755 | char *sym_nvram_type(struct sym_nvram *nvp) |
756 | { |
757 | switch (nvp->type) { |
758 | case SYM_SYMBIOS_NVRAM: |
759 | return "Symbios NVRAM" ; |
760 | case SYM_TEKRAM_NVRAM: |
761 | return "Tekram NVRAM" ; |
762 | case SYM_PARISC_PDC: |
763 | return "PA-RISC Firmware" ; |
764 | default: |
765 | return "No NVRAM" ; |
766 | } |
767 | } |
768 | |