]>
Commit | Line | Data |
---|---|---|
1a59d1b8 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
1da177e4 LT |
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 | *----------------------------------------------------------------------------- | |
1da177e4 LT |
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 | |
b37df489 | 82 | sym_Symbios_setup_target(struct sym_tcb *tp, int target, Symbios_nvram *nvram) |
1da177e4 | 83 | { |
1da177e4 LT |
84 | Symbios_target *tn = &nvram->target[target]; |
85 | ||
b37df489 MW |
86 | if (!(tn->flags & SYMBIOS_QUEUE_TAGS_ENABLED)) |
87 | tp->usrtags = 0; | |
1da177e4 LT |
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; | |
b37df489 MW |
94 | tp->usr_period = (tn->sync_period + 3) / 4; |
95 | tp->usr_width = (tn->bus_width == 0x8) ? 0 : 1; | |
1da177e4 LT |
96 | } |
97 | ||
b37df489 MW |
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 | ||
1da177e4 LT |
102 | /* |
103 | * Get target set-up from Tekram format NVRAM. | |
104 | */ | |
105 | static void | |
b37df489 | 106 | sym_Tekram_setup_target(struct sym_tcb *tp, int target, Tekram_nvram *nvram) |
1da177e4 | 107 | { |
1da177e4 LT |
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 | ||
b37df489 MW |
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; | |
1da177e4 LT |
120 | } |
121 | ||
122 | /* | |
123 | * Get target setup from NVRAM. | |
124 | */ | |
b37df489 | 125 | void sym_nvram_setup_target(struct sym_tcb *tp, int target, struct sym_nvram *nvp) |
1da177e4 LT |
126 | { |
127 | switch (nvp->type) { | |
128 | case SYM_SYMBIOS_NVRAM: | |
b37df489 | 129 | sym_Symbios_setup_target(tp, target, &nvp->data.Symbios); |
1da177e4 LT |
130 | break; |
131 | case SYM_TEKRAM_NVRAM: | |
b37df489 | 132 | sym_Tekram_setup_target(tp, target, &nvp->data.Tekram); |
1da177e4 LT |
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 | * | |
08fcc87b | 230 | * GPIO0 - data in/data out |
1da177e4 LT |
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); | |
53222b90 | 263 | INB(np, nc_mbox1); |
1da177e4 LT |
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, 1, gpreg, SET_BIT); | |
273 | S24C16_set_bit(np, 0, gpreg, SET_CLK); | |
274 | S24C16_set_bit(np, 0, gpreg, CLR_BIT); | |
275 | S24C16_set_bit(np, 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, 0, gpreg, SET_CLK); | |
284 | S24C16_set_bit(np, 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, 0, gpreg, SET_CLK); | |
296 | if (read_bit) | |
297 | *read_bit = INB(np, nc_gpreg); | |
298 | S24C16_set_bit(np, 0, gpreg, CLR_CLK); | |
299 | S24C16_set_bit(np, 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, 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_data >> (7 - x)) & 0x01, gpreg); | |
337 | ||
338 | S24C16_read_ack(np, 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, 1, gpreg); | |
354 | *read_data |= ((read_bit & 0x01) << (7 - x)); | |
355 | } | |
356 | ||
357 | S24C16_write_ack(np, ack_data, gpreg, gpcntl); | |
358 | } | |
359 | ||
44456d37 | 360 | #ifdef SYM_CONF_NVRAM_WRITE_SUPPORT |
1da177e4 LT |
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, 0, &gpreg, CLR_CLK); | |
438 | S24C16_set_bit(np, 0, &gpreg, CLR_BIT); | |
439 | ||
440 | /* now set NVRAM inactive with GPIO0/1 both high */ | |
441 | S24C16_stop(np, &gpreg); | |
442 | ||
443 | /* activate NVRAM */ | |
444 | S24C16_start(np, &gpreg); | |
445 | ||
446 | /* write device code and random address MSB */ | |
447 | S24C16_write_byte(np, &ack_data, | |
448 | 0xa0 | ((offset >> 7) & 0x0e), &gpreg, &gpcntl); | |
449 | if (ack_data & 0x01) | |
450 | goto out; | |
451 | ||
452 | /* write random address LSB */ | |
453 | S24C16_write_byte(np, &ack_data, | |
454 | offset & 0xff, &gpreg, &gpcntl); | |
455 | if (ack_data & 0x01) | |
456 | goto out; | |
457 | ||
458 | /* regenerate START state to set up for reading */ | |
459 | S24C16_start(np, &gpreg); | |
460 | ||
461 | /* rewrite device code and address MSB with read bit set (lsb = 0x01) */ | |
462 | S24C16_write_byte(np, &ack_data, | |
463 | 0xa1 | ((offset >> 7) & 0x0e), &gpreg, &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, &data[x], (x == (len-1)), &gpreg, &gpcntl); | |
474 | ||
475 | /* finally put NVRAM back in inactive mode */ | |
476 | gpcntl &= 0xfe; | |
477 | OUTB(np, nc_gpcntl, gpcntl); | |
478 | S24C16_stop(np, &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(nvram->trailer, Symbios_trailer, 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 | * | |
08fcc87b | 527 | * GPIO0 - data in |
1da177e4 LT |
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); | |
53222b90 | 541 | INB(np, nc_mbox1); |
1da177e4 LT |
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); | |
53222b90 | 569 | INB(np, nc_mbox1); |
1da177e4 LT |
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); | |
53222b90 | 582 | INB(np, nc_mbox1); |
1da177e4 LT |
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, (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, 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, 0x180 | x, &read_bit, gpreg); | |
635 | if (read_bit & 0x01) | |
636 | return 1; /* Bad */ | |
637 | T93C46_Read_Word(np, &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; | |
1d4f4a5e | 651 | int retv; |
1da177e4 LT |
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, (u_short *) nvram, | |
666 | sizeof(*nvram) / sizeof(short), &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 | ||
e58bc06e | 686 | switch (np->pdev->device) { |
1da177e4 LT |
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; | |
df561f66 | 698 | fallthrough; |
1da177e4 LT |
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 | |
53222b90 MW |
731 | static inline int sym_read_parisc_pdc(struct sym_device *np, |
732 | struct pdc_initiator *x) | |
1da177e4 LT |
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, &nvp->data.Symbios)) { | |
744 | nvp->type = SYM_SYMBIOS_NVRAM; | |
745 | sym_display_Symbios_nvram(np, &nvp->data.Symbios); | |
746 | } else if (!sym_read_Tekram_nvram(np, &nvp->data.Tekram)) { | |
747 | nvp->type = SYM_TEKRAM_NVRAM; | |
748 | sym_display_Tekram_nvram(np, &nvp->data.Tekram); | |
749 | } else { | |
750 | nvp->type = sym_read_parisc_pdc(np, &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 | } |