blob: 3b81e67df891ff84a933d6d280b29f5f031b1d39 [file] [log] [blame]
wdenk7152b1d2003-09-05 23:19:14 +00001/******************************************************************************
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 *
26 * History:
27 *
28 * $Log: skvpd.c,v $
29 * Revision 1.37 2003/01/13 10:42:45 rschmidt
30 * Replaced check for PCI device Id from YUKON with GENESIS
31 * to set the VPD size in VpdInit()
32 * Editorial changes
wdenk42d1f032003-10-15 23:53:47 +000033 *
wdenk7152b1d2003-09-05 23:19:14 +000034 * Revision 1.36 2002/11/14 15:16:56 gheinig
35 * Added const specifier to key and buf parameters for VpdPara, VpdRead
36 * and VpdWrite for Diag 7 GUI
wdenk42d1f032003-10-15 23:53:47 +000037 *
wdenk7152b1d2003-09-05 23:19:14 +000038 * Revision 1.35 2002/10/21 14:31:59 gheinig
39 * Took out CVS web garbage at head of file
wdenk42d1f032003-10-15 23:53:47 +000040 *
wdenk7152b1d2003-09-05 23:19:14 +000041 * Revision 1.34 2002/10/21 11:47:24 gheinig
42 * Reverted to version 1.32 due to unwanted commit
wdenk42d1f032003-10-15 23:53:47 +000043 *
wdenk7152b1d2003-09-05 23:19:14 +000044 * Revision 1.32 2002/10/14 16:04:29 rschmidt
45 * Added saving of VPD ROM Size from PCI_OUR_REG_2
46 * Avoid reading of PCI_OUR_REG_2 in VpdTransferBlock()
47 * Editorial changes
wdenk42d1f032003-10-15 23:53:47 +000048 *
wdenk7152b1d2003-09-05 23:19:14 +000049 * Revision 1.31 2002/09/10 09:21:32 mkarl
50 * Replaced all if(GIChipId == CHIP_ID_GENESIS) with new entry GIGenesis
wdenk42d1f032003-10-15 23:53:47 +000051 *
wdenk7152b1d2003-09-05 23:19:14 +000052 * Revision 1.30 2002/09/09 14:43:03 mkarl
53 * changes for diagnostics in order to read VPD data before the adapter
54 * has been initialized
55 * editorial changes
wdenk42d1f032003-10-15 23:53:47 +000056 *
wdenk7152b1d2003-09-05 23:19:14 +000057 * Revision 1.29 2002/07/26 13:20:43 mkarl
58 * added Yukon support
59 * save size of VPD in pAC->vpd.vpd_size
wdenk42d1f032003-10-15 23:53:47 +000060 *
wdenk7152b1d2003-09-05 23:19:14 +000061 * Revision 1.28 2002/04/02 15:31:47 afischer
62 * Bug fix in VpdWait()
wdenk42d1f032003-10-15 23:53:47 +000063 *
wdenk7152b1d2003-09-05 23:19:14 +000064 * Revision 1.27 2000/08/10 11:29:06 rassmann
65 * Editorial changes.
66 * Preserving 32-bit alignment in structs for the adapter context.
67 * Removed unused function VpdWriteDword() (#if 0).
68 * Made VpdReadKeyword() available for SKDIAG only.
wdenk42d1f032003-10-15 23:53:47 +000069 *
wdenk7152b1d2003-09-05 23:19:14 +000070 * Revision 1.26 2000/06/13 08:00:01 mkarl
71 * additional cast to avoid compile problems in 64 bit environment
wdenk42d1f032003-10-15 23:53:47 +000072 *
wdenk7152b1d2003-09-05 23:19:14 +000073 * Revision 1.25 1999/11/22 13:39:32 cgoos
74 * Changed license header to GPL.
wdenk42d1f032003-10-15 23:53:47 +000075 *
wdenk7152b1d2003-09-05 23:19:14 +000076 * Revision 1.24 1999/03/11 14:25:49 malthoff
77 * Replace __STDC__ with SK_KR_PROTO.
wdenk42d1f032003-10-15 23:53:47 +000078 *
wdenk7152b1d2003-09-05 23:19:14 +000079 * Revision 1.23 1999/01/11 15:13:11 gklug
80 * fix: syntax error
wdenk42d1f032003-10-15 23:53:47 +000081 *
wdenk7152b1d2003-09-05 23:19:14 +000082 * Revision 1.22 1998/10/30 06:41:15 gklug
83 * rmv: WARNING
wdenk42d1f032003-10-15 23:53:47 +000084 *
wdenk7152b1d2003-09-05 23:19:14 +000085 * Revision 1.21 1998/10/29 07:15:14 gklug
86 * fix: Write Stream function needs verify.
wdenk42d1f032003-10-15 23:53:47 +000087 *
wdenk7152b1d2003-09-05 23:19:14 +000088 * Revision 1.20 1998/10/28 18:05:08 gklug
89 * chg: no DEBUG in VpdMayWrite
wdenk42d1f032003-10-15 23:53:47 +000090 *
wdenk7152b1d2003-09-05 23:19:14 +000091 * Revision 1.19 1998/10/28 15:56:11 gklug
92 * fix: Return len at end of ReadStream
93 * fix: Write even less than 4 bytes correctly
wdenk42d1f032003-10-15 23:53:47 +000094 *
wdenk7152b1d2003-09-05 23:19:14 +000095 * Revision 1.18 1998/10/28 09:00:47 gklug
96 * fix: unreferenced local vars
wdenk42d1f032003-10-15 23:53:47 +000097 *
wdenk7152b1d2003-09-05 23:19:14 +000098 * Revision 1.17 1998/10/28 08:25:45 gklug
99 * fix: WARNING
wdenk42d1f032003-10-15 23:53:47 +0000100 *
wdenk7152b1d2003-09-05 23:19:14 +0000101 * Revision 1.16 1998/10/28 08:17:30 gklug
102 * fix: typo
wdenk42d1f032003-10-15 23:53:47 +0000103 *
wdenk7152b1d2003-09-05 23:19:14 +0000104 * Revision 1.15 1998/10/28 07:50:32 gklug
105 * fix: typo
wdenk42d1f032003-10-15 23:53:47 +0000106 *
wdenk7152b1d2003-09-05 23:19:14 +0000107 * Revision 1.14 1998/10/28 07:20:38 gklug
108 * chg: Interface functions to use IoC as parameter as well
109 * fix: VpdRead/WriteDWord now returns SK_U32
110 * chg: VPD_IN/OUT names conform to SK_IN/OUT
111 * add: usage of VPD_IN/OUT8 macros
112 * add: VpdRead/Write Stream functions to r/w a stream of data
113 * fix: VpdTransferBlock swapped illegal
114 * add: VpdMayWrite
wdenk42d1f032003-10-15 23:53:47 +0000115 *
wdenk7152b1d2003-09-05 23:19:14 +0000116 * Revision 1.13 1998/10/22 10:02:37 gklug
117 * fix: SysKonnectFileId typo
wdenk42d1f032003-10-15 23:53:47 +0000118 *
wdenk7152b1d2003-09-05 23:19:14 +0000119 * Revision 1.12 1998/10/20 10:01:01 gklug
120 * fix: parameter to SkOsGetTime
wdenk42d1f032003-10-15 23:53:47 +0000121 *
wdenk7152b1d2003-09-05 23:19:14 +0000122 * Revision 1.11 1998/10/15 12:51:48 malthoff
123 * Remove unrequired parameter p in vpd_setup_para().
wdenk42d1f032003-10-15 23:53:47 +0000124 *
wdenk7152b1d2003-09-05 23:19:14 +0000125 * Revision 1.10 1998/10/08 14:52:43 malthoff
126 * Remove CvsId by SysKonnectFileId.
wdenk42d1f032003-10-15 23:53:47 +0000127 *
wdenk7152b1d2003-09-05 23:19:14 +0000128 * Revision 1.9 1998/09/16 07:33:52 malthoff
129 * replace memcmp() by SK_MEMCMP and
130 * memcpy() by SK_MEMCPY() to be
131 * independent from the 'C' Standard Library.
wdenk42d1f032003-10-15 23:53:47 +0000132 *
wdenk7152b1d2003-09-05 23:19:14 +0000133 * Revision 1.8 1998/08/19 12:52:35 malthoff
134 * compiler fix: use SK_VPD_KEY instead of S_VPD.
wdenk42d1f032003-10-15 23:53:47 +0000135 *
wdenk7152b1d2003-09-05 23:19:14 +0000136 * Revision 1.7 1998/08/19 08:14:01 gklug
137 * fix: remove struct keyword as much as possible from the C-code (see CCC)
wdenk42d1f032003-10-15 23:53:47 +0000138 *
wdenk7152b1d2003-09-05 23:19:14 +0000139 * Revision 1.6 1998/08/18 13:03:58 gklug
140 * SkOsGetTime now returns SK_U64
wdenk42d1f032003-10-15 23:53:47 +0000141 *
wdenk7152b1d2003-09-05 23:19:14 +0000142 * Revision 1.5 1998/08/18 08:17:29 malthoff
143 * Ensure we issue a VPD read in vpd_read_dword().
144 * Discard all VPD keywords other than Vx or Yx, where
145 * x is '0..9' or 'A..Z'.
wdenk42d1f032003-10-15 23:53:47 +0000146 *
wdenk7152b1d2003-09-05 23:19:14 +0000147 * Revision 1.4 1998/07/03 14:52:19 malthoff
148 * Add category SK_DBGCAT_FATAL to some debug macros.
149 * bug fix: correct the keyword name check in vpd_write().
wdenk42d1f032003-10-15 23:53:47 +0000150 *
wdenk7152b1d2003-09-05 23:19:14 +0000151 * Revision 1.3 1998/06/26 11:16:53 malthoff
152 * Correct the modified File Identifier.
wdenk42d1f032003-10-15 23:53:47 +0000153 *
wdenk7152b1d2003-09-05 23:19:14 +0000154 * Revision 1.2 1998/06/26 11:13:43 malthoff
155 * Modify the File Identifier.
wdenk42d1f032003-10-15 23:53:47 +0000156 *
wdenk7152b1d2003-09-05 23:19:14 +0000157 * Revision 1.1 1998/06/19 14:11:08 malthoff
158 * Created, Tests with AIX were performed successfully
wdenk42d1f032003-10-15 23:53:47 +0000159 *
wdenk7152b1d2003-09-05 23:19:14 +0000160 *
161 ******************************************************************************/
162
wdenk149dded2003-09-10 18:20:28 +0000163#include <config.h>
164
165#ifdef CONFIG_SK98
166
wdenk7152b1d2003-09-05 23:19:14 +0000167/*
168 Please refer skvpd.txt for infomation how to include this module
169 */
170static const char SysKonnectFileId[] =
171 "@(#)$Id: skvpd.c,v 1.37 2003/01/13 10:42:45 rschmidt Exp $ (C) SK";
172
173#include "h/skdrv1st.h"
174#include "h/sktypes.h"
175#include "h/skdebug.h"
176#include "h/skdrv2nd.h"
177
178/*
179 * Static functions
180 */
181#ifndef SK_KR_PROTO
182static SK_VPD_PARA *vpd_find_para(
183 SK_AC *pAC,
184 const char *key,
185 SK_VPD_PARA *p);
186#else /* SK_KR_PROTO */
187static SK_VPD_PARA *vpd_find_para();
188#endif /* SK_KR_PROTO */
189
190/*
191 * waits for a completion of a VPD transfer
192 * The VPD transfer must complete within SK_TICKS_PER_SEC/16
193 *
194 * returns 0: success, transfer completes
195 * error exit(9) with a error message
196 */
197static int VpdWait(
198SK_AC *pAC, /* Adapters context */
199SK_IOC IoC, /* IO Context */
200int event) /* event to wait for (VPD_READ / VPD_write) completion*/
201{
202 SK_U64 start_time;
203 SK_U16 state;
204
205 SK_DBG_MSG(pAC,SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
206 ("VPD wait for %s\n", event?"Write":"Read"));
207 start_time = SkOsGetTime(pAC);
208 do {
209 if (SkOsGetTime(pAC) - start_time > SK_TICKS_PER_SEC) {
210
211 /* Bug fix AF: Thu Mar 28 2002
212 * Do not call: VPD_STOP(pAC, IoC);
213 * A pending VPD read cycle can not be aborted by writing
214 * VPD_WRITE to the PCI_VPD_ADR_REG (VPD address register).
215 * Although the write threshold in the OUR-register protects
216 * VPD read only space from being overwritten this does not
217 * protect a VPD read from being `converted` into a VPD write
218 * operation (on the fly). As a consequence the VPD_STOP would
219 * delete VPD read only data. In case of any problems with the
220 * I2C bus we exit the loop here. The I2C read operation can
221 * not be aborted except by a reset (->LR).
222 */
223 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_FATAL | SK_DBGCAT_ERR,
224 ("ERROR:VPD wait timeout\n"));
225 return(1);
226 }
wdenk42d1f032003-10-15 23:53:47 +0000227
wdenk7152b1d2003-09-05 23:19:14 +0000228 VPD_IN16(pAC, IoC, PCI_VPD_ADR_REG, &state);
wdenk42d1f032003-10-15 23:53:47 +0000229
wdenk7152b1d2003-09-05 23:19:14 +0000230 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
231 ("state = %x, event %x\n",state,event));
232 } while((int)(state & PCI_VPD_FLAG) == event);
233
234 return(0);
235}
236
237#ifdef SKDIAG
238
239/*
240 * Read the dword at address 'addr' from the VPD EEPROM.
241 *
242 * Needed Time: MIN 1,3 ms MAX 2,6 ms
243 *
244 * Note: The DWord is returned in the endianess of the machine the routine
245 * is running on.
246 *
247 * Returns the data read.
248 */
249SK_U32 VpdReadDWord(
250SK_AC *pAC, /* Adapters context */
251SK_IOC IoC, /* IO Context */
252int addr) /* VPD address */
253{
254 SK_U32 Rtv;
255
256 /* start VPD read */
257 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
258 ("VPD read dword at 0x%x\n",addr));
259 addr &= ~VPD_WRITE; /* ensure the R/W bit is set to read */
260
261 VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, (SK_U16)addr);
262
263 /* ignore return code here */
264 (void)VpdWait(pAC, IoC, VPD_READ);
265
266 /* Don't swap here, it's a data stream of bytes */
267 Rtv = 0;
268
269 VPD_IN32(pAC, IoC, PCI_VPD_DAT_REG, &Rtv);
wdenk42d1f032003-10-15 23:53:47 +0000270
wdenk7152b1d2003-09-05 23:19:14 +0000271 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
272 ("VPD read dword data = 0x%x\n",Rtv));
273 return(Rtv);
274}
275
276#endif /* SKDIAG */
277
278#if 0
279
280/*
281 Write the dword 'data' at address 'addr' into the VPD EEPROM, and
282 verify that the data is written.
283
284 Needed Time:
285
286. MIN MAX
287. -------------------------------------------------------------------
288. write 1.8 ms 3.6 ms
289. internal write cyles 0.7 ms 7.0 ms
290. -------------------------------------------------------------------
291. over all program time 2.5 ms 10.6 ms
292. read 1.3 ms 2.6 ms
293. -------------------------------------------------------------------
294. over all 3.8 ms 13.2 ms
295.
296
297
298 Returns 0: success
299 1: error, I2C transfer does not terminate
300 2: error, data verify error
301
302 */
303static int VpdWriteDWord(
304SK_AC *pAC, /* pAC pointer */
305SK_IOC IoC, /* IO Context */
306int addr, /* VPD address */
307SK_U32 data) /* VPD data to write */
308{
309 /* start VPD write */
310 /* Don't swap here, it's a data stream of bytes */
311 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
312 ("VPD write dword at addr 0x%x, data = 0x%x\n",addr,data));
313 VPD_OUT32(pAC, IoC, PCI_VPD_DAT_REG, (SK_U32)data);
314 /* But do it here */
315 addr |= VPD_WRITE;
316
317 VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, (SK_U16)(addr | VPD_WRITE));
318
319 /* this may take up to 10,6 ms */
320 if (VpdWait(pAC, IoC, VPD_WRITE)) {
321 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
322 ("Write Timed Out\n"));
323 return(1);
324 };
325
326 /* verify data */
327 if (VpdReadDWord(pAC, IoC, addr) != data) {
328 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
329 ("Data Verify Error\n"));
330 return(2);
331 }
332 return(0);
333} /* VpdWriteDWord */
334
335#endif /* 0 */
336
337/*
338 * Read one Stream of 'len' bytes of VPD data, starting at 'addr' from
339 * or to the I2C EEPROM.
340 *
341 * Returns number of bytes read / written.
342 */
343static int VpdWriteStream(
344SK_AC *pAC, /* Adapters context */
345SK_IOC IoC, /* IO Context */
346char *buf, /* data buffer */
347int Addr, /* VPD start address */
348int Len) /* number of bytes to read / to write */
349{
350 int i;
351 int j;
352 SK_U16 AdrReg;
353 int Rtv;
354 SK_U8 * pComp; /* Compare pointer */
355 SK_U8 Data; /* Input Data for Compare */
356
357 /* Init Compare Pointer */
358 pComp = (SK_U8 *) buf;
359
360 for (i = 0; i < Len; i++, buf++) {
361 if ((i%sizeof(SK_U32)) == 0) {
362 /*
363 * At the begin of each cycle read the Data Reg
364 * So it is initialized even if only a few bytes
365 * are written.
366 */
367 AdrReg = (SK_U16) Addr;
368 AdrReg &= ~VPD_WRITE; /* READ operation */
369
370 VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
371
372 /* Wait for termination */
373 Rtv = VpdWait(pAC, IoC, VPD_READ);
374 if (Rtv != 0) {
375 return(i);
376 }
377 }
378
379 /* Write current Byte */
380 VPD_OUT8(pAC, IoC, PCI_VPD_DAT_REG + (i%sizeof(SK_U32)),
381 *(SK_U8*)buf);
382
383 if (((i%sizeof(SK_U32)) == 3) || (i == (Len - 1))) {
384 /* New Address needs to be written to VPD_ADDR reg */
385 AdrReg = (SK_U16) Addr;
386 Addr += sizeof(SK_U32);
387 AdrReg |= VPD_WRITE; /* WRITE operation */
388
389 VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
390
391 /* Wait for termination */
392 Rtv = VpdWait(pAC, IoC, VPD_WRITE);
393 if (Rtv != 0) {
394 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
395 ("Write Timed Out\n"));
396 return(i - (i%sizeof(SK_U32)));
397 }
398
399 /*
400 * Now re-read to verify
401 */
402 AdrReg &= ~VPD_WRITE; /* READ operation */
403
404 VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
405
406 /* Wait for termination */
407 Rtv = VpdWait(pAC, IoC, VPD_READ);
408 if (Rtv != 0) {
409 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
410 ("Verify Timed Out\n"));
411 return(i - (i%sizeof(SK_U32)));
412 }
413
414 for (j = 0; j <= (int)(i%sizeof(SK_U32)); j++, pComp++) {
wdenk42d1f032003-10-15 23:53:47 +0000415
wdenk7152b1d2003-09-05 23:19:14 +0000416 VPD_IN8(pAC, IoC, PCI_VPD_DAT_REG + j, &Data);
wdenk42d1f032003-10-15 23:53:47 +0000417
wdenk7152b1d2003-09-05 23:19:14 +0000418 if (Data != *pComp) {
419 /* Verify Error */
420 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
421 ("WriteStream Verify Error\n"));
422 return(i - (i%sizeof(SK_U32)) + j);
423 }
424 }
425 }
426 }
427
428 return(Len);
429}
wdenk42d1f032003-10-15 23:53:47 +0000430
wdenk7152b1d2003-09-05 23:19:14 +0000431
432/*
433 * Read one Stream of 'len' bytes of VPD data, starting at 'addr' from
434 * or to the I2C EEPROM.
435 *
436 * Returns number of bytes read / written.
437 */
438static int VpdReadStream(
439SK_AC *pAC, /* Adapters context */
440SK_IOC IoC, /* IO Context */
441char *buf, /* data buffer */
442int Addr, /* VPD start address */
443int Len) /* number of bytes to read / to write */
444{
445 int i;
446 SK_U16 AdrReg;
447 int Rtv;
448
449 for (i = 0; i < Len; i++, buf++) {
450 if ((i%sizeof(SK_U32)) == 0) {
451 /* New Address needs to be written to VPD_ADDR reg */
452 AdrReg = (SK_U16) Addr;
453 Addr += sizeof(SK_U32);
454 AdrReg &= ~VPD_WRITE; /* READ operation */
455
456 VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
457
458 /* Wait for termination */
459 Rtv = VpdWait(pAC, IoC, VPD_READ);
460 if (Rtv != 0) {
461 return(i);
462 }
463 }
464 VPD_IN8(pAC, IoC, PCI_VPD_DAT_REG + (i%sizeof(SK_U32)),
465 (SK_U8 *)buf);
466 }
467
468 return(Len);
469}
470
471/*
472 * Read ore writes 'len' bytes of VPD data, starting at 'addr' from
473 * or to the I2C EEPROM.
474 *
475 * Returns number of bytes read / written.
476 */
477static int VpdTransferBlock(
478SK_AC *pAC, /* Adapters context */
479SK_IOC IoC, /* IO Context */
480char *buf, /* data buffer */
481int addr, /* VPD start address */
482int len, /* number of bytes to read / to write */
483int dir) /* transfer direction may be VPD_READ or VPD_WRITE */
484{
485 int Rtv; /* Return value */
486 int vpd_rom_size;
487
488 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
489 ("VPD %s block, addr = 0x%x, len = %d\n",
490 dir ? "write" : "read", addr, len));
491
492 if (len == 0)
493 return(0);
494
495 vpd_rom_size = pAC->vpd.rom_size;
wdenk42d1f032003-10-15 23:53:47 +0000496
wdenk7152b1d2003-09-05 23:19:14 +0000497 if (addr > vpd_rom_size - 4) {
498 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
499 ("Address error: 0x%x, exp. < 0x%x\n",
500 addr, vpd_rom_size - 4));
501 return(0);
502 }
wdenk42d1f032003-10-15 23:53:47 +0000503
wdenk7152b1d2003-09-05 23:19:14 +0000504 if (addr + len > vpd_rom_size) {
505 len = vpd_rom_size - addr;
506 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
507 ("Warning: len was cut to %d\n", len));
508 }
509
510 if (dir == VPD_READ) {
511 Rtv = VpdReadStream(pAC, IoC, buf, addr, len);
512 }
513 else {
514 Rtv = VpdWriteStream(pAC, IoC, buf, addr, len);
515 }
516
517 return(Rtv);
518}
519
520#ifdef SKDIAG
521
522/*
523 * Read 'len' bytes of VPD data, starting at 'addr'.
524 *
525 * Returns number of bytes read.
526 */
527int VpdReadBlock(
528SK_AC *pAC, /* pAC pointer */
529SK_IOC IoC, /* IO Context */
530char *buf, /* buffer were the data should be stored */
531int addr, /* start reading at the VPD address */
532int len) /* number of bytes to read */
533{
534 return(VpdTransferBlock(pAC, IoC, buf, addr, len, VPD_READ));
535}
536
537/*
538 * Write 'len' bytes of *but to the VPD EEPROM, starting at 'addr'.
539 *
540 * Returns number of bytes writes.
541 */
542int VpdWriteBlock(
543SK_AC *pAC, /* pAC pointer */
544SK_IOC IoC, /* IO Context */
545char *buf, /* buffer, holds the data to write */
546int addr, /* start writing at the VPD address */
547int len) /* number of bytes to write */
548{
549 return(VpdTransferBlock(pAC, IoC, buf, addr, len, VPD_WRITE));
550}
551#endif /* SKDIAG */
552
553/*
554 * (re)initialize the VPD buffer
555 *
556 * Reads the VPD data from the EEPROM into the VPD buffer.
557 * Get the remaining read only and read / write space.
558 *
559 * return 0: success
560 * 1: fatal VPD error
561 */
562static int VpdInit(
563SK_AC *pAC, /* Adapters context */
564SK_IOC IoC) /* IO Context */
565{
566 SK_VPD_PARA *r, rp; /* RW or RV */
567 int i;
568 unsigned char x;
569 int vpd_size;
570 SK_U16 dev_id;
571 SK_U32 our_reg2;
572
573 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_INIT, ("VpdInit .. "));
wdenk42d1f032003-10-15 23:53:47 +0000574
wdenk7152b1d2003-09-05 23:19:14 +0000575 VPD_IN16(pAC, IoC, PCI_DEVICE_ID, &dev_id);
wdenk42d1f032003-10-15 23:53:47 +0000576
wdenk7152b1d2003-09-05 23:19:14 +0000577 VPD_IN32(pAC, IoC, PCI_OUR_REG_2, &our_reg2);
wdenk42d1f032003-10-15 23:53:47 +0000578
wdenk7152b1d2003-09-05 23:19:14 +0000579 pAC->vpd.rom_size = 256 << ((our_reg2 & PCI_VPD_ROM_SZ) >> 14);
wdenk42d1f032003-10-15 23:53:47 +0000580
wdenk7152b1d2003-09-05 23:19:14 +0000581 /*
582 * this function might get used before the hardware is initialized
583 * therefore we cannot always trust in GIChipId
584 */
585 if (((pAC->vpd.v.vpd_status & VPD_VALID) == 0 &&
586 dev_id != VPD_DEV_ID_GENESIS) ||
587 ((pAC->vpd.v.vpd_status & VPD_VALID) != 0 &&
588 !pAC->GIni.GIGenesis)) {
589
590 /* for Yukon the VPD size is always 256 */
591 vpd_size = VPD_SIZE_YUKON;
592 }
593 else {
594 /* Genesis uses the maximum ROM size up to 512 for VPD */
595 if (pAC->vpd.rom_size > VPD_SIZE_GENESIS) {
596 vpd_size = VPD_SIZE_GENESIS;
597 }
598 else {
599 vpd_size = pAC->vpd.rom_size;
600 }
601 }
602
603 /* read the VPD data into the VPD buffer */
604 if (VpdTransferBlock(pAC, IoC, pAC->vpd.vpd_buf, 0, vpd_size, VPD_READ)
605 != vpd_size) {
606
607 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
608 ("Block Read Error\n"));
609 return(1);
610 }
wdenk42d1f032003-10-15 23:53:47 +0000611
wdenk7152b1d2003-09-05 23:19:14 +0000612 pAC->vpd.vpd_size = vpd_size;
613
614 /* find the end tag of the RO area */
615 if (!(r = vpd_find_para(pAC, VPD_RV, &rp))) {
616 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
617 ("Encoding Error: RV Tag not found\n"));
618 return(1);
619 }
wdenk42d1f032003-10-15 23:53:47 +0000620
wdenk7152b1d2003-09-05 23:19:14 +0000621 if (r->p_val + r->p_len > pAC->vpd.vpd_buf + vpd_size/2) {
622 SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
623 ("Encoding Error: Invalid VPD struct size\n"));
624 return(1);
625 }
626 pAC->vpd.v.vpd_free_ro = r->p_len - 1;
627
628 /* test the checksum */
629 for (i = 0, x = 0; (unsigned)i <= (unsigned)vpd_size/2 - r->p_len; i++) {
630 x += pAC->vpd.vpd_buf[i];
631 }
wdenk42d1f032003-10-15 23:53:47 +0000632
wdenk7152b1d2003-09-05 23:19:14 +0000633 if (x != 0) {
634 /* checksum error */
635 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
636 ("VPD Checksum Error\n"));
637 return(1);
638 }
639
640 /* find and check the end tag of the RW area */
641 if (!(r = vpd_find_para(pAC, VPD_RW, &rp))) {
642 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
643 ("Encoding Error: RV Tag not found\n"));
644 return(1);
645 }
wdenk42d1f032003-10-15 23:53:47 +0000646
wdenk7152b1d2003-09-05 23:19:14 +0000647 if (r->p_val < pAC->vpd.vpd_buf + vpd_size/2) {
648 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
649 ("Encoding Error: Invalid VPD struct size\n"));
650 return(1);
651 }
652 pAC->vpd.v.vpd_free_rw = r->p_len;
653
654 /* everything seems to be ok */
655 if (pAC->GIni.GIChipId != 0) {
656 pAC->vpd.v.vpd_status |= VPD_VALID;
657 }
658
659 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_INIT,
660 ("done. Free RO = %d, Free RW = %d\n",
661 pAC->vpd.v.vpd_free_ro, pAC->vpd.v.vpd_free_rw));
662
663 return(0);
664}
665
666/*
667 * find the Keyword 'key' in the VPD buffer and fills the
668 * parameter struct 'p' with it's values
669 *
670 * returns *p success
671 * 0: parameter was not found or VPD encoding error
672 */
673static SK_VPD_PARA *vpd_find_para(
674SK_AC *pAC, /* common data base */
675const char *key, /* keyword to find (e.g. "MN") */
676SK_VPD_PARA *p) /* parameter description struct */
677{
678 char *v ; /* points to VPD buffer */
679 int max; /* Maximum Number of Iterations */
680
681 v = pAC->vpd.vpd_buf;
682 max = 128;
683
684 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
685 ("VPD find para %s .. ",key));
686
687 /* check mandatory resource type ID string (Product Name) */
688 if (*v != (char)RES_ID) {
689 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
690 ("Error: 0x%x missing\n", RES_ID));
691 return(0);
692 }
693
694 if (strcmp(key, VPD_NAME) == 0) {
695 p->p_len = VPD_GET_RES_LEN(v);
696 p->p_val = VPD_GET_VAL(v);
697 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
698 ("found, len = %d\n", p->p_len));
699 return(p);
700 }
701
702 v += 3 + VPD_GET_RES_LEN(v) + 3;
703 for (;; ) {
704 if (SK_MEMCMP(key,v,2) == 0) {
705 p->p_len = VPD_GET_VPD_LEN(v);
706 p->p_val = VPD_GET_VAL(v);
707 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
708 ("found, len = %d\n",p->p_len));
709 return(p);
710 }
711
712 /* exit when reaching the "RW" Tag or the maximum of itera. */
713 max--;
714 if (SK_MEMCMP(VPD_RW,v,2) == 0 || max == 0) {
715 break;
716 }
717
718 if (SK_MEMCMP(VPD_RV,v,2) == 0) {
719 v += 3 + VPD_GET_VPD_LEN(v) + 3; /* skip VPD-W */
720 }
721 else {
722 v += 3 + VPD_GET_VPD_LEN(v);
723 }
724 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
725 ("scanning '%c%c' len = %d\n",v[0],v[1],v[2]));
726 }
727
728#ifdef DEBUG
729 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL, ("not found\n"));
730 if (max == 0) {
731 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
732 ("Key/Len Encoding error\n"));
733 }
734#endif /* DEBUG */
735 return(0);
736}
737
738/*
739 * Move 'n' bytes. Begin with the last byte if 'n' is > 0,
740 * Start with the last byte if n is < 0.
741 *
742 * returns nothing
743 */
744static void vpd_move_para(
745char *start, /* start of memory block */
746char *end, /* end of memory block to move */
747int n) /* number of bytes the memory block has to be moved */
748{
749 char *p;
750 int i; /* number of byte copied */
751
752 if (n == 0)
753 return;
754
755 i = (int) (end - start + 1);
756 if (n < 0) {
757 p = start + n;
758 while (i != 0) {
759 *p++ = *start++;
760 i--;
761 }
762 }
763 else {
764 p = end + n;
765 while (i != 0) {
766 *p-- = *end--;
767 i--;
768 }
769 }
770}
771
772/*
773 * setup the VPD keyword 'key' at 'ip'.
774 *
775 * returns nothing
776 */
777static void vpd_insert_key(
778const char *key, /* keyword to insert */
779const char *buf, /* buffer with the keyword value */
780int len, /* length of the value string */
781char *ip) /* inseration point */
782{
783 SK_VPD_KEY *p;
784
785 p = (SK_VPD_KEY *) ip;
786 p->p_key[0] = key[0];
787 p->p_key[1] = key[1];
788 p->p_len = (unsigned char) len;
789 SK_MEMCPY(&p->p_val,buf,len);
790}
791
792/*
793 * Setup the VPD end tag "RV" / "RW".
794 * Also correct the remaining space variables vpd_free_ro / vpd_free_rw.
795 *
796 * returns 0: success
797 * 1: encoding error
798 */
799static int vpd_mod_endtag(
800SK_AC *pAC, /* common data base */
801char *etp) /* end pointer input position */
802{
803 SK_VPD_KEY *p;
804 unsigned char x;
805 int i;
806 int vpd_size;
807
808 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
809 ("VPD modify endtag at 0x%x = '%c%c'\n",etp,etp[0],etp[1]));
810
811 vpd_size = pAC->vpd.vpd_size;
812
813 p = (SK_VPD_KEY *) etp;
814
815 if (p->p_key[0] != 'R' || (p->p_key[1] != 'V' && p->p_key[1] != 'W')) {
816 /* something wrong here, encoding error */
817 SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
818 ("Encoding Error: invalid end tag\n"));
819 return(1);
820 }
821 if (etp > pAC->vpd.vpd_buf + vpd_size/2) {
822 /* create "RW" tag */
823 p->p_len = (unsigned char)(pAC->vpd.vpd_buf+vpd_size-etp-3-1);
824 pAC->vpd.v.vpd_free_rw = (int) p->p_len;
825 i = pAC->vpd.v.vpd_free_rw;
826 etp += 3;
827 }
828 else {
829 /* create "RV" tag */
830 p->p_len = (unsigned char)(pAC->vpd.vpd_buf+vpd_size/2-etp-3);
831 pAC->vpd.v.vpd_free_ro = (int) p->p_len - 1;
832
833 /* setup checksum */
834 for (i = 0, x = 0; i < vpd_size/2 - p->p_len; i++) {
835 x += pAC->vpd.vpd_buf[i];
836 }
837 p->p_val = (char) 0 - x;
838 i = pAC->vpd.v.vpd_free_ro;
839 etp += 4;
840 }
841 while (i) {
842 *etp++ = 0x00;
843 i--;
844 }
845
846 return(0);
847}
848
849/*
850 * Insert a VPD keyword into the VPD buffer.
851 *
852 * The keyword 'key' is inserted at the position 'ip' in the
853 * VPD buffer.
854 * The keywords behind the input position will
855 * be moved. The VPD end tag "RV" or "RW" is generated again.
856 *
857 * returns 0: success
858 * 2: value string was cut
859 * 4: VPD full, keyword was not written
860 * 6: fatal VPD error
861 *
862 */
863int VpdSetupPara(
864SK_AC *pAC, /* common data base */
865const char *key, /* keyword to insert */
866const char *buf, /* buffer with the keyword value */
867int len, /* length of the keyword value */
868int type, /* VPD_RO_KEY or VPD_RW_KEY */
869int op) /* operation to do: ADD_KEY or OWR_KEY */
870{
871 SK_VPD_PARA vp;
872 char *etp; /* end tag position */
873 int free; /* remaining space in selected area */
874 char *ip; /* input position inside the VPD buffer */
875 int rtv; /* return code */
876 int head; /* additional haeder bytes to move */
877 int found; /* additinoal bytes if the keyword was found */
878 int vpd_size;
879
880 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
881 ("VPD setup para key = %s, val = %s\n",key,buf));
wdenk42d1f032003-10-15 23:53:47 +0000882
wdenk7152b1d2003-09-05 23:19:14 +0000883 vpd_size = pAC->vpd.vpd_size;
884
885 rtv = 0;
886 ip = 0;
887 if (type == VPD_RW_KEY) {
888 /* end tag is "RW" */
889 free = pAC->vpd.v.vpd_free_rw;
890 etp = pAC->vpd.vpd_buf + (vpd_size - free - 1 - 3);
891 }
892 else {
893 /* end tag is "RV" */
894 free = pAC->vpd.v.vpd_free_ro;
895 etp = pAC->vpd.vpd_buf + (vpd_size/2 - free - 4);
896 }
897 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
898 ("Free RO = %d, Free RW = %d\n",
899 pAC->vpd.v.vpd_free_ro, pAC->vpd.v.vpd_free_rw));
900
901 head = 0;
902 found = 0;
903 if (op == OWR_KEY) {
904 if (vpd_find_para(pAC, key, &vp)) {
905 found = 3;
906 ip = vp.p_val - 3;
907 free += vp.p_len + 3;
908 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
909 ("Overwrite Key\n"));
910 }
911 else {
912 op = ADD_KEY;
913 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
914 ("Add Key\n"));
915 }
916 }
917 if (op == ADD_KEY) {
918 ip = etp;
919 vp.p_len = 0;
920 head = 3;
921 }
922
923 if (len + 3 > free) {
924 if (free < 7) {
925 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
926 ("VPD Buffer Overflow, keyword not written\n"));
927 return(4);
928 }
929 /* cut it again */
930 len = free - 3;
931 rtv = 2;
932 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
933 ("VPD Buffer Full, Keyword was cut\n"));
934 }
935
936 vpd_move_para(ip + vp.p_len + found, etp+2, len-vp.p_len+head);
937 vpd_insert_key(key, buf, len, ip);
938 if (vpd_mod_endtag(pAC, etp + len - vp.p_len + head)) {
939 pAC->vpd.v.vpd_status &= ~VPD_VALID;
940 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
941 ("VPD Encoding Error\n"));
942 return(6);
943 }
944
945 return(rtv);
946}
947
948
949/*
950 * Read the contents of the VPD EEPROM and copy it to the
951 * VPD buffer if not already done.
952 *
953 * return: A pointer to the vpd_status structure. The structure contains
954 * this fields.
955 */
956SK_VPD_STATUS *VpdStat(
957SK_AC *pAC, /* Adapters context */
958SK_IOC IoC) /* IO Context */
959{
960 if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
961 (void)VpdInit(pAC, IoC);
962 }
963 return(&pAC->vpd.v);
964}
965
966
967/*
968 * Read the contents of the VPD EEPROM and copy it to the VPD
969 * buffer if not already done.
970 * Scan the VPD buffer for VPD keywords and create the VPD
971 * keyword list by copying the keywords to 'buf', all after
972 * each other and terminated with a '\0'.
973 *
974 * Exceptions: o The Resource Type ID String (product name) is called "Name"
975 * o The VPD end tags 'RV' and 'RW' are not listed
976 *
977 * The number of copied keywords is counted in 'elements'.
978 *
979 * returns 0: success
980 * 2: buffer overfull, one or more keywords are missing
981 * 6: fatal VPD error
982 *
983 * example values after returning:
984 *
985 * buf = "Name\0PN\0EC\0MN\0SN\0CP\0VF\0VL\0YA\0"
986 * *len = 30
987 * *elements = 9
988 */
989int VpdKeys(
990SK_AC *pAC, /* common data base */
991SK_IOC IoC, /* IO Context */
992char *buf, /* buffer where to copy the keywords */
993int *len, /* buffer length */
994int *elements) /* number of keywords returned */
995{
996 char *v;
997 int n;
998
999 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX, ("list VPD keys .. "));
1000 *elements = 0;
1001 if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
1002 if (VpdInit(pAC, IoC) != 0) {
1003 *len = 0;
1004 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1005 ("VPD Init Error, terminated\n"));
1006 return(6);
1007 }
1008 }
1009
1010 if ((signed)strlen(VPD_NAME) + 1 <= *len) {
1011 v = pAC->vpd.vpd_buf;
1012 strcpy(buf,VPD_NAME);
1013 n = strlen(VPD_NAME) + 1;
1014 buf += n;
1015 *elements = 1;
1016 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX,
1017 ("'%c%c' ",v[0],v[1]));
1018 }
1019 else {
1020 *len = 0;
1021 SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
1022 ("buffer overflow\n"));
1023 return(2);
1024 }
1025
1026 v += 3 + VPD_GET_RES_LEN(v) + 3;
1027 for (;; ) {
1028 /* exit when reaching the "RW" Tag */
1029 if (SK_MEMCMP(VPD_RW,v,2) == 0) {
1030 break;
1031 }
1032
1033 if (SK_MEMCMP(VPD_RV,v,2) == 0) {
1034 v += 3 + VPD_GET_VPD_LEN(v) + 3; /* skip VPD-W */
1035 continue;
1036 }
1037
1038 if (n+3 <= *len) {
1039 SK_MEMCPY(buf,v,2);
1040 buf += 2;
1041 *buf++ = '\0';
1042 n += 3;
1043 v += 3 + VPD_GET_VPD_LEN(v);
1044 *elements += 1;
1045 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX,
1046 ("'%c%c' ",v[0],v[1]));
1047 }
1048 else {
1049 *len = n;
1050 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1051 ("buffer overflow\n"));
1052 return(2);
1053 }
1054 }
1055
1056 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX, ("\n"));
1057 *len = n;
1058 return(0);
1059}
1060
1061
1062/*
1063 * Read the contents of the VPD EEPROM and copy it to the
1064 * VPD buffer if not already done. Search for the VPD keyword
1065 * 'key' and copy its value to 'buf'. Add a terminating '\0'.
1066 * If the value does not fit into the buffer cut it after
1067 * 'len' - 1 bytes.
1068 *
1069 * returns 0: success
1070 * 1: keyword not found
1071 * 2: value string was cut
1072 * 3: VPD transfer timeout
1073 * 6: fatal VPD error
1074 */
1075int VpdRead(
1076SK_AC *pAC, /* common data base */
1077SK_IOC IoC, /* IO Context */
1078const char *key, /* keyword to read (e.g. "MN") */
1079char *buf, /* buffer where to copy the keyword value */
1080int *len) /* buffer length */
1081{
1082 SK_VPD_PARA *p, vp;
1083
1084 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX, ("VPD read %s .. ", key));
1085 if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
1086 if (VpdInit(pAC, IoC) != 0) {
1087 *len = 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_len > (*(unsigned *)len)-1) {
1096 p->p_len = *len - 1;
1097 }
1098 SK_MEMCPY(buf, p->p_val, p->p_len);
1099 buf[p->p_len] = '\0';
1100 *len = p->p_len;
1101 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX,
1102 ("%c%c%c%c.., len = %d\n",
1103 buf[0],buf[1],buf[2],buf[3],*len));
1104 }
1105 else {
1106 *len = 0;
1107 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR, ("not found\n"));
1108 return(1);
1109 }
1110 return(0);
1111}
1112
1113
1114/*
1115 * Check whether a given key may be written
1116 *
1117 * returns
1118 * SK_TRUE Yes it may be written
1119 * SK_FALSE No it may be written
1120 */
1121SK_BOOL VpdMayWrite(
1122char *key) /* keyword to write (allowed values "Yx", "Vx") */
1123{
1124 if ((*key != 'Y' && *key != 'V') ||
1125 key[1] < '0' || key[1] > 'Z' ||
1126 (key[1] > '9' && key[1] < 'A') || strlen(key) != 2) {
1127
1128 return(SK_FALSE);
1129 }
1130 return(SK_TRUE);
1131}
1132
1133/*
1134 * Read the contents of the VPD EEPROM and copy it to the VPD
1135 * buffer if not already done. Insert/overwrite the keyword 'key'
1136 * in the VPD buffer. Cut the keyword value if it does not fit
1137 * into the VPD read / write area.
1138 *
1139 * returns 0: success
1140 * 2: value string was cut
1141 * 3: VPD transfer timeout
1142 * 4: VPD full, keyword was not written
1143 * 5: keyword cannot be written
1144 * 6: fatal VPD error
1145 */
1146int VpdWrite(
1147SK_AC *pAC, /* common data base */
1148SK_IOC IoC, /* IO Context */
1149const char *key, /* keyword to write (allowed values "Yx", "Vx") */
1150const char *buf) /* buffer where the keyword value can be read from */
1151{
1152 int len; /* length of the keyword to write */
1153 int rtv; /* return code */
1154 int rtv2;
1155
1156 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX,
1157 ("VPD write %s = %s\n",key,buf));
1158
1159 if ((*key != 'Y' && *key != 'V') ||
1160 key[1] < '0' || key[1] > 'Z' ||
1161 (key[1] > '9' && key[1] < 'A') || strlen(key) != 2) {
1162
1163 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1164 ("illegal key tag, keyword not written\n"));
1165 return(5);
1166 }
1167
1168 if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
1169 if (VpdInit(pAC, IoC) != 0) {
1170 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1171 ("VPD init error\n"));
1172 return(6);
1173 }
1174 }
1175
1176 rtv = 0;
1177 len = strlen(buf);
1178 if (len > VPD_MAX_LEN) {
1179 /* cut it */
1180 len = VPD_MAX_LEN;
1181 rtv = 2;
1182 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1183 ("keyword too long, cut after %d bytes\n",VPD_MAX_LEN));
1184 }
1185 if ((rtv2 = VpdSetupPara(pAC, key, buf, len, VPD_RW_KEY, OWR_KEY)) != 0) {
1186 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1187 ("VPD write error\n"));
1188 return(rtv2);
1189 }
1190
1191 return(rtv);
1192}
1193
1194/*
1195 * Read the contents of the VPD EEPROM and copy it to the
1196 * VPD buffer if not already done. Remove the VPD keyword
1197 * 'key' from the VPD buffer.
1198 * Only the keywords in the read/write area can be deleted.
1199 * Keywords in the read only area cannot be deleted.
1200 *
1201 * returns 0: success, keyword was removed
1202 * 1: keyword not found
1203 * 5: keyword cannot be deleted
1204 * 6: fatal VPD error
1205 */
1206int VpdDelete(
1207SK_AC *pAC, /* common data base */
1208SK_IOC IoC, /* IO Context */
1209char *key) /* keyword to read (e.g. "MN") */
1210{
1211 SK_VPD_PARA *p, vp;
1212 char *etp;
1213 int vpd_size;
1214
1215 vpd_size = pAC->vpd.vpd_size;
1216
1217 SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_TX,("VPD delete key %s\n",key));
1218 if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
1219 if (VpdInit(pAC, IoC) != 0) {
1220 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1221 ("VPD init error\n"));
1222 return(6);
1223 }
1224 }
1225
1226 if ((p = vpd_find_para(pAC, key, &vp)) != NULL) {
1227 if (p->p_val < pAC->vpd.vpd_buf + vpd_size/2) {
1228 /* try to delete read only keyword */
1229 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1230 ("cannot delete RO keyword\n"));
1231 return(5);
1232 }
1233
1234 etp = pAC->vpd.vpd_buf + (vpd_size-pAC->vpd.v.vpd_free_rw-1-3);
1235
1236 vpd_move_para(vp.p_val+vp.p_len, etp+2,
1237 - ((int)(vp.p_len + 3)));
1238 if (vpd_mod_endtag(pAC, etp - vp.p_len - 3)) {
1239 pAC->vpd.v.vpd_status &= ~VPD_VALID;
1240 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1241 ("VPD encoding error\n"));
1242 return(6);
1243 }
1244 }
1245 else {
1246 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1247 ("keyword not found\n"));
1248 return(1);
1249 }
1250
1251 return(0);
1252}
1253
1254/*
1255 * If the VPD buffer contains valid data write the VPD
1256 * read/write area back to the VPD EEPROM.
1257 *
1258 * returns 0: success
1259 * 3: VPD transfer timeout
1260 */
1261int VpdUpdate(
1262SK_AC *pAC, /* Adapters context */
1263SK_IOC IoC) /* IO Context */
1264{
1265 int vpd_size;
1266
1267 vpd_size = pAC->vpd.vpd_size;
1268
1269 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX, ("VPD update .. "));
1270 if ((pAC->vpd.v.vpd_status & VPD_VALID) != 0) {
1271 if (VpdTransferBlock(pAC, IoC, pAC->vpd.vpd_buf + vpd_size/2,
1272 vpd_size/2, vpd_size/2, VPD_WRITE) != vpd_size/2) {
1273
1274 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1275 ("transfer timed out\n"));
1276 return(3);
1277 }
1278 }
1279 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX, ("done\n"));
1280 return(0);
1281}
1282
1283
wdenk7152b1d2003-09-05 23:19:14 +00001284/*
1285 * Read the contents of the VPD EEPROM and copy it to the VPD buffer
1286 * if not already done. If the keyword "VF" is not present it will be
1287 * created and the error log message will be stored to this keyword.
1288 * If "VF" is not present the error log message will be stored to the
1289 * keyword "VL". "VL" will created or overwritten if "VF" is present.
1290 * The VPD read/write area is saved to the VPD EEPROM.
1291 *
1292 * returns nothing, errors will be ignored.
1293 */
1294void VpdErrLog(
1295SK_AC *pAC, /* common data base */
1296SK_IOC IoC, /* IO Context */
1297char *msg) /* error log message */
1298{
1299 SK_VPD_PARA *v, vf; /* VF */
1300 int len;
1301
1302 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX,
1303 ("VPD error log msg %s\n", msg));
1304 if ((pAC->vpd.v.vpd_status & VPD_VALID) == 0) {
1305 if (VpdInit(pAC, IoC) != 0) {
1306 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
1307 ("VPD init error\n"));
1308 return;
1309 }
1310 }
1311
1312 len = strlen(msg);
1313 if (len > VPD_MAX_LEN) {
1314 /* cut it */
1315 len = VPD_MAX_LEN;
1316 }
1317 if ((v = vpd_find_para(pAC, VPD_VF, &vf)) != NULL) {
1318 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX, ("overwrite VL\n"));
1319 (void)VpdSetupPara(pAC, VPD_VL, msg, len, VPD_RW_KEY, OWR_KEY);
1320 }
1321 else {
1322 SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX, ("write VF\n"));
1323 (void)VpdSetupPara(pAC, VPD_VF, msg, len, VPD_RW_KEY, ADD_KEY);
1324 }
1325
1326 (void)VpdUpdate(pAC, IoC);
1327}
1328
wdenk149dded2003-09-10 18:20:28 +00001329#endif /* CONFIG_SK98 */