]>
Commit | Line | Data |
---|---|---|
7152b1d0 WD |
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 | * | |
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 | |
42d1f039 | 33 | * |
7152b1d0 WD |
34 | * 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 | |
42d1f039 | 37 | * |
7152b1d0 WD |
38 | * Revision 1.35 2002/10/21 14:31:59 gheinig |
39 | * Took out CVS web garbage at head of file | |
42d1f039 | 40 | * |
7152b1d0 WD |
41 | * Revision 1.34 2002/10/21 11:47:24 gheinig |
42 | * Reverted to version 1.32 due to unwanted commit | |
42d1f039 | 43 | * |
7152b1d0 WD |
44 | * 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 | |
42d1f039 | 48 | * |
7152b1d0 WD |
49 | * Revision 1.31 2002/09/10 09:21:32 mkarl |
50 | * Replaced all if(GIChipId == CHIP_ID_GENESIS) with new entry GIGenesis | |
42d1f039 | 51 | * |
7152b1d0 WD |
52 | * 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 | |
42d1f039 | 56 | * |
7152b1d0 WD |
57 | * Revision 1.29 2002/07/26 13:20:43 mkarl |
58 | * added Yukon support | |
59 | * save size of VPD in pAC->vpd.vpd_size | |
42d1f039 | 60 | * |
7152b1d0 WD |
61 | * Revision 1.28 2002/04/02 15:31:47 afischer |
62 | * Bug fix in VpdWait() | |
42d1f039 | 63 | * |
7152b1d0 WD |
64 | * 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. | |
42d1f039 | 69 | * |
7152b1d0 WD |
70 | * Revision 1.26 2000/06/13 08:00:01 mkarl |
71 | * additional cast to avoid compile problems in 64 bit environment | |
42d1f039 | 72 | * |
7152b1d0 WD |
73 | * Revision 1.25 1999/11/22 13:39:32 cgoos |
74 | * Changed license header to GPL. | |
42d1f039 | 75 | * |
7152b1d0 WD |
76 | * Revision 1.24 1999/03/11 14:25:49 malthoff |
77 | * Replace __STDC__ with SK_KR_PROTO. | |
42d1f039 | 78 | * |
7152b1d0 WD |
79 | * Revision 1.23 1999/01/11 15:13:11 gklug |
80 | * fix: syntax error | |
42d1f039 | 81 | * |
7152b1d0 WD |
82 | * Revision 1.22 1998/10/30 06:41:15 gklug |
83 | * rmv: WARNING | |
42d1f039 | 84 | * |
7152b1d0 WD |
85 | * Revision 1.21 1998/10/29 07:15:14 gklug |
86 | * fix: Write Stream function needs verify. | |
42d1f039 | 87 | * |
7152b1d0 WD |
88 | * Revision 1.20 1998/10/28 18:05:08 gklug |
89 | * chg: no DEBUG in VpdMayWrite | |
42d1f039 | 90 | * |
7152b1d0 WD |
91 | * 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 | |
42d1f039 | 94 | * |
7152b1d0 WD |
95 | * Revision 1.18 1998/10/28 09:00:47 gklug |
96 | * fix: unreferenced local vars | |
42d1f039 | 97 | * |
7152b1d0 WD |
98 | * Revision 1.17 1998/10/28 08:25:45 gklug |
99 | * fix: WARNING | |
42d1f039 | 100 | * |
7152b1d0 WD |
101 | * Revision 1.16 1998/10/28 08:17:30 gklug |
102 | * fix: typo | |
42d1f039 | 103 | * |
7152b1d0 WD |
104 | * Revision 1.15 1998/10/28 07:50:32 gklug |
105 | * fix: typo | |
42d1f039 | 106 | * |
7152b1d0 WD |
107 | * 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 | |
42d1f039 | 115 | * |
7152b1d0 WD |
116 | * Revision 1.13 1998/10/22 10:02:37 gklug |
117 | * fix: SysKonnectFileId typo | |
42d1f039 | 118 | * |
7152b1d0 WD |
119 | * Revision 1.12 1998/10/20 10:01:01 gklug |
120 | * fix: parameter to SkOsGetTime | |
42d1f039 | 121 | * |
7152b1d0 WD |
122 | * Revision 1.11 1998/10/15 12:51:48 malthoff |
123 | * Remove unrequired parameter p in vpd_setup_para(). | |
42d1f039 | 124 | * |
7152b1d0 WD |
125 | * Revision 1.10 1998/10/08 14:52:43 malthoff |
126 | * Remove CvsId by SysKonnectFileId. | |
42d1f039 | 127 | * |
7152b1d0 WD |
128 | * 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. | |
42d1f039 | 132 | * |
7152b1d0 WD |
133 | * Revision 1.8 1998/08/19 12:52:35 malthoff |
134 | * compiler fix: use SK_VPD_KEY instead of S_VPD. | |
42d1f039 | 135 | * |
7152b1d0 WD |
136 | * 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) | |
42d1f039 | 138 | * |
7152b1d0 WD |
139 | * Revision 1.6 1998/08/18 13:03:58 gklug |
140 | * SkOsGetTime now returns SK_U64 | |
42d1f039 | 141 | * |
7152b1d0 WD |
142 | * 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'. | |
42d1f039 | 146 | * |
7152b1d0 WD |
147 | * 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(). | |
42d1f039 | 150 | * |
7152b1d0 WD |
151 | * Revision 1.3 1998/06/26 11:16:53 malthoff |
152 | * Correct the modified File Identifier. | |
42d1f039 | 153 | * |
7152b1d0 WD |
154 | * Revision 1.2 1998/06/26 11:13:43 malthoff |
155 | * Modify the File Identifier. | |
42d1f039 | 156 | * |
7152b1d0 WD |
157 | * Revision 1.1 1998/06/19 14:11:08 malthoff |
158 | * Created, Tests with AIX were performed successfully | |
42d1f039 | 159 | * |
7152b1d0 WD |
160 | * |
161 | ******************************************************************************/ | |
162 | ||
149dded2 WD |
163 | #include <config.h> |
164 | ||
165 | #ifdef CONFIG_SK98 | |
166 | ||
7152b1d0 WD |
167 | /* |
168 | Please refer skvpd.txt for infomation how to include this module | |
169 | */ | |
170 | static 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 | |
182 | static SK_VPD_PARA *vpd_find_para( | |
183 | SK_AC *pAC, | |
184 | const char *key, | |
185 | SK_VPD_PARA *p); | |
186 | #else /* SK_KR_PROTO */ | |
187 | static 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 | */ | |
197 | static int VpdWait( | |
198 | SK_AC *pAC, /* Adapters context */ | |
199 | SK_IOC IoC, /* IO Context */ | |
200 | int 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 | } | |
42d1f039 | 227 | |
7152b1d0 | 228 | VPD_IN16(pAC, IoC, PCI_VPD_ADR_REG, &state); |
42d1f039 | 229 | |
7152b1d0 WD |
230 | 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 | */ | |
249 | SK_U32 VpdReadDWord( | |
250 | SK_AC *pAC, /* Adapters context */ | |
251 | SK_IOC IoC, /* IO Context */ | |
252 | int 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); | |
42d1f039 | 270 | |
7152b1d0 WD |
271 | 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 | . ------------------------------------------------------------------- | |
53677ef1 | 291 | . over all program time 2.5 ms 10.6 ms |
7152b1d0 WD |
292 | . read 1.3 ms 2.6 ms |
293 | . ------------------------------------------------------------------- | |
53677ef1 | 294 | . over all 3.8 ms 13.2 ms |
7152b1d0 WD |
295 | . |
296 | ||
297 | ||
298 | Returns 0: success | |
299 | 1: error, I2C transfer does not terminate | |
300 | 2: error, data verify error | |
301 | ||
302 | */ | |
303 | static int VpdWriteDWord( | |
304 | SK_AC *pAC, /* pAC pointer */ | |
305 | SK_IOC IoC, /* IO Context */ | |
306 | int addr, /* VPD address */ | |
307 | SK_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 | */ | |
343 | static int VpdWriteStream( | |
344 | SK_AC *pAC, /* Adapters context */ | |
345 | SK_IOC IoC, /* IO Context */ | |
346 | char *buf, /* data buffer */ | |
347 | int Addr, /* VPD start address */ | |
348 | int 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++) { | |
42d1f039 | 415 | |
7152b1d0 | 416 | VPD_IN8(pAC, IoC, PCI_VPD_DAT_REG + j, &Data); |
42d1f039 | 417 | |
7152b1d0 WD |
418 | 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 | } | |
42d1f039 | 430 | |
7152b1d0 WD |
431 | |
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 | */ | |
438 | static int VpdReadStream( | |
439 | SK_AC *pAC, /* Adapters context */ | |
440 | SK_IOC IoC, /* IO Context */ | |
441 | char *buf, /* data buffer */ | |
442 | int Addr, /* VPD start address */ | |
443 | int 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 | */ | |
477 | static int VpdTransferBlock( | |
478 | SK_AC *pAC, /* Adapters context */ | |
479 | SK_IOC IoC, /* IO Context */ | |
480 | char *buf, /* data buffer */ | |
481 | int addr, /* VPD start address */ | |
482 | int len, /* number of bytes to read / to write */ | |
483 | int 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; | |
42d1f039 | 496 | |
7152b1d0 WD |
497 | 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 | } | |
42d1f039 | 503 | |
7152b1d0 WD |
504 | 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 | */ | |
527 | int VpdReadBlock( | |
528 | SK_AC *pAC, /* pAC pointer */ | |
529 | SK_IOC IoC, /* IO Context */ | |
530 | char *buf, /* buffer were the data should be stored */ | |
531 | int addr, /* start reading at the VPD address */ | |
532 | int 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 | */ | |
542 | int VpdWriteBlock( | |
543 | SK_AC *pAC, /* pAC pointer */ | |
544 | SK_IOC IoC, /* IO Context */ | |
545 | char *buf, /* buffer, holds the data to write */ | |
546 | int addr, /* start writing at the VPD address */ | |
547 | int 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 | */ | |
562 | static int VpdInit( | |
563 | SK_AC *pAC, /* Adapters context */ | |
564 | SK_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 .. ")); | |
42d1f039 | 574 | |
7152b1d0 | 575 | VPD_IN16(pAC, IoC, PCI_DEVICE_ID, &dev_id); |
42d1f039 | 576 | |
7152b1d0 | 577 | VPD_IN32(pAC, IoC, PCI_OUR_REG_2, &our_reg2); |
42d1f039 | 578 | |
7152b1d0 | 579 | pAC->vpd.rom_size = 256 << ((our_reg2 & PCI_VPD_ROM_SZ) >> 14); |
42d1f039 | 580 | |
7152b1d0 WD |
581 | /* |
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 | } | |
42d1f039 | 611 | |
7152b1d0 WD |
612 | 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 | } | |
42d1f039 | 620 | |
7152b1d0 WD |
621 | 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 | } | |
42d1f039 | 632 | |
7152b1d0 WD |
633 | 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 | } | |
42d1f039 | 646 | |
7152b1d0 WD |
647 | 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 | */ | |
673 | static SK_VPD_PARA *vpd_find_para( | |
674 | SK_AC *pAC, /* common data base */ | |
675 | const char *key, /* keyword to find (e.g. "MN") */ | |
676 | SK_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 | */ | |
744 | static void vpd_move_para( | |
745 | char *start, /* start of memory block */ | |
746 | char *end, /* end of memory block to move */ | |
747 | int 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 | */ | |
777 | static void vpd_insert_key( | |
778 | const char *key, /* keyword to insert */ | |
779 | const char *buf, /* buffer with the keyword value */ | |
780 | int len, /* length of the value string */ | |
781 | char *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 | */ | |
799 | static int vpd_mod_endtag( | |
800 | SK_AC *pAC, /* common data base */ | |
801 | char *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 | */ | |
863 | int VpdSetupPara( | |
864 | SK_AC *pAC, /* common data base */ | |
865 | const char *key, /* keyword to insert */ | |
866 | const char *buf, /* buffer with the keyword value */ | |
867 | int len, /* length of the keyword value */ | |
868 | int type, /* VPD_RO_KEY or VPD_RW_KEY */ | |
869 | int 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)); | |
42d1f039 | 882 | |
7152b1d0 WD |
883 | 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 | */ | |
956 | SK_VPD_STATUS *VpdStat( | |
957 | SK_AC *pAC, /* Adapters context */ | |
958 | SK_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 | */ | |
989 | int VpdKeys( | |
990 | SK_AC *pAC, /* common data base */ | |
991 | SK_IOC IoC, /* IO Context */ | |
992 | char *buf, /* buffer where to copy the keywords */ | |
993 | int *len, /* buffer length */ | |
994 | int *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 | */ | |
1075 | int VpdRead( | |
1076 | SK_AC *pAC, /* common data base */ | |
1077 | SK_IOC IoC, /* IO Context */ | |
1078 | const char *key, /* keyword to read (e.g. "MN") */ | |
1079 | char *buf, /* buffer where to copy the keyword value */ | |
1080 | int *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 | */ | |
1121 | SK_BOOL VpdMayWrite( | |
1122 | char *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 | */ | |
1146 | int VpdWrite( | |
1147 | SK_AC *pAC, /* common data base */ | |
1148 | SK_IOC IoC, /* IO Context */ | |
1149 | const char *key, /* keyword to write (allowed values "Yx", "Vx") */ | |
1150 | const 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 | */ | |
1206 | int VpdDelete( | |
1207 | SK_AC *pAC, /* common data base */ | |
1208 | SK_IOC IoC, /* IO Context */ | |
1209 | char *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 | */ | |
1261 | int VpdUpdate( | |
1262 | SK_AC *pAC, /* Adapters context */ | |
1263 | SK_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 | ||
7152b1d0 WD |
1284 | /* |
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 | */ | |
1294 | void VpdErrLog( | |
1295 | SK_AC *pAC, /* common data base */ | |
1296 | SK_IOC IoC, /* IO Context */ | |
1297 | char *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 | ||
149dded2 | 1329 | #endif /* CONFIG_SK98 */ |