Logo Search packages:      
Sourcecode: linux version File versions  Download package

csr1212.c

/*
 * csr1212.c -- IEEE 1212 Control and Status Register support for Linux
 *
 * Copyright (C) 2003 Francois Retief <fgretief@sun.ac.za>
 *                    Steve Kinneberg <kinnebergsteve@acmsystems.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *    1. Redistributions of source code must retain the above copyright notice,
 *       this list of conditions and the following disclaimer.
 *    2. Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *    3. The name of the author may not be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


/* TODO List:
 * - Verify interface consistency: i.e., public functions that take a size
 *   parameter expect size to be in bytes.
 */

#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <asm/bug.h>
#include <asm/byteorder.h>

#include "csr1212.h"


/* Permitted key type for each key id */
#define __I (1 << CSR1212_KV_TYPE_IMMEDIATE)
#define __C (1 << CSR1212_KV_TYPE_CSR_OFFSET)
#define __D (1 << CSR1212_KV_TYPE_DIRECTORY)
#define __L (1 << CSR1212_KV_TYPE_LEAF)
static const u8 csr1212_key_id_type_map[0x30] = {
      __C,              /* used by Apple iSight */
      __D | __L,        /* Descriptor */
      __I | __D | __L,  /* Bus_Dependent_Info */
      __I | __D | __L,  /* Vendor */
      __I,              /* Hardware_Version */
      0, 0,             /* Reserved */
      __D | __L | __I,  /* Module */
      __I, 0, 0, 0,           /* used by Apple iSight, Reserved */
      __I,              /* Node_Capabilities */
      __L,              /* EUI_64 */
      0, 0, 0,          /* Reserved */
      __D,              /* Unit */
      __I,              /* Specifier_ID */
      __I,              /* Version */
      __I | __C | __D | __L,  /* Dependent_Info */
      __L,              /* Unit_Location */
      0,                /* Reserved */
      __I,              /* Model */
      __D,              /* Instance */
      __L,              /* Keyword */
      __D,              /* Feature */
      __L,              /* Extended_ROM */
      __I,              /* Extended_Key_Specifier_ID */
      __I,              /* Extended_Key */
      __I | __C | __D | __L,  /* Extended_Data */
      __L,              /* Modifiable_Descriptor */
      __I,              /* Directory_ID */
      __I,              /* Revision */
};
#undef __I
#undef __C
#undef __D
#undef __L


#define quads_to_bytes(_q) ((_q) * sizeof(u32))
#define bytes_to_quads(_b) (((_b) + sizeof(u32) - 1) / sizeof(u32))

static void free_keyval(struct csr1212_keyval *kv)
{
      if ((kv->key.type == CSR1212_KV_TYPE_LEAF) &&
          (kv->key.id != CSR1212_KV_ID_EXTENDED_ROM))
            CSR1212_FREE(kv->value.leaf.data);

      CSR1212_FREE(kv);
}

static u16 csr1212_crc16(const u32 *buffer, size_t length)
{
      int shift;
      u32 data;
      u16 sum, crc = 0;

      for (; length; length--) {
            data = be32_to_cpu(*buffer);
            buffer++;
            for (shift = 28; shift >= 0; shift -= 4 ) {
                  sum = ((crc >> 12) ^ (data >> shift)) & 0xf;
                  crc = (crc << 4) ^ (sum << 12) ^ (sum << 5) ^ (sum);
            }
            crc &= 0xffff;
      }

      return cpu_to_be16(crc);
}

/* Microsoft computes the CRC with the bytes in reverse order. */
static u16 csr1212_msft_crc16(const u32 *buffer, size_t length)
{
      int shift;
      u32 data;
      u16 sum, crc = 0;

      for (; length; length--) {
            data = le32_to_cpu(*buffer);
            buffer++;
            for (shift = 28; shift >= 0; shift -= 4 ) {
                  sum = ((crc >> 12) ^ (data >> shift)) & 0xf;
                  crc = (crc << 4) ^ (sum << 12) ^ (sum << 5) ^ (sum);
            }
            crc &= 0xffff;
      }

      return cpu_to_be16(crc);
}

static struct csr1212_dentry *
csr1212_find_keyval(struct csr1212_keyval *dir, struct csr1212_keyval *kv)
{
      struct csr1212_dentry *pos;

      for (pos = dir->value.directory.dentries_head;
           pos != NULL; pos = pos->next)
            if (pos->kv == kv)
                  return pos;
      return NULL;
}

static struct csr1212_keyval *
csr1212_find_keyval_offset(struct csr1212_keyval *kv_list, u32 offset)
{
      struct csr1212_keyval *kv;

      for (kv = kv_list->next; kv && (kv != kv_list); kv = kv->next)
            if (kv->offset == offset)
                  return kv;
      return NULL;
}


/* Creation Routines */

struct csr1212_csr *csr1212_create_csr(struct csr1212_bus_ops *ops,
                               size_t bus_info_size, void *private)
{
      struct csr1212_csr *csr;

      csr = CSR1212_MALLOC(sizeof(*csr));
      if (!csr)
            return NULL;

      csr->cache_head =
            csr1212_rom_cache_malloc(CSR1212_CONFIG_ROM_SPACE_OFFSET,
                               CSR1212_CONFIG_ROM_SPACE_SIZE);
      if (!csr->cache_head) {
            CSR1212_FREE(csr);
            return NULL;
      }

      /* The keyval key id is not used for the root node, but a valid key id
       * that can be used for a directory needs to be passed to
       * csr1212_new_directory(). */
      csr->root_kv = csr1212_new_directory(CSR1212_KV_ID_VENDOR);
      if (!csr->root_kv) {
            CSR1212_FREE(csr->cache_head);
            CSR1212_FREE(csr);
            return NULL;
      }

      csr->bus_info_data = csr->cache_head->data;
      csr->bus_info_len = bus_info_size;
      csr->crc_len = bus_info_size;
      csr->ops = ops;
      csr->private = private;
      csr->cache_tail = csr->cache_head;

      return csr;
}

void csr1212_init_local_csr(struct csr1212_csr *csr,
                      const u32 *bus_info_data, int max_rom)
{
      static const int mr_map[] = { 4, 64, 1024, 0 };

      BUG_ON(max_rom & ~0x3);
      csr->max_rom = mr_map[max_rom];
      memcpy(csr->bus_info_data, bus_info_data, csr->bus_info_len);
}

