Merge branch 'linus'
[linux-2.6] / drivers / net / sk98lin / skvpd.c
1 /******************************************************************************
2  *
3  * Name:        skvpd.c
4  * Project:     GEnesis, PCI Gigabit Ethernet Adapter
5  * Version:     $Revision: 1.37 $
6  * Date:        $Date: 2003/01/13 10:42:45 $
7  * Purpose:     Shared software to read and write VPD data
8  *
9  ******************************************************************************/
10
11 /******************************************************************************
12  *
13  *      (C)Copyright 1998-2003 SysKonnect GmbH.
14  *
15  *      This program is free software; you can redistribute it and/or modify
16  *      it under the terms of the GNU General Public License as published by
17  *      the Free Software Foundation; either version 2 of the License, or
18  *      (at your option) any later version.
19  *
20  *      The information in this file is provided "AS IS" without warranty.
21  *
22  ******************************************************************************/
23
24 /*
25         Please refer skvpd.txt for infomation how to include this module
26  */
27 static const char SysKonnectFileId[] =
28         "@(#)$Id: skvpd.c,v 1.37 2003/01/13 10:42:45 rschmidt Exp $ (C) SK";
29
30 #include "h/skdrv1st.h"
31 #include "h/sktypes.h"
32 #include "h/skdebug.h"
33 #include "h/skdrv2nd.h"
34
35 /*
36  * Static functions
37  */
38 #ifndef SK_KR_PROTO
39 static SK_VPD_PARA      *vpd_find_para(
40         SK_AC   *pAC,
41         const char      *key,
42         SK_VPD_PARA *p);
43 #else   /* SK_KR_PROTO */
44 static SK_VPD_PARA      *vpd_find_para();
45 #endif  /* SK_KR_PROTO */
46
47 /*
48  * waits for a completion of a VPD transfer
49  * The VPD transfer must complete within SK_TICKS_PER_SEC/16
50  *
51  * returns      0:      success, transfer completes
52  *              error   exit(9) with a error message
53  */
54 static int VpdWait(
55 SK_AC   *pAC,   /* Adapters context */
56 SK_IOC  IoC,    /* IO Context */
57 int             event)  /* event to wait for (VPD_READ / VPD_write) completion*/
58 {
59         SK_U64  start_time;
60         SK_U16  state;
61
62         SK_DBG_MSG(pAC,SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
63                 ("VPD wait for %s\n", event?"Write":"Read"));
64         start_time = SkOsGetTime(pAC);
65         do {
66                 if (SkOsGetTime(pAC) - start_time > SK_TICKS_PER_SEC) {
67
68                         /* Bug fix AF: Thu Mar 28 2002
69                          * Do not call: VPD_STOP(pAC, IoC);
70                          * A pending VPD read cycle can not be aborted by writing
71                          * VPD_WRITE to the PCI_VPD_ADR_REG (VPD address register).
72                          * Although the write threshold in the OUR-register protects
73                          * VPD read only space from being overwritten this does not
74                          * protect a VPD read from being `converted` into a VPD write
75                          * operation (on the fly). As a consequence the VPD_STOP would
76                          * delete VPD read only data. In case of any problems with the
77                          * I2C bus we exit the loop here. The I2C read operation can
78                          * not be aborted except by a reset (->LR).
79                          */
80                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_FATAL | SK_DBGCAT_ERR,
81                                 ("ERROR:VPD wait timeout\n"));
82                         return(1);
83                 }
84                 
85                 VPD_IN16(pAC, IoC, PCI_VPD_ADR_REG, &state);
86                 
87                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
88                         ("state = %x, event %x\n",state,event));
89         } while((int)(state & PCI_VPD_FLAG) == event);
90
91         return(0);
92 }
93
94 #ifdef SKDIAG
95
96 /*
97  * Read the dword at address 'addr' from the VPD EEPROM.
98  *
99  * Needed Time: MIN 1,3 ms      MAX 2,6 ms
100  *
101  * Note: The DWord is returned in the endianess of the machine the routine
102  *       is running on.
103  *
104  * Returns the data read.
105  */
106 SK_U32 VpdReadDWord(
107 SK_AC   *pAC,   /* Adapters context */
108 SK_IOC  IoC,    /* IO Context */
109 int             addr)   /* VPD address */
110 {
111         SK_U32  Rtv;
112
113         /* start VPD read */
114         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
115                 ("VPD read dword at 0x%x\n",addr));
116         addr &= ~VPD_WRITE;             /* ensure the R/W bit is set to read */
117
118         VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, (SK_U16)addr);
119
120         /* ignore return code here */
121         (void)VpdWait(pAC, IoC, VPD_READ);
122
123         /* Don't swap here, it's a data stream of bytes */
124         Rtv = 0;
125
126         VPD_IN32(pAC, IoC, PCI_VPD_DAT_REG, &Rtv);
127         
128         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
129                 ("VPD read dword data = 0x%x\n",Rtv));
130         return(Rtv);
131 }
132
133 #endif  /* SKDIAG */
134
135 /*
136  *      Read one Stream of 'len' bytes of VPD data, starting at 'addr' from
137  *      or to the I2C EEPROM.
138  *
139  * Returns number of bytes read / written.
140  */
141 static int VpdWriteStream(
142 SK_AC   *pAC,   /* Adapters context */
143 SK_IOC  IoC,    /* IO Context */
144 char    *buf,   /* data buffer */
145 int             Addr,   /* VPD start address */
146 int             Len)    /* number of bytes to read / to write */
147 {
148         int             i;
149         int             j;
150         SK_U16  AdrReg;
151         int             Rtv;
152         SK_U8   * pComp;        /* Compare pointer */
153         SK_U8   Data;           /* Input Data for Compare */
154
155         /* Init Compare Pointer */
156         pComp = (SK_U8 *) buf;
157
158         for (i = 0; i < Len; i++, buf++) {
159                 if ((i%sizeof(SK_U32)) == 0) {
160                         /*
161                          * At the begin of each cycle read the Data Reg
162                          * So it is initialized even if only a few bytes
163                          * are written.
164                          */
165                         AdrReg = (SK_U16) Addr;
166                         AdrReg &= ~VPD_WRITE;   /* READ operation */
167
168                         VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
169
170                         /* Wait for termination */
171                         Rtv = VpdWait(pAC, IoC, VPD_READ);
172                         if (Rtv != 0) {
173                                 return(i);
174                         }
175                 }
176
177                 /* Write current Byte */
178                 VPD_OUT8(pAC, IoC, PCI_VPD_DAT_REG + (i%sizeof(SK_U32)),
179                                 *(SK_U8*)buf);
180
181                 if (((i%sizeof(SK_U32)) == 3) || (i == (Len - 1))) {
182                         /* New Address needs to be written to VPD_ADDR reg */
183                         AdrReg = (SK_U16) Addr;
184                         Addr += sizeof(SK_U32);
185                         AdrReg |= VPD_WRITE;    /* WRITE operation */
186
187                         VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
188
189                         /* Wait for termination */
190                         Rtv = VpdWait(pAC, IoC, VPD_WRITE);
191                         if (Rtv != 0) {
192                                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
193                                         ("Write Timed Out\n"));
194                                 return(i - (i%sizeof(SK_U32)));
195                         }
196
197                         /*
198                          * Now re-read to verify
199                          */
200                         AdrReg &= ~VPD_WRITE;   /* READ operation */
201
202                         VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
203
204                         /* Wait for termination */
205                         Rtv = VpdWait(pAC, IoC, VPD_READ);
206                         if (Rtv != 0) {
207                                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
208                                         ("Verify Timed Out\n"));
209                                 return(i - (i%sizeof(SK_U32)));
210                         }
211
212                         for (j = 0; j <= (int)(i%sizeof(SK_U32)); j++, pComp++) {
213                                 
214                                 VPD_IN8(pAC, IoC, PCI_VPD_DAT_REG + j, &Data);
215                                 
216                                 if (Data != *pComp) {
217                                         /* Verify Error */
218                                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
219                                                 ("WriteStream Verify Error\n"));
220                                         return(i - (i%sizeof(SK_U32)) + j);
221                                 }
222                         }
223                 }
224         }
225
226         return(Len);
227 }
228         
229
230 /*
231  *      Read one Stream of 'len' bytes of VPD data, starting at 'addr' from
232  *      or to the I2C EEPROM.
233  *
234  * Returns number of bytes read / written.
235  */
236 static int VpdReadStream(
237 SK_AC   *pAC,   /* Adapters context */
238 SK_IOC  IoC,    /* IO Context */
239 char    *buf,   /* data buffer */
240 int             Addr,   /* VPD start address */
241 int             Len)    /* number of bytes to read / to write */
242 {
243         int             i;
244         SK_U16  AdrReg;
245         int             Rtv;
246
247         for (i = 0; i < Len; i++, buf++) {
248                 if ((i%sizeof(SK_U32)) == 0) {
249                         /* New Address needs to be written to VPD_ADDR reg */
250                         AdrReg = (SK_U16) Addr;
251                         Addr += sizeof(SK_U32);
252                         AdrReg &= ~VPD_WRITE;   /* READ operation */
253
254                         VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
255
256                         /* Wait for termination */
257                         Rtv = VpdWait(pAC, IoC, VPD_READ);
258                         if (Rtv != 0) {
259                                 return(i);
260                         }
261                 }
262                 VPD_IN8(pAC, IoC, PCI_VPD_DAT_REG + (i%sizeof(SK_U32)),
263                         (SK_U8 *)buf);
264         }
265
266         return(Len);
267 }
268
269 /*
270  *      Read ore writes 'len' bytes of VPD data, starting at 'addr' from
271  *      or to the I2C EEPROM.
272  *
273  * Returns number of bytes read / written.
274  */
275 static int VpdTransferBlock(
276 SK_AC   *pAC,   /* Adapters context */
277 SK_IOC  IoC,    /* IO Context */
278 char    *buf,   /* data buffer */
279 int             addr,   /* VPD start address */
280 int             len,    /* number of bytes to read / to write */
281 int             dir)    /* transfer direction may be VPD_READ or VPD_WRITE */
282 {
283         int             Rtv;    /* Return value */
284         int             vpd_rom_size;
285
286         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
287                 ("VPD %s block, addr = 0x%x, len = %d\n",
288                 dir ? "write" : "read", addr, len));
289
290         if (len == 0)
291                 return(0);
292
293         vpd_rom_size = pAC->vpd.rom_size;
294         
295         if (addr > vpd_rom_size - 4) {
296                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
297                         ("Address error: 0x%x, exp. < 0x%x\n",
298                         addr, vpd_rom_size - 4));
299                 return(0);
300         }
301         
302         if (addr + len > vpd_rom_size) {
303                 len = vpd_rom_size - addr;
304                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
305                         ("Warning: len was cut to %d\n", len));
306         }
307
308         if (dir == VPD_READ) {
309                 Rtv = VpdReadStream(pAC, IoC, buf, addr, len);
310         }
311         else {
312                 Rtv = VpdWriteStream(pAC, IoC, buf, addr, len);
313         }
314
315         return(Rtv);
316 }
317
318 #ifdef SKDIAG
319
320 /*
321  *      Read 'len' bytes of VPD data, starting at 'addr'.
322  *
323  * Returns number of bytes read.
324  */
325 int VpdReadBlock(
326 SK_AC   *pAC,   /* pAC pointer */
327 SK_IOC  IoC,    /* IO Context */
328 char    *buf,   /* buffer were the data should be stored */
329 int             addr,   /* start reading at the VPD address */
330 int             len)    /* number of bytes to read */
331 {
332         return(VpdTransferBlock(pAC, IoC, buf, addr, len, VPD_READ));
333 }
334
335 /*
336  *      Write 'len' bytes of *but to the VPD EEPROM, starting at 'addr'.
337  *
338  * Returns number of bytes writes.
339  */
340 int VpdWriteBlock(
341 SK_AC   *pAC,   /* pAC pointer */
342 SK_IOC  IoC,    /* IO Context */
343 char    *buf,   /* buffer, holds the data to write */
344 int             addr,   /* start writing at the VPD address */
345 int             len)    /* number of bytes to write */
346 {
347         return(VpdTransferBlock(pAC, IoC, buf, addr, len, VPD_WRITE));
348 }
349 #endif  /* SKDIAG */
350
351 /*
352  * (re)initialize the VPD buffer
353  *
354  * Reads the VPD data from the EEPROM into the VPD buffer.
355  * Get the remaining read only and read / write space.
356  *
357  * return       0:      success
358  *              1:      fatal VPD error
359  */
360 static int VpdInit(
361 SK_AC   *pAC,   /* Adapters context */
362 SK_IOC  IoC)    /* IO Context */
363 {
364         SK_VPD_PARA *r, rp;     /* RW or RV */
365         int             i;
366         unsigned char   x;
367         int             vpd_size;
368         SK_U16  dev_id;
369         SK_U32  our_reg2;
370
371         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_INIT, ("VpdInit .. "));
372         
373         VPD_IN16(pAC, IoC, PCI_DEVICE_ID, &dev_id);
374         
375         VPD_IN32(pAC, IoC, PCI_OUR_REG_2, &our_reg2);
376         
377         pAC->vpd.rom_size = 256 << ((our_reg2 & PCI_VPD_ROM_SZ) >> 14);
378         
379         /*
380          * this function might get used before the hardware is initialized
381          * therefore we cannot always trust in GIChipId
382          */
383         if (((pAC->vpd.v.vpd_status & VPD_VALID) == 0 &&
384                 dev_id != VPD_DEV_ID_GENESIS) ||
385                 ((pAC->vpd.v.vpd_status & VPD_VALID) != 0 &&
386                 !pAC->GIni.GIGenesis)) {
387
388                 /* for Yukon the VPD size is always 256 */
389                 vpd_size = VPD_SIZE_YUKON;
390         }
391         else {
392                 /* Genesis uses the maximum ROM size up to 512 for VPD */
393                 if (pAC->vpd.rom_size > VPD_SIZE_GENESIS) {
394                         vpd_size = VPD_SIZE_GENESIS;
395                 }
396                 else {
397                         vpd_size = pAC->vpd.rom_size;
398                 }
399         }
400
401         /* read the VPD data into the VPD buffer */
402         if (VpdTransferBlock(pAC, IoC, pAC->vpd.vpd_buf, 0, vpd_size, VPD_READ)
403                 != vpd_size) {
404
405                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
406                         ("Block Read Error\n"));
407                 return(1);
408         }
409         
410         pAC->vpd.vpd_size = vpd_size;
411
412         /* Asus K8V Se Deluxe bugfix. Correct VPD content */
413         /* MBo April 2004 */
414         if (((unsigned char)pAC->vpd.vpd_buf[0x3f] == 0x38) &&
415             ((unsigned char)pAC->vpd.vpd_buf[0x40] == 0x3c) &&
416             ((unsigned char)pAC->vpd.vpd_buf[0x41] == 0x45)) {
417                 printk("sk98lin: Asus mainboard with buggy VPD? "
418                                 "Correcting data.\n");
419                 pAC->vpd.vpd_buf[0x40] = 0x38;
420         }
421
422
423         /* find the end tag of the RO area */
424         if (!(r = vpd_find_para(pAC, VPD_RV, &rp))) {
425                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
426                         ("Encoding Error: RV Tag not found\n"));
427                 return(1);
428         }
429         
430         if (r->p_val + r->p_len > pAC->vpd.vpd_buf + vpd_size/2) {
431                 SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
432                         ("Encoding Error: Invalid VPD struct size\n"));
433                 return(1);
434         }
435         pAC->vpd.v.vpd_free_ro = r->p_len - 1;
436
437         /* test the checksum */
438         for (i = 0, x = 0; (unsigned)i <= (unsigned)vpd_size/2 - r->p_len; i++) {
439                 x += pAC->vpd.vpd_buf[i];
440         }
441         
442         if (x != 0) {
443                 /* checksum error */
444                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
445                         ("VPD Checksum Error\n"));
446                 return(1);
447         }
448
449         /* find and check the end tag of the RW area */
450         if (!(r = vpd_find_para(pAC, VPD_RW, &rp))) {
451                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
452                         ("Encoding Error: RV Tag not found\n"));
453                 return(1);
454         }
455         
456         if (r->p_val < pAC->vpd.vpd_buf + vpd_size/2) {
457                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
458                         ("Encoding Error: Invalid VPD struct size\n"));
459                 return(1);
460         }
461         pAC->vpd.v.vpd_free_rw = r->p_len;
462
463         /* everything seems to be ok */
464         if (pAC->GIni.GIChipId != 0) {
465                 pAC->vpd.v.vpd_status |= VPD_VALID;
466         }
467
468         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_INIT,
469                 ("done. Free RO = %d, Free RW = %d\n",
470                 pAC->vpd.v.vpd_free_ro, pAC->vpd.v.vpd_free_rw));
471
472         return(0);
473 }
474
475 /*
476  *      find the Keyword 'key' in the VPD buffer and fills the
477  *      parameter struct 'p' with it's values
478  *
479  * returns      *p      success
480  *              0:      parameter was not found or VPD encoding error
481  */
482 static SK_VPD_PARA *vpd_find_para(
483 SK_AC           *pAC,   /* common data base */
484 const char      *key,   /* keyword to find (e.g. "MN") */
485 SK_VPD_PARA *p)         /* parameter description struct */
486 {
487         char *v ;       /* points to VPD buffer */
488         int max;        /* Maximum Number of Iterations */
489
490         v = pAC->vpd.vpd_buf;
491         max = 128;
492
493         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
494                 ("VPD find para %s .. ",key));
495
496         /* check mandatory resource type ID string (Product Name) */
497         if (*v != (char)RES_ID) {
498                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
499                         ("Error: 0x%x missing\n", RES_ID));
500                 return NULL;
501         }
502
503         if (strcmp(key, VPD_NAME) == 0) {
504                 p->p_len = VPD_GET_RES_LEN(v);
505                 p->p_val = VPD_GET_VAL(v);
506                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
507                         ("found, len = %d\n", p->p_len));
508                 return(p);
509         }
510
511         v += 3 + VPD_GET_RES_LEN(v) + 3;
512         for (;; ) {
513                 if (SK_MEMCMP(key,v,2) == 0) {
514                         p->p_len = VPD_GET_VPD_LEN(v);
515                         p->p_val = VPD_GET_VAL(v);
516                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
517                                 ("found, len = %d\n",p->p_len));
518                         return(p);
519                 }
520
521                 /* exit when reaching the "RW" Tag or the maximum of itera. */
522                 max--;
523                 if (SK_MEMCMP(VPD_RW,v,2) == 0 || max == 0) {
524                         break;
525                 }
526
527                 if (SK_MEMCMP(VPD_RV,v,2) == 0) {
528                         v += 3 + VPD_GET_VPD_LEN(v) + 3;        /* skip VPD-W */
529                 }
530                 else {
531                         v += 3 + VPD_GET_VPD_LEN(v);
532                 }
533                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
534                         ("scanning '%c%c' len = %d\n",v[0],v[1],v[2]));
535         }
536
537 #ifdef DEBUG
538         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL, ("not found\n"));
539         if (max == 0) {
540                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
541                         ("Key/Len Encoding error\n"));
542         }
543 #endif /* DEBUG */
544         return NULL;
545 }
546
547 /*
548  *      Move 'n' bytes. Begin with the last byte if 'n' is > 0,
549  *      Start with the last byte if n is < 0.
550  *
551  * returns nothing
552  */
553 static void vpd_move_para(
554 char    *start,         /* start of memory block */
555 char    *end,           /* end of memory block to move */
556 int             n)                      /* number of bytes the memory block has to be moved */
557 {
558         char *p;
559         int i;          /* number of byte copied */
560
561         if (n == 0)
562                 return;
563
564         i = (int) (end - start + 1);
565         if (n < 0) {
566                 p = start + n;
567                 while (i != 0) {
568                         *p++ = *start++;
569                         i--;
570                 }
571         }
572         else {
573                 p = end + n;
574                 while (i != 0) {
575                         *p-- = *end--;
576                         i--;
577                 }
578         }
579 }
580
581 /*
582  *      setup the VPD keyword 'key' at 'ip'.
583  *
584  * returns nothing
585  */
586 static void vpd_insert_key(
587 const char      *key,   /* keyword to insert */
588 const char      *buf,   /* buffer with the keyword value */
589 int             len,            /* length of the value string */
590 char    *ip)            /* inseration point */
591 {
592         SK_VPD_KEY *p;
593
594         p = (SK_VPD_KEY *) ip;
595         p->p_key[0] = key[0];
596         p->p_key[1] = key[1];
597         p->p_len = (unsigned char) len;
598         SK_MEMCPY(&p->p_val,buf,len);
599 }
600
601 /*
602  *      Setup the VPD end tag "RV" / "RW".
603  *      Also correct the remaining space variables vpd_free_ro / vpd_free_rw.
604  *
605  * returns      0:      success
606  *              1:      encoding error
607  */
608 static int vpd_mod_endtag(
609 SK_AC   *pAC,           /* common data base */
610 char    *etp)           /* end pointer input position */
611 {
612         SK_VPD_KEY *p;
613         unsigned char   x;
614         int     i;
615         int     vpd_size;
616
617         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
618                 ("VPD modify endtag at 0x%x = '%c%c'\n",etp,etp[0],etp[1]));
619
620         vpd_size = pAC->vpd.vpd_size;
621
622         p = (SK_VPD_KEY *) etp;
623
624         if (p->p_key[0] != 'R' || (p->p_key[1] != 'V' && p->p_key[1] != 'W')) {
625                 /* something wrong here, encoding error */
626                 SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
627                         ("Encoding Error: invalid end tag\n"));
628                 return(1);
629         }
630         if (etp > pAC->vpd.vpd_buf + vpd_size/2) {
631                 /* create "RW" tag */
632                 p->p_len = (unsigned char)(pAC->vpd.vpd_buf+vpd_size-etp-3-1);
633                 pAC->vpd.v.vpd_free_rw = (int) p->p_len;
634                 i = pAC->vpd.v.vpd_free_rw;
635                 etp += 3;
636         }
637         else {
638                 /* create "RV" tag */
639                 p->p_len = (unsigned char)(pAC->vpd.vpd_buf+vpd_size/2-etp-3);
640                 pAC->vpd.v.vpd_free_ro = (int) p->p_len - 1;
641
642                 /* setup checksum */
643                 for (i = 0, x = 0; i < vpd_size/2 - p->p_len; i++) {
644                         x += pAC->vpd.vpd_buf[i];
645                 }
646                 p->p_val = (char) 0 - x;
647                 i = pAC->vpd.v.vpd_free_ro;
648                 etp += 4;
649         }
650         while (i) {
651                 *etp++ = 0x00;
652                 i--;
653         }
654
655         return(0);
656 }
657
658 /*
659  *      Insert a VPD keyword into the VPD buffer.
660  *
661  *      The keyword 'key' is inserted at the position 'ip' in the
662  *      VPD buffer.
663  *      The keywords behind the input position will
664  *      be moved. The VPD end tag "RV" or "RW" is generated again.
665  *
666  * returns      0:      success
667  *              2:      value string was cut
668  *              4:      VPD full, keyword was not written
669  *              6:      fatal VPD error
670  *
671  */
672 static int      VpdSetupPara(
673 SK_AC   *pAC,           /* common data base */
674 const char      *key,   /* keyword to insert */
675 const char      *buf,   /* buffer with the keyword value */
676 int             len,            /* length of the keyword value */
677 int             type,           /* VPD_RO_KEY or VPD_RW_KEY */
678 int             op)                     /* operation to do: ADD_KEY or OWR_KEY */
679 {
680         SK_VPD_PARA vp;
681         char    *etp;           /* end tag position */
682         int     free;           /* remaining space in selected area */
683         char    *ip;            /* input position inside the VPD buffer */
684         int     rtv;            /* return code */
685         int     head;           /* additional haeder bytes to move */
686         int     found;          /* additinoal bytes if the keyword was found */
687         int vpd_size;
688
689         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
690                 ("VPD setup para key = %s, val = %s\n",key,buf));
691         
692         vpd_size = pAC->vpd.vpd_size;
693
694         rtv = 0;
695         ip = NULL;
696         if (type == VPD_RW_KEY) {
697                 /* end tag is "RW" */
698                 free = pAC->vpd.v.vpd_free_rw;
699                 etp = pAC->vpd.vpd_buf + (vpd_size - free - 1 - 3);
700         }
701         else {
702                 /* end tag is "RV" */
703                 free = pAC->vpd.v.vpd_free_ro;
704                 etp = pAC->vpd.vpd_buf + (vpd_size/2 - free - 4);
705         }
706         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
707                 ("Free RO = %d, Free RW = %d\n",
708                 pAC->vpd.v.vpd_free_ro, pAC->vpd.v.vpd_free_rw));
709
710         head = 0;
711         found = 0;
712         if (op == OWR_KEY) {
713                 if (vpd_find_para(pAC, key, &vp)) {
714                         found = 3;
715                         ip = vp.p_val - 3;
716                         free += vp.p_len + 3;
717                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
718                                 ("Overwrite Key\n"));
719                 }
720                 else {
721                         op = ADD_KEY;
722                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
723                                 ("Add Key\n"));
724                 }
725         }
726         if (op == ADD_KEY) {
727                 ip = etp;
728                 vp.p_len = 0;
729                 head = 3;
730         }
731
732         if (len + 3 > free) {
733                 if (free < 7) {
734                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
735                                 ("VPD Buffer Overflow, keyword not written\n"));
736                         return(4);
737                 }
738                 /* cut it again */
739                 len = free - 3;
740                 rtv = 2;
741                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
742                         ("VPD Buffer Full, Keyword was cut\n"));
743         }
744
745         vpd_move_para(ip + vp.p_len + found, etp+2, len-vp.p_len+head);
746         vpd_insert_key(key, buf, len, ip);
747         if (vpd_mod_endtag(pAC, etp + len - vp.p_len + head)) {
748                 pAC->vpd.v.vpd_status &= ~VPD_VALID;
749                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
750                         ("VPD Encoding Error\n"));
751                 return(6);
752         }
753
754         return(rtv);
755 }
756
757
758 /*
759  *      Read the contents of the VPD EEPROM and copy it to the
760  *      VPD buffer if not already done.
761  *
762  * return:      A pointer to the vpd_status structure. The structure contains
763  *              this fields.
764  */
765 SK_VPD_STATUS *VpdStat(
766 SK_AC   *pAC,   /* Adapters context */
767 SK_IOC  IoC)    /* IO Context */
768 {
769         if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
770                 (void)VpdInit(pAC, IoC);
771         }
772         return(&pAC->vpd.v);
773 }
774
775
776 /*
777  *      Read the contents of the VPD EEPROM and copy it to the VPD
778  *      buffer if not already done.
779  *      Scan the VPD buffer for VPD keywords and create the VPD
780  *      keyword list by copying the keywords to 'buf', all after
781  *      each other and terminated with a '\0'.
782  *
783  * Exceptions:  o The Resource Type ID String (product name) is called "Name"
784  *              o The VPD end tags 'RV' and 'RW' are not listed
785  *
786  *      The number of copied keywords is counted in 'elements'.
787  *
788  * returns      0:      success
789  *              2:      buffer overfull, one or more keywords are missing
790  *              6:      fatal VPD error
791  *
792  *      example values after returning:
793  *
794  *              buf =   "Name\0PN\0EC\0MN\0SN\0CP\0VF\0VL\0YA\0"
795  *              *len =          30
796  *              *elements =      9
797  */
798 int VpdKeys(
799 SK_AC   *pAC,           /* common data base */
800 SK_IOC  IoC,            /* IO Context */
801 char    *buf,           /* buffer where to copy the keywords */
802 int             *len,           /* buffer length */
803 int             *elements)      /* number of keywords returned */
804 {
805         char *v;
806         int n;
807
808         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX, ("list VPD keys .. "));
809         *elements = 0;
810         if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
811                 if (VpdInit(pAC, IoC) != 0) {
812                         *len = 0;
813                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
814                                 ("VPD Init Error, terminated\n"));
815                         return(6);
816                 }
817         }
818
819         if ((signed)strlen(VPD_NAME) + 1 <= *len) {
820                 v = pAC->vpd.vpd_buf;
821                 strcpy(buf,VPD_NAME);
822                 n = strlen(VPD_NAME) + 1;
823                 buf += n;
824                 *elements = 1;
825                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX,
826                         ("'%c%c' ",v[0],v[1]));
827         }
828         else {
829                 *len = 0;
830                 SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
831                         ("buffer overflow\n"));
832                 return(2);
833         }
834
835         v += 3 + VPD_GET_RES_LEN(v) + 3;
836         for (;; ) {
837                 /* exit when reaching the "RW" Tag */
838                 if (SK_MEMCMP(VPD_RW,v,2) == 0) {
839                         break;
840                 }
841
842                 if (SK_MEMCMP(VPD_RV,v,2) == 0) {
843                         v += 3 + VPD_GET_VPD_LEN(v) + 3;        /* skip VPD-W */
844                         continue;
845                 }
846
847                 if (n+3 <= *len) {
848                         SK_MEMCPY(buf,v,2);
849                         buf += 2;
850                         *buf++ = '\0';
851                         n += 3;
852                         v += 3 + VPD_GET_VPD_LEN(v);
853                         *elements += 1;
854                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX,
855                                 ("'%c%c' ",v[0],v[1]));
856                 }
857                 else {
858                         *len = n;
859                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
860                                 ("buffer overflow\n"));
861                         return(2);
862                 }
863         }
864
865         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX, ("\n"));
866         *len = n;
867         return(0);
868 }
869
870
871 /*
872  *      Read the contents of the VPD EEPROM and copy it to the
873  *      VPD buffer if not already done. Search for the VPD keyword
874  *      'key' and copy its value to 'buf'. Add a terminating '\0'.
875  *      If the value does not fit into the buffer cut it after
876  *      'len' - 1 bytes.
877  *
878  * returns      0:      success
879  *              1:      keyword not found
880  *              2:      value string was cut
881  *              3:      VPD transfer timeout
882  *              6:      fatal VPD error
883  */
884 int VpdRead(
885 SK_AC           *pAC,   /* common data base */
886 SK_IOC          IoC,    /* IO Context */
887 const char      *key,   /* keyword to read (e.g. "MN") */
888 char            *buf,   /* buffer where to copy the keyword value */
889 int                     *len)   /* buffer length */
890 {
891         SK_VPD_PARA *p, vp;
892
893         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX, ("VPD read %s .. ", key));
894         if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
895                 if (VpdInit(pAC, IoC) != 0) {
896                         *len = 0;
897                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
898                                 ("VPD init error\n"));
899                         return(6);
900                 }
901         }
902
903         if ((p = vpd_find_para(pAC, key, &vp)) != NULL) {
904                 if (p->p_len > (*(unsigned *)len)-1) {
905                         p->p_len = *len - 1;
906                 }
907                 SK_MEMCPY(buf, p->p_val, p->p_len);
908                 buf[p->p_len] = '\0';
909                 *len = p->p_len;
910                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX,
911                         ("%c%c%c%c.., len = %d\n",
912                         buf[0],buf[1],buf[2],buf[3],*len));
913         }
914         else {
915                 *len = 0;
916                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR, ("not found\n"));
917                 return(1);
918         }
919         return(0);
920 }
921
922
923 /*
924  *      Check whether a given key may be written
925  *
926  * returns
927  *      SK_TRUE         Yes it may be written
928  *      SK_FALSE        No it may be written
929  */
930 SK_BOOL VpdMayWrite(
931 char    *key)   /* keyword to write (allowed values "Yx", "Vx") */
932 {
933         if ((*key != 'Y' && *key != 'V') ||
934                 key[1] < '0' || key[1] > 'Z' ||
935                 (key[1] > '9' && key[1] < 'A') || strlen(key) != 2) {
936
937                 return(SK_FALSE);
938         }
939         return(SK_TRUE);
940 }
941
942 /*
943  *      Read the contents of the VPD EEPROM and copy it to the VPD
944  *      buffer if not already done. Insert/overwrite the keyword 'key'
945  *      in the VPD buffer. Cut the keyword value if it does not fit
946  *      into the VPD read / write area.
947  *
948  * returns      0:      success
949  *              2:      value string was cut
950  *              3:      VPD transfer timeout
951  *              4:      VPD full, keyword was not written
952  *              5:      keyword cannot be written
953  *              6:      fatal VPD error
954  */
955 int VpdWrite(
956 SK_AC           *pAC,   /* common data base */
957 SK_IOC          IoC,    /* IO Context */
958 const char      *key,   /* keyword to write (allowed values "Yx", "Vx") */
959 const char      *buf)   /* buffer where the keyword value can be read from */
960 {
961         int len;                /* length of the keyword to write */
962         int rtv;                /* return code */
963         int rtv2;
964
965         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX,
966                 ("VPD write %s = %s\n",key,buf));
967
968         if ((*key != 'Y' && *key != 'V') ||
969                 key[1] < '0' || key[1] > 'Z' ||
970                 (key[1] > '9' && key[1] < 'A') || strlen(key) != 2) {
971
972                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
973                         ("illegal key tag, keyword not written\n"));
974                 return(5);
975         }
976
977         if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
978                 if (VpdInit(pAC, IoC) != 0) {
979                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
980                                 ("VPD init error\n"));
981                         return(6);
982                 }
983         }
984
985         rtv = 0;
986         len = strlen(buf);
987         if (len > VPD_MAX_LEN) {
988                 /* cut it */
989                 len = VPD_MAX_LEN;
990                 rtv = 2;
991                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
992                         ("keyword too long, cut after %d bytes\n",VPD_MAX_LEN));
993         }
994         if ((rtv2 = VpdSetupPara(pAC, key, buf, len, VPD_RW_KEY, OWR_KEY)) != 0) {
995                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
996                         ("VPD write error\n"));
997                 return(rtv2);
998         }
999
1000         return(rtv);
1001 }
1002
1003 /*
1004  *      Read the contents of the VPD EEPROM and copy it to the
1005  *      VPD buffer if not already done. Remove the VPD keyword
1006  *      'key' from the VPD buffer.
1007  *      Only the keywords in the read/write area can be deleted.
1008  *      Keywords in the read only area cannot be deleted.
1009  *
1010  * returns      0:      success, keyword was removed
1011  *              1:      keyword not found
1012  *              5:      keyword cannot be deleted
1013  *              6:      fatal VPD error
1014  */
1015 int VpdDelete(
1016 SK_AC   *pAC,   /* common data base */
1017 SK_IOC  IoC,    /* IO Context */
1018 char    *key)   /* keyword to read (e.g. "MN") */
1019 {
1020         SK_VPD_PARA *p, vp;
1021         char *etp;
1022         int     vpd_size;
1023
1024         vpd_size = pAC->vpd.vpd_size;
1025
1026         SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_TX,("VPD delete key %s\n",key));
1027         if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
1028                 if (VpdInit(pAC, IoC) != 0) {
1029                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1030                                 ("VPD init error\n"));
1031                         return(6);
1032                 }
1033         }
1034
1035         if ((p = vpd_find_para(pAC, key, &vp)) != NULL) {
1036                 if (p->p_val < pAC->vpd.vpd_buf + vpd_size/2) {
1037                         /* try to delete read only keyword */
1038                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1039                                 ("cannot delete RO keyword\n"));
1040                         return(5);
1041                 }
1042
1043                 etp = pAC->vpd.vpd_buf + (vpd_size-pAC->vpd.v.vpd_free_rw-1-3);
1044
1045                 vpd_move_para(vp.p_val+vp.p_len, etp+2,
1046                         - ((int)(vp.p_len + 3)));
1047                 if (vpd_mod_endtag(pAC, etp - vp.p_len - 3)) {
1048                         pAC->vpd.v.vpd_status &= ~VPD_VALID;
1049                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1050                                 ("VPD encoding error\n"));
1051                         return(6);
1052                 }
1053         }
1054         else {
1055                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1056                         ("keyword not found\n"));
1057                 return(1);
1058         }
1059
1060         return(0);
1061 }
1062
1063 /*
1064  *      If the VPD buffer contains valid data write the VPD
1065  *      read/write area back to the VPD EEPROM.
1066  *
1067  * returns      0:      success
1068  *              3:      VPD transfer timeout
1069  */
1070 int VpdUpdate(
1071 SK_AC   *pAC,   /* Adapters context */
1072 SK_IOC  IoC)    /* IO Context */
1073 {
1074         int vpd_size;
1075
1076         vpd_size = pAC->vpd.vpd_size;
1077
1078         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX, ("VPD update .. "));
1079         if ((pAC->vpd.v.vpd_status & VPD_VALID) != 0) {
1080                 if (VpdTransferBlock(pAC, IoC, pAC->vpd.vpd_buf + vpd_size/2,
1081                         vpd_size/2, vpd_size/2, VPD_WRITE) != vpd_size/2) {
1082
1083                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1084                                 ("transfer timed out\n"));
1085                         return(3);
1086                 }
1087         }
1088         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX, ("done\n"));
1089         return(0);
1090 }
1091