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