static struct csr1212_keyval *csr1212_new_keyval(u8 type, u8 key)
{
      struct csr1212_keyval *kv;

      if (key < 0x30 && ((csr1212_key_id_type_map[key] & (1 << type)) == 0))
            return NULL;

      kv = CSR1212_MALLOC(sizeof(*kv));
      if (!kv)
            return NULL;

      atomic_set(&kv->refcnt, 1);
      kv->key.type = type;
      kv->key.id = key;
      kv->associate = NULL;
      kv->next = NULL;
      kv->prev = NULL;
      kv->offset = 0;
      kv->valid = 0;
      return kv;
}

struct csr1212_keyval *csr1212_new_immediate(u8 key, u32 value)
{
      struct csr1212_keyval *kv;

      kv = csr1212_new_keyval(CSR1212_KV_TYPE_IMMEDIATE, key);
      if (!kv)
            return NULL;

      kv->value.immediate = value;
      kv->valid = 1;
      return kv;
}

static struct csr1212_keyval *
csr1212_new_leaf(u8 key, const void *data, size_t data_len)
{
      struct csr1212_keyval *kv;

      kv = csr1212_new_keyval(CSR1212_KV_TYPE_LEAF, key);
      if (!kv)
            return NULL;

      if (data_len > 0) {
            kv->value.leaf.data = CSR1212_MALLOC(data_len);
            if (!kv->value.leaf.data) {
                  CSR1212_FREE(kv);
                  return NULL;
            }

            if (data)
                  memcpy(kv->value.leaf.data, data, data_len);
      } else {
            kv->value.leaf.data = NULL;
      }

      kv->value.leaf.len = bytes_to_quads(data_len);
      kv->offset = 0;
      kv->valid = 1;

      return kv;
}

static struct csr1212_keyval *
csr1212_new_csr_offset(u8 key, u32 csr_offset)
{
      struct csr1212_keyval *kv;

      kv = csr1212_new_keyval(CSR1212_KV_TYPE_CSR_OFFSET, key);
      if (!kv)
            return NULL;

      kv->value.csr_offset = csr_offset;

      kv->offset = 0;
      kv->valid = 1;
      return kv;
}

struct csr1212_keyval *csr1212_new_directory(u8 key)
{
      struct csr1212_keyval *kv;

      kv = csr1212_new_keyval(CSR1212_KV_TYPE_DIRECTORY, key);
      if (!kv)
            return NULL;

      kv->value.directory.len = 0;
      kv->offset = 0;
      kv->value.directory.dentries_head = NULL;
      kv->value.directory.dentries_tail = NULL;
      kv->valid = 1;
      return kv;
}

void csr1212_associate_keyval(struct csr1212_keyval *kv,
                        struct csr1212_keyval *associate)
{
      BUG_ON(!kv || !associate || kv->key.id == CSR1212_KV_ID_DESCRIPTOR ||
             (associate->key.id != CSR1212_KV_ID_DESCRIPTOR &&
            associate->key.id != CSR1212_KV_ID_DEPENDENT_INFO &&
            associate->key.id != CSR1212_KV_ID_EXTENDED_KEY &&
            associate->key.id != CSR1212_KV_ID_EXTENDED_DATA &&
            associate->key.id < 0x30) ||
             (kv->key.id == CSR1212_KV_ID_EXTENDED_KEY_SPECIFIER_ID &&
            associate->key.id != CSR1212_KV_ID_EXTENDED_KEY) ||
             (kv->key.id == CSR1212_KV_ID_EXTENDED_KEY &&
            associate->key.id != CSR1212_KV_ID_EXTENDED_DATA) ||
             (associate->key.id == CSR1212_KV_ID_EXTENDED_KEY &&
            kv->key.id != CSR1212_KV_ID_EXTENDED_KEY_SPECIFIER_ID) ||
             (associate->key.id == CSR1212_KV_ID_EXTENDED_DATA &&
            kv->key.id != CSR1212_KV_ID_EXTENDED_KEY));

      if (kv->associate)
            csr1212_release_keyval(kv->associate);

      csr1212_keep_keyval(associate);
      kv->associate = associate;
}

static int __csr1212_attach_keyval_to_directory(struct csr1212_keyval *dir,
                                    struct csr1212_keyval *kv,
                                    bool keep_keyval)
{
      struct csr1212_dentry *dentry;

      BUG_ON(!kv || !dir || dir->key.type != CSR1212_KV_TYPE_DIRECTORY);

      dentry = CSR1212_MALLOC(sizeof(*dentry));
      if (!dentry)
            return -ENOMEM;

      if (keep_keyval)
            csr1212_keep_keyval(kv);
      dentry->kv = kv;

      dentry->next = NULL;
      dentry->prev = dir->value.directory.dentries_tail;

      if (!dir->value.directory.dentries_head)
            dir->value.directory.dentries_head = dentry;

      if (dir->value.directory.dentries_tail)
            dir->value.directory.dentries_tail->next = dentry;
      dir->value.directory.dentries_tail = dentry;

      return CSR1212_SUCCESS;
}

int csr1212_attach_keyval_to_directory(struct csr1212_keyval *dir,
                               struct csr1212_keyval *kv)
{
      return __csr1212_attach_keyval_to_directory(dir, kv, true);
}

#define CSR1212_DESCRIPTOR_LEAF_DATA(kv) \
      (&((kv)->value.leaf.data[1]))

#define CSR1212_DESCRIPTOR_LEAF_SET_TYPE(kv, type) \
      ((kv)->value.leaf.data[0] = \
       cpu_to_be32(CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID(kv) | \
                 ((type) << CSR1212_DESCRIPTOR_LEAF_TYPE_SHIFT)))
#define CSR1212_DESCRIPTOR_LEAF_SET_SPECIFIER_ID(kv, spec_id) \
      ((kv)->value.leaf.data[0] = \
       cpu_to_be32((CSR1212_DESCRIPTOR_LEAF_TYPE(kv) << \
                  CSR1212_DESCRIPTOR_LEAF_TYPE_SHIFT) | \
                 ((spec_id) & CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID_MASK)))

