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