drivers/ieee1394/csr1212.c

   1 /*
   2  * csr1212.c -- IEEE 1212 Control and Status Register support for Linux
   3  *
   4  * Copyright (C) 2003 Francois Retief <fgretief@sun.ac.za>
   5  *                    Steve Kinneberg <kinnebergsteve@acmsystems.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions are met:
   9  *
  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.
  17  *
  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.
  28  */
  29
  30
  31 /* TODO List:
  32  * - Verify interface consistency: i.e., public functions that take a size
  33  *   parameter expect size to be in bytes.
  34  * - Convenience functions for reading a block of data from a given offset.
  35  */
  36
  37 #ifndef __KERNEL__
  38 #include <string.h>
  39 #endif
  40
  41 #include "csr1212.h"
  42
  43
  44 /* Permitted key type for each key id */
  45 #define __I (1 << CSR1212_KV_TYPE_IMMEDIATE)
  46 #define __C (1 << CSR1212_KV_TYPE_CSR_OFFSET)
  47 #define __D (1 << CSR1212_KV_TYPE_DIRECTORY)
  48 #define __L (1 << CSR1212_KV_TYPE_LEAF)
  49 static const u_int8_t csr1212_key_id_type_map[0x30] = {
  50         0,                      /* Reserved */
  51         __D | __L,              /* Descriptor */
  52         __I | __D | __L,        /* Bus_Dependent_Info */
  53         __I | __D | __L,        /* Vendor */
  54         __I,                    /* Hardware_Version */
  55         0, 0,                   /* Reserved */
  56         __D | __L,              /* Module */
  57         0, 0, 0, 0,             /* Reserved */
  58         __I,                    /* Node_Capabilities */
  59         __L,                    /* EUI_64 */
  60         0, 0, 0,                /* Reserved */
  61         __D,                    /* Unit */
  62         __I,                    /* Specifier_ID */
  63         __I,                    /* Version */
  64         __I | __C | __D | __L,  /* Dependent_Info */
  65         __L,                    /* Unit_Location */
  66         0,                      /* Reserved */
  67         __I,                    /* Model */
  68         __D,                    /* Instance */
  69         __L,                    /* Keyword */
  70         __D,                    /* Feature */
  71         __L,                    /* Extended_ROM */
  72         __I,                    /* Extended_Key_Specifier_ID */
  73         __I,                    /* Extended_Key */
  74         __I | __C | __D | __L,  /* Extended_Data */
  75         __L,                    /* Modifiable_Descriptor */
  76         __I,                    /* Directory_ID */
  77         __I,                    /* Revision */
  78 };
  79 #undef __I
  80 #undef __C
  81 #undef __D
  82 #undef __L
  83
  84
  85 #define quads_to_bytes(_q) ((_q) * sizeof(u_int32_t))
  86 #define bytes_to_quads(_b) (((_b) + sizeof(u_int32_t) - 1) / sizeof(u_int32_t))
  87
  88 static inline void free_keyval(struct csr1212_keyval *kv)
  89 {
  90         if (kv->key.type == CSR1212_KV_TYPE_LEAF)
  91                 CSR1212_FREE(kv->value.leaf.data);
  92
  93         CSR1212_FREE(kv);
  94 }
  95
  96 static u_int16_t csr1212_crc16(const u_int32_t *buffer, size_t length)
  97 {
  98         int shift;
  99         u_int32_t data;
 100         u_int16_t sum, crc = 0;
 101
 102         for (; length; length--) {
 103                 data = CSR1212_BE32_TO_CPU(*buffer);
 104                 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);
 108                 }
 109                 crc &= 0xffff;
 110         }
 111
 112         return CSR1212_CPU_TO_BE16(crc);
 113 }
 114
 115 #if 0
 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
 118  * software. */
 119 static u_int16_t csr1212_msft_crc16(const u_int32_t *buffer, size_t length)
 120 {
 121         int shift;
 122         u_int32_t data;
 123         u_int16_t sum, crc = 0;
 124
 125         for (; length; length--) {
 126                 data = CSR1212_LE32_TO_CPU(*buffer);
 127                 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);
 131                 }
 132                 crc &= 0xffff;
 133         }
 134
 135         return CSR1212_CPU_TO_BE16(crc);
 136 }
 137 #endif
 138
 139 static inline struct csr1212_dentry *csr1212_find_keyval(struct csr1212_keyval *dir,
 140                                                          struct csr1212_keyval *kv)
 141 {
 142         struct csr1212_dentry *pos;
 143
 144         for (pos = dir->value.directory.dentries_head;
 145              pos != NULL; pos = pos->next) {
 146                 if (pos->kv == kv)
 147                         return pos;
 148         }
 149         return NULL;
 150 }
 151
 152
 153 static inline struct csr1212_keyval *csr1212_find_keyval_offset(struct csr1212_keyval *kv_list,
 154                                                                 u_int32_t offset)
 155 {
 156         struct csr1212_keyval *kv;
 157
 158         for (kv = kv_list; kv != NULL; kv = kv->next) {
 159                 if (kv->offset == offset)
 160                         return kv;
 161         }
 162         return NULL;
 163 }
 164
 165
 166 /* Creation Routines */
 167 struct csr1212_csr *csr1212_create_csr(struct csr1212_bus_ops *ops,
 168                                        size_t bus_info_size, void *private)
 169 {
 170         struct csr1212_csr *csr;
 171
 172         csr = CSR1212_MALLOC(sizeof(*csr));
 173         if (!csr)
 174                 return NULL;
 175
 176         csr->cache_head =
 177                 csr1212_rom_cache_malloc(CSR1212_CONFIG_ROM_SPACE_OFFSET,
 178                                          CSR1212_CONFIG_ROM_SPACE_SIZE);
 179         if (!csr->cache_head) {
 180                 CSR1212_FREE(csr);
 181                 return NULL;
 182         }
 183
 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);
 188         if (!csr->root_kv) {
 189                 CSR1212_FREE(csr->cache_head);
 190                 CSR1212_FREE(csr);
 191                 return NULL;
 192         }
 193
 194         csr->bus_info_data = csr->cache_head->data;
 195         csr->bus_info_len = bus_info_size;
 196         csr->crc_len = bus_info_size;
 197         csr->ops = ops;
 198         csr->private = private;
 199         csr->cache_tail = csr->cache_head;
 200
 201         return csr;
 202 }
 203
 204
 205
 206 void csr1212_init_local_csr(struct csr1212_csr *csr,
 207                             const u_int32_t *bus_info_data, int max_rom)
 208 {
 209         csr->max_rom = max_rom;
 210         memcpy(csr->bus_info_data, bus_info_data, csr->bus_info_len);
 211 }
 212
 213
 214 static struct csr1212_keyval *csr1212_new_keyval(u_int8_t type, u_int8_t key)
 215 {
 216         struct csr1212_keyval *kv;
 217
 218         if (key < 0x30 && ((csr1212_key_id_type_map[key] & (1 << type)) == 0))
 219                 return NULL;
 220
 221         kv = CSR1212_MALLOC(sizeof(*kv));
 222         if (!kv)
 223                 return NULL;
 224
 225         kv->key.type = type;
 226         kv->key.id = key;
 227
 228         kv->associate = NULL;
 229         kv->refcnt = 1;
 230
 231         kv->next = NULL;
 232         kv->prev = NULL;
 233         kv->offset = 0;
 234         kv->valid = 0;
 235         return kv;
 236 }
 237
 238 struct csr1212_keyval *csr1212_new_immediate(u_int8_t key, u_int32_t value)
 239 {
 240         struct csr1212_keyval *kv = csr1212_new_keyval(CSR1212_KV_TYPE_IMMEDIATE, key);
 241
 242         if (!kv)
 243                 return NULL;
 244
 245         kv->value.immediate = value;
 246         kv->valid = 1;
 247         return kv;
 248 }
 249
 250 struct csr1212_keyval *csr1212_new_leaf(u_int8_t key, const void *data, size_t data_len)
 251 {
 252         struct csr1212_keyval *kv = csr1212_new_keyval(CSR1212_KV_TYPE_LEAF, key);
 253
 254         if (!kv)
 255                 return NULL;
 256
 257         if (data_len > 0) {
 258                 kv->value.leaf.data = CSR1212_MALLOC(data_len);
 259                 if (!kv->value.leaf.data) {
 260                         CSR1212_FREE(kv);
 261                         return NULL;
 262                 }
 263
 264                 if (data)
 265                         memcpy(kv->value.leaf.data, data, data_len);
 266         } else {
 267                 kv->value.leaf.data = NULL;
 268         }
 269
 270         kv->value.leaf.len = bytes_to_quads(data_len);
 271         kv->offset = 0;
 272         kv->valid = 1;
 273
 274         return kv;
 275 }
 276
 277 struct csr1212_keyval *csr1212_new_csr_offset(u_int8_t key, u_int32_t csr_offset)
 278 {
 279         struct csr1212_keyval *kv = csr1212_new_keyval(CSR1212_KV_TYPE_CSR_OFFSET, key);
 280
 281         if (!kv)
 282                 return NULL;
 283
 284         kv->value.csr_offset = csr_offset;
 285
 286         kv->offset = 0;
 287         kv->valid = 1;
 288         return kv;
 289 }
 290
 291 struct csr1212_keyval *csr1212_new_directory(u_int8_t key)
 292 {
 293         struct csr1212_keyval *kv = csr1212_new_keyval(CSR1212_KV_TYPE_DIRECTORY, key);
 294
 295         if (!kv)
 296                 return NULL;
 297
 298         kv->value.directory.len = 0;
 299         kv->offset = 0;
 300         kv->value.directory.dentries_head = NULL;
 301         kv->value.directory.dentries_tail = NULL;
 302         kv->valid = 1;
 303         return kv;
 304 }
 305
 306 int csr1212_associate_keyval(struct csr1212_keyval *kv,
 307                              struct csr1212_keyval *associate)
 308 {
 309         if (!kv || !associate)
 310                 return CSR1212_EINVAL;
 311
 312         if (kv->key.id == CSR1212_KV_ID_DESCRIPTOR ||
 313            (associate->key.id != CSR1212_KV_ID_DESCRIPTOR &&
 314             associate->key.id != CSR1212_KV_ID_DEPENDENT_INFO &&
 315             associate->key.id != CSR1212_KV_ID_EXTENDED_KEY &&
 316             associate->key.id != CSR1212_KV_ID_EXTENDED_DATA &&
 317             associate->key.id < 0x30))
 318                 return CSR1212_EINVAL;
 319
 320         if (kv->key.id == CSR1212_KV_ID_EXTENDED_KEY_SPECIFIER_ID &&
 321            associate->key.id != CSR1212_KV_ID_EXTENDED_KEY)
 322                 return CSR1212_EINVAL;
 323
 324         if (kv->key.id == CSR1212_KV_ID_EXTENDED_KEY &&
 325            associate->key.id != CSR1212_KV_ID_EXTENDED_DATA)
 326                 return CSR1212_EINVAL;
 327
 328         if (associate->key.id == CSR1212_KV_ID_EXTENDED_KEY &&
 329            kv->key.id != CSR1212_KV_ID_EXTENDED_KEY_SPECIFIER_ID)
 330                 return CSR1212_EINVAL;
 331
 332         if (associate->key.id == CSR1212_KV_ID_EXTENDED_DATA &&
 333            kv->key.id != CSR1212_KV_ID_EXTENDED_KEY)
 334                 return CSR1212_EINVAL;
 335
 336         if (kv->associate)
 337                 csr1212_release_keyval(kv->associate);
 338
 339         associate->refcnt++;
 340         kv->associate = associate;
 341
 342         return CSR1212_SUCCESS;
 343 }
 344
 345 int csr1212_attach_keyval_to_directory(struct csr1212_keyval *dir,
 346                                        struct csr1212_keyval *kv)
 347 {
 348         struct csr1212_dentry *dentry;
 349
 350         if (!kv || !dir || dir->key.type != CSR1212_KV_TYPE_DIRECTORY)
 351                 return CSR1212_EINVAL;
 352
 353         dentry = CSR1212_MALLOC(sizeof(*dentry));
 354         if (!dentry)
 355                 return CSR1212_ENOMEM;
 356
 357         dentry->kv = kv;
 358
 359         kv->refcnt++;
 360
 361         dentry->next = NULL;
 362         dentry->prev = dir->value.directory.dentries_tail;
 363
 364         if (!dir->value.directory.dentries_head)
 365                 dir->value.directory.dentries_head = dentry;
 366
 367         if (dir->value.directory.dentries_tail)
 368                 dir->value.directory.dentries_tail->next = dentry;
 369         dir->value.directory.dentries_tail = dentry;
 370
 371         return CSR1212_SUCCESS;
 372 }
 373
 374 struct csr1212_keyval *csr1212_new_extended_immediate(u_int32_t spec, u_int32_t key,
 375                                                       u_int32_t value)
 376 {
 377         struct csr1212_keyval *kvs, *kvk, *kvv;
 378
 379         kvs = csr1212_new_immediate(CSR1212_KV_ID_EXTENDED_KEY_SPECIFIER_ID, spec);
 380         kvk = csr1212_new_immediate(CSR1212_KV_ID_EXTENDED_KEY, key);
 381         kvv = csr1212_new_immediate(CSR1212_KV_ID_EXTENDED_DATA, value);
 382
 383         if (!kvs || !kvk || !kvv) {
 384                 if (kvs)
 385                         free_keyval(kvs);
 386                 if (kvk)
 387                         free_keyval(kvk);
 388                 if (kvv)
 389                         free_keyval(kvv);
 390                 return NULL;
 391         }
 392
 393         /* Don't keep a local reference to the extended key or value. */
 394         kvk->refcnt = 0;
 395         kvv->refcnt = 0;
 396
 397         csr1212_associate_keyval(kvk, kvv);
 398         csr1212_associate_keyval(kvs, kvk);
 399
 400         return kvs;
 401 }
 402
 403 struct csr1212_keyval *csr1212_new_extended_leaf(u_int32_t spec, u_int32_t key,
 404                                                  const void *data, size_t data_len)
 405 {
 406         struct csr1212_keyval *kvs, *kvk, *kvv;
 407
 408         kvs = csr1212_new_immediate(CSR1212_KV_ID_EXTENDED_KEY_SPECIFIER_ID, spec);
 409         kvk = csr1212_new_immediate(CSR1212_KV_ID_EXTENDED_KEY, key);
 410         kvv = csr1212_new_leaf(CSR1212_KV_ID_EXTENDED_DATA, data, data_len);
 411
 412         if (!kvs || !kvk || !kvv) {
 413                 if (kvs)
 414                         free_keyval(kvs);
 415                 if (kvk)
 416                         free_keyval(kvk);
 417                 if (kvv)
 418                         free_keyval(kvv);
 419                 return NULL;
 420         }
 421
 422         /* Don't keep a local reference to the extended key or value. */
 423         kvk->refcnt = 0;
 424         kvv->refcnt = 0;
 425
 426         csr1212_associate_keyval(kvk, kvv);
 427         csr1212_associate_keyval(kvs, kvk);
 428
 429         return kvs;
 430 }
 431
 432 struct csr1212_keyval *csr1212_new_descriptor_leaf(u_int8_t dtype, u_int32_t specifier_id,
 433                                                    const void *data, size_t data_len)
 434 {
 435         struct csr1212_keyval *kv;
 436
 437         kv = csr1212_new_leaf(CSR1212_KV_ID_DESCRIPTOR, NULL,
 438                               data_len + CSR1212_DESCRIPTOR_LEAF_OVERHEAD);
 439         if (!kv)
 440                 return NULL;
 441
 442         CSR1212_DESCRIPTOR_LEAF_SET_TYPE(kv, dtype);
 443         CSR1212_DESCRIPTOR_LEAF_SET_SPECIFIER_ID(kv, specifier_id);
 444
 445         if (data) {
 446                 memcpy(CSR1212_DESCRIPTOR_LEAF_DATA(kv), data, data_len);
 447         }
 448
 449         return kv;
 450 }
 451
 452
 453 struct csr1212_keyval *csr1212_new_textual_descriptor_leaf(u_int8_t cwidth,
 454                                                            u_int16_t cset,
 455                                                            u_int16_t language,
 456                                                            const void *data,
 457                                                            size_t data_len)
 458 {
 459         struct csr1212_keyval *kv;
 460         char *lstr;
 461
 462         kv = csr1212_new_descriptor_leaf(0, 0, NULL, data_len +
 463                                          CSR1212_TEXTUAL_DESCRIPTOR_LEAF_OVERHEAD);
 464         if (!kv)
 465                 return NULL;
 466
 467         CSR1212_TEXTUAL_DESCRIPTOR_LEAF_SET_WIDTH(kv, cwidth);
 468         CSR1212_TEXTUAL_DESCRIPTOR_LEAF_SET_CHAR_SET(kv, cset);
 469         CSR1212_TEXTUAL_DESCRIPTOR_LEAF_SET_LANGUAGE(kv, language);
 470
 471         lstr = (char*)CSR1212_TEXTUAL_DESCRIPTOR_LEAF_DATA(kv);
 472
 473         /* make sure last quadlet is zeroed out */
 474         *((u_int32_t*)&(lstr[(data_len - 1) & ~0x3])) = 0;
 475
 476         /* don't copy the NUL terminator */
 477         memcpy(lstr, data, data_len);
 478
 479         return kv;
 480 }
 481
 482 static int csr1212_check_minimal_ascii(const char *s)
 483 {
 484         static const char minimal_ascii_table[] = {
 485                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
 486                 0x00, 0x00, 0x0a, 0x00, 0x0C, 0x0D, 0x00, 0x00,
 487                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 488                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 489                 0x20, 0x21, 0x22, 0x00, 0x00, 0x25, 0x26, 0x27,
 490                 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 491                 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 492                 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 493                 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
 494                 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
 495                 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
 496                 0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x5f,
 497                 0x00, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
 498                 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 499                 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
 500                 0x78, 0x79, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00,
 501         };
 502         for (; *s; s++) {
 503                 if (minimal_ascii_table[*s & 0x7F] != *s)
 504                         return -1; /* failed */
 505         }
 506         /* String conforms to minimal-ascii, as specified by IEEE 1212,
 507          * par. 7.4 */
 508         return 0;
 509 }
 510
 511 struct csr1212_keyval *csr1212_new_string_descriptor_leaf(const char *s)
 512 {
 513         /* Check if string conform to minimal_ascii format */
 514         if (csr1212_check_minimal_ascii(s))
 515                 return NULL;
 516
 517         /* IEEE 1212, par. 7.5.4.1  Textual descriptors (minimal ASCII) */
 518         return csr1212_new_textual_descriptor_leaf(0, 0, 0, s, strlen(s));
 519 }
 520
 521 struct csr1212_keyval *csr1212_new_icon_descriptor_leaf(u_int32_t version,
 522                                                         u_int8_t palette_depth,
 523                                                         u_int8_t color_space,
 524                                                         u_int16_t language,
 525                                                         u_int16_t hscan,
 526                                                         u_int16_t vscan,
 527                                                         u_int32_t *palette,
 528                                                         u_int32_t *pixels)
 529 {
 530         static const int pd[4] = { 0, 4, 16, 256 };
 531         static const int cs[16] = { 4, 2 };
 532         struct csr1212_keyval *kv;
 533         int palette_size = pd[palette_depth] * cs[color_space];
 534         int pixel_size = (hscan * vscan + 3) & ~0x3;
 535
 536         if ((palette_depth && !palette) || !pixels)
 537                 return NULL;
 538
 539         kv = csr1212_new_descriptor_leaf(1, 0, NULL,
 540                                          palette_size + pixel_size +
 541                                          CSR1212_ICON_DESCRIPTOR_LEAF_OVERHEAD);
 542         if (!kv)
 543                 return NULL;
 544
 545         CSR1212_ICON_DESCRIPTOR_LEAF_SET_VERSION(kv, version);
 546         CSR1212_ICON_DESCRIPTOR_LEAF_SET_PALETTE_DEPTH(kv, palette_depth);
 547         CSR1212_ICON_DESCRIPTOR_LEAF_SET_COLOR_SPACE(kv, color_space);
 548         CSR1212_ICON_DESCRIPTOR_LEAF_SET_LANGUAGE(kv, language);
 549         CSR1212_ICON_DESCRIPTOR_LEAF_SET_HSCAN(kv, hscan);
 550         CSR1212_ICON_DESCRIPTOR_LEAF_SET_VSCAN(kv, vscan);
 551
 552         if (palette_size)
 553                 memcpy(CSR1212_ICON_DESCRIPTOR_LEAF_PALETTE(kv), palette,
 554                        palette_size);
 555
 556         memcpy(CSR1212_ICON_DESCRIPTOR_LEAF_PIXELS(kv), pixels, pixel_size);
 557
 558         return kv;
 559 }
 560
 561 struct csr1212_keyval *csr1212_new_modifiable_descriptor_leaf(u_int16_t max_size,
 562                                                               u_int64_t address)
 563 {
 564         struct csr1212_keyval *kv;
 565
 566         /* IEEE 1212, par. 7.5.4.3  Modifiable descriptors */
 567         kv = csr1212_new_leaf(CSR1212_KV_ID_MODIFIABLE_DESCRIPTOR, NULL, sizeof(u_int64_t));
 568         if(!kv)
 569                 return NULL;
 570
 571         CSR1212_MODIFIABLE_DESCRIPTOR_SET_MAX_SIZE(kv, max_size);
 572         CSR1212_MODIFIABLE_DESCRIPTOR_SET_ADDRESS_HI(kv, address);
 573         CSR1212_MODIFIABLE_DESCRIPTOR_SET_ADDRESS_LO(kv, address);
 574
 575         return kv;
 576 }
 577
 578 static int csr1212_check_keyword(const char *s)
 579 {
 580         for (; *s; s++) {
 581
 582                 if (('A' <= *s) && (*s <= 'Z'))
 583                         continue;
 584                 if (('0' <= *s) && (*s <= '9'))
 585                         continue;
 586                 if (*s == '-')
 587                         continue;
 588
 589                 return -1; /* failed */
 590         }
 591         /* String conforms to keyword, as specified by IEEE 1212,
 592          * par. 7.6.5 */
 593         return CSR1212_SUCCESS;
 594 }
 595
 596 struct csr1212_keyval *csr1212_new_keyword_leaf(int strc, const char *strv[])
 597 {
 598         struct csr1212_keyval *kv;
 599         char *buffer;
 600         int i, data_len = 0;
 601
 602         /* Check all keywords to see if they conform to restrictions:
 603          * Only the following characters is allowed ['A'..'Z','0'..'9','-']
 604          * Each word is zero-terminated.
 605          * Also calculate the total length of the keywords.
 606          */
 607         for (i = 0; i < strc; i++) {
 608                 if (!strv[i] || csr1212_check_keyword(strv[i])) {
 609                         return NULL;
 610                 }
 611                 data_len += strlen(strv[i]) + 1; /* Add zero-termination char. */
 612         }
 613
 614         /* IEEE 1212, par. 7.6.5 Keyword leaves */
 615         kv = csr1212_new_leaf(CSR1212_KV_ID_KEYWORD, NULL, data_len);
 616         if (!kv)
 617                 return NULL;
 618
 619         buffer = (char *)kv->value.leaf.data;
 620
 621         /* make sure last quadlet is zeroed out */
 622         *((u_int32_t*)&(buffer[(data_len - 1) & ~0x3])) = 0;
 623
 624         /* Copy keyword(s) into leaf data buffer */
 625         for (i = 0; i < strc; i++) {
 626                 int len = strlen(strv[i]) + 1;
 627                 memcpy(buffer, strv[i], len);
 628                 buffer += len;
 629         }
 630         return kv;
 631 }
 632
 633
 634 /* Destruction Routines */
 635
 636 void csr1212_detach_keyval_from_directory(struct csr1212_keyval *dir,
 637                                           struct csr1212_keyval *kv)
 638 {
 639         struct csr1212_dentry *dentry;
 640
 641         if (!kv || !dir || dir->key.type != CSR1212_KV_TYPE_DIRECTORY)
 642                 return;
 643
 644         dentry = csr1212_find_keyval(dir, kv);
 645
 646         if (!dentry)
 647                 return;
 648
 649         if (dentry->prev)
 650                 dentry->prev->next = dentry->next;
 651         if (dentry->next)
 652                 dentry->next->prev = dentry->prev;
 653         if (dir->value.directory.dentries_head == dentry)
 654                 dir->value.directory.dentries_head = dentry->next;
 655         if (dir->value.directory.dentries_tail == dentry)
 656                 dir->value.directory.dentries_tail = dentry->prev;
 657
 658         CSR1212_FREE(dentry);
 659
 660         csr1212_release_keyval(kv);
 661 }
 662
 663
 664 void csr1212_disassociate_keyval(struct csr1212_keyval *kv)
 665 {
 666         if (kv->associate) {
 667                 csr1212_release_keyval(kv->associate);
 668         }
 669
 670         kv->associate = NULL;
 671 }
 672
 673
 674 /* This function is used to free the memory taken by a keyval.  If the given
 675  * keyval is a directory type, then any keyvals contained in that directory
 676  * will be destroyed as well if their respective refcnts are 0.  By means of
 677  * list manipulation, this routine will descend a directory structure in a
 678  * non-recursive manner. */
 679 void _csr1212_destroy_keyval(struct csr1212_keyval *kv)
 680 {
 681         struct csr1212_keyval *k, *a;
 682         struct csr1212_dentry dentry;
 683         struct csr1212_dentry *head, *tail;
 684
 685         dentry.kv = kv;
 686         dentry.next = NULL;
 687         dentry.prev = NULL;
 688
 689         head = &dentry;
 690         tail = head;
 691
 692         while (head) {
 693                 k = head->kv;
 694
 695                 while (k) {
 696                         k->refcnt--;
 697
 698                         if (k->refcnt > 0)
 699                                 break;
 700
 701                         a = k->associate;
 702
 703                         if (k->key.type == CSR1212_KV_TYPE_DIRECTORY) {
 704                                 /* If the current entry is a directory, then move all
 705                                  * the entries to the destruction list. */
 706                                 if (k->value.directory.dentries_head) {
 707                                         tail->next = k->value.directory.dentries_head;
 708                                         k->value.directory.dentries_head->prev = tail;
 709                                         tail = k->value.directory.dentries_tail;
 710                                 }
 711                         }
 712                         free_keyval(k);
 713                         k = a;
 714                 }
 715
 716                 head = head->next;
 717                 if (head) {
 718                         if (head->prev && head->prev != &dentry) {
 719                                 CSR1212_FREE(head->prev);
 720                         }
 721                         head->prev = NULL;
 722                 } else if (tail != &dentry)
 723                         CSR1212_FREE(tail);
 724         }
 725 }
 726
 727
 728 void csr1212_destroy_csr(struct csr1212_csr *csr)
 729 {
 730         struct csr1212_csr_rom_cache *c, *oc;
 731         struct csr1212_cache_region *cr, *ocr;
 732
 733         csr1212_release_keyval(csr->root_kv);
 734
 735         c = csr->cache_head;
 736         while (c) {
 737                 oc = c;
 738                 cr = c->filled_head;
 739                 while (cr) {
 740                         ocr = cr;
 741                         cr = cr->next;
 742                         CSR1212_FREE(ocr);
 743                 }
 744                 c = c->next;
 745                 CSR1212_FREE(oc);
 746         }
 747
 748         CSR1212_FREE(csr);
 749 }
 750
 751
 752
 753 /* CSR Image Creation */
 754
 755 static int csr1212_append_new_cache(struct csr1212_csr *csr, size_t romsize)
 756 {
 757         struct csr1212_csr_rom_cache *cache;
 758         u_int64_t csr_addr;
 759
 760         if (!csr || !csr->ops->allocate_addr_range ||
 761             !csr->ops->release_addr)
 762                 return CSR1212_ENOMEM;
 763
 764         /* ROM size must be a multiple of csr->max_rom */
 765         romsize = (romsize + (csr->max_rom - 1)) & ~(csr->max_rom - 1);
 766
 767         csr_addr = csr->ops->allocate_addr_range(romsize, csr->max_rom, csr->private);
 768         if (csr_addr == ~0ULL) {
 769                 return CSR1212_ENOMEM;
 770         }
 771         if (csr_addr < CSR1212_REGISTER_SPACE_BASE) {
 772                 /* Invalid address returned from allocate_addr_range(). */
 773                 csr->ops->release_addr(csr_addr, csr->private);
 774                 return CSR1212_ENOMEM;
 775         }
 776
 777         cache = csr1212_rom_cache_malloc(csr_addr - CSR1212_REGISTER_SPACE_BASE, romsize);
 778         if (!cache) {
 779                 csr->ops->release_addr(csr_addr, csr->private);
 780                 return CSR1212_ENOMEM;
 781         }
 782
 783         cache->ext_rom = csr1212_new_keyval(CSR1212_KV_TYPE_LEAF, CSR1212_KV_ID_EXTENDED_ROM);
 784         if (!cache->ext_rom) {
 785                 csr->ops->release_addr(csr_addr, csr->private);
 786                 CSR1212_FREE(cache);
 787                 return CSR1212_ENOMEM;
 788         }
 789
 790         if (csr1212_attach_keyval_to_directory(csr->root_kv, cache->ext_rom) != CSR1212_SUCCESS) {
 791                 csr1212_release_keyval(cache->ext_rom);
 792                 csr->ops->release_addr(csr_addr, csr->private);
 793                 CSR1212_FREE(cache);
 794                 return CSR1212_ENOMEM;
 795         }
 796         cache->ext_rom->offset = csr_addr - CSR1212_REGISTER_SPACE_BASE;
 797         cache->ext_rom->value.leaf.len = 0;
 798
 799         /* Add cache to tail of cache list */
 800         cache->prev = csr->cache_tail;
 801         csr->cache_tail->next = cache;
 802         csr->cache_tail = cache;
 803         return CSR1212_SUCCESS;
 804 }
 805
 806 static inline void csr1212_remove_cache(struct csr1212_csr *csr,
 807                                         struct csr1212_csr_rom_cache *cache)
 808 {
 809         if (csr->cache_head == cache)
 810                 csr->cache_head = cache->next;
 811         if (csr->cache_tail == cache)
 812                 csr->cache_tail = cache->prev;
 813
 814         if (cache->prev)
 815                 cache->prev->next = cache->next;
 816         if (cache->next)
 817                 cache->next->prev = cache->prev;
 818
 819         if (cache->ext_rom) {
 820                 csr1212_detach_keyval_from_directory(csr->root_kv, cache->ext_rom);
 821                 csr1212_release_keyval(cache->ext_rom);
 822         }
 823
 824         CSR1212_FREE(cache);
 825 }
 826
 827 static int csr1212_generate_layout_subdir(struct csr1212_keyval *dir,
 828                                           struct csr1212_keyval **layout_tail)
 829 {
 830         struct csr1212_dentry *dentry;
 831         struct csr1212_keyval *dkv;
 832         struct csr1212_keyval *last_extkey_spec = NULL;
 833         struct csr1212_keyval *last_extkey = NULL;
 834         int num_entries = 0;
 835
 836         for (dentry = dir->value.directory.dentries_head; dentry;
 837              dentry = dentry->next) {
 838                 for (dkv = dentry->kv; dkv; dkv = dkv->associate) {
 839                         /* Special Case: Extended Key Specifier_ID */
 840                         if (dkv->key.id == CSR1212_KV_ID_EXTENDED_KEY_SPECIFIER_ID) {
 841                                 if (last_extkey_spec == NULL) {
 842                                         last_extkey_spec = dkv;
 843                                 } else if (dkv->value.immediate != last_extkey_spec->value.immediate) {
 844                                         last_extkey_spec = dkv;
 845                                 } else {
 846                                         continue;
 847                                 }
 848                         /* Special Case: Extended Key */
 849                         } else if (dkv->key.id == CSR1212_KV_ID_EXTENDED_KEY) {
 850                                 if (last_extkey == NULL) {
 851                                         last_extkey = dkv;
 852                                 } else if (dkv->value.immediate != last_extkey->value.immediate) {
 853                                         last_extkey = dkv;
 854                                 } else {
 855                                         continue;
 856                                 }
 857                         }
 858
 859                         num_entries += 1;
 860
 861                         switch(dkv->key.type) {
 862                         default:
 863                         case CSR1212_KV_TYPE_IMMEDIATE:
 864                         case CSR1212_KV_TYPE_CSR_OFFSET:
 865                                 continue;
 866                         case CSR1212_KV_TYPE_LEAF:
 867                         case CSR1212_KV_TYPE_DIRECTORY:
 868                                 /* Remove from list */
 869                                 if (dkv->prev)
 870                                         dkv->prev->next = dkv->next;
 871                                 if (dkv->next)
 872                                         dkv->next->prev = dkv->prev;
 873                                 if (dkv == *layout_tail)
 874                                         *layout_tail = dkv->prev;
 875
 876                                 /* Special case: Extended ROM leafs */
 877                                 if (dkv->key.id == CSR1212_KV_ID_EXTENDED_ROM) {
 878                                         dkv->value.leaf.len = 0; /* initialize to zero */
 879                                         /* Don't add Extended ROM leafs in the layout list,
 880                                          * they are handled differently. */
 881                                         break;
 882                                 }
 883
 884                                 /* Add to tail of list */
 885                                 dkv->next = NULL;
 886                                 dkv->prev = *layout_tail;
 887                                 (*layout_tail)->next = dkv;
 888                                 *layout_tail = dkv;
 889                                 break;
 890                         }
 891                 }
 892         }
 893         return num_entries;
 894 }
 895
 896 size_t csr1212_generate_layout_order(struct csr1212_keyval *kv)
 897 {
 898         struct csr1212_keyval *ltail = kv;
 899         size_t agg_size = 0;
 900
 901         while(kv) {
 902                 switch(kv->key.type) {
 903                 case CSR1212_KV_TYPE_LEAF:
 904                         /* Add 1 quadlet for crc/len field */
 905                         agg_size += kv->value.leaf.len + 1;
 906                         break;
 907
 908                 case CSR1212_KV_TYPE_DIRECTORY:
 909                         kv->value.directory.len = csr1212_generate_layout_subdir(kv, &ltail);
 910                         /* Add 1 quadlet for crc/len field */
 911                         agg_size += kv->value.directory.len + 1;
 912                         break;
 913                 }
 914                 kv = kv->next;
 915         }
 916         return quads_to_bytes(agg_size);
 917 }
 918
 919 struct csr1212_keyval *csr1212_generate_positions(struct csr1212_csr_rom_cache *cache,
 920                                                   struct csr1212_keyval *start_kv,
 921                                                   int start_pos)
 922 {
 923         struct csr1212_keyval *kv = start_kv;
 924         struct csr1212_keyval *okv = start_kv;
 925         int pos = start_pos;
 926         int kv_len = 0, okv_len = 0;
 927
 928         cache->layout_head = kv;
 929
 930         while(kv && pos < cache->size) {
 931                 kv->offset = cache->offset + pos;
 932
 933                 switch(kv->key.type) {
 934                 case CSR1212_KV_TYPE_LEAF:
 935                         kv_len = kv->value.leaf.len;
 936                         break;
 937
 938                 case CSR1212_KV_TYPE_DIRECTORY:
 939                         kv_len = kv->value.directory.len;
 940                         break;
 941
 942                 default:
 943                         /* Should never get here */
 944                         break;
 945                 }
 946
 947                 pos += quads_to_bytes(kv_len + 1);
 948
 949                 if (pos <= cache->size) {
 950                         okv = kv;
 951                         okv_len = kv_len;
 952                         kv = kv->next;
 953                 }
 954         }
 955
 956         cache->layout_tail = okv;
 957         cache->len = (okv->offset - cache->offset) + quads_to_bytes(okv_len + 1);
 958
 959         return kv;
 960 }
 961
 962 static void csr1212_generate_tree_subdir(struct csr1212_keyval *dir,
 963                                          u_int32_t *data_buffer)
 964 {
 965         struct csr1212_dentry *dentry;
 966         struct csr1212_keyval *last_extkey_spec = NULL;
 967         struct csr1212_keyval *last_extkey = NULL;
 968         int index = 0;
 969
 970         for (dentry = dir->value.directory.dentries_head; dentry; dentry = dentry->next) {
 971                 struct csr1212_keyval *a;
 972
 973                 for (a = dentry->kv; a; a = a->associate) {
 974                         u_int32_t value = 0;
 975
 976                         /* Special Case: Extended Key Specifier_ID */
 977                         if (a->key.id == CSR1212_KV_ID_EXTENDED_KEY_SPECIFIER_ID) {
 978                                 if (last_extkey_spec == NULL) {
 979                                         last_extkey_spec = a;
 980                                 } else if (a->value.immediate != last_extkey_spec->value.immediate) {
 981                                         last_extkey_spec = a;
 982                                 } else {
 983                                         continue;
 984                                 }
 985                         /* Special Case: Extended Key */
 986                         } else if (a->key.id == CSR1212_KV_ID_EXTENDED_KEY) {
 987                                 if (last_extkey == NULL) {
 988                                         last_extkey = a;
 989                                 } else if (a->value.immediate != last_extkey->value.immediate) {
 990                                         last_extkey = a;
 991                                 } else {
 992                                         continue;
 993                                 }
 994                         }
 995
 996                         switch(a->key.type) {
 997                         case CSR1212_KV_TYPE_IMMEDIATE:
 998                                 value = a->value.immediate;
 999                                 break;
1000                         case CSR1212_KV_TYPE_CSR_OFFSET:
1001                                 value = a->value.csr_offset;
1002                                 break;
1003                         case CSR1212_KV_TYPE_LEAF:
1004                                 value = a->offset;
1005                                 value -= dir->offset + quads_to_bytes(1+index);
1006                                 value = bytes_to_quads(value);
1007                                 break;
1008                         case CSR1212_KV_TYPE_DIRECTORY:
1009                                 value = a->offset;
1010                                 value -= dir->offset + quads_to_bytes(1+index);
1011                                 value = bytes_to_quads(value);
1012                                 break;
1013                         default:
1014                                 /* Should never get here */
1015                                 break; /* GDB breakpoint */
1016                         }
1017
1018                         value |= (a->key.id & CSR1212_KV_KEY_ID_MASK) << CSR1212_KV_KEY_SHIFT;
1019                         value |= (a->key.type & CSR1212_KV_KEY_TYPE_MASK) <<
1020                                 (CSR1212_KV_KEY_SHIFT + CSR1212_KV_KEY_TYPE_SHIFT);
1021                         data_buffer[index] = CSR1212_CPU_TO_BE32(value);
1022                         index++;
1023                 }
1024         }
1025 }
1026
1027 void csr1212_fill_cache(struct csr1212_csr_rom_cache *cache)
1028 {
1029         struct csr1212_keyval *kv, *nkv;
1030         struct csr1212_keyval_img *kvi;
1031
1032         for (kv = cache->layout_head; kv != cache->layout_tail->next; kv = nkv) {
1033                 kvi = (struct csr1212_keyval_img *)
1034                         (cache->data + bytes_to_quads(kv->offset - cache->offset));
1035                 switch(kv->key.type) {
1036                 default:
1037                 case CSR1212_KV_TYPE_IMMEDIATE:
1038                 case CSR1212_KV_TYPE_CSR_OFFSET:
1039                         /* Should never get here */
1040                         break; /* GDB breakpoint */
1041
1042                 case CSR1212_KV_TYPE_LEAF:
1043                         /* Don't copy over Extended ROM areas, they are
1044                          * already filled out! */
1045                         if (kv->key.id != CSR1212_KV_ID_EXTENDED_ROM)
1046                                 memcpy(kvi->data, kv->value.leaf.data,
1047                                        quads_to_bytes(kv->value.leaf.len));
1048
1049                         kvi->length = CSR1212_CPU_TO_BE16(kv->value.leaf.len);
1050                         kvi->crc = csr1212_crc16(kvi->data, kv->value.leaf.len);
1051                         break;
1052
1053                 case CSR1212_KV_TYPE_DIRECTORY:
1054                         csr1212_generate_tree_subdir(kv, kvi->data);
1055
1056                         kvi->length = CSR1212_CPU_TO_BE16(kv->value.directory.len);
1057                         kvi->crc = csr1212_crc16(kvi->data, kv->value.directory.len);
1058                         break;
1059                 }
1060
1061                 nkv = kv->next;
1062                 kv->prev = NULL;
1063                 kv->next = NULL;
1064         }
1065 }
1066
1067 int csr1212_generate_csr_image(struct csr1212_csr *csr)
1068 {
1069         struct csr1212_bus_info_block_img *bi;
1070         struct csr1212_csr_rom_cache *cache;
1071         struct csr1212_keyval *kv;
1072         size_t agg_size;
1073         int ret;
1074         int init_offset;
1075
1076         if (!csr)
1077                 return CSR1212_EINVAL;
1078
1079         cache = csr->cache_head;
1080
1081         bi = (struct csr1212_bus_info_block_img*)cache->data;
1082
1083         bi->length = bytes_to_quads(csr->bus_info_len) - 1;
1084         bi->crc_length = bi->length;
1085         bi->crc = csr1212_crc16(bi->data, bi->crc_length);
1086
1087         agg_size = csr1212_generate_layout_order(csr->root_kv);
1088
1089         init_offset = csr->bus_info_len;
1090
1091         for (kv = csr->root_kv, cache = csr->cache_head; kv; cache = cache->next) {
1092                 if (!cache) {
1093                         /* Estimate approximate number of additional cache
1094                          * regions needed (it assumes that the cache holding
1095                          * the first 1K Config ROM space always exists). */
1096                         int est_c = agg_size / (CSR1212_EXTENDED_ROM_SIZE -
1097                                                 (2 * sizeof(u_int32_t))) + 1;
1098
1099                         /* Add additional cache regions, extras will be
1100                          * removed later */
1101                         for (; est_c; est_c--) {
1102                                 ret = csr1212_append_new_cache(csr, CSR1212_EXTENDED_ROM_SIZE);
1103                                 if (ret != CSR1212_SUCCESS)
1104                                         return ret;
1105                         }
1106                         /* Need to re-layout for additional cache regions */
1107                         agg_size = csr1212_generate_layout_order(csr->root_kv);
1108                         kv = csr->root_kv;
1109                         cache = csr->cache_head;
1110                         init_offset = csr->bus_info_len;
1111                 }
1112                 kv = csr1212_generate_positions(cache, kv, init_offset);
1113                 agg_size -= cache->len;
1114                 init_offset = sizeof(u_int32_t);
1115         }
1116
1117         /* Remove unused, excess cache regions */
1118         while (cache) {
1119                 struct csr1212_csr_rom_cache *oc = cache;
1120
1121                 cache = cache->next;
1122                 csr1212_remove_cache(csr, oc);
1123         }
1124
1125         /* Go through the list backward so that when done, the correct CRC
1126          * will be calculated for the Extended ROM areas. */
1127         for(cache = csr->cache_tail; cache; cache = cache->prev) {
1128                 /* Only Extended ROM caches should have this set. */
1129                 if (cache->ext_rom) {
1130                         int leaf_size;
1131
1132                         /* Make sure the Extended ROM leaf is a multiple of
1133                          * max_rom in size. */
1134                         leaf_size = (cache->len + (csr->max_rom - 1)) &
1135                                 (csr->max_rom - 1);
1136
1137                         /* Zero out the unused ROM region */
1138                         memset(cache->data + bytes_to_quads(cache->len), 0x00,
1139                                leaf_size - cache->len);
1140
1141                         /* Subtract leaf header */
1142                         leaf_size -= sizeof(u_int32_t);
1143
1144                         /* Update the Extended ROM leaf length */
1145                         cache->ext_rom->value.leaf.len =
1146                                 bytes_to_quads(leaf_size);
1147                 } else {
1148                         /* Zero out the unused ROM region */
1149                         memset(cache->data + bytes_to_quads(cache->len), 0x00,
1150                                cache->size - cache->len);
1151                 }
1152
1153                 /* Copy the data into the cache buffer */
1154                 csr1212_fill_cache(cache);
1155         }
1156
1157         return CSR1212_SUCCESS;
1158 }
1159
1160 int csr1212_read(struct csr1212_csr *csr, u_int32_t offset, void *buffer, u_int32_t len)
1161 {
1162         struct csr1212_csr_rom_cache *cache;
1163
1164         for (cache = csr->cache_head; cache; cache = cache->next) {
1165                 if (offset >= cache->offset &&
1166                     (offset + len) <= (cache->offset + cache->size)) {
1167                         memcpy(buffer,
1168                                &cache->data[bytes_to_quads(offset - cache->offset)],
1169                                len);
1170                         return CSR1212_SUCCESS;
1171                 } else if (((offset < cache->offset) &&
1172                             ((offset + len) >= cache->offset)) ||
1173                            ((offset >= cache->offset) &&
1174                             ((offset + len) > (cache->offset + cache->size)))) {
1175                         return CSR1212_EINVAL;
1176                 }
1177         }
1178         return CSR1212_ENOENT;
1179 }
1180
1181
1182
1183 /* Parse a chunk of data as a Config ROM */
1184
1185 static int csr1212_parse_bus_info_block(struct csr1212_csr *csr)
1186 {
1187         struct csr1212_bus_info_block_img *bi;
1188         struct csr1212_cache_region *cr;
1189         int i;
1190         int ret;
1191
1192         /* IEEE 1212 says that the entire bus info block should be readable in
1193          * a single transaction regardless of the max_rom value.
1194          * Unfortunately, many IEEE 1394 devices do not abide by that, so the
1195          * bus info block will be read 1 quadlet at a time.  The rest of the
1196          * ConfigROM will be read according to the max_rom field. */
1197         for (i = 0; i < csr->bus_info_len; i += sizeof(csr1212_quad_t)) {
1198                 ret = csr->ops->bus_read(csr, CSR1212_CONFIG_ROM_SPACE_BASE + i,
1199                                          sizeof(csr1212_quad_t),
1200                                          &csr->cache_head->data[bytes_to_quads(i)],
1201                                          csr->private);
1202                 if (ret != CSR1212_SUCCESS)
1203                         return ret;
1204         }
1205
1206         bi = (struct csr1212_bus_info_block_img*)csr->cache_head->data;
1207         csr->crc_len = quads_to_bytes(bi->crc_length);
1208
1209         /* IEEE 1212 recommends that crc_len be equal to bus_info_len, but that is not
1210          * always the case, so read the rest of the crc area 1 quadlet at a time. */
1211         for (i = csr->bus_info_len; i <= csr->crc_len; i += sizeof(csr1212_quad_t)) {
1212                 ret = csr->ops->bus_read(csr, CSR1212_CONFIG_ROM_SPACE_BASE + i,
1213                                          sizeof(csr1212_quad_t),
1214                                          &csr->cache_head->data[bytes_to_quads(i)],
1215                                          csr->private);
1216                 if (ret != CSR1212_SUCCESS)
1217                         return ret;
1218         }
1219
1220         if (bytes_to_quads(csr->bus_info_len - sizeof(csr1212_quad_t)) != bi->length)
1221                 return CSR1212_EINVAL;
1222
1223 #if 0
1224         /* Apparently there are too many differnt wrong implementations of the
1225          * CRC algorithm that verifying them is moot. */
1226         if ((csr1212_crc16(bi->data, bi->crc_length) != bi->crc) &&
1227             (csr1212_msft_crc16(bi->data, bi->crc_length) != bi->crc))
1228                 return CSR1212_EINVAL;
1229 #endif
1230
1231         cr = CSR1212_MALLOC(sizeof(struct csr1212_cache_region));
1232         if (!cr)
1233                 return CSR1212_ENOMEM;
1234
1235         cr->next = NULL;
1236         cr->prev = NULL;
1237         cr->offset_start = 0;
1238         cr->offset_end = csr->crc_len + 4;
1239
1240         csr->cache_head->filled_head = cr;
1241         csr->cache_head->filled_tail = cr;
1242
1243         return CSR1212_SUCCESS;
1244 }
1245
1246 static inline int csr1212_parse_dir_entry(struct csr1212_keyval *dir,
1247                                           csr1212_quad_t ki,
1248                                           u_int32_t kv_pos,
1249                                           struct csr1212_csr_rom_cache *cache)
1250 {
1251         int ret = CSR1212_SUCCESS;
1252         struct csr1212_keyval *k = NULL;
1253         u_int32_t offset;
1254
1255         switch(CSR1212_KV_KEY_TYPE(ki)) {
1256         case CSR1212_KV_TYPE_IMMEDIATE:
1257                 k = csr1212_new_immediate(CSR1212_KV_KEY_ID(ki),
1258                                           CSR1212_KV_VAL(ki));
1259                 if (!k) {
1260                         ret = CSR1212_ENOMEM;
1261                         goto fail;
1262                 }
1263
1264                 k->refcnt = 0;  /* Don't keep local reference when parsing. */
1265                 break;
1266
1267         case CSR1212_KV_TYPE_CSR_OFFSET:
1268                 k = csr1212_new_csr_offset(CSR1212_KV_KEY_ID(ki),
1269                                            CSR1212_KV_VAL(ki));
1270                 if (!k) {
1271                         ret = CSR1212_ENOMEM;
1272                         goto fail;
1273                 }
1274                 k->refcnt = 0;  /* Don't keep local reference when parsing. */
1275                 break;
1276
1277         default:
1278                 /* Compute the offset from 0xffff f000 0000. */
1279                 offset = quads_to_bytes(CSR1212_KV_VAL(ki)) + kv_pos;
1280                 if (offset == kv_pos) {
1281                         /* Uh-oh.  Can't have a relative offset of 0 for Leaves
1282                          * or Directories.  The Config ROM image is most likely
1283                          * messed up, so we'll just abort here. */
1284                         ret = CSR1212_EIO;
1285                         goto fail;
1286                 }
1287
1288                 k = csr1212_find_keyval_offset(cache->layout_head, offset);
1289
1290                 if (k)
1291                         break;          /* Found it. */
1292
1293                 if (CSR1212_KV_KEY_TYPE(ki) == CSR1212_KV_TYPE_DIRECTORY) {
1294                         k = csr1212_new_directory(CSR1212_KV_KEY_ID(ki));
1295                 } else {
1296                         k = csr1212_new_leaf(CSR1212_KV_KEY_ID(ki), NULL, 0);
1297                 }
1298                 if (!k) {
1299                         ret = CSR1212_ENOMEM;
1300                         goto fail;
1301                 }
1302                 k->refcnt = 0;  /* Don't keep local reference when parsing. */
1303                 k->valid = 0;   /* Contents not read yet so it's not valid. */
1304                 k->offset = offset;
1305
1306                 k->prev = cache->layout_tail;
1307                 k->next = NULL;
1308                 if (cache->layout_tail)
1309                         cache->layout_tail->next = k;
1310                 cache->layout_tail = k;
1311         }
1312         ret = csr1212_attach_keyval_to_directory(dir, k);
1313
1314 fail:
1315         if (ret != CSR1212_SUCCESS) {
1316                 if (k)
1317                         free_keyval(k);
1318         }
1319         return ret;
1320 }
1321
1322 int csr1212_parse_keyval(struct csr1212_keyval *kv,
1323                          struct csr1212_csr_rom_cache *cache)
1324 {
1325         struct csr1212_keyval_img *kvi;
1326         int i;
1327         int ret = CSR1212_SUCCESS;
1328         int kvi_len;
1329
1330         kvi = (struct csr1212_keyval_img*)&cache->data[bytes_to_quads(kv->offset -
1331                                                                       cache->offset)];
1332         kvi_len = CSR1212_BE16_TO_CPU(kvi->length);
1333
1334 #if 0
1335         /* Apparently there are too many differnt wrong implementations of the
1336          * CRC algorithm that verifying them is moot. */
1337         if ((csr1212_crc16(kvi->data, kvi_len) != kvi->crc) &&
1338             (csr1212_msft_crc16(kvi->data, kvi_len) != kvi->crc)) {
1339                 ret = CSR1212_EINVAL;
1340                 goto fail;
1341         }
1342 #endif
1343
1344         switch(kv->key.type) {
1345         case CSR1212_KV_TYPE_DIRECTORY:
1346                 for (i = 0; i < kvi_len; i++) {
1347                         csr1212_quad_t ki = kvi->data[i];
1348
1349                         /* Some devices put null entries in their unit
1350                          * directories.  If we come across such and entry,
1351                          * then skip it. */
1352                         if (ki == 0x0)
1353                                 continue;
1354                         ret = csr1212_parse_dir_entry(kv, ki,
1355                                                       (kv->offset +
1356                                                        quads_to_bytes(i + 1)),
1357                                                       cache);
1358                 }
1359                 kv->value.directory.len = kvi_len;
1360                 break;
1361
1362         case CSR1212_KV_TYPE_LEAF:
1363                 if (kv->key.id == CSR1212_KV_ID_EXTENDED_ROM) {
1364                         kv->value.leaf.data = cache->data;
1365                 } else {
1366                         kv->value.leaf.data = CSR1212_MALLOC(quads_to_bytes(kvi_len));
1367                         if (!kv->value.leaf.data)
1368                         {
1369                                 ret = CSR1212_ENOMEM;
1370                                 goto fail;
1371                         }
1372
1373                         kv->value.leaf.len = kvi_len;
1374                         memcpy(kv->value.leaf.data, kvi->data, quads_to_bytes(kvi_len));
1375                 }
1376                 break;
1377         }
1378
1379         kv->valid = 1;
1380
1381 fail:
1382         return ret;
1383 }
1384
1385
1386 int _csr1212_read_keyval(struct csr1212_csr *csr, struct csr1212_keyval *kv)
1387 {
1388         struct csr1212_cache_region *cr, *ncr, *newcr = NULL;
1389         struct csr1212_keyval_img *kvi = NULL;
1390         struct csr1212_csr_rom_cache *cache;
1391         int cache_index;
1392         u_int64_t addr;
1393         u_int32_t *cache_ptr;
1394         u_int16_t kv_len = 0;
1395
1396
1397         if (!csr || !kv)
1398                 return CSR1212_EINVAL;
1399
1400         /* First find which cache the data should be in (or go in if not read
1401          * yet). */
1402         for (cache = csr->cache_head; cache; cache = cache->next) {
1403                 if (kv->offset >= cache->offset &&
1404                     kv->offset < (cache->offset + cache->size))
1405                         break;
1406         }
1407
1408         if (!cache) {
1409                 csr1212_quad_t q;
1410                 struct csr1212_csr_rom_cache *nc;
1411
1412                 /* Only create a new cache for Extended ROM leaves. */
1413                 if (kv->key.id != CSR1212_KV_ID_EXTENDED_ROM)
1414                         return CSR1212_EINVAL;
1415
1416                 if (csr->ops->bus_read(csr,
1417                                        CSR1212_REGISTER_SPACE_BASE + kv->offset,
1418                                        sizeof(csr1212_quad_t), &q, csr->private)) {
1419                         return CSR1212_EIO;
1420                 }
1421
1422                 kv->value.leaf.len = quads_to_bytes(CSR1212_BE32_TO_CPU(q)>>16);
1423
1424                 nc = csr1212_rom_cache_malloc(kv->offset, kv->value.leaf.len);
1425                 cache->next = nc;
1426                 nc->prev = cache;
1427                 csr->cache_tail = nc;
1428                 cache->filled_head =
1429                         CSR1212_MALLOC(sizeof(struct csr1212_cache_region));
1430                 if (!cache->filled_head) {
1431                         return CSR1212_ENOMEM;
1432                 }
1433
1434                 cache->filled_head->offset_start = 0;
1435                 cache->filled_head->offset_end = sizeof(csr1212_quad_t);
1436                 cache->filled_tail = cache->filled_head;
1437                 cache->filled_head->next = NULL;
1438                 cache->filled_head->prev = NULL;
1439                 cache->data[0] = q;
1440         }
1441
1442         cache_index = kv->offset - cache->offset;
1443
1444         /* Now seach read portions of the cache to see if it is there. */
1445         for (cr = cache->filled_head; cr; cr = cr->next) {
1446                 if (cache_index < cr->offset_start) {
1447                         newcr = CSR1212_MALLOC(sizeof(struct csr1212_cache_region));
1448                         if (!newcr)
1449                                 return CSR1212_ENOMEM;
1450
1451                         newcr->offset_start = cache_index & ~(csr->max_rom - 1);
1452                         newcr->offset_end = newcr->offset_start;
1453                         newcr->next = cr;
1454                         newcr->prev = cr->prev;
1455                         cr->prev = newcr;
1456                         cr = newcr;
1457                         break;
1458                 } else if ((cache_index >= cr->offset_start) &&
1459                            (cache_index < cr->offset_end)) {
1460                         kvi = (struct csr1212_keyval_img*)
1461                                 (&cache->data[bytes_to_quads(cache_index)]);
1462                         kv_len = quads_to_bytes(CSR1212_BE16_TO_CPU(kvi->length) +
1463                                                 1);
1464                         break;
1465                 } else if (cache_index == cr->offset_end)
1466                         break;
1467         }
1468
1469         if (!cr) {
1470                 cr = cache->filled_tail;
1471                 newcr = CSR1212_MALLOC(sizeof(struct csr1212_cache_region));
1472                 if (!newcr)
1473                         return CSR1212_ENOMEM;
1474
1475                 newcr->offset_start = cache_index & ~(csr->max_rom - 1);
1476                 newcr->offset_end = newcr->offset_start;
1477                 newcr->prev = cr;
1478                 newcr->next = cr->next;
1479                 cr->next = newcr;
1480                 cr = newcr;
1481                 cache->filled_tail = newcr;
1482         }
1483
1484         while(!kvi || cr->offset_end < cache_index + kv_len) {
1485                 cache_ptr = &cache->data[bytes_to_quads(cr->offset_end &
1486                                                         ~(csr->max_rom - 1))];
1487
1488                 addr = (CSR1212_CSR_ARCH_REG_SPACE_BASE + cache->offset +
1489                         cr->offset_end) & ~(csr->max_rom - 1);
1490
1491                 if (csr->ops->bus_read(csr, addr, csr->max_rom, cache_ptr,
1492                                        csr->private)) {
1493                         if (csr->max_rom == 4)
1494                                 /* We've got problems! */
1495                                 return CSR1212_EIO;
1496
1497                         /* Apperently the max_rom value was a lie, set it to
1498                          * do quadlet reads and try again. */
1499                         csr->max_rom = 4;
1500                         continue;
1501                 }
1502
1503                 cr->offset_end += csr->max_rom - (cr->offset_end &
1504                                                   (csr->max_rom - 1));
1505
1506                 if (!kvi && (cr->offset_end > cache_index)) {
1507                         kvi = (struct csr1212_keyval_img*)
1508                                 (&cache->data[bytes_to_quads(cache_index)]);
1509                         kv_len = quads_to_bytes(CSR1212_BE16_TO_CPU(kvi->length) +
1510                                                 1);
1511                 }
1512
1513                 if ((kv_len + (kv->offset - cache->offset)) > cache->size) {
1514                         /* The Leaf or Directory claims its length extends
1515                          * beyond the ConfigROM image region and thus beyond the
1516                          * end of our cache region.  Therefore, we abort now
1517                          * rather than seg faulting later. */
1518                         return CSR1212_EIO;
1519                 }
1520
1521                 ncr = cr->next;
1522
1523                 if (ncr && (cr->offset_end >= ncr->offset_start)) {
1524                         /* consolidate region entries */
1525                         ncr->offset_start = cr->offset_start;
1526
1527                         if (cr->prev)
1528                                 cr->prev->next = cr->next;
1529                         ncr->prev = cr->prev;
1530                         if (cache->filled_head == cr)
1531                                 cache->filled_head = ncr;
1532                         CSR1212_FREE(cr);
1533                         cr = ncr;
1534                 }
1535         }
1536
1537         return csr1212_parse_keyval(kv, cache);
1538 }
1539
1540
1541
1542 int csr1212_parse_csr(struct csr1212_csr *csr)
1543 {
1544         static const int mr_map[] = { 4, 64, 1024, 0 };
1545         int ret;
1546
1547         if (!csr || !csr->ops->bus_read)
1548                 return CSR1212_EINVAL;
1549
1550         ret = csr1212_parse_bus_info_block(csr);
1551         if (ret != CSR1212_SUCCESS)
1552                 return ret;
1553
1554         if (!csr->ops->get_max_rom)
1555                 csr->max_rom = mr_map[0];       /* default value */
1556         else
1557                 csr->max_rom = mr_map[csr->ops->get_max_rom(csr->bus_info_data,
1558                                                             csr->private)];
1559
1560         csr->cache_head->layout_head = csr->root_kv;
1561         csr->cache_head->layout_tail = csr->root_kv;
1562
1563         csr->root_kv->offset = (CSR1212_CONFIG_ROM_SPACE_BASE & 0xffff) +
1564                 csr->bus_info_len;
1565
1566         csr->root_kv->valid = 0;
1567         csr1212_get_keyval(csr, csr->root_kv);
1568
1569         return CSR1212_SUCCESS;
1570 }