static struct csr1212_keyval *
csr1212_new_descriptor_leaf(u8 dtype, u32 specifier_id,
                      const void *data, size_t data_len)
{
      struct csr1212_keyval *kv;

      kv = csr1212_new_leaf(CSR1212_KV_ID_DESCRIPTOR, NULL,
                        data_len + CSR1212_DESCRIPTOR_LEAF_OVERHEAD);
      if (!kv)
            return NULL;

      CSR1212_DESCRIPTOR_LEAF_SET_TYPE(kv, dtype);
      CSR1212_DESCRIPTOR_LEAF_SET_SPECIFIER_ID(kv, specifier_id);

      if (data)
            memcpy(CSR1212_DESCRIPTOR_LEAF_DATA(kv), data, data_len);

      return kv;
}

/* Check if string conforms to minimal ASCII as per IEEE 1212 clause 7.4 */
static int csr1212_check_minimal_ascii(const char *s)
{
      static const char minimal_ascii_table[] = {
                              /*  1   2   4   8  16  32  64  128 */
            128,              /* --, --, --, --, --, --, --, 07, */
            4 + 16 + 32,            /* --, --, 0a, --, 0C, 0D, --, --, */
            0,                /* --, --, --, --, --, --, --, --, */
            0,                /* --, --, --, --, --, --, --, --, */
            255 - 8 - 16,           /* 20, 21, 22, --, --, 25, 26, 27, */
            255,              /* 28, 29, 2a, 2b, 2c, 2d, 2e, 2f, */
            255,              /* 30, 31, 32, 33, 34, 35, 36, 37, */
            255,              /* 38, 39, 3a, 3b, 3c, 3d, 3e, 3f, */
            255,              /* 40, 41, 42, 43, 44, 45, 46, 47, */
            255,              /* 48, 49, 4a, 4b, 4c, 4d, 4e, 4f, */
            255,              /* 50, 51, 52, 53, 54, 55, 56, 57, */
            1 + 2 + 4 + 128,  /* 58, 59, 5a, --, --, --, --, 5f, */
            255 - 1,          /* --, 61, 62, 63, 64, 65, 66, 67, */
            255,              /* 68, 69, 6a, 6b, 6c, 6d, 6e, 6f, */
            255,              /* 70, 71, 72, 73, 74, 75, 76, 77, */
            1 + 2 + 4,        /* 78, 79, 7a, --, --, --, --, --, */
      };
      int i, j;

      for (; *s; s++) {
            i = *s >> 3;            /*  i = *s / 8;         */
            j = 1 << (*s & 3);      /*  j = 1 << (*s % 8);  */

            if (i >= ARRAY_SIZE(minimal_ascii_table) ||
                !(minimal_ascii_table[i] & j))
                  return -EINVAL;
      }
      return 0;
}

/* IEEE 1212 clause 7.5.4.1 textual descriptors (English, minimal ASCII) */
struct csr1212_keyval *csr1212_new_string_descriptor_leaf(const char *s)
{
      struct csr1212_keyval *kv;
      u32 *text;
      size_t str_len, quads;

      if (!s || !*s || csr1212_check_minimal_ascii(s))
            return NULL;

      str_len = strlen(s);
      quads = bytes_to_quads(str_len);
      kv = csr1212_new_descriptor_leaf(0, 0, NULL, quads_to_bytes(quads) +
                              CSR1212_TEXTUAL_DESCRIPTOR_LEAF_OVERHEAD);
      if (!kv)
            return NULL;

      kv->value.leaf.data[1] = 0;   /* width, character_set, language */
      text = CSR1212_TEXTUAL_DESCRIPTOR_LEAF_DATA(kv);
      text[quads - 1] = 0;          /* padding */
      memcpy(text, s, str_len);

      return kv;
}


/* Destruction Routines */

void csr1212_detach_keyval_from_directory(struct csr1212_keyval *dir,
                                struct csr1212_keyval *kv)
{
      struct csr1212_dentry *dentry;

      if (!kv || !dir || dir->key.type != CSR1212_KV_TYPE_DIRECTORY)
            return;

      dentry = csr1212_find_keyval(dir, kv);

      if (!dentry)
            return;

      if (dentry->prev)
            dentry->prev->next = dentry->next;
      if (dentry->next)
            dentry->next->prev = dentry->prev;
      if (dir->value.directory.dentries_head == dentry)
            dir->value.directory.dentries_head = dentry->next;
      if (dir->value.directory.dentries_tail == dentry)
            dir->value.directory.dentries_tail = dentry->prev;

      CSR1212_FREE(dentry);

      csr1212_release_keyval(kv);
}

/* This function is used to free the memory taken by a keyval.  If the given
 * keyval is a directory type, then any keyvals contained in that directory
 * will be destroyed as well if noone holds a reference on them.  By means of
 * list manipulation, this routine will descend a directory structure in a
 * non-recursive manner. */
void csr1212_release_keyval(struct csr1212_keyval *kv)
{
      struct csr1212_keyval *k, *a;
      struct csr1212_dentry dentry;
      struct csr1212_dentry *head, *tail;

      if (!atomic_dec_and_test(&kv->refcnt))
            return;

      dentry.kv = kv;
      dentry.next = NULL;
      dentry.prev = NULL;

      head = &dentry;
      tail = head;

      while (head) {
            k = head->kv;

            while (k) {
                  /* must not dec_and_test kv->refcnt again */
                  if (k != kv && !atomic_dec_and_test(&k->refcnt))
                        break;

                  a = k->associate;

                  if (k->key.type == CSR1212_KV_TYPE_DIRECTORY) {
                        /* If the current entry is a directory, move all
                         * the entries to the destruction list. */
                        if (k->value.directory.dentries_head) {
                              tail->next =
                                  k->value.directory.dentries_head;
                              k->value.directory.dentries_head->prev =
                                  tail;
                              tail = k->value.directory.dentries_tail;
                        }
                  }
                  free_keyval(k);
                  k = a;
            }

            head = head->next;
            if (head) {
                  if (head->prev && head->prev != &dentry)
                        CSR1212_FREE(head->prev);
                  head->prev = NULL;
            } else if (tail != &dentry) {
                  CSR1212_FREE(tail);
            }
      }
}

void csr1212_destroy_csr(struct csr1212_csr *csr)
{
      struct csr1212_csr_rom_cache *c, *oc;
      struct csr1212_cache_region *cr, *ocr;

      csr1212_release_keyval(csr->root_kv);

      c = csr->cache_head;
      while (c) {
            oc = c;
            cr = c->filled_head;
            while (cr) {
                  ocr = cr;
                  cr = cr->next;
                  CSR1212_FREE(ocr);
            }
            c = c->next;
            CSR1212_FREE(oc);
      }

      CSR1212_FREE(csr);
}


/* CSR Image Creation */

