This commit was manufactured by cvs2svn to create branch 'vserver'.
[linux-2.6.git] / 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 #if 0
136
137 /*
138         Write the dword 'data' at address 'addr' into the VPD EEPROM, and
139         verify that the data is written.
140
141  Needed Time:
142
143 .                               MIN             MAX
144 . -------------------------------------------------------------------
145 . write                         1.8 ms          3.6 ms
146 . internal write cyles          0.7 ms          7.0 ms
147 . -------------------------------------------------------------------
148 . over all program time         2.5 ms          10.6 ms
149 . read                          1.3 ms          2.6 ms
150 . -------------------------------------------------------------------
151 . over all                      3.8 ms          13.2 ms
152 .
153
154
155  Returns        0:      success
156                         1:      error,  I2C transfer does not terminate
157                         2:      error,  data verify error
158
159  */
160 static int VpdWriteDWord(
161 SK_AC   *pAC,   /* pAC pointer */
162 SK_IOC  IoC,    /* IO Context */
163 int             addr,   /* VPD address */
164 SK_U32  data)   /* VPD data to write */
165 {
166         /* start VPD write */
167         /* Don't swap here, it's a data stream of bytes */
168         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
169                 ("VPD write dword at addr 0x%x, data = 0x%x\n",addr,data));
170         VPD_OUT32(pAC, IoC, PCI_VPD_DAT_REG, (SK_U32)data);
171         /* But do it here */
172         addr |= VPD_WRITE;
173
174         VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, (SK_U16)(addr | VPD_WRITE));
175
176         /* this may take up to 10,6 ms */
177         if (VpdWait(pAC, IoC, VPD_WRITE)) {
178                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
179                         ("Write Timed Out\n"));
180                 return(1);
181         };
182
183         /* verify data */
184         if (VpdReadDWord(pAC, IoC, addr) != data) {
185                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
186                         ("Data Verify Error\n"));
187                 return(2);
188         }
189         return(0);
190 }       /* VpdWriteDWord */
191
192 #endif  /* 0 */
193
194 /*
195  *      Read one Stream of 'len' bytes of VPD data, starting at 'addr' from
196  *      or to the I2C EEPROM.
197  *
198  * Returns number of bytes read / written.
199  */
200 static int VpdWriteStream(
201 SK_AC   *pAC,   /* Adapters context */
202 SK_IOC  IoC,    /* IO Context */
203 char    *buf,   /* data buffer */
204 int             Addr,   /* VPD start address */
205 int             Len)    /* number of bytes to read / to write */
206 {
207         int             i;
208         int             j;
209         SK_U16  AdrReg;
210         int             Rtv;
211         SK_U8   * pComp;        /* Compare pointer */
212         SK_U8   Data;           /* Input Data for Compare */
213
214         /* Init Compare Pointer */
215         pComp = (SK_U8 *) buf;
216
217         for (i = 0; i < Len; i++, buf++) {
218                 if ((i%sizeof(SK_U32)) == 0) {
219                         /*
220                          * At the begin of each cycle read the Data Reg
221                          * So it is initialized even if only a few bytes
222                          * are written.
223                          */
224                         AdrReg = (SK_U16) Addr;
225                         AdrReg &= ~VPD_WRITE;   /* READ operation */
226
227                         VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
228
229                         /* Wait for termination */
230                         Rtv = VpdWait(pAC, IoC, VPD_READ);
231                         if (Rtv != 0) {
232                                 return(i);
233                         }
234                 }
235
236                 /* Write current Byte */
237                 VPD_OUT8(pAC, IoC, PCI_VPD_DAT_REG + (i%sizeof(SK_U32)),
238                                 *(SK_U8*)buf);
239
240                 if (((i%sizeof(SK_U32)) == 3) || (i == (Len - 1))) {
241                         /* New Address needs to be written to VPD_ADDR reg */
242                         AdrReg = (SK_U16) Addr;
243                         Addr += sizeof(SK_U32);
244                         AdrReg |= VPD_WRITE;    /* WRITE operation */
245
246                         VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
247
248                         /* Wait for termination */
249                         Rtv = VpdWait(pAC, IoC, VPD_WRITE);
250                         if (Rtv != 0) {
251                                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
252                                         ("Write Timed Out\n"));
253                                 return(i - (i%sizeof(SK_U32)));
254                         }
255
256                         /*
257                          * Now re-read to verify
258                          */
259                         AdrReg &= ~VPD_WRITE;   /* READ operation */
260
261                         VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
262
263                         /* Wait for termination */
264                         Rtv = VpdWait(pAC, IoC, VPD_READ);
265                         if (Rtv != 0) {
266                                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
267                                         ("Verify Timed Out\n"));
268                                 return(i - (i%sizeof(SK_U32)));
269                         }
270
271                         for (j = 0; j <= (int)(i%sizeof(SK_U32)); j++, pComp++) {
272                                 
273                                 VPD_IN8(pAC, IoC, PCI_VPD_DAT_REG + j, &Data);
274                                 
275                                 if (Data != *pComp) {
276                                         /* Verify Error */
277                                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
278                                                 ("WriteStream Verify Error\n"));
279                                         return(i - (i%sizeof(SK_U32)) + j);
280                                 }
281                         }
282                 }
283         }
284
285         return(Len);
286 }
287         
288
289 /*
290  *      Read one Stream of 'len' bytes of VPD data, starting at 'addr' from
291  *      or to the I2C EEPROM.
292  *
293  * Returns number of bytes read / written.
294  */
295 static int VpdReadStream(
296 SK_AC   *pAC,   /* Adapters context */
297 SK_IOC  IoC,    /* IO Context */
298 char    *buf,   /* data buffer */
299 int             Addr,   /* VPD start address */
300 int             Len)    /* number of bytes to read / to write */
301 {
302         int             i;
303         SK_U16  AdrReg;
304         int             Rtv;
305
306         for (i = 0; i < Len; i++, buf++) {
307                 if ((i%sizeof(SK_U32)) == 0) {
308                         /* New Address needs to be written to VPD_ADDR reg */
309                         AdrReg = (SK_U16) Addr;
310                         Addr += sizeof(SK_U32);
311                         AdrReg &= ~VPD_WRITE;   /* READ operation */
312
313                         VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
314
315                         /* Wait for termination */
316                         Rtv = VpdWait(pAC, IoC, VPD_READ);
317                         if (Rtv != 0) {
318                                 return(i);
319                         }
320                 }
321                 VPD_IN8(pAC, IoC, PCI_VPD_DAT_REG + (i%sizeof(SK_U32)),
322                         (SK_U8 *)buf);
323         }
324
325         return(Len);
326 }
327
328 /*
329  *      Read ore writes 'len' bytes of VPD data, starting at 'addr' from
330  *      or to the I2C EEPROM.
331  *
332  * Returns number of bytes read / written.
333  */
334 static int VpdTransferBlock(
335 SK_AC   *pAC,   /* Adapters context */
336 SK_IOC  IoC,    /* IO Context */
337 char    *buf,   /* data buffer */
338 int             addr,   /* VPD start address */
339 int             len,    /* number of bytes to read / to write */
340 int             dir)    /* transfer direction may be VPD_READ or VPD_WRITE */
341 {
342         int             Rtv;    /* Return value */
343         int             vpd_rom_size;
344
345         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
346                 ("VPD %s block, addr = 0x%x, len = %d\n",
347                 dir ? "write" : "read", addr, len));
348
349         if (len == 0)
350                 return(0);
351
352         vpd_rom_size = pAC->vpd.rom_size;
353         
354         if (addr > vpd_rom_size - 4) {
355                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
356                         ("Address error: 0x%x, exp. < 0x%x\n",
357                         addr, vpd_rom_size - 4));
358                 return(0);
359         }
360         
361         if (addr + len > vpd_rom_size) {
362                 len = vpd_rom_size - addr;
363                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
364                         ("Warning: len was cut to %d\n", len));
365         }
366
367         if (dir == VPD_READ) {
368                 Rtv = VpdReadStream(pAC, IoC, buf, addr, len);
369         }
370         else {
371                 Rtv = VpdWriteStream(pAC, IoC, buf, addr, len);
372         }
373
374         return(Rtv);
375 }
376
377 #ifdef SKDIAG
378
379 /*
380  *      Read 'len' bytes of VPD data, starting at 'addr'.
381  *
382  * Returns number of bytes read.
383  */
384 int VpdReadBlock(
385 SK_AC   *pAC,   /* pAC pointer */
386 SK_IOC  IoC,    /* IO Context */
387 char    *buf,   /* buffer were the data should be stored */
388 int             addr,   /* start reading at the VPD address */
389 int             len)    /* number of bytes to read */
390 {
391         return(VpdTransferBlock(pAC, IoC, buf, addr, len, VPD_READ));
392 }
393
394 /*
395  *      Write 'len' bytes of *but to the VPD EEPROM, starting at 'addr'.
396  *
397  * Returns number of bytes writes.
398  */
399 int VpdWriteBlock(
400 SK_AC   *pAC,   /* pAC pointer */
401 SK_IOC  IoC,    /* IO Context */
402 char    *buf,   /* buffer, holds the data to write */
403 int             addr,   /* start writing at the VPD address */
404 int             len)    /* number of bytes to write */
405 {
406         return(VpdTransferBlock(pAC, IoC, buf, addr, len, VPD_WRITE));
407 }
408 #endif  /* SKDIAG */
409
410 /*
411  * (re)initialize the VPD buffer
412  *
413  * Reads the VPD data from the EEPROM into the VPD buffer.
414  * Get the remaining read only and read / write space.
415  *
416  * return       0:      success
417  *              1:      fatal VPD error
418  */
419 static int VpdInit(
420 SK_AC   *pAC,   /* Adapters context */
421 SK_IOC  IoC)    /* IO Context */
422 {
423         SK_VPD_PARA *r, rp;     /* RW or RV */
424         int             i;
425         unsigned char   x;
426         int             vpd_size;
427         SK_U16  dev_id;
428         SK_U32  our_reg2;
429
430         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_INIT, ("VpdInit .. "));
431         
432         VPD_IN16(pAC, IoC, PCI_DEVICE_ID, &dev_id);
433         
434         VPD_IN32(pAC, IoC, PCI_OUR_REG_2, &our_reg2);
435         
436         pAC->vpd.rom_size = 256 << ((our_reg2 & PCI_VPD_ROM_SZ) >> 14);
437         
438         /*
439          * this function might get used before the hardware is initialized
440          * therefore we cannot always trust in GIChipId
441          */
442         if (((pAC->vpd.v.vpd_status & VPD_VALID) == 0 &&
443                 dev_id != VPD_DEV_ID_GENESIS) ||
444                 ((pAC->vpd.v.vpd_status & VPD_VALID) != 0 &&
445                 !pAC->GIni.GIGenesis)) {
446
447                 /* for Yukon the VPD size is always 256 */
448                 vpd_size = VPD_SIZE_YUKON;
449         }
450         else {
451                 /* Genesis uses the maximum ROM size up to 512 for VPD */
452                 if (pAC->vpd.rom_size > VPD_SIZE_GENESIS) {
453                         vpd_size = VPD_SIZE_GENESIS;
454                 }
455                 else {
456                         vpd_size = pAC->vpd.rom_size;
457                 }
458         }
459
460         /* read the VPD data into the VPD buffer */
461         if (VpdTransferBlock(pAC, IoC, pAC->vpd.vpd_buf, 0, vpd_size, VPD_READ)
462                 != vpd_size) {
463
464                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
465                         ("Block Read Error\n"));
466                 return(1);
467         }
468         
469         pAC->vpd.vpd_size = vpd_size;
470
471         /* Asus K8V Se Deluxe bugfix. Correct VPD content */
472         /* MBo April 2004 */
473         if (((unsigned char)pAC->vpd.vpd_buf[0x3f] == 0x38) &&
474             ((unsigned char)pAC->vpd.vpd_buf[0x40] == 0x3c) &&
475             ((unsigned char)pAC->vpd.vpd_buf[0x41] == 0x45)) {
476                 printk("sk98lin: Asus mainboard with buggy VPD? "
477                                 "Correcting data.\n");
478                 pAC->vpd.vpd_buf[0x40] = 0x38;
479         }
480
481
482         /* find the end tag of the RO area */
483         if (!(r = vpd_find_para(pAC, VPD_RV, &rp))) {
484                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
485                         ("Encoding Error: RV Tag not found\n"));
486                 return(1);
487         }
488         
489         if (r->p_val + r->p_len > pAC->vpd.vpd_buf + vpd_size/2) {
490                 SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
491                         ("Encoding Error: Invalid VPD struct size\n"));
492                 return(1);
493         }
494         pAC->vpd.v.vpd_free_ro = r->p_len - 1;
495
496         /* test the checksum */
497         for (i = 0, x = 0; (unsigned)i <= (unsigned)vpd_size/2 - r->p_len; i++) {
498                 x += pAC->vpd.vpd_buf[i];
499         }
500         
501         if (x != 0) {
502                 /* checksum error */
503                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
504                         ("VPD Checksum Error\n"));
505                 return(1);
506         }
507
508         /* find and check the end tag of the RW area */
509         if (!(r = vpd_find_para(pAC, VPD_RW, &rp))) {
510                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
511                         ("Encoding Error: RV Tag not found\n"));
512                 return(1);
513         }
514         
515         if (r->p_val < pAC->vpd.vpd_buf + vpd_size/2) {
516                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
517                         ("Encoding Error: Invalid VPD struct size\n"));
518                 return(1);
519         }
520         pAC->vpd.v.vpd_free_rw = r->p_len;
521
522         /* everything seems to be ok */
523         if (pAC->GIni.GIChipId != 0) {
524                 pAC->vpd.v.vpd_status |= VPD_VALID;
525         }
526
527         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_INIT,
528                 ("done. Free RO = %d, Free RW = %d\n",
529                 pAC->vpd.v.vpd_free_ro, pAC->vpd.v.vpd_free_rw));
530
531         return(0);
532 }
533
534 /*
535  *      find the Keyword 'key' in the VPD buffer and fills the
536  *      parameter struct 'p' with it's values
537  *
538  * returns      *p      success
539  *              0:      parameter was not found or VPD encoding error
540  */
541 static SK_VPD_PARA *vpd_find_para(
542 SK_AC           *pAC,   /* common data base */
543 const char      *key,   /* keyword to find (e.g. "MN") */
544 SK_VPD_PARA *p)         /* parameter description struct */
545 {
546         char *v ;       /* points to VPD buffer */
547         int max;        /* Maximum Number of Iterations */
548
549         v = pAC->vpd.vpd_buf;
550         max = 128;
551
552         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
553                 ("VPD find para %s .. ",key));
554
555         /* check mandatory resource type ID string (Product Name) */
556         if (*v != (char)RES_ID) {
557                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
558                         ("Error: 0x%x missing\n", RES_ID));
559                 return NULL;
560         }
561
562         if (strcmp(key, VPD_NAME) == 0) {
563                 p->p_len = VPD_GET_RES_LEN(v);
564                 p->p_val = VPD_GET_VAL(v);
565                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
566                         ("found, len = %d\n", p->p_len));
567                 return(p);
568         }
569
570         v += 3 + VPD_GET_RES_LEN(v) + 3;
571         for (;; ) {
572                 if (SK_MEMCMP(key,v,2) == 0) {
573                         p->p_len = VPD_GET_VPD_LEN(v);
574                         p->p_val = VPD_GET_VAL(v);
575                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
576                                 ("found, len = %d\n",p->p_len));
577                         return(p);
578                 }
579
580                 /* exit when reaching the "RW" Tag or the maximum of itera. */
581                 max--;
582                 if (SK_MEMCMP(VPD_RW,v,2) == 0 || max == 0) {
583                         break;
584                 }
585
586                 if (SK_MEMCMP(VPD_RV,v,2) == 0) {
587                         v += 3 + VPD_GET_VPD_LEN(v) + 3;        /* skip VPD-W */
588                 }
589                 else {
590                         v += 3 + VPD_GET_VPD_LEN(v);
591                 }
592                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
593                         ("scanning '%c%c' len = %d\n",v[0],v[1],v[2]));
594         }
595
596 #ifdef DEBUG
597         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL, ("not found\n"));
598         if (max == 0) {
599                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
600                         ("Key/Len Encoding error\n"));
601         }
602 #endif /* DEBUG */
603         return NULL;
604 }
605
606 /*
607  *      Move 'n' bytes. Begin with the last byte if 'n' is > 0,
608  *      Start with the last byte if n is < 0.
609  *
610  * returns nothing
611  */
612 static void vpd_move_para(
613 char    *start,         /* start of memory block */
614 char    *end,           /* end of memory block to move */
615 int             n)                      /* number of bytes the memory block has to be moved */
616 {
617         char *p;
618         int i;          /* number of byte copied */
619
620         if (n == 0)
621                 return;
622
623         i = (int) (end - start + 1);
624         if (n < 0) {
625                 p = start + n;
626                 while (i != 0) {
627                         *p++ = *start++;
628                         i--;
629                 }
630         }
631         else {
632                 p = end + n;
633                 while (i != 0) {
634                         *p-- = *end--;
635                         i--;
636                 }
637         }
638 }
639
640 /*
641  *      setup the VPD keyword 'key' at 'ip'.
642  *
643  * returns nothing
644  */
645 static void vpd_insert_key(
646 const char      *key,   /* keyword to insert */
647 const char      *buf,   /* buffer with the keyword value */
648 int             len,            /* length of the value string */
649 char    *ip)            /* inseration point */
650 {
651         SK_VPD_KEY *p;
652
653         p = (SK_VPD_KEY *) ip;
654         p->p_key[0] = key[0];
655         p->p_key[1] = key[1];
656         p->p_len = (unsigned char) len;
657         SK_MEMCPY(&p->p_val,buf,len);
658 }
659
660 /*
661  *      Setup the VPD end tag "RV" / "RW".
662  *      Also correct the remaining space variables vpd_free_ro / vpd_free_rw.
663  *
664  * returns      0:      success
665  *              1:      encoding error
666  */
667 static int vpd_mod_endtag(
668 SK_AC   *pAC,           /* common data base */
669 char    *etp)           /* end pointer input position */
670 {
671         SK_VPD_KEY *p;
672         unsigned char   x;
673         int     i;
674         int     vpd_size;
675
676         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
677                 ("VPD modify endtag at 0x%x = '%c%c'\n",etp,etp[0],etp[1]));
678
679         vpd_size = pAC->vpd.vpd_size;
680
681         p = (SK_VPD_KEY *) etp;
682
683         if (p->p_key[0] != 'R' || (p->p_key[1] != 'V' && p->p_key[1] != 'W')) {
684                 /* something wrong here, encoding error */
685                 SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
686                         ("Encoding Error: invalid end tag\n"));
687                 return(1);
688         }
689         if (etp > pAC->vpd.vpd_buf + vpd_size/2) {
690                 /* create "RW" tag */
691                 p->p_len = (unsigned char)(pAC->vpd.vpd_buf+vpd_size-etp-3-1);
692                 pAC->vpd.v.vpd_free_rw = (int) p->p_len;
693                 i = pAC->vpd.v.vpd_free_rw;
694                 etp += 3;
695         }
696         else {
697                 /* create "RV" tag */
698                 p->p_len = (unsigned char)(pAC->vpd.vpd_buf+vpd_size/2-etp-3);
699                 pAC->vpd.v.vpd_free_ro = (int) p->p_len - 1;
700
701                 /* setup checksum */
702                 for (i = 0, x = 0; i < vpd_size/2 - p->p_len; i++) {
703                         x += pAC->vpd.vpd_buf[i];
704                 }
705                 p->p_val = (char) 0 - x;
706                 i = pAC->vpd.v.vpd_free_ro;
707                 etp += 4;
708         }
709         while (i) {
710                 *etp++ = 0x00;
711                 i--;
712         }
713
714         return(0);
715 }
716
717 /*
718  *      Insert a VPD keyword into the VPD buffer.
719  *
720  *      The keyword 'key' is inserted at the position 'ip' in the
721  *      VPD buffer.
722  *      The keywords behind the input position will
723  *      be moved. The VPD end tag "RV" or "RW" is generated again.
724  *
725  * returns      0:      success
726  *              2:      value string was cut
727  *              4:      VPD full, keyword was not written
728  *              6:      fatal VPD error
729  *
730  */
731 int     VpdSetupPara(
732 SK_AC   *pAC,           /* common data base */
733 const char      *key,   /* keyword to insert */
734 const char      *buf,   /* buffer with the keyword value */
735 int             len,            /* length of the keyword value */
736 int             type,           /* VPD_RO_KEY or VPD_RW_KEY */
737 int             op)                     /* operation to do: ADD_KEY or OWR_KEY */
738 {
739         SK_VPD_PARA vp;
740         char    *etp;           /* end tag position */
741         int     free;           /* remaining space in selected area */
742         char    *ip;            /* input position inside the VPD buffer */
743         int     rtv;            /* return code */
744         int     head;           /* additional haeder bytes to move */
745         int     found;          /* additinoal bytes if the keyword was found */
746         int vpd_size;
747
748         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
749                 ("VPD setup para key = %s, val = %s\n",key,buf));
750         
751         vpd_size = pAC->vpd.vpd_size;
752
753         rtv = 0;
754         ip = NULL;
755         if (type == VPD_RW_KEY) {
756                 /* end tag is "RW" */
757                 free = pAC->vpd.v.vpd_free_rw;
758                 etp = pAC->vpd.vpd_buf + (vpd_size - free - 1 - 3);
759         }
760         else {
761                 /* end tag is "RV" */
762                 free = pAC->vpd.v.vpd_free_ro;
763                 etp = pAC->vpd.vpd_buf + (vpd_size/2 - free - 4);
764         }
765         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
766                 ("Free RO = %d, Free RW = %d\n",
767                 pAC->vpd.v.vpd_free_ro, pAC->vpd.v.vpd_free_rw));
768
769         head = 0;
770         found = 0;
771         if (op == OWR_KEY) {
772                 if (vpd_find_para(pAC, key, &vp)) {
773                         found = 3;
774                         ip = vp.p_val - 3;
775                         free += vp.p_len + 3;
776                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
777                                 ("Overwrite Key\n"));
778                 }
779                 else {
780                         op = ADD_KEY;
781                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
782                                 ("Add Key\n"));
783                 }
784         }
785         if (op == ADD_KEY) {
786                 ip = etp;
787                 vp.p_len = 0;
788                 head = 3;
789         }
790
791         if (len + 3 > free) {
792                 if (free < 7) {
793                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
794                                 ("VPD Buffer Overflow, keyword not written\n"));
795                         return(4);
796                 }
797                 /* cut it again */
798                 len = free - 3;
799                 rtv = 2;
800                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
801                         ("VPD Buffer Full, Keyword was cut\n"));
802         }
803
804         vpd_move_para(ip + vp.p_len + found, etp+2, len-vp.p_len+head);
805         vpd_insert_key(key, buf, len, ip);
806         if (vpd_mod_endtag(pAC, etp + len - vp.p_len + head)) {
807                 pAC->vpd.v.vpd_status &= ~VPD_VALID;
808                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
809                         ("VPD Encoding Error\n"));
810                 return(6);
811         }
812
813         return(rtv);
814 }
815
816
817 /*
818  *      Read the contents of the VPD EEPROM and copy it to the
819  *      VPD buffer if not already done.
820  *
821  * return:      A pointer to the vpd_status structure. The structure contains
822  *              this fields.
823  */
824 SK_VPD_STATUS *VpdStat(
825 SK_AC   *pAC,   /* Adapters context */
826 SK_IOC  IoC)    /* IO Context */
827 {
828         if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
829                 (void)VpdInit(pAC, IoC);
830         }
831         return(&pAC->vpd.v);
832 }
833
834
835 /*
836  *      Read the contents of the VPD EEPROM and copy it to the VPD
837  *      buffer if not already done.
838  *      Scan the VPD buffer for VPD keywords and create the VPD
839  *      keyword list by copying the keywords to 'buf', all after
840  *      each other and terminated with a '\0'.
841  *
842  * Exceptions:  o The Resource Type ID String (product name) is called "Name"
843  *              o The VPD end tags 'RV' and 'RW' are not listed
844  *
845  *      The number of copied keywords is counted in 'elements'.
846  *
847  * returns      0:      success
848  *              2:      buffer overfull, one or more keywords are missing
849  *              6:      fatal VPD error
850  *
851  *      example values after returning:
852  *
853  *              buf =   "Name\0PN\0EC\0MN\0SN\0CP\0VF\0VL\0YA\0"
854  *              *len =          30
855  *              *elements =      9
856  */
857 int VpdKeys(
858 SK_AC   *pAC,           /* common data base */
859 SK_IOC  IoC,            /* IO Context */
860 char    *buf,           /* buffer where to copy the keywords */
861 int             *len,           /* buffer length */
862 int             *elements)      /* number of keywords returned */
863 {
864         char *v;
865         int n;
866
867         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX, ("list VPD keys .. "));
868         *elements = 0;
869         if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
870                 if (VpdInit(pAC, IoC) != 0) {
871                         *len = 0;
872                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
873                                 ("VPD Init Error, terminated\n"));
874                         return(6);
875                 }
876         }
877
878         if ((signed)strlen(VPD_NAME) + 1 <= *len) {
879                 v = pAC->vpd.vpd_buf;
880                 strcpy(buf,VPD_NAME);
881                 n = strlen(VPD_NAME) + 1;
882                 buf += n;
883                 *elements = 1;
884                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX,
885                         ("'%c%c' ",v[0],v[1]));
886         }
887         else {
888                 *len = 0;
889                 SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
890                         ("buffer overflow\n"));
891                 return(2);
892         }
893
894         v += 3 + VPD_GET_RES_LEN(v) + 3;
895         for (;; ) {
896                 /* exit when reaching the "RW" Tag */
897                 if (SK_MEMCMP(VPD_RW,v,2) == 0) {
898                         break;
899                 }
900
901                 if (SK_MEMCMP(VPD_RV,v,2) == 0) {
902                         v += 3 + VPD_GET_VPD_LEN(v) + 3;        /* skip VPD-W */
903                         continue;
904                 }
905
906                 if (n+3 <= *len) {
907                         SK_MEMCPY(buf,v,2);
908                         buf += 2;
909                         *buf++ = '\0';
910                         n += 3;
911                         v += 3 + VPD_GET_VPD_LEN(v);
912                         *elements += 1;
913                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX,
914                                 ("'%c%c' ",v[0],v[1]));
915                 }
916                 else {
917                         *len = n;
918                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
919                                 ("buffer overflow\n"));
920                         return(2);
921                 }
922         }
923
924         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX, ("\n"));
925         *len = n;
926         return(0);
927 }
928
929
930 /*
931  *      Read the contents of the VPD EEPROM and copy it to the
932  *      VPD buffer if not already done. Search for the VPD keyword
933  *      'key' and copy its value to 'buf'. Add a terminating '\0'.
934  *      If the value does not fit into the buffer cut it after
935  *      'len' - 1 bytes.
936  *
937  * returns      0:      success
938  *              1:      keyword not found
939  *              2:      value string was cut
940  *              3:      VPD transfer timeout
941  *              6:      fatal VPD error
942  */
943 int VpdRead(
944 SK_AC           *pAC,   /* common data base */
945 SK_IOC          IoC,    /* IO Context */
946 const char      *key,   /* keyword to read (e.g. "MN") */
947 char            *buf,   /* buffer where to copy the keyword value */
948 int                     *len)   /* buffer length */
949 {
950         SK_VPD_PARA *p, vp;
951
952         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX, ("VPD read %s .. ", key));
953         if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
954                 if (VpdInit(pAC, IoC) != 0) {
955                         *len = 0;
956                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
957                                 ("VPD init error\n"));
958                         return(6);
959                 }
960         }
961
962         if ((p = vpd_find_para(pAC, key, &vp)) != NULL) {
963                 if (p->p_len > (*(unsigned *)len)-1) {
964                         p->p_len = *len - 1;
965                 }
966                 SK_MEMCPY(buf, p->p_val, p->p_len);
967                 buf[p->p_len] = '\0';
968                 *len = p->p_len;
969                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX,
970                         ("%c%c%c%c.., len = %d\n",
971                         buf[0],buf[1],buf[2],buf[3],*len));
972         }
973         else {
974                 *len = 0;
975                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR, ("not found\n"));
976                 return(1);
977         }
978         return(0);
979 }
980
981
982 /*
983  *      Check whether a given key may be written
984  *
985  * returns
986  *      SK_TRUE         Yes it may be written
987  *      SK_FALSE        No it may be written
988  */
989 SK_BOOL VpdMayWrite(
990 char    *key)   /* keyword to write (allowed values "Yx", "Vx") */
991 {
992         if ((*key != 'Y' && *key != 'V') ||
993                 key[1] < '0' || key[1] > 'Z' ||
994                 (key[1] > '9' && key[1] < 'A') || strlen(key) != 2) {
995
996                 return(SK_FALSE);
997         }
998         return(SK_TRUE);
999 }
1000
1001 /*
1002  *      Read the contents of the VPD EEPROM and copy it to the VPD
1003  *      buffer if not already done. Insert/overwrite the keyword 'key'
1004  *      in the VPD buffer. Cut the keyword value if it does not fit
1005  *      into the VPD read / write area.
1006  *
1007  * returns      0:      success
1008  *              2:      value string was cut
1009  *              3:      VPD transfer timeout
1010  *              4:      VPD full, keyword was not written
1011  *              5:      keyword cannot be written
1012  *              6:      fatal VPD error
1013  */
1014 int VpdWrite(
1015 SK_AC           *pAC,   /* common data base */
1016 SK_IOC          IoC,    /* IO Context */
1017 const char      *key,   /* keyword to write (allowed values "Yx", "Vx") */
1018 const char      *buf)   /* buffer where the keyword value can be read from */
1019 {
1020         int len;                /* length of the keyword to write */
1021         int rtv;                /* return code */
1022         int rtv2;
1023
1024         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX,
1025                 ("VPD write %s = %s\n",key,buf));
1026
1027         if ((*key != 'Y' && *key != 'V') ||
1028                 key[1] < '0' || key[1] > 'Z' ||
1029                 (key[1] > '9' && key[1] < 'A') || strlen(key) != 2) {
1030
1031                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1032                         ("illegal key tag, keyword not written\n"));
1033                 return(5);
1034         }
1035
1036         if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
1037                 if (VpdInit(pAC, IoC) != 0) {
1038                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1039                                 ("VPD init error\n"));
1040                         return(6);
1041                 }
1042         }
1043
1044         rtv = 0;
1045         len = strlen(buf);
1046         if (len > VPD_MAX_LEN) {
1047                 /* cut it */
1048                 len = VPD_MAX_LEN;
1049                 rtv = 2;
1050                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1051                         ("keyword too long, cut after %d bytes\n",VPD_MAX_LEN));
1052         }
1053         if ((rtv2 = VpdSetupPara(pAC, key, buf, len, VPD_RW_KEY, OWR_KEY)) != 0) {
1054                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1055                         ("VPD write error\n"));
1056                 return(rtv2);
1057         }
1058
1059         return(rtv);
1060 }
1061
1062 /*
1063  *      Read the contents of the VPD EEPROM and copy it to the
1064  *      VPD buffer if not already done. Remove the VPD keyword
1065  *      'key' from the VPD buffer.
1066  *      Only the keywords in the read/write area can be deleted.
1067  *      Keywords in the read only area cannot be deleted.
1068  *
1069  * returns      0:      success, keyword was removed
1070  *              1:      keyword not found
1071  *              5:      keyword cannot be deleted
1072  *              6:      fatal VPD error
1073  */
1074 int VpdDelete(
1075 SK_AC   *pAC,   /* common data base */
1076 SK_IOC  IoC,    /* IO Context */
1077 char    *key)   /* keyword to read (e.g. "MN") */
1078 {
1079         SK_VPD_PARA *p, vp;
1080         char *etp;
1081         int     vpd_size;
1082
1083         vpd_size = pAC->vpd.vpd_size;
1084
1085         SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_TX,("VPD delete key %s\n",key));
1086         if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
1087                 if (VpdInit(pAC, IoC) != 0) {
1088                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1089                                 ("VPD init error\n"));
1090                         return(6);
1091                 }
1092         }
1093
1094         if ((p = vpd_find_para(pAC, key, &vp)) != NULL) {
1095                 if (p->p_val < pAC->vpd.vpd_buf + vpd_size/2) {
1096                         /* try to delete read only keyword */
1097                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1098                                 ("cannot delete RO keyword\n"));
1099                         return(5);
1100                 }
1101
1102                 etp = pAC->vpd.vpd_buf + (vpd_size-pAC->vpd.v.vpd_free_rw-1-3);
1103
1104                 vpd_move_para(vp.p_val+vp.p_len, etp+2,
1105                         - ((int)(vp.p_len + 3)));
1106                 if (vpd_mod_endtag(pAC, etp - vp.p_len - 3)) {
1107                         pAC->vpd.v.vpd_status &= ~VPD_VALID;
1108                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1109                                 ("VPD encoding error\n"));
1110                         return(6);
1111                 }
1112         }
1113         else {
1114                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1115                         ("keyword not found\n"));
1116                 return(1);
1117         }
1118
1119         return(0);
1120 }
1121
1122 /*
1123  *      If the VPD buffer contains valid data write the VPD
1124  *      read/write area back to the VPD EEPROM.
1125  *
1126  * returns      0:      success
1127  *              3:      VPD transfer timeout
1128  */
1129 int VpdUpdate(
1130 SK_AC   *pAC,   /* Adapters context */
1131 SK_IOC  IoC)    /* IO Context */
1132 {
1133         int vpd_size;
1134
1135         vpd_size = pAC->vpd.vpd_size;
1136
1137         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX, ("VPD update .. "));
1138         if ((pAC->vpd.v.vpd_status & VPD_VALID) != 0) {
1139                 if (VpdTransferBlock(pAC, IoC, pAC->vpd.vpd_buf + vpd_size/2,
1140                         vpd_size/2, vpd_size/2, VPD_WRITE) != vpd_size/2) {
1141
1142                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1143                                 ("transfer timed out\n"));
1144                         return(3);
1145                 }
1146         }
1147         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX, ("done\n"));
1148         return(0);
1149 }
1150
1151
1152
1153 /*
1154  *      Read the contents of the VPD EEPROM and copy it to the VPD buffer
1155  *      if not already done. If the keyword "VF" is not present it will be
1156  *      created and the error log message will be stored to this keyword.
1157  *      If "VF" is not present the error log message will be stored to the
1158  *      keyword "VL". "VL" will created or overwritten if "VF" is present.
1159  *      The VPD read/write area is saved to the VPD EEPROM.
1160  *
1161  * returns nothing, errors will be ignored.
1162  */
1163 void VpdErrLog(
1164 SK_AC   *pAC,   /* common data base */
1165 SK_IOC  IoC,    /* IO Context */
1166 char    *msg)   /* error log message */
1167 {
1168         SK_VPD_PARA *v, vf;     /* VF */
1169         int len;
1170
1171         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX,
1172                 ("VPD error log msg %s\n", msg));
1173         if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
1174                 if (VpdInit(pAC, IoC) != 0) {
1175                         SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1176                                 ("VPD init error\n"));
1177                         return;
1178                 }
1179         }
1180
1181         len = strlen(msg);
1182         if (len > VPD_MAX_LEN) {
1183                 /* cut it */
1184                 len = VPD_MAX_LEN;
1185         }
1186         if ((v = vpd_find_para(pAC, VPD_VF, &vf)) != NULL) {
1187                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX, ("overwrite VL\n"));
1188                 (void)VpdSetupPara(pAC, VPD_VL, msg, len, VPD_RW_KEY, OWR_KEY);
1189         }
1190         else {
1191                 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX, ("write VF\n"));
1192                 (void)VpdSetupPara(pAC, VPD_VF, msg, len, VPD_RW_KEY, ADD_KEY);
1193         }
1194
1195         (void)VpdUpdate(pAC, IoC);
1196 }
1197