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