static int csr1212_append_new_cache(struct csr1212_csr *csr, size_t romsize)
{
      struct csr1212_csr_rom_cache *cache;
      u64 csr_addr;

      BUG_ON(!csr || !csr->ops || !csr->ops->allocate_addr_range ||
             !csr->ops->release_addr || csr->max_rom < 1);

      /* ROM size must be a multiple of csr->max_rom */
      romsize = (romsize + (csr->max_rom - 1)) & ~(csr->max_rom - 1);

      csr_addr = csr->ops->allocate_addr_range(romsize, csr->max_rom,
                                     csr->private);
      if (csr_addr == CSR1212_INVALID_ADDR_SPACE)
            return -ENOMEM;

      if (csr_addr < CSR1212_REGISTER_SPACE_BASE) {
            /* Invalid address returned from allocate_addr_range(). */
            csr->ops->release_addr(csr_addr, csr->private);
            return -ENOMEM;
      }

      cache = csr1212_rom_cache_malloc(csr_addr - CSR1212_REGISTER_SPACE_BASE,
                               romsize);
      if (!cache) {
            csr->ops->release_addr(csr_addr, csr->private);
            return -ENOMEM;
      }

      cache->ext_rom = csr1212_new_keyval(CSR1212_KV_TYPE_LEAF,
                                  CSR1212_KV_ID_EXTENDED_ROM);
      if (!cache->ext_rom) {
            csr->ops->release_addr(csr_addr, csr->private);
            CSR1212_FREE(cache);
            return -ENOMEM;
      }

      if (csr1212_attach_keyval_to_directory(csr->root_kv, cache->ext_rom) !=
          CSR1212_SUCCESS) {
            csr1212_release_keyval(cache->ext_rom);
            csr->ops->release_addr(csr_addr, csr->private);
            CSR1212_FREE(cache);
            return -ENOMEM;
      }
      cache->ext_rom->offset = csr_addr - CSR1212_REGISTER_SPACE_BASE;
      cache->ext_rom->value.leaf.len = -1;
      cache->ext_rom->value.leaf.data = cache->data;

      /* Add cache to tail of cache list */
      cache->prev = csr->cache_tail;
      csr->cache_tail->next = cache;
      csr->cache_tail = cache;
      return CSR1212_SUCCESS;
}

static void csr1212_remove_cache(struct csr1212_csr *csr,
                         struct csr1212_csr_rom_cache *cache)
{
      if (csr->cache_head == cache)
            csr->cache_head = cache->next;
      if (csr->cache_tail == cache)
            csr->cache_tail = cache->prev;

      if (cache->prev)
            cache->prev->next = cache->next;
      if (cache->next)
            cache->next->prev = cache->prev;

      if (cache->ext_rom) {
            csr1212_detach_keyval_from_directory(csr->root_kv,
                                         cache->ext_rom);
            csr1212_release_keyval(cache->ext_rom);
      }

      CSR1212_FREE(cache);
}

static int csr1212_generate_layout_subdir(struct csr1212_keyval *dir,
                                struct csr1212_keyval **layout_tail)
{
      struct csr1212_dentry *dentry;
      struct csr1212_keyval *dkv;
      struct csr1212_keyval *last_extkey_spec = NULL;
      struct csr1212_keyval *last_extkey = NULL;
      int num_entries = 0;

      for (dentry = dir->value.directory.dentries_head; dentry;
           dentry = dentry->next) {
            for (dkv = dentry->kv; dkv; dkv = dkv->associate) {
                  /* Special Case: Extended Key Specifier_ID */
                  if (dkv->key.id ==
                      CSR1212_KV_ID_EXTENDED_KEY_SPECIFIER_ID) {
                        if (last_extkey_spec == NULL)
                              last_extkey_spec = dkv;
                        else if (dkv->value.immediate !=
                               last_extkey_spec->value.immediate)
                              last_extkey_spec = dkv;
                        else
                              continue;
                  /* Special Case: Extended Key */
                  } else if (dkv->key.id == CSR1212_KV_ID_EXTENDED_KEY) {
                        if (last_extkey == NULL)
                              last_extkey = dkv;
                        else if (dkv->value.immediate !=
                               last_extkey->value.immediate)
                              last_extkey = dkv;
                        else
                              continue;
                  }

                  num_entries += 1;

                  switch (dkv->key.type) {
                  default:
                  case CSR1212_KV_TYPE_IMMEDIATE:
                  case CSR1212_KV_TYPE_CSR_OFFSET:
                        break;
                  case CSR1212_KV_TYPE_LEAF:
                  case CSR1212_KV_TYPE_DIRECTORY:
                        /* Remove from list */
                        if (dkv->prev && (dkv->prev->next == dkv))
                              dkv->prev->next = dkv->next;
                        if (dkv->next && (dkv->next->prev == dkv))
                              dkv->next->prev = dkv->prev;
                        //if (dkv == *layout_tail)
                        //    *layout_tail = dkv->prev;

                        /* Special case: Extended ROM leafs */
                        if (dkv->key.id == CSR1212_KV_ID_EXTENDED_ROM) {
                              dkv->value.leaf.len = -1;
                              /* Don't add Extended ROM leafs in the
                               * layout list, they are handled
                               * differently. */
                              break;
                        }

                        /* Add to tail of list */
                        dkv->next = NULL;
                        dkv->prev = *layout_tail;
                        (*layout_tail)->next = dkv;
                        *layout_tail = dkv;
                        break;
                  }
            }
      }
      return num_entries;
}

static size_t csr1212_generate_layout_order(struct csr1212_keyval *kv)
{
      struct csr1212_keyval *ltail = kv;
      size_t agg_size = 0;

      while (kv) {
            switch (kv->key.type) {
            case CSR1212_KV_TYPE_LEAF:
                  /* Add 1 quadlet for crc/len field */
                  agg_size += kv->value.leaf.len + 1;
                  break;

            case CSR1212_KV_TYPE_DIRECTORY:
                  kv->value.directory.len =
                        csr1212_generate_layout_subdir(kv, &ltail);
                  /* Add 1 quadlet for crc/len field */
                  agg_size += kv->value.directory.len + 1;
                  break;
            }
            kv = kv->next;
      }
      return quads_to_bytes(agg_size);
}

