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