2 * csr1212.c -- IEEE 1212 Control and Status Register support for Linux
4 * Copyright (C) 2003 Francois Retief <fgretief@sun.ac.za>
5 * Steve Kinneberg <kinnebergsteve@acmsystems.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are met:
10 * 1. Redistributions of source code must retain the above copyright notice,
11 * this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
19 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
20 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
21 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
24 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
27 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 * - Verify interface consistency: i.e., public functions that take a size
33 * parameter expect size to be in bytes.
36 #include <linux/errno.h>
37 #include <linux/string.h>
38 #include <asm/byteorder.h>
43 /* Permitted key type for each key id */
44 #define __I (1 << CSR1212_KV_TYPE_IMMEDIATE)
45 #define __C (1 << CSR1212_KV_TYPE_CSR_OFFSET)
46 #define __D (1 << CSR1212_KV_TYPE_DIRECTORY)
47 #define __L (1 << CSR1212_KV_TYPE_LEAF)
48 static const u_int8_t csr1212_key_id_type_map[0x30] = {
49 __C, /* used by Apple iSight */
50 __D | __L, /* Descriptor */
51 __I | __D | __L, /* Bus_Dependent_Info */
52 __I | __D | __L, /* Vendor */
53 __I, /* Hardware_Version */
55 __D | __L | __I, /* Module */
56 __I, 0, 0, 0, /* used by Apple iSight, Reserved */
57 __I, /* Node_Capabilities */
59 0, 0, 0, /* Reserved */
61 __I, /* Specifier_ID */
63 __I | __C | __D | __L, /* Dependent_Info */
64 __L, /* Unit_Location */
70 __L, /* Extended_ROM */
71 __I, /* Extended_Key_Specifier_ID */
72 __I, /* Extended_Key */
73 __I | __C | __D | __L, /* Extended_Data */
74 __L, /* Modifiable_Descriptor */
75 __I, /* Directory_ID */
84 #define quads_to_bytes(_q) ((_q) * sizeof(u_int32_t))
85 #define bytes_to_quads(_b) (((_b) + sizeof(u_int32_t) - 1) / sizeof(u_int32_t))
87 static void free_keyval(struct csr1212_keyval *kv)
89 if ((kv->key.type == CSR1212_KV_TYPE_LEAF) &&
90 (kv->key.id != CSR1212_KV_ID_EXTENDED_ROM))
91 CSR1212_FREE(kv->value.leaf.data);
96 static u_int16_t csr1212_crc16(const u_int32_t *buffer, size_t length)
100 u_int16_t sum, crc = 0;
102 for (; length; length--) {
103 data = be32_to_cpu(*buffer);
105 for (shift = 28; shift >= 0; shift -= 4 ) {
106 sum = ((crc >> 12) ^ (data >> shift)) & 0xf;
107 crc = (crc << 4) ^ (sum << 12) ^ (sum << 5) ^ (sum);
112 return cpu_to_be16(crc);
116 /* Microsoft computes the CRC with the bytes in reverse order. Therefore we
117 * have a special version of the CRC algorithm to account for their buggy
119 static u_int16_t csr1212_msft_crc16(const u_int32_t *buffer, size_t length)
123 u_int16_t sum, crc = 0;
125 for (; length; length--) {
126 data = le32_to_cpu(*buffer);
128 for (shift = 28; shift >= 0; shift -= 4 ) {
129 sum = ((crc >> 12) ^ (data >> shift)) & 0xf;
130 crc = (crc << 4) ^ (sum << 12) ^ (sum << 5) ^ (sum);
135 return cpu_to_be16(crc);
139 static struct csr1212_dentry *
140 csr1212_find_keyval(struct csr1212_keyval *dir, struct csr1212_keyval *kv)
142 struct csr1212_dentry *pos;
144 for (pos = dir->value.directory.dentries_head;
145 pos != NULL; pos = pos->next) {
152 static struct csr1212_keyval *
153 csr1212_find_keyval_offset(struct csr1212_keyval *kv_list, u_int32_t offset)
155 struct csr1212_keyval *kv;
157 for (kv = kv_list->next; kv && (kv != kv_list); kv = kv->next) {
158 if (kv->offset == offset)
165 /* Creation Routines */
167 struct csr1212_csr *csr1212_create_csr(struct csr1212_bus_ops *ops,
168 size_t bus_info_size, void *private)
170 struct csr1212_csr *csr;
172 csr = CSR1212_MALLOC(sizeof(*csr));
177 csr1212_rom_cache_malloc(CSR1212_CONFIG_ROM_SPACE_OFFSET,
178 CSR1212_CONFIG_ROM_SPACE_SIZE);
179 if (!csr->cache_head) {
184 /* The keyval key id is not used for the root node, but a valid key id
185 * that can be used for a directory needs to be passed to
186 * csr1212_new_directory(). */
187 csr->root_kv = csr1212_new_directory(CSR1212_KV_ID_VENDOR);
189 CSR1212_FREE(csr->cache_head);
194 csr->bus_info_data = csr->cache_head->data;
195 csr->bus_info_len = bus_info_size;
196 csr->crc_len = bus_info_size;
198 csr->private = private;
199 csr->cache_tail = csr->cache_head;
204 void csr1212_init_local_csr(struct csr1212_csr *csr,
205 const u_int32_t *bus_info_data, int max_rom)
207 static const int mr_map[] = { 4, 64, 1024, 0 };
209 BUG_ON(max_rom & ~0x3);
210 csr->max_rom = mr_map[max_rom];
211 memcpy(csr->bus_info_data, bus_info_data, csr->bus_info_len);
214 static struct csr1212_keyval *csr1212_new_keyval(u_int8_t type, u_int8_t key)
216 struct csr1212_keyval *kv;
218 if (key < 0x30 && ((csr1212_key_id_type_map[key] & (1 << type)) == 0))
221 kv = CSR1212_MALLOC(sizeof(*kv));
228 kv->associate = NULL;
238 struct csr1212_keyval *csr1212_new_immediate(u_int8_t key, u_int32_t value)
240 struct csr1212_keyval *kv = csr1212_new_keyval(CSR1212_KV_TYPE_IMMEDIATE, key);
245 kv->value.immediate = value;
250 static struct csr1212_keyval *
251 csr1212_new_leaf(u_int8_t key, const void *data, size_t data_len)
253 struct csr1212_keyval *kv = csr1212_new_keyval(CSR1212_KV_TYPE_LEAF, key);
259 kv->value.leaf.data = CSR1212_MALLOC(data_len);
260 if (!kv->value.leaf.data) {
266 memcpy(kv->value.leaf.data, data, data_len);
268 kv->value.leaf.data = NULL;
271 kv->value.leaf.len = bytes_to_quads(data_len);
278 static struct csr1212_keyval *
279 csr1212_new_csr_offset(u_int8_t key, u_int32_t csr_offset)
281 struct csr1212_keyval *kv = csr1212_new_keyval(CSR1212_KV_TYPE_CSR_OFFSET, key);
286 kv->value.csr_offset = csr_offset;
293 struct csr1212_keyval *csr1212_new_directory(u_int8_t key)
295 struct csr1212_keyval *kv = csr1212_new_keyval(CSR1212_KV_TYPE_DIRECTORY, key);
300 kv->value.directory.len = 0;
302 kv->value.directory.dentries_head = NULL;
303 kv->value.directory.dentries_tail = NULL;
308 int csr1212_associate_keyval(struct csr1212_keyval *kv,
309 struct csr1212_keyval *associate)
311 if (!kv || !associate)
314 if (kv->key.id == CSR1212_KV_ID_DESCRIPTOR ||
315 (associate->key.id != CSR1212_KV_ID_DESCRIPTOR &&
316 associate->key.id != CSR1212_KV_ID_DEPENDENT_INFO &&
317 associate->key.id != CSR1212_KV_ID_EXTENDED_KEY &&
318 associate->key.id != CSR1212_KV_ID_EXTENDED_DATA &&
319 associate->key.id < 0x30))
322 if (kv->key.id == CSR1212_KV_ID_EXTENDED_KEY_SPECIFIER_ID &&
323 associate->key.id != CSR1212_KV_ID_EXTENDED_KEY)
326 if (kv->key.id == CSR1212_KV_ID_EXTENDED_KEY &&
327 associate->key.id != CSR1212_KV_ID_EXTENDED_DATA)
330 if (associate->key.id == CSR1212_KV_ID_EXTENDED_KEY &&
331 kv->key.id != CSR1212_KV_ID_EXTENDED_KEY_SPECIFIER_ID)
334 if (associate->key.id == CSR1212_KV_ID_EXTENDED_DATA &&
335 kv->key.id != CSR1212_KV_ID_EXTENDED_KEY)
339 csr1212_release_keyval(kv->associate);
342 kv->associate = associate;
344 return CSR1212_SUCCESS;
347 int csr1212_attach_keyval_to_directory(struct csr1212_keyval *dir,
348 struct csr1212_keyval *kv)
350 struct csr1212_dentry *dentry;
352 if (!kv || !dir || dir->key.type != CSR1212_KV_TYPE_DIRECTORY)
355 dentry = CSR1212_MALLOC(sizeof(*dentry));
364 dentry->prev = dir->value.directory.dentries_tail;
366 if (!dir->value.directory.dentries_head)
367 dir->value.directory.dentries_head = dentry;
369 if (dir->value.directory.dentries_tail)
370 dir->value.directory.dentries_tail->next = dentry;
371 dir->value.directory.dentries_tail = dentry;
373 return CSR1212_SUCCESS;
376 #define CSR1212_DESCRIPTOR_LEAF_DATA(kv) \
377 (&((kv)->value.leaf.data[1]))
379 #define CSR1212_DESCRIPTOR_LEAF_SET_TYPE(kv, type) \
380 ((kv)->value.leaf.data[0] = \
381 cpu_to_be32(CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID(kv) | \
382 ((type) << CSR1212_DESCRIPTOR_LEAF_TYPE_SHIFT)))
383 #define CSR1212_DESCRIPTOR_LEAF_SET_SPECIFIER_ID(kv, spec_id) \
384 ((kv)->value.leaf.data[0] = \
385 cpu_to_be32((CSR1212_DESCRIPTOR_LEAF_TYPE(kv) << \
386 CSR1212_DESCRIPTOR_LEAF_TYPE_SHIFT) | \
387 ((spec_id) & CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID_MASK)))
389 static struct csr1212_keyval *
390 csr1212_new_descriptor_leaf(u_int8_t dtype, u_int32_t specifier_id,
391 const void *data, size_t data_len)
393 struct csr1212_keyval *kv;
395 kv = csr1212_new_leaf(CSR1212_KV_ID_DESCRIPTOR, NULL,
396 data_len + CSR1212_DESCRIPTOR_LEAF_OVERHEAD);
400 CSR1212_DESCRIPTOR_LEAF_SET_TYPE(kv, dtype);
401 CSR1212_DESCRIPTOR_LEAF_SET_SPECIFIER_ID(kv, specifier_id);
404 memcpy(CSR1212_DESCRIPTOR_LEAF_DATA(kv), data, data_len);
410 #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_SET_WIDTH(kv, width) \
411 ((kv)->value.leaf.data[1] = \
412 ((kv)->value.leaf.data[1] & \
413 cpu_to_be32(~(CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH_MASK << \
414 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH_SHIFT))) | \
415 cpu_to_be32(((width) & CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH_MASK) << \
416 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH_SHIFT))
418 #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_SET_CHAR_SET(kv, char_set) \
419 ((kv)->value.leaf.data[1] = \
420 ((kv)->value.leaf.data[1] & \
421 cpu_to_be32(~(CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET_MASK << \
422 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET_SHIFT))) | \
423 cpu_to_be32(((char_set) & \
424 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET_MASK) << \
425 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET_SHIFT))
427 #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_SET_LANGUAGE(kv, language) \
428 ((kv)->value.leaf.data[1] = \
429 ((kv)->value.leaf.data[1] & \
430 cpu_to_be32(~(CSR1212_TEXTUAL_DESCRIPTOR_LEAF_LANGUAGE_MASK))) | \
431 cpu_to_be32(((language) & \
432 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_LANGUAGE_MASK)))
434 static struct csr1212_keyval *
435 csr1212_new_textual_descriptor_leaf(u_int8_t cwidth, u_int16_t cset,
436 u_int16_t language, const void *data,
439 struct csr1212_keyval *kv;
442 kv = csr1212_new_descriptor_leaf(0, 0, NULL, data_len +
443 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_OVERHEAD);
447 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_SET_WIDTH(kv, cwidth);
448 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_SET_CHAR_SET(kv, cset);
449 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_SET_LANGUAGE(kv, language);
451 lstr = (char*)CSR1212_TEXTUAL_DESCRIPTOR_LEAF_DATA(kv);
453 /* make sure last quadlet is zeroed out */
454 *((u_int32_t*)&(lstr[(data_len - 1) & ~0x3])) = 0;
456 /* don't copy the NUL terminator */
457 memcpy(lstr, data, data_len);
462 static int csr1212_check_minimal_ascii(const char *s)
464 static const char minimal_ascii_table[] = {
465 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
466 0x00, 0x00, 0x0a, 0x00, 0x0C, 0x0D, 0x00, 0x00,
467 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
468 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
469 0x20, 0x21, 0x22, 0x00, 0x00, 0x25, 0x26, 0x27,
470 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
471 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
472 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
473 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
474 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
475 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
476 0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x5f,
477 0x00, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
478 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
479 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
480 0x78, 0x79, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00,
483 if (minimal_ascii_table[*s & 0x7F] != *s)
484 return -1; /* failed */
486 /* String conforms to minimal-ascii, as specified by IEEE 1212,
491 struct csr1212_keyval *csr1212_new_string_descriptor_leaf(const char *s)
493 /* Check if string conform to minimal_ascii format */
494 if (csr1212_check_minimal_ascii(s))
497 /* IEEE 1212, par. 7.5.4.1 Textual descriptors (minimal ASCII) */
498 return csr1212_new_textual_descriptor_leaf(0, 0, 0, s, strlen(s));
502 /* Destruction Routines */
504 void csr1212_detach_keyval_from_directory(struct csr1212_keyval *dir,
505 struct csr1212_keyval *kv)
507 struct csr1212_dentry *dentry;
509 if (!kv || !dir || dir->key.type != CSR1212_KV_TYPE_DIRECTORY)
512 dentry = csr1212_find_keyval(dir, kv);
518 dentry->prev->next = dentry->next;
520 dentry->next->prev = dentry->prev;
521 if (dir->value.directory.dentries_head == dentry)
522 dir->value.directory.dentries_head = dentry->next;
523 if (dir->value.directory.dentries_tail == dentry)
524 dir->value.directory.dentries_tail = dentry->prev;
526 CSR1212_FREE(dentry);
528 csr1212_release_keyval(kv);
531 /* This function is used to free the memory taken by a keyval. If the given
532 * keyval is a directory type, then any keyvals contained in that directory
533 * will be destroyed as well if their respective refcnts are 0. By means of
534 * list manipulation, this routine will descend a directory structure in a
535 * non-recursive manner. */
536 void _csr1212_destroy_keyval(struct csr1212_keyval *kv)
538 struct csr1212_keyval *k, *a;
539 struct csr1212_dentry dentry;
540 struct csr1212_dentry *head, *tail;
560 if (k->key.type == CSR1212_KV_TYPE_DIRECTORY) {
561 /* If the current entry is a directory, then move all
562 * the entries to the destruction list. */
563 if (k->value.directory.dentries_head) {
564 tail->next = k->value.directory.dentries_head;
565 k->value.directory.dentries_head->prev = tail;
566 tail = k->value.directory.dentries_tail;
575 if (head->prev && head->prev != &dentry) {
576 CSR1212_FREE(head->prev);
579 } else if (tail != &dentry)
584 void csr1212_destroy_csr(struct csr1212_csr *csr)
586 struct csr1212_csr_rom_cache *c, *oc;
587 struct csr1212_cache_region *cr, *ocr;
589 csr1212_release_keyval(csr->root_kv);
608 /* CSR Image Creation */
610 static int csr1212_append_new_cache(struct csr1212_csr *csr, size_t romsize)
612 struct csr1212_csr_rom_cache *cache;
615 if (!csr || !csr->ops || !csr->ops->allocate_addr_range ||
616 !csr->ops->release_addr || csr->max_rom < 1)
619 /* ROM size must be a multiple of csr->max_rom */
620 romsize = (romsize + (csr->max_rom - 1)) & ~(csr->max_rom - 1);
622 csr_addr = csr->ops->allocate_addr_range(romsize, csr->max_rom, csr->private);
623 if (csr_addr == CSR1212_INVALID_ADDR_SPACE) {
626 if (csr_addr < CSR1212_REGISTER_SPACE_BASE) {
627 /* Invalid address returned from allocate_addr_range(). */
628 csr->ops->release_addr(csr_addr, csr->private);
632 cache = csr1212_rom_cache_malloc(csr_addr - CSR1212_REGISTER_SPACE_BASE, romsize);
634 csr->ops->release_addr(csr_addr, csr->private);
638 cache->ext_rom = csr1212_new_keyval(CSR1212_KV_TYPE_LEAF, CSR1212_KV_ID_EXTENDED_ROM);
639 if (!cache->ext_rom) {
640 csr->ops->release_addr(csr_addr, csr->private);
645 if (csr1212_attach_keyval_to_directory(csr->root_kv, cache->ext_rom) != CSR1212_SUCCESS) {
646 csr1212_release_keyval(cache->ext_rom);
647 csr->ops->release_addr(csr_addr, csr->private);
651 cache->ext_rom->offset = csr_addr - CSR1212_REGISTER_SPACE_BASE;
652 cache->ext_rom->value.leaf.len = -1;
653 cache->ext_rom->value.leaf.data = cache->data;
655 /* Add cache to tail of cache list */
656 cache->prev = csr->cache_tail;
657 csr->cache_tail->next = cache;
658 csr->cache_tail = cache;
659 return CSR1212_SUCCESS;
662 static void csr1212_remove_cache(struct csr1212_csr *csr,
663 struct csr1212_csr_rom_cache *cache)
665 if (csr->cache_head == cache)
666 csr->cache_head = cache->next;
667 if (csr->cache_tail == cache)
668 csr->cache_tail = cache->prev;
671 cache->prev->next = cache->next;
673 cache->next->prev = cache->prev;
675 if (cache->ext_rom) {
676 csr1212_detach_keyval_from_directory(csr->root_kv, cache->ext_rom);
677 csr1212_release_keyval(cache->ext_rom);
683 static int csr1212_generate_layout_subdir(struct csr1212_keyval *dir,
684 struct csr1212_keyval **layout_tail)
686 struct csr1212_dentry *dentry;
687 struct csr1212_keyval *dkv;
688 struct csr1212_keyval *last_extkey_spec = NULL;
689 struct csr1212_keyval *last_extkey = NULL;
692 for (dentry = dir->value.directory.dentries_head; dentry;
693 dentry = dentry->next) {
694 for (dkv = dentry->kv; dkv; dkv = dkv->associate) {
695 /* Special Case: Extended Key Specifier_ID */
696 if (dkv->key.id == CSR1212_KV_ID_EXTENDED_KEY_SPECIFIER_ID) {
697 if (last_extkey_spec == NULL) {
698 last_extkey_spec = dkv;
699 } else if (dkv->value.immediate != last_extkey_spec->value.immediate) {
700 last_extkey_spec = dkv;
704 /* Special Case: Extended Key */
705 } else if (dkv->key.id == CSR1212_KV_ID_EXTENDED_KEY) {
706 if (last_extkey == NULL) {
708 } else if (dkv->value.immediate != last_extkey->value.immediate) {
717 switch(dkv->key.type) {
719 case CSR1212_KV_TYPE_IMMEDIATE:
720 case CSR1212_KV_TYPE_CSR_OFFSET:
722 case CSR1212_KV_TYPE_LEAF:
723 case CSR1212_KV_TYPE_DIRECTORY:
724 /* Remove from list */
725 if (dkv->prev && (dkv->prev->next == dkv))
726 dkv->prev->next = dkv->next;
727 if (dkv->next && (dkv->next->prev == dkv))
728 dkv->next->prev = dkv->prev;
729 //if (dkv == *layout_tail)
730 // *layout_tail = dkv->prev;
732 /* Special case: Extended ROM leafs */
733 if (dkv->key.id == CSR1212_KV_ID_EXTENDED_ROM) {
734 dkv->value.leaf.len = -1;
735 /* Don't add Extended ROM leafs in the layout list,
736 * they are handled differently. */
740 /* Add to tail of list */
742 dkv->prev = *layout_tail;
743 (*layout_tail)->next = dkv;
752 static size_t csr1212_generate_layout_order(struct csr1212_keyval *kv)
754 struct csr1212_keyval *ltail = kv;
758 switch(kv->key.type) {
759 case CSR1212_KV_TYPE_LEAF:
760 /* Add 1 quadlet for crc/len field */
761 agg_size += kv->value.leaf.len + 1;
764 case CSR1212_KV_TYPE_DIRECTORY:
765 kv->value.directory.len = csr1212_generate_layout_subdir(kv, <ail);
766 /* Add 1 quadlet for crc/len field */
767 agg_size += kv->value.directory.len + 1;
772 return quads_to_bytes(agg_size);
775 static struct csr1212_keyval *
776 csr1212_generate_positions(struct csr1212_csr_rom_cache *cache,
777 struct csr1212_keyval *start_kv, int start_pos)
779 struct csr1212_keyval *kv = start_kv;
780 struct csr1212_keyval *okv = start_kv;
782 int kv_len = 0, okv_len = 0;
784 cache->layout_head = kv;
786 while(kv && pos < cache->size) {
787 /* Special case: Extended ROM leafs */
788 if (kv->key.id != CSR1212_KV_ID_EXTENDED_ROM) {
789 kv->offset = cache->offset + pos;
792 switch(kv->key.type) {
793 case CSR1212_KV_TYPE_LEAF:
794 kv_len = kv->value.leaf.len;
797 case CSR1212_KV_TYPE_DIRECTORY:
798 kv_len = kv->value.directory.len;
802 /* Should never get here */
806 pos += quads_to_bytes(kv_len + 1);
808 if (pos <= cache->size) {
815 cache->layout_tail = okv;
816 cache->len = (okv->offset - cache->offset) + quads_to_bytes(okv_len + 1);
821 #define CSR1212_KV_KEY_SHIFT 24
822 #define CSR1212_KV_KEY_TYPE_SHIFT 6
823 #define CSR1212_KV_KEY_ID_MASK 0x3f
824 #define CSR1212_KV_KEY_TYPE_MASK 0x3 /* after shift */
827 csr1212_generate_tree_subdir(struct csr1212_keyval *dir, u_int32_t *data_buffer)
829 struct csr1212_dentry *dentry;
830 struct csr1212_keyval *last_extkey_spec = NULL;
831 struct csr1212_keyval *last_extkey = NULL;
834 for (dentry = dir->value.directory.dentries_head; dentry; dentry = dentry->next) {
835 struct csr1212_keyval *a;
837 for (a = dentry->kv; a; a = a->associate) {
840 /* Special Case: Extended Key Specifier_ID */
841 if (a->key.id == CSR1212_KV_ID_EXTENDED_KEY_SPECIFIER_ID) {
842 if (last_extkey_spec == NULL) {
843 last_extkey_spec = a;
844 } else if (a->value.immediate != last_extkey_spec->value.immediate) {
845 last_extkey_spec = a;
849 /* Special Case: Extended Key */
850 } else if (a->key.id == CSR1212_KV_ID_EXTENDED_KEY) {
851 if (last_extkey == NULL) {
853 } else if (a->value.immediate != last_extkey->value.immediate) {
860 switch(a->key.type) {
861 case CSR1212_KV_TYPE_IMMEDIATE:
862 value = a->value.immediate;
864 case CSR1212_KV_TYPE_CSR_OFFSET:
865 value = a->value.csr_offset;
867 case CSR1212_KV_TYPE_LEAF:
869 value -= dir->offset + quads_to_bytes(1+index);
870 value = bytes_to_quads(value);
872 case CSR1212_KV_TYPE_DIRECTORY:
874 value -= dir->offset + quads_to_bytes(1+index);
875 value = bytes_to_quads(value);
878 /* Should never get here */
879 break; /* GDB breakpoint */
882 value |= (a->key.id & CSR1212_KV_KEY_ID_MASK) << CSR1212_KV_KEY_SHIFT;
883 value |= (a->key.type & CSR1212_KV_KEY_TYPE_MASK) <<
884 (CSR1212_KV_KEY_SHIFT + CSR1212_KV_KEY_TYPE_SHIFT);
885 data_buffer[index] = cpu_to_be32(value);
891 struct csr1212_keyval_img {
896 csr1212_quad_t data[0]; /* older gcc can't handle [] which is standard */
899 static void csr1212_fill_cache(struct csr1212_csr_rom_cache *cache)
901 struct csr1212_keyval *kv, *nkv;
902 struct csr1212_keyval_img *kvi;
904 for (kv = cache->layout_head; kv != cache->layout_tail->next; kv = nkv) {
905 kvi = (struct csr1212_keyval_img *)
906 (cache->data + bytes_to_quads(kv->offset - cache->offset));
907 switch(kv->key.type) {
909 case CSR1212_KV_TYPE_IMMEDIATE:
910 case CSR1212_KV_TYPE_CSR_OFFSET:
911 /* Should never get here */
912 break; /* GDB breakpoint */
914 case CSR1212_KV_TYPE_LEAF:
915 /* Don't copy over Extended ROM areas, they are
916 * already filled out! */
917 if (kv->key.id != CSR1212_KV_ID_EXTENDED_ROM)
918 memcpy(kvi->data, kv->value.leaf.data,
919 quads_to_bytes(kv->value.leaf.len));
921 kvi->length = cpu_to_be16(kv->value.leaf.len);
922 kvi->crc = csr1212_crc16(kvi->data, kv->value.leaf.len);
925 case CSR1212_KV_TYPE_DIRECTORY:
926 csr1212_generate_tree_subdir(kv, kvi->data);
928 kvi->length = cpu_to_be16(kv->value.directory.len);
929 kvi->crc = csr1212_crc16(kvi->data, kv->value.directory.len);
935 kv->prev->next = NULL;
937 kv->next->prev = NULL;
943 #define CSR1212_EXTENDED_ROM_SIZE (0x10000 * sizeof(u_int32_t))
945 int csr1212_generate_csr_image(struct csr1212_csr *csr)
947 struct csr1212_bus_info_block_img *bi;
948 struct csr1212_csr_rom_cache *cache;
949 struct csr1212_keyval *kv;
957 cache = csr->cache_head;
959 bi = (struct csr1212_bus_info_block_img*)cache->data;
961 bi->length = bytes_to_quads(csr->bus_info_len) - 1;
962 bi->crc_length = bi->length;
963 bi->crc = csr1212_crc16(bi->data, bi->crc_length);
965 csr->root_kv->next = NULL;
966 csr->root_kv->prev = NULL;
968 agg_size = csr1212_generate_layout_order(csr->root_kv);
970 init_offset = csr->bus_info_len;
972 for (kv = csr->root_kv, cache = csr->cache_head; kv; cache = cache->next) {
974 /* Estimate approximate number of additional cache
975 * regions needed (it assumes that the cache holding
976 * the first 1K Config ROM space always exists). */
977 int est_c = agg_size / (CSR1212_EXTENDED_ROM_SIZE -
978 (2 * sizeof(u_int32_t))) + 1;
980 /* Add additional cache regions, extras will be
982 for (; est_c; est_c--) {
983 ret = csr1212_append_new_cache(csr, CSR1212_EXTENDED_ROM_SIZE);
984 if (ret != CSR1212_SUCCESS)
987 /* Need to re-layout for additional cache regions */
988 agg_size = csr1212_generate_layout_order(csr->root_kv);
990 cache = csr->cache_head;
991 init_offset = csr->bus_info_len;
993 kv = csr1212_generate_positions(cache, kv, init_offset);
994 agg_size -= cache->len;
995 init_offset = sizeof(u_int32_t);
998 /* Remove unused, excess cache regions */
1000 struct csr1212_csr_rom_cache *oc = cache;
1002 cache = cache->next;
1003 csr1212_remove_cache(csr, oc);
1006 /* Go through the list backward so that when done, the correct CRC
1007 * will be calculated for the Extended ROM areas. */
1008 for(cache = csr->cache_tail; cache; cache = cache->prev) {
1009 /* Only Extended ROM caches should have this set. */
1010 if (cache->ext_rom) {
1013 /* Make sure the Extended ROM leaf is a multiple of
1014 * max_rom in size. */
1015 if (csr->max_rom < 1)
1017 leaf_size = (cache->len + (csr->max_rom - 1)) &
1018 ~(csr->max_rom - 1);
1020 /* Zero out the unused ROM region */
1021 memset(cache->data + bytes_to_quads(cache->len), 0x00,
1022 leaf_size - cache->len);
1024 /* Subtract leaf header */
1025 leaf_size -= sizeof(u_int32_t);
1027 /* Update the Extended ROM leaf length */
1028 cache->ext_rom->value.leaf.len =
1029 bytes_to_quads(leaf_size);
1031 /* Zero out the unused ROM region */
1032 memset(cache->data + bytes_to_quads(cache->len), 0x00,
1033 cache->size - cache->len);
1036 /* Copy the data into the cache buffer */
1037 csr1212_fill_cache(cache);
1039 if (cache != csr->cache_head) {
1040 /* Set the length and CRC of the extended ROM. */
1041 struct csr1212_keyval_img *kvi =
1042 (struct csr1212_keyval_img*)cache->data;
1043 u_int16_t len = bytes_to_quads(cache->len) - 1;
1045 kvi->length = cpu_to_be16(len);
1046 kvi->crc = csr1212_crc16(kvi->data, len);
1050 return CSR1212_SUCCESS;
1053 int csr1212_read(struct csr1212_csr *csr, u_int32_t offset, void *buffer, u_int32_t len)
1055 struct csr1212_csr_rom_cache *cache;
1057 for (cache = csr->cache_head; cache; cache = cache->next) {
1058 if (offset >= cache->offset &&
1059 (offset + len) <= (cache->offset + cache->size)) {
1061 &cache->data[bytes_to_quads(offset - cache->offset)],
1063 return CSR1212_SUCCESS;
1070 /* Parse a chunk of data as a Config ROM */
1072 static int csr1212_parse_bus_info_block(struct csr1212_csr *csr)
1074 struct csr1212_bus_info_block_img *bi;
1075 struct csr1212_cache_region *cr;
1079 /* IEEE 1212 says that the entire bus info block should be readable in
1080 * a single transaction regardless of the max_rom value.
1081 * Unfortunately, many IEEE 1394 devices do not abide by that, so the
1082 * bus info block will be read 1 quadlet at a time. The rest of the
1083 * ConfigROM will be read according to the max_rom field. */
1084 for (i = 0; i < csr->bus_info_len; i += sizeof(csr1212_quad_t)) {
1085 ret = csr->ops->bus_read(csr, CSR1212_CONFIG_ROM_SPACE_BASE + i,
1086 sizeof(csr1212_quad_t),
1087 &csr->cache_head->data[bytes_to_quads(i)],
1089 if (ret != CSR1212_SUCCESS)
1092 /* check ROM header's info_length */
1094 be32_to_cpu(csr->cache_head->data[0]) >> 24 !=
1095 bytes_to_quads(csr->bus_info_len) - 1)
1099 bi = (struct csr1212_bus_info_block_img*)csr->cache_head->data;
1100 csr->crc_len = quads_to_bytes(bi->crc_length);
1102 /* IEEE 1212 recommends that crc_len be equal to bus_info_len, but that is not
1103 * always the case, so read the rest of the crc area 1 quadlet at a time. */
1104 for (i = csr->bus_info_len; i <= csr->crc_len; i += sizeof(csr1212_quad_t)) {
1105 ret = csr->ops->bus_read(csr, CSR1212_CONFIG_ROM_SPACE_BASE + i,
1106 sizeof(csr1212_quad_t),
1107 &csr->cache_head->data[bytes_to_quads(i)],
1109 if (ret != CSR1212_SUCCESS)
1114 /* Apparently there are too many differnt wrong implementations of the
1115 * CRC algorithm that verifying them is moot. */
1116 if ((csr1212_crc16(bi->data, bi->crc_length) != bi->crc) &&
1117 (csr1212_msft_crc16(bi->data, bi->crc_length) != bi->crc))
1121 cr = CSR1212_MALLOC(sizeof(*cr));
1127 cr->offset_start = 0;
1128 cr->offset_end = csr->crc_len + 4;
1130 csr->cache_head->filled_head = cr;
1131 csr->cache_head->filled_tail = cr;
1133 return CSR1212_SUCCESS;
1136 #define CSR1212_KV_KEY(q) (be32_to_cpu(q) >> CSR1212_KV_KEY_SHIFT)
1137 #define CSR1212_KV_KEY_TYPE(q) (CSR1212_KV_KEY(q) >> CSR1212_KV_KEY_TYPE_SHIFT)
1138 #define CSR1212_KV_KEY_ID(q) (CSR1212_KV_KEY(q) & CSR1212_KV_KEY_ID_MASK)
1139 #define CSR1212_KV_VAL_MASK 0xffffff
1140 #define CSR1212_KV_VAL(q) (be32_to_cpu(q) & CSR1212_KV_VAL_MASK)
1142 static int csr1212_parse_dir_entry(struct csr1212_keyval *dir,
1146 int ret = CSR1212_SUCCESS;
1147 struct csr1212_keyval *k = NULL;
1150 switch(CSR1212_KV_KEY_TYPE(ki)) {
1151 case CSR1212_KV_TYPE_IMMEDIATE:
1152 k = csr1212_new_immediate(CSR1212_KV_KEY_ID(ki),
1153 CSR1212_KV_VAL(ki));
1159 k->refcnt = 0; /* Don't keep local reference when parsing. */
1162 case CSR1212_KV_TYPE_CSR_OFFSET:
1163 k = csr1212_new_csr_offset(CSR1212_KV_KEY_ID(ki),
1164 CSR1212_KV_VAL(ki));
1169 k->refcnt = 0; /* Don't keep local reference when parsing. */
1173 /* Compute the offset from 0xffff f000 0000. */
1174 offset = quads_to_bytes(CSR1212_KV_VAL(ki)) + kv_pos;
1175 if (offset == kv_pos) {
1176 /* Uh-oh. Can't have a relative offset of 0 for Leaves
1177 * or Directories. The Config ROM image is most likely
1178 * messed up, so we'll just abort here. */
1183 k = csr1212_find_keyval_offset(dir, offset);
1186 break; /* Found it. */
1188 if (CSR1212_KV_KEY_TYPE(ki) == CSR1212_KV_TYPE_DIRECTORY) {
1189 k = csr1212_new_directory(CSR1212_KV_KEY_ID(ki));
1191 k = csr1212_new_leaf(CSR1212_KV_KEY_ID(ki), NULL, 0);
1197 k->refcnt = 0; /* Don't keep local reference when parsing. */
1198 k->valid = 0; /* Contents not read yet so it's not valid. */
1202 k->next = dir->next;
1203 dir->next->prev = k;
1206 ret = csr1212_attach_keyval_to_directory(dir, k);
1209 if (ret != CSR1212_SUCCESS && k != NULL)
1214 int csr1212_parse_keyval(struct csr1212_keyval *kv,
1215 struct csr1212_csr_rom_cache *cache)
1217 struct csr1212_keyval_img *kvi;
1219 int ret = CSR1212_SUCCESS;
1222 kvi = (struct csr1212_keyval_img*)&cache->data[bytes_to_quads(kv->offset -
1224 kvi_len = be16_to_cpu(kvi->length);
1227 /* Apparently there are too many differnt wrong implementations of the
1228 * CRC algorithm that verifying them is moot. */
1229 if ((csr1212_crc16(kvi->data, kvi_len) != kvi->crc) &&
1230 (csr1212_msft_crc16(kvi->data, kvi_len) != kvi->crc)) {
1236 switch(kv->key.type) {
1237 case CSR1212_KV_TYPE_DIRECTORY:
1238 for (i = 0; i < kvi_len; i++) {
1239 csr1212_quad_t ki = kvi->data[i];
1241 /* Some devices put null entries in their unit
1242 * directories. If we come across such an entry,
1246 ret = csr1212_parse_dir_entry(kv, ki,
1248 quads_to_bytes(i + 1)));
1250 kv->value.directory.len = kvi_len;
1253 case CSR1212_KV_TYPE_LEAF:
1254 if (kv->key.id != CSR1212_KV_ID_EXTENDED_ROM) {
1255 kv->value.leaf.data = CSR1212_MALLOC(quads_to_bytes(kvi_len));
1256 if (!kv->value.leaf.data) {
1261 kv->value.leaf.len = kvi_len;
1262 memcpy(kv->value.leaf.data, kvi->data, quads_to_bytes(kvi_len));
1273 int _csr1212_read_keyval(struct csr1212_csr *csr, struct csr1212_keyval *kv)
1275 struct csr1212_cache_region *cr, *ncr, *newcr = NULL;
1276 struct csr1212_keyval_img *kvi = NULL;
1277 struct csr1212_csr_rom_cache *cache;
1280 u_int32_t *cache_ptr;
1281 u_int16_t kv_len = 0;
1283 if (!csr || !kv || csr->max_rom < 1)
1286 /* First find which cache the data should be in (or go in if not read
1288 for (cache = csr->cache_head; cache; cache = cache->next) {
1289 if (kv->offset >= cache->offset &&
1290 kv->offset < (cache->offset + cache->size))
1296 u_int32_t cache_size;
1298 /* Only create a new cache for Extended ROM leaves. */
1299 if (kv->key.id != CSR1212_KV_ID_EXTENDED_ROM)
1302 if (csr->ops->bus_read(csr,
1303 CSR1212_REGISTER_SPACE_BASE + kv->offset,
1304 sizeof(csr1212_quad_t), &q, csr->private)) {
1308 kv->value.leaf.len = be32_to_cpu(q) >> 16;
1310 cache_size = (quads_to_bytes(kv->value.leaf.len + 1) +
1311 (csr->max_rom - 1)) & ~(csr->max_rom - 1);
1313 cache = csr1212_rom_cache_malloc(kv->offset, cache_size);
1317 kv->value.leaf.data = &cache->data[1];
1318 csr->cache_tail->next = cache;
1319 cache->prev = csr->cache_tail;
1321 csr->cache_tail = cache;
1322 cache->filled_head =
1323 CSR1212_MALLOC(sizeof(*cache->filled_head));
1324 if (!cache->filled_head) {
1328 cache->filled_head->offset_start = 0;
1329 cache->filled_head->offset_end = sizeof(csr1212_quad_t);
1330 cache->filled_tail = cache->filled_head;
1331 cache->filled_head->next = NULL;
1332 cache->filled_head->prev = NULL;
1335 /* Don't read the entire extended ROM now. Pieces of it will
1336 * be read when entries inside it are read. */
1337 return csr1212_parse_keyval(kv, cache);
1340 cache_index = kv->offset - cache->offset;
1342 /* Now seach read portions of the cache to see if it is there. */
1343 for (cr = cache->filled_head; cr; cr = cr->next) {
1344 if (cache_index < cr->offset_start) {
1345 newcr = CSR1212_MALLOC(sizeof(*newcr));
1349 newcr->offset_start = cache_index & ~(csr->max_rom - 1);
1350 newcr->offset_end = newcr->offset_start;
1352 newcr->prev = cr->prev;
1356 } else if ((cache_index >= cr->offset_start) &&
1357 (cache_index < cr->offset_end)) {
1358 kvi = (struct csr1212_keyval_img*)
1359 (&cache->data[bytes_to_quads(cache_index)]);
1360 kv_len = quads_to_bytes(be16_to_cpu(kvi->length) + 1);
1362 } else if (cache_index == cr->offset_end)
1367 cr = cache->filled_tail;
1368 newcr = CSR1212_MALLOC(sizeof(*newcr));
1372 newcr->offset_start = cache_index & ~(csr->max_rom - 1);
1373 newcr->offset_end = newcr->offset_start;
1375 newcr->next = cr->next;
1378 cache->filled_tail = newcr;
1381 while(!kvi || cr->offset_end < cache_index + kv_len) {
1382 cache_ptr = &cache->data[bytes_to_quads(cr->offset_end &
1383 ~(csr->max_rom - 1))];
1385 addr = (CSR1212_CSR_ARCH_REG_SPACE_BASE + cache->offset +
1386 cr->offset_end) & ~(csr->max_rom - 1);
1388 if (csr->ops->bus_read(csr, addr, csr->max_rom, cache_ptr,
1390 if (csr->max_rom == 4)
1391 /* We've got problems! */
1394 /* Apperently the max_rom value was a lie, set it to
1395 * do quadlet reads and try again. */
1400 cr->offset_end += csr->max_rom - (cr->offset_end &
1401 (csr->max_rom - 1));
1403 if (!kvi && (cr->offset_end > cache_index)) {
1404 kvi = (struct csr1212_keyval_img*)
1405 (&cache->data[bytes_to_quads(cache_index)]);
1406 kv_len = quads_to_bytes(be16_to_cpu(kvi->length) + 1);
1409 if ((kv_len + (kv->offset - cache->offset)) > cache->size) {
1410 /* The Leaf or Directory claims its length extends
1411 * beyond the ConfigROM image region and thus beyond the
1412 * end of our cache region. Therefore, we abort now
1413 * rather than seg faulting later. */
1419 if (ncr && (cr->offset_end >= ncr->offset_start)) {
1420 /* consolidate region entries */
1421 ncr->offset_start = cr->offset_start;
1424 cr->prev->next = cr->next;
1425 ncr->prev = cr->prev;
1426 if (cache->filled_head == cr)
1427 cache->filled_head = ncr;
1433 return csr1212_parse_keyval(kv, cache);
1436 int csr1212_parse_csr(struct csr1212_csr *csr)
1438 static const int mr_map[] = { 4, 64, 1024, 0 };
1439 struct csr1212_dentry *dentry;
1442 if (!csr || !csr->ops || !csr->ops->bus_read)
1445 ret = csr1212_parse_bus_info_block(csr);
1446 if (ret != CSR1212_SUCCESS)
1449 if (!csr->ops->get_max_rom)
1450 csr->max_rom = mr_map[0]; /* default value */
1452 int i = csr->ops->get_max_rom(csr->bus_info_data,
1456 csr->max_rom = mr_map[i];
1459 csr->cache_head->layout_head = csr->root_kv;
1460 csr->cache_head->layout_tail = csr->root_kv;
1462 csr->root_kv->offset = (CSR1212_CONFIG_ROM_SPACE_BASE & 0xffff) +
1465 csr->root_kv->valid = 0;
1466 csr->root_kv->next = csr->root_kv;
1467 csr->root_kv->prev = csr->root_kv;
1468 ret = _csr1212_read_keyval(csr, csr->root_kv);
1469 if (ret != CSR1212_SUCCESS)
1472 /* Scan through the Root directory finding all extended ROM regions
1473 * and make cache regions for them */
1474 for (dentry = csr->root_kv->value.directory.dentries_head;
1475 dentry; dentry = dentry->next) {
1476 if (dentry->kv->key.id == CSR1212_KV_ID_EXTENDED_ROM &&
1477 !dentry->kv->valid) {
1478 ret = _csr1212_read_keyval(csr, dentry->kv);
1479 if (ret != CSR1212_SUCCESS)
1484 return CSR1212_SUCCESS;