static struct csr1212_keyval *
csr1212_generate_positions(struct csr1212_csr_rom_cache *cache,
                     struct csr1212_keyval *start_kv, int start_pos)
{
      struct csr1212_keyval *kv = start_kv;
      struct csr1212_keyval *okv = start_kv;
      int pos = start_pos;
      int kv_len = 0, okv_len = 0;

      cache->layout_head = kv;

      while (kv && pos < cache->size) {
            /* Special case: Extended ROM leafs */
            if (kv->key.id != CSR1212_KV_ID_EXTENDED_ROM)
                  kv->offset = cache->offset + pos;

            switch (kv->key.type) {
            case CSR1212_KV_TYPE_LEAF:
                  kv_len = kv->value.leaf.len;
                  break;

            case CSR1212_KV_TYPE_DIRECTORY:
                  kv_len = kv->value.directory.len;
                  break;

            default:
                  /* Should never get here */
                  WARN_ON(1);
                  break;
            }

            pos += quads_to_bytes(kv_len + 1);

            if (pos <= cache->size) {
                  okv = kv;
                  okv_len = kv_len;
                  kv = kv->next;
            }
      }

      cache->layout_tail = okv;
      cache->len = okv->offset - cache->offset + quads_to_bytes(okv_len + 1);

      return kv;
}

#define CSR1212_KV_KEY_SHIFT        24
#define CSR1212_KV_KEY_TYPE_SHIFT   6
#define CSR1212_KV_KEY_ID_MASK            0x3f
#define CSR1212_KV_KEY_TYPE_MASK    0x3   /* after shift */

static void
csr1212_generate_tree_subdir(struct csr1212_keyval *dir, u32 *data_buffer)
{
      struct csr1212_dentry *dentry;
      struct csr1212_keyval *last_extkey_spec = NULL;
      struct csr1212_keyval *last_extkey = NULL;
      int index = 0;

      for (dentry = dir->value.directory.dentries_head;
           dentry;
           dentry = dentry->next) {
            struct csr1212_keyval *a;

            for (a = dentry->kv; a; a = a->associate) {
                  u32 value = 0;

                  /* Special Case: Extended Key Specifier_ID */
                  if (a->key.id ==
                      CSR1212_KV_ID_EXTENDED_KEY_SPECIFIER_ID) {
                        if (last_extkey_spec == NULL)
                              last_extkey_spec = a;
                        else if (a->value.immediate !=
                               last_extkey_spec->value.immediate)
                              last_extkey_spec = a;
                        else
                              continue;

                  /* Special Case: Extended Key */
                  } else if (a->key.id == CSR1212_KV_ID_EXTENDED_KEY) {
                        if (last_extkey == NULL)
                              last_extkey = a;
                        else if (a->value.immediate !=
                               last_extkey->value.immediate)
                              last_extkey = a;
                        else
                              continue;
                  }

                  switch (a->key.type) {
                  case CSR1212_KV_TYPE_IMMEDIATE:
                        value = a->value.immediate;
                        break;
                  case CSR1212_KV_TYPE_CSR_OFFSET:
                        value = a->value.csr_offset;
                        break;
                  case CSR1212_KV_TYPE_LEAF:
                        value = a->offset;
                        value -= dir->offset + quads_to_bytes(1+index);
                        value = bytes_to_quads(value);
                        break;
                  case CSR1212_KV_TYPE_DIRECTORY:
                        value = a->offset;
                        value -= dir->offset + quads_to_bytes(1+index);
                        value = bytes_to_quads(value);
                        break;
                  default:
                        /* Should never get here */
                        WARN_ON(1);
                        break;
                  }

                  value |= (a->key.id & CSR1212_KV_KEY_ID_MASK) <<
                         CSR1212_KV_KEY_SHIFT;
                  value |= (a->key.type & CSR1212_KV_KEY_TYPE_MASK) <<
                         (CSR1212_KV_KEY_SHIFT +
                          CSR1212_KV_KEY_TYPE_SHIFT);
                  data_buffer[index] = cpu_to_be32(value);
                  index++;
            }
      }
}

struct csr1212_keyval_img {
      u16 length;
      u16 crc;

      /* Must be last */
      u32 data[0];      /* older gcc can't handle [] which is standard */
};

static void csr1212_fill_cache(struct csr1212_csr_rom_cache *cache)
{
      struct csr1212_keyval *kv, *nkv;
      struct csr1212_keyval_img *kvi;

      for (kv = cache->layout_head;
           kv != cache->layout_tail->next;
           kv = nkv) {
            kvi = (struct csr1212_keyval_img *)(cache->data +
                        bytes_to_quads(kv->offset - cache->offset));
            switch (kv->key.type) {
            default:
            case CSR1212_KV_TYPE_IMMEDIATE:
            case CSR1212_KV_TYPE_CSR_OFFSET:
                  /* Should never get here */
                  WARN_ON(1);
                  break;

            case CSR1212_KV_TYPE_LEAF:
                  /* Don't copy over Extended ROM areas, they are
                   * already filled out! */
                  if (kv->key.id != CSR1212_KV_ID_EXTENDED_ROM)
                        memcpy(kvi->data, kv->value.leaf.data,
                               quads_to_bytes(kv->value.leaf.len));

                  kvi->length = cpu_to_be16(kv->value.leaf.len);
                  kvi->crc = csr1212_crc16(kvi->data, kv->value.leaf.len);
                  break;

            case CSR1212_KV_TYPE_DIRECTORY:
                  csr1212_generate_tree_subdir(kv, kvi->data);

                  kvi->length = cpu_to_be16(kv->value.directory.len);
                  kvi->crc = csr1212_crc16(kvi->data,
                                     kv->value.directory.len);
                  break;
            }

            nkv = kv->next;
            if (kv->prev)
                  kv->prev->next = NULL;
            if (kv->next)
                  kv->next->prev = NULL;
            kv->prev = NULL;
            kv->next = NULL;
      }
}

/* This size is arbitrarily chosen.
 * The struct overhead is subtracted for more economic allocations. */
#define CSR1212_EXTENDED_ROM_SIZE (2048 - sizeof(struct csr1212_csr_rom_cache))

