![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pcivpd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / drivers / bus|
Return to pcivpd.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / drivers / bus |
1.1 root 1: /*
2: * Copyright (C) 2010 Michael Brown <[email protected]>.
3: *
4: * This program is free software; you can redistribute it and/or
5: * modify it under the terms of the GNU General Public License as
6: * published by the Free Software Foundation; either version 2 of the
7: * License, or any later version.
8: *
9: * This program is distributed in the hope that it will be useful, but
10: * WITHOUT ANY WARRANTY; without even the implied warranty of
11: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12: * General Public License for more details.
13: *
14: * You should have received a copy of the GNU General Public License
15: * along with this program; if not, write to the Free Software
16: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17: */
18:
19: FILE_LICENCE ( GPL2_OR_LATER );
20:
21: #include <stdint.h>
22: #include <stdlib.h>
23: #include <unistd.h>
24: #include <errno.h>
25: #include <byteswap.h>
26: #include <ipxe/pci.h>
27: #include <ipxe/isapnp.h>
28: #include <ipxe/pcivpd.h>
29:
30: /** @file
31: *
32: * PCI Vital Product Data
33: *
34: */
35:
36: /**
37: * Initialise PCI Vital Product Data
38: *
39: * @v vpd PCI VPD
40: * @v pci PCI device
41: * @ret rc Return status code
42: */
43: int pci_vpd_init ( struct pci_vpd *vpd, struct pci_device *pci ) {
44:
45: /* Initialise structure */
46: vpd->pci = pci;
47: pci_vpd_invalidate_cache ( vpd );
48:
49: /* Locate VPD capability */
50: vpd->cap = pci_find_capability ( pci, PCI_CAP_ID_VPD );
51: if ( ! vpd->cap ) {
52: DBGC ( vpd, PCI_FMT " does not support VPD\n",
53: PCI_ARGS ( pci ) );
54: return -ENOTTY;
55: }
56:
57: DBGC ( vpd, PCI_FMT " VPD is at offset %02x\n",
58: PCI_ARGS ( pci ), vpd->cap );
59: return 0;
60: }
61:
62: /**
63: * Read one dword of PCI Vital Product Data
64: *
65: * @v vpd PCI VPD
66: * @v address Address to read
67: * @ret data Read data
68: * @ret rc Return status code
69: */
70: static int pci_vpd_read_dword ( struct pci_vpd *vpd, int address,
71: uint32_t *data ) {
72: struct pci_device *pci = vpd->pci;
73: unsigned int cap = vpd->cap;
74: unsigned int retries;
75: uint16_t flag;
76:
77: /* Fail if no VPD present */
78: if ( ! cap )
79: return -ENOTTY;
80:
81: /* Return cached value, if present */
82: if ( pci_vpd_cache_is_valid ( vpd ) &&
83: ( vpd->cache.address == address ) ) {
84: *data = vpd->cache.data;
85: return 0;
86: }
87:
88: /* Initiate read */
89: pci_write_config_word ( pci, ( cap + PCI_VPD_ADDRESS ), address );
90:
91: /* Wait for read to complete */
92: for ( retries = 0 ; retries < PCI_VPD_MAX_WAIT_MS ; retries++ ) {
93:
94: /* Check if data is ready */
95: pci_read_config_word ( pci, ( cap + PCI_VPD_ADDRESS ), &flag );
96: if ( flag & PCI_VPD_FLAG ) {
97:
98: /* Read data */
99: pci_read_config_dword ( pci, ( cap + PCI_VPD_DATA ),
100: data );
101: DBGC2 ( vpd, PCI_FMT " VPD %04x => %08x\n",
102: PCI_ARGS ( pci ), address, htonl ( *data ) );
103:
104: /* Populate cache */
105: vpd->cache.address = address;
106: vpd->cache.data = *data;
107:
108: return 0;
109: }
110:
111: /* Wait 1ms before retrying */
112: mdelay ( 1 );
113: }
114:
115: DBGC ( vpd, PCI_FMT " VPD %04x read via %02x timed out\n",
116: PCI_ARGS ( pci ), address, cap );
117: return -ETIMEDOUT;
118: }
119:
120: /**
121: * Write one dword of PCI Vital Product Data
122: *
123: * @v vpd PCI VPD
124: * @v address Address to write
125: * @v data Data to write
126: * @ret rc Return status code
127: */
128: static int pci_vpd_write_dword ( struct pci_vpd *vpd, int address,
129: uint32_t data ) {
130: struct pci_device *pci = vpd->pci;
131: unsigned int cap = vpd->cap;
132: unsigned int retries;
133: uint16_t flag;
134:
135: /* Fail if no VPD present */
136: if ( ! cap )
137: return -ENOTTY;
138:
139: /* Invalidate cache */
140: pci_vpd_invalidate_cache ( vpd );
141:
142: DBGC2 ( vpd, PCI_FMT " VPD %04x <= %08x\n",
143: PCI_ARGS ( pci ), address, htonl ( data ) );
144:
145: /* Write data */
146: pci_write_config_dword ( pci, ( cap + PCI_VPD_DATA ), data );
147:
148: /* Initiate write */
149: pci_write_config_word ( pci, ( cap + PCI_VPD_ADDRESS ),
150: ( address | PCI_VPD_FLAG ) );
151:
152: /* Wait for write to complete */
153: for ( retries = 0 ; retries < PCI_VPD_MAX_WAIT_MS ; retries++ ) {
154:
155: /* Check if write has completed */
156: pci_read_config_word ( pci, ( cap + PCI_VPD_ADDRESS ), &flag );
157: if ( ! ( flag & PCI_VPD_FLAG ) )
158: return 0;
159:
160: /* Wait 1ms before retrying */
161: mdelay ( 1 );
162: }
163:
164: DBGC ( vpd, PCI_FMT " VPD %04x write via %02x timed out\n",
165: PCI_ARGS ( pci ), address, cap );
166: return -ETIMEDOUT;
167: }
168:
169: /**
170: * Read PCI VPD
171: *
172: * @v vpd PCI VPD
173: * @v address Starting address
174: * @v buf Data buffer
175: * @v len Length of data buffer
176: * @ret rc Return status code
177: */
178: int pci_vpd_read ( struct pci_vpd *vpd, unsigned int address, void *buf,
179: size_t len ) {
180: uint8_t *bytes = buf;
181: uint32_t data;
182: size_t skip_len;
183: unsigned int i;
184: int rc;
185:
186: /* Calculate length to skip at start of data */
187: skip_len = ( address & 0x03 );
188:
189: /* Read data, a dword at a time */
190: for ( address &= ~0x03 ; len ; address += 4 ) {
191:
192: /* Read whole dword */
193: if ( ( rc = pci_vpd_read_dword ( vpd, address, &data ) ) != 0 )
194: return rc;
195:
196: /* Copy data to buffer */
197: for ( i = 4 ; i ; i-- ) {
198: if ( skip_len ) {
199: skip_len--;
200: } else if ( len ) {
201: *(bytes++) = data;
202: len--;
203: }
204: data = ( ( data << 24 ) | ( data >> 8 ) );
205: }
206: }
207:
208: return 0;
209: }
210:
211: /**
212: * Write PCI VPD
213: *
214: * @v vpd PCI VPD
215: * @v address Starting address
216: * @v buf Data buffer
217: * @v len Length of data buffer
218: * @ret rc Return status code
219: */
220: int pci_vpd_write ( struct pci_vpd *vpd, unsigned int address, const void *buf,
221: size_t len ) {
222: const uint8_t *bytes = buf;
223: uint32_t data;
224: size_t skip_len;
225: unsigned int i;
226: int rc;
227:
228: /* Calculate length to skip at start of data */
229: skip_len = ( address & 0x03 );
230:
231: /* Write data, a dword at a time */
232: for ( address &= ~0x03 ; len ; address += 4 ) {
233:
234: /* Read existing dword, if necessary */
235: if ( skip_len || ( len <= 0x03 ) ) {
236: if ( ( rc = pci_vpd_read_dword ( vpd, address,
237: &data ) ) != 0 )
238: return rc;
239: }
240:
241: /* Copy data from buffer */
242: for ( i = 4 ; i ; i-- ) {
243: if ( skip_len ) {
244: skip_len--;
245: } else if ( len ) {
246: data = ( ( data & ~0xff ) | *(bytes++) );
247: len--;
248: }
249: data = ( ( data << 24 ) | ( data >> 8 ) );
250: }
251:
252: /* Write whole dword */
253: if ( ( rc = pci_vpd_write_dword ( vpd, address, data ) ) != 0 )
254: return rc;
255: }
256: return 0;
257: }
258:
259: /**
260: * Dump PCI VPD region (for debugging)
261: *
262: * @v vpd PCI VPD
263: * @v address Starting address
264: * @v len Length of data
265: */
266: static void pci_vpd_dump ( struct pci_vpd *vpd, unsigned int address,
267: size_t len ) {
268: int rc;
269:
270: /* Do nothing in non-debug builds */
271: if ( ! DBG_LOG )
272: return;
273:
274: /* Read data */
275: {
276: char buf[len];
277: if ( ( rc = pci_vpd_read ( vpd, address, buf,
278: sizeof ( buf ) ) ) != 0 )
279: return;
280: DBGC_HDA ( vpd, address, buf, sizeof ( buf ) );
281: }
282: }
283:
284: /**
285: * Locate PCI VPD tag
286: *
287: * @v vpd PCI VPD
288: * @v tag ISAPnP tag
289: * @ret address Address of tag body
290: * @ret len Length of tag body
291: * @ret rc Return status code
292: */
293: static int pci_vpd_find_tag ( struct pci_vpd *vpd, unsigned int tag,
294: unsigned int *address, size_t *len ) {
295: uint8_t read_tag;
296: uint16_t read_len;
297: int rc;
298:
299: /* Scan through tags looking for a match */
300: *address = 0;
301: do {
302: /* Read tag byte */
303: if ( ( rc = pci_vpd_read ( vpd, (*address)++, &read_tag,
304: sizeof ( read_tag ) ) ) != 0 )
305: return rc;
306:
307: /* Extract tag and length */
308: if ( ISAPNP_IS_LARGE_TAG ( read_tag ) ) {
309: if ( ( rc = pci_vpd_read ( vpd, *address, &read_len,
310: sizeof ( read_len ) ) ) != 0)
311: return rc;
312: *address += sizeof ( read_len );
313: read_len = le16_to_cpu ( read_len );
314: read_tag = ISAPNP_LARGE_TAG_NAME ( read_tag );
315: } else {
316: read_len = ISAPNP_SMALL_TAG_LEN ( read_tag );
317: read_tag = ISAPNP_SMALL_TAG_NAME ( read_tag );
318: }
319:
320: /* Check for tag match */
321: if ( tag == read_tag ) {
322: *len = read_len;
323: DBGC ( vpd, PCI_FMT " VPD tag %02x is at "
324: "[%04x,%04zx)\n", PCI_ARGS ( vpd->pci ), tag,
325: *address, ( *address + *len ) );
326: return 0;
327: }
328:
329: /* Move to next tag */
330: *address += read_len;
331:
332: } while ( read_tag != ISAPNP_TAG_END );
333:
334: DBGC ( vpd, PCI_FMT " VPD tag %02x not found\n",
335: PCI_ARGS ( vpd->pci ), tag );
336: return -ENOENT;
337: }
338:
339: /**
340: * Locate PCI VPD field
341: *
342: * @v vpd PCI VPD
343: * @v field VPD field descriptor
344: * @ret address Address of field body
345: * @ret len Length of field body
346: * @ret rc Return status code
347: */
348: int pci_vpd_find ( struct pci_vpd *vpd, unsigned int field,
349: unsigned int *address, size_t *len ) {
350: struct pci_vpd_field read_field;
351: int rc;
352:
353: /* Locate containing tag */
354: if ( ( rc = pci_vpd_find_tag ( vpd, PCI_VPD_TAG ( field ),
355: address, len ) ) != 0 )
356: return rc;
357:
358: /* Return immediately if we are searching for a whole-tag field */
359: if ( ! PCI_VPD_KEYWORD ( field ) ) {
360: pci_vpd_dump ( vpd, *address, *len );
361: return 0;
362: }
363:
364: /* Scan through fields looking for a match */
365: while ( *len >= sizeof ( read_field ) ) {
366:
367: /* Read field header */
368: if ( ( rc = pci_vpd_read ( vpd, *address, &read_field,
369: sizeof ( read_field ) ) ) != 0 )
370: return rc;
371: *address += sizeof ( read_field );
372: *len -= sizeof ( read_field );
373:
374: /* Check for keyword match */
375: if ( read_field.keyword == PCI_VPD_KEYWORD ( field ) ) {
376: *len = read_field.len;
377: DBGC ( vpd, PCI_FMT " VPD field " PCI_VPD_FIELD_FMT
378: " is at [%04x,%04zx)\n", PCI_ARGS ( vpd->pci ),
379: PCI_VPD_FIELD_ARGS ( field ),
380: *address, ( *address + *len ) );
381: pci_vpd_dump ( vpd, *address, *len );
382: return 0;
383: }
384:
385: /* Move to next field */
386: if ( read_field.len > *len )
387: break;
388: *address += read_field.len;
389: *len -= read_field.len;
390: }
391:
392: DBGC ( vpd, PCI_FMT " VPD field " PCI_VPD_FIELD_FMT " not found\n",
393: PCI_ARGS ( vpd->pci ), PCI_VPD_FIELD_ARGS ( field ) );
394: return -ENOENT;
395: }
396:
397: /**
398: * Resize VPD field
399: *
400: * @v vpd PCI VPD
401: * @v field VPD field descriptor
402: * @v len New length of field body
403: * @ret address Address of field body
404: * @ret rc Return status code
405: */
406: int pci_vpd_resize ( struct pci_vpd *vpd, unsigned int field, size_t len,
407: unsigned int *address ) {
408: struct pci_vpd_field rw_field;
409: struct pci_vpd_field old_field;
410: struct pci_vpd_field new_field;
411: unsigned int rw_address;
412: unsigned int old_address;
413: unsigned int copy_address;
414: unsigned int dst_address;
415: unsigned int dump_address;
416: size_t rw_len;
417: size_t old_len;
418: size_t available_len;
419: size_t copy_len;
420: size_t dump_len;
421: void *copy;
422: int rc;
423:
424: /* Sanity checks */
425: assert ( PCI_VPD_TAG ( field ) == PCI_VPD_TAG_RW );
426: assert ( PCI_VPD_KEYWORD ( field ) != 0 );
427: assert ( field != PCI_VPD_FIELD_RW );
428:
429: /* Locate 'RW' field */
430: if ( ( rc = pci_vpd_find ( vpd, PCI_VPD_FIELD_RW, &rw_address,
431: &rw_len ) ) != 0 )
432: goto err_no_rw;
433:
434: /* Locate old field, if any */
435: if ( ( rc = pci_vpd_find ( vpd, field, &old_address,
436: &old_len ) ) == 0 ) {
437:
438: /* Field already exists */
439: if ( old_address > rw_address ) {
440: DBGC ( vpd, PCI_FMT " VPD field " PCI_VPD_FIELD_FMT
441: " at [%04x,%04zx) is after field "
442: PCI_VPD_FIELD_FMT " at [%04x,%04zx)\n",
443: PCI_ARGS ( vpd->pci ),
444: PCI_VPD_FIELD_ARGS ( field ),
445: old_address, ( old_address + old_len ),
446: PCI_VPD_FIELD_ARGS ( PCI_VPD_FIELD_RW ),
447: rw_address, ( rw_address + rw_len ) );
448: rc = -ENXIO;
449: goto err_after_rw;
450: }
451: dst_address = ( old_address - sizeof ( old_field ) );
452: copy_address = ( old_address + old_len );
453: copy_len = ( rw_address - sizeof ( rw_field ) - copy_address );
454:
455: /* Calculate available length */
456: available_len = ( rw_len + old_len );
457:
458: } else {
459:
460: /* Field does not yet exist */
461: dst_address = ( rw_address - sizeof ( rw_field ) );
462: copy_address = dst_address;
463: copy_len = 0;
464:
465: /* Calculate available length */
466: available_len = ( ( rw_len > sizeof ( new_field ) ) ?
467: ( rw_len - sizeof ( new_field ) ) : 0 );
468: }
469:
470: /* Dump region before changes */
471: dump_address = dst_address;
472: dump_len = ( rw_address + rw_len - dump_address );
473: DBGC ( vpd, PCI_FMT " VPD before resizing field " PCI_VPD_FIELD_FMT
474: " to %zd bytes:\n", PCI_ARGS ( vpd->pci ),
475: PCI_VPD_FIELD_ARGS ( field ), len );
476: pci_vpd_dump ( vpd, dump_address, dump_len );
477:
478: /* Check available length */
479: if ( available_len > PCI_VPD_MAX_LEN )
480: available_len = PCI_VPD_MAX_LEN;
481: if ( len > available_len ) {
482: DBGC ( vpd, PCI_FMT " VPD no space for field "
483: PCI_VPD_FIELD_FMT " (need %02zx, have %02zx)\n",
484: PCI_ARGS ( vpd->pci ), PCI_VPD_FIELD_ARGS ( field ),
485: len, available_len );
486: rc = -ENOSPC;
487: goto err_no_space;
488: }
489:
490: /* Preserve intermediate fields, if any */
491: copy = malloc ( copy_len );
492: if ( ! copy ) {
493: rc = -ENOMEM;
494: goto err_copy_alloc;
495: }
496: if ( ( rc = pci_vpd_read ( vpd, copy_address, copy, copy_len ) ) != 0 )
497: goto err_copy_read;
498:
499: /* Create new field, if applicable */
500: if ( len ) {
501: new_field.keyword = PCI_VPD_KEYWORD ( field );
502: new_field.len = len;
503: if ( ( rc = pci_vpd_write ( vpd, dst_address, &new_field,
504: sizeof ( new_field ) ) ) != 0 )
505: goto err_new_write;
506: dst_address += sizeof ( new_field );
507: *address = dst_address;
508: DBGC ( vpd, PCI_FMT " VPD field " PCI_VPD_FIELD_FMT " is now "
509: "at [%04x,%04x)\n", PCI_ARGS ( vpd->pci ),
510: PCI_VPD_FIELD_ARGS ( field ), dst_address,
511: ( dst_address + new_field.len ) );
512: dst_address += len;
513: } else {
514: DBGC ( vpd, PCI_FMT " VPD field " PCI_VPD_FIELD_FMT
515: " no longer exists\n", PCI_ARGS ( vpd->pci ),
516: PCI_VPD_FIELD_ARGS ( field ) );
517: }
518:
519: /* Restore intermediate fields, if any */
520: if ( ( rc = pci_vpd_write ( vpd, dst_address, copy, copy_len ) ) != 0 )
521: goto err_copy_write;
522: dst_address += copy_len;
523:
524: /* Create 'RW' field */
525: rw_field.keyword = PCI_VPD_KEYWORD ( PCI_VPD_FIELD_RW );
526: rw_field.len = ( rw_len +
527: ( rw_address - sizeof ( rw_field ) ) - dst_address );
528: if ( ( rc = pci_vpd_write ( vpd, dst_address, &rw_field,
529: sizeof ( rw_field ) ) ) != 0 )
530: goto err_rw_write;
531: dst_address += sizeof ( rw_field );
532: DBGC ( vpd, PCI_FMT " VPD field " PCI_VPD_FIELD_FMT " is now "
533: "at [%04x,%04x)\n", PCI_ARGS ( vpd->pci ),
534: PCI_VPD_FIELD_ARGS ( PCI_VPD_FIELD_RW ), dst_address,
535: ( dst_address + rw_field.len ) );
536:
537: /* Dump region after changes */
538: DBGC ( vpd, PCI_FMT " VPD after resizing field " PCI_VPD_FIELD_FMT
539: " to %zd bytes:\n", PCI_ARGS ( vpd->pci ),
540: PCI_VPD_FIELD_ARGS ( field ), len );
541: pci_vpd_dump ( vpd, dump_address, dump_len );
542:
543: rc = 0;
544:
545: err_rw_write:
546: err_new_write:
547: err_copy_write:
548: err_copy_read:
549: free ( copy );
550: err_copy_alloc:
551: err_no_space:
552: err_after_rw:
553: err_no_rw:
554: return rc;
555: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.