int csr1212_generate_csr_image(struct csr1212_csr *csr)
{
      struct csr1212_bus_info_block_img *bi;
      struct csr1212_csr_rom_cache *cache;
      struct csr1212_keyval *kv;
      size_t agg_size;
      int ret;
      int init_offset;

      BUG_ON(!csr);

      cache = csr->cache_head;

      bi = (struct csr1212_bus_info_block_img*)cache->data;

      bi->length = bytes_to_quads(csr->bus_info_len) - 1;
      bi->crc_length = bi->length;
      bi->crc = csr1212_crc16(bi->data, bi->crc_length);

      csr->root_kv->next = NULL;
      csr->root_kv->prev = NULL;

      agg_size = csr1212_generate_layout_order(csr->root_kv);

      init_offset = csr->bus_info_len;

      for (kv = csr->root_kv, cache = csr->cache_head;
           kv;
           cache = cache->next) {
            if (!cache) {
                  /* Estimate approximate number of additional cache
                   * regions needed (it assumes that the cache holding
                   * the first 1K Config ROM space always exists). */
                  int est_c = agg_size / (CSR1212_EXTENDED_ROM_SIZE -
                                    (2 * sizeof(u32))) + 1;

                  /* Add additional cache regions, extras will be
                   * removed later */
                  for (; est_c; est_c--) {
                        ret = csr1212_append_new_cache(csr,
                                    CSR1212_EXTENDED_ROM_SIZE);
                        if (ret != CSR1212_SUCCESS)
                              return ret;
                  }
                  /* Need to re-layout for additional cache regions */
                  agg_size = csr1212_generate_layout_order(csr->root_kv);
                  kv = csr->root_kv;
                  cache = csr->cache_head;
                  init_offset = csr->bus_info_len;
            }
            kv = csr1212_generate_positions(cache, kv, init_offset);
            agg_size -= cache->len;
            init_offset = sizeof(u32);
      }

      /* Remove unused, excess cache regions */
      while (cache) {
            struct csr1212_csr_rom_cache *oc = cache;

            cache = cache->next;
            csr1212_remove_cache(csr, oc);
      }

      /* Go through the list backward so that when done, the correct CRC
       * will be calculated for the Extended ROM areas. */
      for (cache = csr->cache_tail; cache; cache = cache->prev) {
            /* Only Extended ROM caches should have this set. */
            if (cache->ext_rom) {
                  int leaf_size;

                  /* Make sure the Extended ROM leaf is a multiple of
                   * max_rom in size. */
                  BUG_ON(csr->max_rom < 1);
                  leaf_size = (cache->len + (csr->max_rom - 1)) &
                        ~(csr->max_rom - 1);

                  /* Zero out the unused ROM region */
                  memset(cache->data + bytes_to_quads(cache->len), 0x00,
                         leaf_size - cache->len);

                  /* Subtract leaf header */
                  leaf_size -= sizeof(u32);

                  /* Update the Extended ROM leaf length */
                  cache->ext_rom->value.leaf.len =
                        bytes_to_quads(leaf_size);
            } else {
                  /* Zero out the unused ROM region */
                  memset(cache->data + bytes_to_quads(cache->len), 0x00,
                         cache->size - cache->len);
            }

            /* Copy the data into the cache buffer */
            csr1212_fill_cache(cache);

            if (cache != csr->cache_head) {
                  /* Set the length and CRC of the extended ROM. */
                  struct csr1212_keyval_img *kvi =
                        (struct csr1212_keyval_img*)cache->data;
                  u16 len = bytes_to_quads(cache->len) - 1;

                  kvi->length = cpu_to_be16(len);
                  kvi->crc = csr1212_crc16(kvi->data, len);
            }
      }

      return CSR1212_SUCCESS;
}

int csr1212_read(struct csr1212_csr *csr, u32 offset, void *buffer, u32 len)
{
      struct csr1212_csr_rom_cache *cache;

      for (cache = csr->cache_head; cache; cache = cache->next)
            if (offset >= cache->offset &&
                (offset + len) <= (cache->offset + cache->size)) {
                  memcpy(buffer, &cache->data[
                              bytes_to_quads(offset - cache->offset)],
                         len);
                  return CSR1212_SUCCESS;
            }

      return -ENOENT;
}


/* Parse a chunk of data as a Config ROM */

static int csr1212_parse_bus_info_block(struct csr1212_csr *csr)
{
      struct csr1212_bus_info_block_img *bi;
      struct csr1212_cache_region *cr;
      int i;
      int ret;

      /* IEEE 1212 says that the entire bus info block should be readable in
       * a single transaction regardless of the max_rom value.
       * Unfortunately, many IEEE 1394 devices do not abide by that, so the
       * bus info block will be read 1 quadlet at a time.  The rest of the
       * ConfigROM will be read according to the max_rom field. */
      for (i = 0; i < csr->bus_info_len; i += sizeof(u32)) {
            ret = csr->ops->bus_read(csr, CSR1212_CONFIG_ROM_SPACE_BASE + i,
                  sizeof(u32), &csr->cache_head->data[bytes_to_quads(i)],
                  csr->private);
            if (ret != CSR1212_SUCCESS)
                  return ret;

            /* check ROM header's info_length */
            if (i == 0 &&
                be32_to_cpu(csr->cache_head->data[0]) >> 24 !=
                bytes_to_quads(csr->bus_info_len) - 1)
                  return -EINVAL;
      }

      bi = (struct csr1212_bus_info_block_img*)csr->cache_head->data;
      csr->crc_len = quads_to_bytes(bi->crc_length);

      /* IEEE 1212 recommends that crc_len be equal to bus_info_len, but that
       * is not always the case, so read the rest of the crc area 1 quadlet at
       * a time. */
      for (i = csr->bus_info_len; i <= csr->crc_len; i += sizeof(u32)) {
            ret = csr->ops->bus_read(csr, CSR1212_CONFIG_ROM_SPACE_BASE + i,
                  sizeof(u32), &csr->cache_head->data[bytes_to_quads(i)],
                  csr->private);
            if (ret != CSR1212_SUCCESS)
                  return ret;
      }

      /* Apparently there are many different wrong implementations of the CRC
       * algorithm.  We don't fail, we just warn. */
      if ((csr1212_crc16(bi->data, bi->crc_length) != bi->crc) &&
          (csr1212_msft_crc16(bi->data, bi->crc_length) != bi->crc))
            printk(KERN_DEBUG "IEEE 1394 device has ROM CRC error\n");

      cr = CSR1212_MALLOC(sizeof(*cr));
      if (!cr)
            return -ENOMEM;

      cr->next = NULL;
      cr->prev = NULL;
      cr->offset_start = 0;
      cr->offset_end = csr->crc_len + 4;

      csr->cache_head->filled_head = cr;
      csr->cache_head->filled_tail = cr;

      return CSR1212_SUCCESS;
}

#define CSR1212_KV_KEY(q)     (be32_to_cpu(q) >> CSR1212_KV_KEY_SHIFT)
#define CSR1212_KV_KEY_TYPE(q)      (CSR1212_KV_KEY(q) >> CSR1212_KV_KEY_TYPE_SHIFT)
#define CSR1212_KV_KEY_ID(q)  (CSR1212_KV_KEY(q) & CSR1212_KV_KEY_ID_MASK)
#define CSR1212_KV_VAL_MASK   0xffffff
#define CSR1212_KV_VAL(q)     (be32_to_cpu(q) & CSR1212_KV_VAL_MASK)

static int
csr1212_parse_dir_entry(struct csr1212_keyval *dir, u32 ki, u32 kv_pos)
{
      int ret = CSR1212_SUCCESS;
      struct csr1212_keyval *k = NULL;
      u32 offset;
      bool keep_keyval = true;

      switch (CSR1212_KV_KEY_TYPE(ki)) {
      case CSR1212_KV_TYPE_IMMEDIATE:
            k = csr1212_new_immediate(CSR1212_KV_KEY_ID(ki),
                                CSR1212_KV_VAL(ki));
            if (!k) {
                  ret = -ENOMEM;
                  goto out;
            }
            /* Don't keep local reference when parsing. */
            keep_keyval = false;
            break;

      case CSR1212_KV_TYPE_CSR_OFFSET:
            k = csr1212_new_csr_offset(CSR1212_KV_KEY_ID(ki),
                                 CSR1212_KV_VAL(ki));
            if (!k) {
                  ret = -ENOMEM;
                  goto out;
            }
            /* Don't keep local reference when parsing. */
            keep_keyval = false;
            break;

      default:
            /* Compute the offset from 0xffff f000 0000. */
            offset = quads_to_bytes(CSR1212_KV_VAL(ki)) + kv_pos;
            if (offset == kv_pos) {
                  /* Uh-oh.  Can't have a relative offset of 0 for Leaves
                   * or Directories.  The Config ROM image is most likely
                   * messed up, so we'll just abort here. */
                  ret = -EIO;
                  goto out;
            }

            k = csr1212_find_keyval_offset(dir, offset);

            if (k)
                  break;            /* Found it. */

            if (CSR1212_KV_KEY_TYPE(ki) == CSR1212_KV_TYPE_DIRECTORY)
                  k = csr1212_new_directory(CSR1212_KV_KEY_ID(ki));
            else
                  k = csr1212_new_leaf(CSR1212_KV_KEY_ID(ki), NULL, 0);

            if (!k) {
                  ret = -ENOMEM;
                  goto out;
            }
            /* Don't keep local reference when parsing. */
            keep_keyval = false;
            /* Contents not read yet so it's not valid. */
            k->valid = 0;
            k->offset = offset;

            k->prev = dir;
            k->next = dir->next;
            dir->next->prev = k;
            dir->next = k;
      }
      ret = __csr1212_attach_keyval_to_directory(dir, k, keep_keyval);
out:
      if (ret != CSR1212_SUCCESS && k != NULL)
            free_keyval(k);
      return ret;
}

int csr1212_parse_keyval(struct csr1212_keyval *kv,
                   struct csr1212_csr_rom_cache *cache)
{
      struct csr1212_keyval_img *kvi;
      int i;
      int ret = CSR1212_SUCCESS;
      int kvi_len;

      kvi = (struct csr1212_keyval_img*)
            &cache->data[bytes_to_quads(kv->offset - cache->offset)];
      kvi_len = be16_to_cpu(kvi->length);

      /* Apparently there are many different wrong implementations of the CRC
       * algorithm.  We don't fail, we just warn. */
      if ((csr1212_crc16(kvi->data, kvi_len) != kvi->crc) &&
          (csr1212_msft_crc16(kvi->data, kvi_len) != kvi->crc))
            printk(KERN_DEBUG "IEEE 1394 device has ROM CRC error\n");

      switch (kv->key.type) {
      case CSR1212_KV_TYPE_DIRECTORY:
            for (i = 0; i < kvi_len; i++) {
                  u32 ki = kvi->data[i];

                  /* Some devices put null entries in their unit
                   * directories.  If we come across such an entry,
                   * then skip it. */
                  if (ki == 0x0)
                        continue;
                  ret = csr1212_parse_dir_entry(kv, ki,
                              kv->offset + quads_to_bytes(i + 1));
            }
            kv->value.directory.len = kvi_len;
            break;

      case CSR1212_KV_TYPE_LEAF:
            if (kv->key.id != CSR1212_KV_ID_EXTENDED_ROM) {
                  size_t size = quads_to_bytes(kvi_len);

                  kv->value.leaf.data = CSR1212_MALLOC(size);
                  if (!kv->value.leaf.data) {
                        ret = -ENOMEM;
                        goto out;
                  }

                  kv->value.leaf.len = kvi_len;
                  memcpy(kv->value.leaf.data, kvi->data, size);
            }
            break;
      }

      kv->valid = 1;
out:
      return ret;
}

static int
csr1212_read_keyval(struct csr1212_csr *csr, struct csr1212_keyval *kv)
{
      struct csr1212_cache_region *cr, *ncr, *newcr = NULL;
      struct csr1212_keyval_img *kvi = NULL;
      struct csr1212_csr_rom_cache *cache;
      int cache_index;
      u64 addr;
      u32 *cache_ptr;
      u16 kv_len = 0;

      BUG_ON(!csr || !kv || csr->max_rom < 1);

      /* First find which cache the data should be in (or go in if not read
       * yet). */
      for (cache = csr->cache_head; cache; cache = cache->next)
            if (kv->offset >= cache->offset &&
                kv->offset < (cache->offset + cache->size))
                  break;

      if (!cache) {
            u32 q, cache_size;

            /* Only create a new cache for Extended ROM leaves. */
            if (kv->key.id != CSR1212_KV_ID_EXTENDED_ROM)
                  return -EINVAL;

            if (csr->ops->bus_read(csr,
                               CSR1212_REGISTER_SPACE_BASE + kv->offset,
                               sizeof(u32), &q, csr->private))
                  return -EIO;

            kv->value.leaf.len = be32_to_cpu(q) >> 16;

            cache_size = (quads_to_bytes(kv->value.leaf.len + 1) +
                        (csr->max_rom - 1)) & ~(csr->max_rom - 1);

            cache = csr1212_rom_cache_malloc(kv->offset, cache_size);
            if (!cache)
                  return -ENOMEM;

            kv->value.leaf.data = &cache->data[1];
            csr->cache_tail->next = cache;
            cache->prev = csr->cache_tail;
            cache->next = NULL;
            csr->cache_tail = cache;
            cache->filled_head =
                  CSR1212_MALLOC(sizeof(*cache->filled_head));
            if (!cache->filled_head)
                  return -ENOMEM;

            cache->filled_head->offset_start = 0;
            cache->filled_head->offset_end = sizeof(u32);
            cache->filled_tail = cache->filled_head;
            cache->filled_head->next = NULL;
            cache->filled_head->prev = NULL;
            cache->data[0] = q;

            /* Don't read the entire extended ROM now.  Pieces of it will
             * be read when entries inside it are read. */
            return csr1212_parse_keyval(kv, cache);
      }

      cache_index = kv->offset - cache->offset;

      /* Now seach read portions of the cache to see if it is there. */
      for (cr = cache->filled_head; cr; cr = cr->next) {
            if (cache_index < cr->offset_start) {
                  newcr = CSR1212_MALLOC(sizeof(*newcr));
                  if (!newcr)
                        return -ENOMEM;

                  newcr->offset_start = cache_index & ~(csr->max_rom - 1);
                  newcr->offset_end = newcr->offset_start;
                  newcr->next = cr;
                  newcr->prev = cr->prev;
                  cr->prev = newcr;
                  cr = newcr;
                  break;
            } else if ((cache_index >= cr->offset_start) &&
                     (cache_index < cr->offset_end)) {
                  kvi = (struct csr1212_keyval_img*)
                        (&cache->data[bytes_to_quads(cache_index)]);
                  kv_len = quads_to_bytes(be16_to_cpu(kvi->length) + 1);
                  break;
            } else if (cache_index == cr->offset_end) {
                  break;
            }
      }

      if (!cr) {
            cr = cache->filled_tail;
            newcr = CSR1212_MALLOC(sizeof(*newcr));
            if (!newcr)
                  return -ENOMEM;

            newcr->offset_start = cache_index & ~(csr->max_rom - 1);
            newcr->offset_end = newcr->offset_start;
            newcr->prev = cr;
            newcr->next = cr->next;
            cr->next = newcr;
            cr = newcr;
            cache->filled_tail = newcr;
      }

      while(!kvi || cr->offset_end < cache_index + kv_len) {
            cache_ptr = &cache->data[bytes_to_quads(cr->offset_end &
                                          ~(csr->max_rom - 1))];

            addr = (CSR1212_CSR_ARCH_REG_SPACE_BASE + cache->offset +
                  cr->offset_end) & ~(csr->max_rom - 1);

            if (csr->ops->bus_read(csr, addr, csr->max_rom, cache_ptr,
                               csr->private)) {
                  if (csr->max_rom == 4)
                        /* We've got problems! */
                        return -EIO;

                  /* Apperently the max_rom value was a lie, set it to
                   * do quadlet reads and try again. */
                  csr->max_rom = 4;
                  continue;
            }

            cr->offset_end += csr->max_rom - (cr->offset_end &
                                      (csr->max_rom - 1));

            if (!kvi && (cr->offset_end > cache_index)) {
                  kvi = (struct csr1212_keyval_img*)
                        (&cache->data[bytes_to_quads(cache_index)]);
                  kv_len = quads_to_bytes(be16_to_cpu(kvi->length) + 1);
            }

            if ((kv_len + (kv->offset - cache->offset)) > cache->size) {
                  /* The Leaf or Directory claims its length extends
                   * beyond the ConfigROM image region and thus beyond the
                   * end of our cache region.  Therefore, we abort now
                   * rather than seg faulting later. */
                  return -EIO;
            }

            ncr = cr->next;

            if (ncr && (cr->offset_end >= ncr->offset_start)) {
                  /* consolidate region entries */
                  ncr->offset_start = cr->offset_start;

                  if (cr->prev)
                        cr->prev->next = cr->next;
                  ncr->prev = cr->prev;
                  if (cache->filled_head == cr)
                        cache->filled_head = ncr;
                  CSR1212_FREE(cr);
                  cr = ncr;
            }
      }

      return csr1212_parse_keyval(kv, cache);
}

struct csr1212_keyval *
csr1212_get_keyval(struct csr1212_csr *csr, struct csr1212_keyval *kv)
{
      if (!kv)
            return NULL;
      if (!kv->valid)
            if (csr1212_read_keyval(csr, kv) != CSR1212_SUCCESS)
                  return NULL;
      return kv;
}

int csr1212_parse_csr(struct csr1212_csr *csr)
{
      static const int mr_map[] = { 4, 64, 1024, 0 };
      struct csr1212_dentry *dentry;
      int ret;

      BUG_ON(!csr || !csr->ops || !csr->ops->bus_read);

      ret = csr1212_parse_bus_info_block(csr);
      if (ret != CSR1212_SUCCESS)
            return ret;

      if (!csr->ops->get_max_rom) {
            csr->max_rom = mr_map[0];     /* default value */
      } else {
            int i = csr->ops->get_max_rom(csr->bus_info_data,
                                    csr->private);
            if (i & ~0x3)
                  return -EINVAL;
            csr->max_rom = mr_map[i];
      }

      csr->cache_head->layout_head = csr->root_kv;
      csr->cache_head->layout_tail = csr->root_kv;

      csr->root_kv->offset = (CSR1212_CONFIG_ROM_SPACE_BASE & 0xffff) +
            csr->bus_info_len;

      csr->root_kv->valid = 0;
      csr->root_kv->next = csr->root_kv;
      csr->root_kv->prev = csr->root_kv;
      ret = csr1212_read_keyval(csr, csr->root_kv);
      if (ret != CSR1212_SUCCESS)
            return ret;

      /* Scan through the Root directory finding all extended ROM regions
       * and make cache regions for them */
      for (dentry = csr->root_kv->value.directory.dentries_head;
           dentry; dentry = dentry->next) {
            if (dentry->kv->key.id == CSR1212_KV_ID_EXTENDED_ROM &&
                  !dentry->kv->valid) {
                  ret = csr1212_read_keyval(csr, dentry->kv);
                  if (ret != CSR1212_SUCCESS)
                        return ret;
            }
      }

      return CSR1212_SUCCESS;
}

Generated by  Doxygen 1.6.0   Back to index