diff options
Diffstat (limited to 'drivers/ieee1394/csr1212.h')
-rw-r--r-- | drivers/ieee1394/csr1212.h | 727 |
1 files changed, 727 insertions, 0 deletions
diff --git a/drivers/ieee1394/csr1212.h b/drivers/ieee1394/csr1212.h new file mode 100644 index 000000000000..e6734263a1d3 --- /dev/null +++ b/drivers/ieee1394/csr1212.h | |||
@@ -0,0 +1,727 @@ | |||
1 | /* | ||
2 | * csr1212.h -- 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 | #ifndef __CSR1212_H__ | ||
31 | #define __CSR1212_H__ | ||
32 | |||
33 | |||
34 | /* Compatibility layer */ | ||
35 | #ifdef __KERNEL__ | ||
36 | |||
37 | #include <linux/types.h> | ||
38 | #include <linux/slab.h> | ||
39 | #include <linux/interrupt.h> | ||
40 | #include <linux/sched.h> | ||
41 | #include <linux/vmalloc.h> | ||
42 | #include <asm/pgalloc.h> | ||
43 | |||
44 | #define CSR1212_MALLOC(size) vmalloc((size)) | ||
45 | #define CSR1212_FREE(ptr) vfree(ptr) | ||
46 | #define CSR1212_BE16_TO_CPU(quad) be16_to_cpu(quad) | ||
47 | #define CSR1212_CPU_TO_BE16(quad) cpu_to_be16(quad) | ||
48 | #define CSR1212_BE32_TO_CPU(quad) be32_to_cpu(quad) | ||
49 | #define CSR1212_CPU_TO_BE32(quad) cpu_to_be32(quad) | ||
50 | #define CSR1212_BE64_TO_CPU(quad) be64_to_cpu(quad) | ||
51 | #define CSR1212_CPU_TO_BE64(quad) cpu_to_be64(quad) | ||
52 | |||
53 | #define CSR1212_LE16_TO_CPU(quad) le16_to_cpu(quad) | ||
54 | #define CSR1212_CPU_TO_LE16(quad) cpu_to_le16(quad) | ||
55 | #define CSR1212_LE32_TO_CPU(quad) le32_to_cpu(quad) | ||
56 | #define CSR1212_CPU_TO_LE32(quad) cpu_to_le32(quad) | ||
57 | #define CSR1212_LE64_TO_CPU(quad) le64_to_cpu(quad) | ||
58 | #define CSR1212_CPU_TO_LE64(quad) cpu_to_le64(quad) | ||
59 | |||
60 | #include <linux/errno.h> | ||
61 | #define CSR1212_SUCCESS (0) | ||
62 | #define CSR1212_EINVAL (-EINVAL) | ||
63 | #define CSR1212_ENOMEM (-ENOMEM) | ||
64 | #define CSR1212_ENOENT (-ENOENT) | ||
65 | #define CSR1212_EIO (-EIO) | ||
66 | #define CSR1212_EBUSY (-EBUSY) | ||
67 | |||
68 | #else /* Userspace */ | ||
69 | |||
70 | #include <sys/types.h> | ||
71 | #include <malloc.h> | ||
72 | #define CSR1212_MALLOC(size) malloc(size) | ||
73 | #define CSR1212_FREE(ptr) free(ptr) | ||
74 | #include <endian.h> | ||
75 | #if __BYTE_ORDER == __LITTLE_ENDIAN | ||
76 | #include <byteswap.h> | ||
77 | #define CSR1212_BE16_TO_CPU(quad) bswap_16(quad) | ||
78 | #define CSR1212_CPU_TO_BE16(quad) bswap_16(quad) | ||
79 | #define CSR1212_BE32_TO_CPU(quad) bswap_32(quad) | ||
80 | #define CSR1212_CPU_TO_BE32(quad) bswap_32(quad) | ||
81 | #define CSR1212_BE64_TO_CPU(quad) bswap_64(quad) | ||
82 | #define CSR1212_CPU_TO_BE64(quad) bswap_64(quad) | ||
83 | |||
84 | #define CSR1212_LE16_TO_CPU(quad) (quad) | ||
85 | #define CSR1212_CPU_TO_LE16(quad) (quad) | ||
86 | #define CSR1212_LE32_TO_CPU(quad) (quad) | ||
87 | #define CSR1212_CPU_TO_LE32(quad) (quad) | ||
88 | #define CSR1212_LE64_TO_CPU(quad) (quad) | ||
89 | #define CSR1212_CPU_TO_LE64(quad) (quad) | ||
90 | #else | ||
91 | #define CSR1212_BE16_TO_CPU(quad) (quad) | ||
92 | #define CSR1212_CPU_TO_BE16(quad) (quad) | ||
93 | #define CSR1212_BE32_TO_CPU(quad) (quad) | ||
94 | #define CSR1212_CPU_TO_BE32(quad) (quad) | ||
95 | #define CSR1212_BE64_TO_CPU(quad) (quad) | ||
96 | #define CSR1212_CPU_TO_BE64(quad) (quad) | ||
97 | |||
98 | #define CSR1212_LE16_TO_CPU(quad) bswap_16(quad) | ||
99 | #define CSR1212_CPU_TO_LE16(quad) bswap_16(quad) | ||
100 | #define CSR1212_LE32_TO_CPU(quad) bswap_32(quad) | ||
101 | #define CSR1212_CPU_TO_LE32(quad) bswap_32(quad) | ||
102 | #define CSR1212_LE64_TO_CPU(quad) bswap_64(quad) | ||
103 | #define CSR1212_CPU_TO_LE64(quad) bswap_64(quad) | ||
104 | #endif | ||
105 | |||
106 | #include <errno.h> | ||
107 | #define CSR1212_SUCCESS (0) | ||
108 | #define CSR1212_EINVAL (EINVAL) | ||
109 | #define CSR1212_ENOMEM (ENOMEM) | ||
110 | #define CSR1212_ENOENT (ENOENT) | ||
111 | #define CSR1212_EIO (EIO) | ||
112 | #define CSR1212_EBUSY (EBUSY) | ||
113 | |||
114 | #endif | ||
115 | |||
116 | |||
117 | #define CSR1212_KV_VAL_MASK 0xffffff | ||
118 | #define CSR1212_KV_KEY_SHIFT 24 | ||
119 | #define CSR1212_KV_KEY_TYPE_SHIFT 6 | ||
120 | #define CSR1212_KV_KEY_ID_MASK 0x3f | ||
121 | #define CSR1212_KV_KEY_TYPE_MASK 0x3 /* After shift */ | ||
122 | |||
123 | |||
124 | /* CSR 1212 key types */ | ||
125 | #define CSR1212_KV_TYPE_IMMEDIATE 0 | ||
126 | #define CSR1212_KV_TYPE_CSR_OFFSET 1 | ||
127 | #define CSR1212_KV_TYPE_LEAF 2 | ||
128 | #define CSR1212_KV_TYPE_DIRECTORY 3 | ||
129 | |||
130 | |||
131 | /* CSR 1212 key ids */ | ||
132 | #define CSR1212_KV_ID_DESCRIPTOR 0x01 | ||
133 | #define CSR1212_KV_ID_BUS_DEPENDENT_INFO 0x02 | ||
134 | #define CSR1212_KV_ID_VENDOR 0x03 | ||
135 | #define CSR1212_KV_ID_HARDWARE_VERSION 0x04 | ||
136 | #define CSR1212_KV_ID_MODULE 0x07 | ||
137 | #define CSR1212_KV_ID_NODE_CAPABILITIES 0x0C | ||
138 | #define CSR1212_KV_ID_EUI_64 0x0D | ||
139 | #define CSR1212_KV_ID_UNIT 0x11 | ||
140 | #define CSR1212_KV_ID_SPECIFIER_ID 0x12 | ||
141 | #define CSR1212_KV_ID_VERSION 0x13 | ||
142 | #define CSR1212_KV_ID_DEPENDENT_INFO 0x14 | ||
143 | #define CSR1212_KV_ID_UNIT_LOCATION 0x15 | ||
144 | #define CSR1212_KV_ID_MODEL 0x17 | ||
145 | #define CSR1212_KV_ID_INSTANCE 0x18 | ||
146 | #define CSR1212_KV_ID_KEYWORD 0x19 | ||
147 | #define CSR1212_KV_ID_FEATURE 0x1A | ||
148 | #define CSR1212_KV_ID_EXTENDED_ROM 0x1B | ||
149 | #define CSR1212_KV_ID_EXTENDED_KEY_SPECIFIER_ID 0x1C | ||
150 | #define CSR1212_KV_ID_EXTENDED_KEY 0x1D | ||
151 | #define CSR1212_KV_ID_EXTENDED_DATA 0x1E | ||
152 | #define CSR1212_KV_ID_MODIFIABLE_DESCRIPTOR 0x1F | ||
153 | #define CSR1212_KV_ID_DIRECTORY_ID 0x20 | ||
154 | #define CSR1212_KV_ID_REVISION 0x21 | ||
155 | |||
156 | |||
157 | /* IEEE 1212 Address space map */ | ||
158 | #define CSR1212_ALL_SPACE_BASE (0x000000000000ULL) | ||
159 | #define CSR1212_ALL_SPACE_SIZE (1ULL << 48) | ||
160 | #define CSR1212_ALL_SPACE_END (CSR1212_ALL_SPACE_BASE + CSR1212_ALL_SPACE_SIZE) | ||
161 | |||
162 | #define CSR1212_MEMORY_SPACE_BASE (0x000000000000ULL) | ||
163 | #define CSR1212_MEMORY_SPACE_SIZE ((256ULL * (1ULL << 40)) - (512ULL * (1ULL << 20))) | ||
164 | #define CSR1212_MEMORY_SPACE_END (CSR1212_MEMORY_SPACE_BASE + CSR1212_MEMORY_SPACE_SIZE) | ||
165 | |||
166 | #define CSR1212_PRIVATE_SPACE_BASE (0xffffe0000000ULL) | ||
167 | #define CSR1212_PRIVATE_SPACE_SIZE (256ULL * (1ULL << 20)) | ||
168 | #define CSR1212_PRIVATE_SPACE_END (CSR1212_PRIVATE_SPACE_BASE + CSR1212_PRIVATE_SPACE_SIZE) | ||
169 | |||
170 | #define CSR1212_REGISTER_SPACE_BASE (0xfffff0000000ULL) | ||
171 | #define CSR1212_REGISTER_SPACE_SIZE (256ULL * (1ULL << 20)) | ||
172 | #define CSR1212_REGISTER_SPACE_END (CSR1212_REGISTER_SPACE_BASE + CSR1212_REGISTER_SPACE_SIZE) | ||
173 | |||
174 | #define CSR1212_CSR_ARCH_REG_SPACE_BASE (0xfffff0000000ULL) | ||
175 | #define CSR1212_CSR_ARCH_REG_SPACE_SIZE (512) | ||
176 | #define CSR1212_CSR_ARCH_REG_SPACE_END (CSR1212_CSR_ARCH_REG_SPACE_BASE + CSR1212_CSR_ARCH_REG_SPACE_SIZE) | ||
177 | #define CSR1212_CSR_ARCH_REG_SPACE_OFFSET (CSR1212_CSR_ARCH_REG_SPACE_BASE - CSR1212_REGISTER_SPACE_BASE) | ||
178 | |||
179 | #define CSR1212_CSR_BUS_DEP_REG_SPACE_BASE (0xfffff0000200ULL) | ||
180 | #define CSR1212_CSR_BUS_DEP_REG_SPACE_SIZE (512) | ||
181 | #define CSR1212_CSR_BUS_DEP_REG_SPACE_END (CSR1212_CSR_BUS_DEP_REG_SPACE_BASE + CSR1212_CSR_BUS_DEP_REG_SPACE_SIZE) | ||
182 | #define CSR1212_CSR_BUS_DEP_REG_SPACE_OFFSET (CSR1212_CSR_BUS_DEP_REG_SPACE_BASE - CSR1212_REGISTER_SPACE_BASE) | ||
183 | |||
184 | #define CSR1212_CONFIG_ROM_SPACE_BASE (0xfffff0000400ULL) | ||
185 | #define CSR1212_CONFIG_ROM_SPACE_SIZE (1024) | ||
186 | #define CSR1212_CONFIG_ROM_SPACE_END (CSR1212_CONFIG_ROM_SPACE_BASE + CSR1212_CONFIG_ROM_SPACE_SIZE) | ||
187 | #define CSR1212_CONFIG_ROM_SPACE_OFFSET (CSR1212_CONFIG_ROM_SPACE_BASE - CSR1212_REGISTER_SPACE_BASE) | ||
188 | |||
189 | #define CSR1212_UNITS_SPACE_BASE (0xfffff0000800ULL) | ||
190 | #define CSR1212_UNITS_SPACE_SIZE ((256ULL * (1ULL << 20)) - 2048) | ||
191 | #define CSR1212_UNITS_SPACE_END (CSR1212_UNITS_SPACE_BASE + CSR1212_UNITS_SPACE_SIZE) | ||
192 | #define CSR1212_UNITS_SPACE_OFFSET (CSR1212_UNITS_SPACE_BASE - CSR1212_REGISTER_SPACE_BASE) | ||
193 | |||
194 | #define CSR1212_EXTENDED_ROM_SIZE (0x10000 * sizeof(u_int32_t)) | ||
195 | |||
196 | |||
197 | /* Config ROM image structures */ | ||
198 | struct csr1212_bus_info_block_img { | ||
199 | u_int8_t length; | ||
200 | u_int8_t crc_length; | ||
201 | u_int16_t crc; | ||
202 | |||
203 | /* Must be last */ | ||
204 | u_int32_t data[0]; /* older gcc can't handle [] which is standard */ | ||
205 | }; | ||
206 | |||
207 | #define CSR1212_KV_KEY(quad) (CSR1212_BE32_TO_CPU(quad) >> CSR1212_KV_KEY_SHIFT) | ||
208 | #define CSR1212_KV_KEY_TYPE(quad) (CSR1212_KV_KEY(quad) >> CSR1212_KV_KEY_TYPE_SHIFT) | ||
209 | #define CSR1212_KV_KEY_ID(quad) (CSR1212_KV_KEY(quad) & CSR1212_KV_KEY_ID_MASK) | ||
210 | #define CSR1212_KV_VAL(quad) (CSR1212_BE32_TO_CPU(quad) & CSR1212_KV_VAL_MASK) | ||
211 | |||
212 | #define CSR1212_SET_KV_KEY(quad, key) ((quad) = \ | ||
213 | CSR1212_CPU_TO_BE32(CSR1212_KV_VAL(quad) | ((key) << CSR1212_KV_KEY_SHIFT))) | ||
214 | #define CSR1212_SET_KV_VAL(quad, val) ((quad) = \ | ||
215 | CSR1212_CPU_TO_BE32((CSR1212_KV_KEY(quad) << CSR1212_KV_KEY_SHIFT) | (val))) | ||
216 | #define CSR1212_SET_KV_TYPEID(quad, type, id) ((quad) = \ | ||
217 | CSR1212_CPU_TO_BE32(CSR1212_KV_VAL(quad) | \ | ||
218 | (((((type) & CSR1212_KV_KEY_TYPE_MASK) << CSR1212_KV_KEY_TYPE_SHIFT) | \ | ||
219 | ((id) & CSR1212_KV_KEY_ID_MASK)) << CSR1212_KV_KEY_SHIFT))) | ||
220 | |||
221 | typedef u_int32_t csr1212_quad_t; | ||
222 | |||
223 | |||
224 | struct csr1212_keyval_img { | ||
225 | u_int16_t length; | ||
226 | u_int16_t crc; | ||
227 | |||
228 | /* Must be last */ | ||
229 | csr1212_quad_t data[0]; /* older gcc can't handle [] which is standard */ | ||
230 | }; | ||
231 | |||
232 | struct csr1212_leaf { | ||
233 | int len; | ||
234 | u_int32_t *data; | ||
235 | }; | ||
236 | |||
237 | struct csr1212_dentry { | ||
238 | struct csr1212_dentry *next, *prev; | ||
239 | struct csr1212_keyval *kv; | ||
240 | }; | ||
241 | |||
242 | struct csr1212_directory { | ||
243 | int len; | ||
244 | struct csr1212_dentry *dentries_head, *dentries_tail; | ||
245 | }; | ||
246 | |||
247 | struct csr1212_keyval { | ||
248 | struct { | ||
249 | u_int8_t type; | ||
250 | u_int8_t id; | ||
251 | } key; | ||
252 | union { | ||
253 | u_int32_t immediate; | ||
254 | u_int32_t csr_offset; | ||
255 | struct csr1212_leaf leaf; | ||
256 | struct csr1212_directory directory; | ||
257 | } value; | ||
258 | struct csr1212_keyval *associate; | ||
259 | int refcnt; | ||
260 | |||
261 | /* used in generating and/or parsing CSR image */ | ||
262 | struct csr1212_keyval *next, *prev; /* flat list of CSR elements */ | ||
263 | u_int32_t offset; /* position in CSR from 0xffff f000 0000 */ | ||
264 | u_int8_t valid; /* flag indicating keyval has valid data*/ | ||
265 | }; | ||
266 | |||
267 | |||
268 | struct csr1212_cache_region { | ||
269 | struct csr1212_cache_region *next, *prev; | ||
270 | u_int32_t offset_start; /* inclusive */ | ||
271 | u_int32_t offset_end; /* exclusive */ | ||
272 | }; | ||
273 | |||
274 | struct csr1212_csr_rom_cache { | ||
275 | struct csr1212_csr_rom_cache *next, *prev; | ||
276 | struct csr1212_cache_region *filled_head, *filled_tail; | ||
277 | struct csr1212_keyval *layout_head, *layout_tail; | ||
278 | size_t size; | ||
279 | u_int32_t offset; | ||
280 | struct csr1212_keyval *ext_rom; | ||
281 | size_t len; | ||
282 | |||
283 | /* Must be last */ | ||
284 | u_int32_t data[0]; /* older gcc can't handle [] which is standard */ | ||
285 | }; | ||
286 | |||
287 | struct csr1212_csr { | ||
288 | size_t bus_info_len; /* bus info block length in bytes */ | ||
289 | size_t crc_len; /* crc length in bytes */ | ||
290 | u_int32_t *bus_info_data; /* bus info data incl bus name and EUI */ | ||
291 | |||
292 | void *private; /* private, bus specific data */ | ||
293 | struct csr1212_bus_ops *ops; | ||
294 | |||
295 | struct csr1212_keyval *root_kv; | ||
296 | |||
297 | int max_rom; /* max bytes readable in Config ROM region */ | ||
298 | |||
299 | /* Items below used for image parsing and generation */ | ||
300 | struct csr1212_csr_rom_cache *cache_head, *cache_tail; | ||
301 | }; | ||
302 | |||
303 | struct csr1212_bus_ops { | ||
304 | /* This function is used by csr1212 to read additional information | ||
305 | * from remote nodes when parsing a Config ROM (i.e., read Config ROM | ||
306 | * entries located in the Units Space. Must return 0 on success | ||
307 | * anything else indicates an error. */ | ||
308 | int (*bus_read) (struct csr1212_csr *csr, u_int64_t addr, | ||
309 | u_int16_t length, void *buffer, void *private); | ||
310 | |||
311 | /* This function is used by csr1212 to allocate a region in units space | ||
312 | * in the event that Config ROM entries don't all fit in the predefined | ||
313 | * 1K region. The void *private parameter is private member of struct | ||
314 | * csr1212_csr. */ | ||
315 | u_int64_t (*allocate_addr_range) (u_int64_t size, u_int32_t alignment, | ||
316 | void *private); | ||
317 | |||
318 | |||
319 | /* This function is used by csr1212 to release a region in units space | ||
320 | * that is no longer needed. */ | ||
321 | void (*release_addr) (u_int64_t addr, void *private); | ||
322 | |||
323 | /* This function is used by csr1212 to determine the max read request | ||
324 | * supported by a remote node when reading the ConfigROM space. Must | ||
325 | * return 0, 1, or 2 per IEEE 1212. */ | ||
326 | int (*get_max_rom) (u_int32_t *bus_info, void *private); | ||
327 | }; | ||
328 | |||
329 | |||
330 | |||
331 | |||
332 | /* Descriptor Leaf manipulation macros */ | ||
333 | #define CSR1212_DESCRIPTOR_LEAF_TYPE_SHIFT 24 | ||
334 | #define CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID_MASK 0xffffff | ||
335 | #define CSR1212_DESCRIPTOR_LEAF_OVERHEAD (1 * sizeof(u_int32_t)) | ||
336 | |||
337 | #define CSR1212_DESCRIPTOR_LEAF_TYPE(kv) \ | ||
338 | (CSR1212_BE32_TO_CPU((kv)->value.leaf.data[0]) >> CSR1212_DESCRIPTOR_LEAF_TYPE_SHIFT) | ||
339 | #define CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID(kv) \ | ||
340 | (CSR1212_BE32_TO_CPU((kv)->value.leaf.data[0]) & \ | ||
341 | CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID_MASK) | ||
342 | #define CSR1212_DESCRIPTOR_LEAF_DATA(kv) \ | ||
343 | (&((kv)->value.leaf.data[1])) | ||
344 | |||
345 | #define CSR1212_DESCRIPTOR_LEAF_SET_TYPE(kv, type) \ | ||
346 | ((kv)->value.leaf.data[0] = \ | ||
347 | CSR1212_CPU_TO_BE32(CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID(kv) | \ | ||
348 | ((type) << CSR1212_DESCRIPTOR_LEAF_TYPE_SHIFT))) | ||
349 | #define CSR1212_DESCRIPTOR_LEAF_SET_SPECIFIER_ID(kv, spec_id) \ | ||
350 | ((kv)->value.leaf.data[0] = \ | ||
351 | CSR1212_CPU_TO_BE32((CSR1212_DESCRIPTOR_LEAF_TYPE(kv) << \ | ||
352 | CSR1212_DESCRIPTOR_LEAF_TYPE_SHIFT) | \ | ||
353 | ((spec_id) & CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID_MASK))) | ||
354 | |||
355 | /* Text Descriptor Leaf manipulation macros */ | ||
356 | #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH_SHIFT 28 | ||
357 | #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH_MASK 0xf /* after shift */ | ||
358 | #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET_SHIFT 16 | ||
359 | #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET_MASK 0xfff /* after shift */ | ||
360 | #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_LANGUAGE_MASK 0xffff | ||
361 | #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_OVERHEAD (1 * sizeof(u_int32_t)) | ||
362 | |||
363 | #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH(kv) \ | ||
364 | (CSR1212_BE32_TO_CPU((kv)->value.leaf.data[1]) >> \ | ||
365 | CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH_SHIFT) | ||
366 | #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET(kv) \ | ||
367 | ((CSR1212_BE32_TO_CPU((kv)->value.leaf.data[1]) >> \ | ||
368 | CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET_SHIFT) & \ | ||
369 | CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET_MASK) | ||
370 | #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_LANGUAGE(kv) \ | ||
371 | (CSR1212_BE32_TO_CPU((kv)->value.leaf.data[1]) & \ | ||
372 | CSR1212_TEXTUAL_DESCRIPTOR_LEAF_LANGUAGE_MASK) | ||
373 | #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_DATA(kv) \ | ||
374 | (&((kv)->value.leaf.data[2])) | ||
375 | |||
376 | #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_SET_WIDTH(kv, width) \ | ||
377 | ((kv)->value.leaf.data[1] = \ | ||
378 | ((kv)->value.leaf.data[1] & \ | ||
379 | CSR1212_CPU_TO_BE32(~(CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH_MASK << \ | ||
380 | CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH_SHIFT))) | \ | ||
381 | CSR1212_CPU_TO_BE32(((width) & \ | ||
382 | CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH_MASK) << \ | ||
383 | CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH_SHIFT)) | ||
384 | #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_SET_CHAR_SET(kv, char_set) \ | ||
385 | ((kv)->value.leaf.data[1] = \ | ||
386 | ((kv)->value.leaf.data[1] & \ | ||
387 | CSR1212_CPU_TO_BE32(~(CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET_MASK << \ | ||
388 | CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET_SHIFT))) | \ | ||
389 | CSR1212_CPU_TO_BE32(((char_set) & \ | ||
390 | CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET_MASK) << \ | ||
391 | CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET_SHIFT)) | ||
392 | #define CSR1212_TEXTUAL_DESCRIPTOR_LEAF_SET_LANGUAGE(kv, language) \ | ||
393 | ((kv)->value.leaf.data[1] = \ | ||
394 | ((kv)->value.leaf.data[1] & \ | ||
395 | CSR1212_CPU_TO_BE32(~(CSR1212_TEXTUAL_DESCRIPTOR_LEAF_LANGUAGE_MASK))) | \ | ||
396 | CSR1212_CPU_TO_BE32(((language) & \ | ||
397 | CSR1212_TEXTUAL_DESCRIPTOR_LEAF_LANGUAGE_MASK))) | ||
398 | |||
399 | |||
400 | /* Icon Descriptor Leaf manipulation macros */ | ||
401 | #define CSR1212_ICON_DESCRIPTOR_LEAF_VERSION_MASK 0xffffff | ||
402 | #define CSR1212_ICON_DESCRIPTOR_LEAF_PALETTE_DEPTH_SHIFT 30 | ||
403 | #define CSR1212_ICON_DESCRIPTOR_LEAF_PALETTE_DEPTH_MASK 0x3 /* after shift */ | ||
404 | #define CSR1212_ICON_DESCRIPTOR_LEAF_COLOR_SPACE_SHIFT 16 | ||
405 | #define CSR1212_ICON_DESCRIPTOR_LEAF_COLOR_SPACE_MASK 0xf /* after shift */ | ||
406 | #define CSR1212_ICON_DESCRIPTOR_LEAF_LANGUAGE_MASK 0xffff | ||
407 | #define CSR1212_ICON_DESCRIPTOR_LEAF_HSCAN_SHIFT 16 | ||
408 | #define CSR1212_ICON_DESCRIPTOR_LEAF_HSCAN_MASK 0xffff /* after shift */ | ||
409 | #define CSR1212_ICON_DESCRIPTOR_LEAF_VSCAN_MASK 0xffff | ||
410 | #define CSR1212_ICON_DESCRIPTOR_LEAF_OVERHEAD (3 * sizeof(u_int32_t)) | ||
411 | |||
412 | #define CSR1212_ICON_DESCRIPTOR_LEAF_VERSION(kv) \ | ||
413 | (CSR1212_BE32_TO_CPU((kv)->value.leaf.data[2]) & \ | ||
414 | CSR1212_ICON_DESCRIPTOR_LEAF_VERSION_MASK) | ||
415 | |||
416 | #define CSR1212_ICON_DESCRIPTOR_LEAF_PALETTE_DEPTH(kv) \ | ||
417 | (CSR1212_BE32_TO_CPU((kv)->value.leaf.data[3]) >> \ | ||
418 | CSR1212_ICON_DESCRIPTOR_LEAF_PALETTE_DEPTH_SHIFT) | ||
419 | |||
420 | #define CSR1212_ICON_DESCRIPTOR_LEAF_COLOR_SPACE(kv) \ | ||
421 | ((CSR1212_BE32_TO_CPU((kv)->value.leaf.data[3]) >> \ | ||
422 | CSR1212_ICON_DESCRIPTOR_LEAF_COLOR_SPACE_SHIFT) & \ | ||
423 | CSR1212_ICON_DESCRIPTOR_LEAF_COLOR_SPACE_MASK) | ||
424 | |||
425 | #define CSR1212_ICON_DESCRIPTOR_LEAF_LANGUAGE(kv) \ | ||
426 | (CSR1212_BE32_TO_CPU((kv)->value.leaf.data[3]) & \ | ||
427 | CSR1212_ICON_DESCRIPTOR_LEAF_LANGUAGE_MASK) | ||
428 | |||
429 | #define CSR1212_ICON_DESCRIPTOR_LEAF_HSCAN(kv) \ | ||
430 | ((CSR1212_BE32_TO_CPU((kv)->value.leaf.data[4]) >> \ | ||
431 | CSR1212_ICON_DESCRIPTOR_LEAF_COLOR_HSCAN_SHIFT) & \ | ||
432 | CSR1212_ICON_DESCRIPTOR_LEAF_COLOR_HSCAN_MASK) | ||
433 | |||
434 | #define CSR1212_ICON_DESCRIPTOR_LEAF_VSCAN(kv) \ | ||
435 | (CSR1212_BE32_TO_CPU((kv)->value.leaf.data[4]) & \ | ||
436 | CSR1212_ICON_DESCRIPTOR_LEAF_VSCAN_MASK) | ||
437 | |||
438 | #define CSR1212_ICON_DESCRIPTOR_LEAF_PALETTE(kv) \ | ||
439 | (&((kv)->value.leaf.data[5])) | ||
440 | |||
441 | static inline u_int32_t *CSR1212_ICON_DESCRIPTOR_LEAF_PIXELS(struct csr1212_keyval *kv) | ||
442 | { | ||
443 | static const int pd[4] = { 0, 4, 16, 256 }; | ||
444 | static const int cs[16] = { 4, 2 }; | ||
445 | int ps = pd[CSR1212_ICON_DESCRIPTOR_LEAF_PALETTE_DEPTH(kv)]; | ||
446 | |||
447 | return &kv->value.leaf.data[5 + | ||
448 | (ps * cs[CSR1212_ICON_DESCRIPTOR_LEAF_COLOR_SPACE(kv)]) / | ||
449 | sizeof(u_int32_t)]; | ||
450 | } | ||
451 | |||
452 | #define CSR1212_ICON_DESCRIPTOR_LEAF_SET_VERSION(kv, version) \ | ||
453 | ((kv)->value.leaf.data[2] = \ | ||
454 | ((kv)->value.leaf.data[2] & \ | ||
455 | CSR1212_CPU_TO_BE32(~(CSR1212_ICON_DESCRIPTOR_LEAF_VERSION_MASK))) | \ | ||
456 | CSR1212_CPU_TO_BE32(((version) & \ | ||
457 | CSR1212_ICON_DESCRIPTOR_LEAF_VERSION_MASK))) | ||
458 | |||
459 | #define CSR1212_ICON_DESCRIPTOR_LEAF_SET_PALETTE_DEPTH(kv, palette_depth) \ | ||
460 | ((kv)->value.leaf.data[3] = \ | ||
461 | ((kv)->value.leaf.data[3] & \ | ||
462 | CSR1212_CPU_TO_BE32(~(CSR1212_ICON_DESCRIPTOR_LEAF_PALETTE_DEPTH_MASK << \ | ||
463 | CSR1212_ICON_DESCRIPTOR_LEAF_PALETTE_DEPTH_SHIFT))) | \ | ||
464 | CSR1212_CPU_TO_BE32(((palette_depth) & \ | ||
465 | CSR1212_ICON_DESCRIPTOR_LEAF_PALETTE_DEPTH_MASK) << \ | ||
466 | CSR1212_ICON_DESCRIPTOR_LEAF_PALETTE_DEPTH_SHIFT)) | ||
467 | |||
468 | #define CSR1212_ICON_DESCRIPTOR_LEAF_SET_COLOR_SPACE(kv, color_space) \ | ||
469 | ((kv)->value.leaf.data[3] = \ | ||
470 | ((kv)->value.leaf.data[3] & \ | ||
471 | CSR1212_CPU_TO_BE32(~(CSR1212_ICON_DESCRIPTOR_LEAF_COLOR_SPACE_MASK << \ | ||
472 | CSR1212_ICON_DESCRIPTOR_LEAF_COLOR_SPACE_SHIFT))) | \ | ||
473 | CSR1212_CPU_TO_BE32(((color_space) & \ | ||
474 | CSR1212_ICON_DESCRIPTOR_LEAF_COLOR_SPACE_MASK) << \ | ||
475 | CSR1212_ICON_DESCRIPTOR_LEAF_COLOR_SPACE_SHIFT)) | ||
476 | |||
477 | #define CSR1212_ICON_DESCRIPTOR_LEAF_SET_LANGUAGE(kv, language) \ | ||
478 | ((kv)->value.leaf.data[3] = \ | ||
479 | ((kv)->value.leaf.data[3] & \ | ||
480 | CSR1212_CPU_TO_BE32(~(CSR1212_ICON_DESCRIPTOR_LEAF_LANGUAGE_MASK))) | \ | ||
481 | CSR1212_CPU_TO_BE32(((language) & \ | ||
482 | CSR1212_ICON_DESCRIPTOR_LEAF_LANGUAGE_MASK))) | ||
483 | |||
484 | #define CSR1212_ICON_DESCRIPTOR_LEAF_SET_HSCAN(kv, hscan) \ | ||
485 | ((kv)->value.leaf.data[4] = \ | ||
486 | ((kv)->value.leaf.data[4] & \ | ||
487 | CSR1212_CPU_TO_BE32(~(CSR1212_ICON_DESCRIPTOR_LEAF_HSCAN_MASK << \ | ||
488 | CSR1212_ICON_DESCRIPTOR_LEAF_HSCAN_SHIFT))) | \ | ||
489 | CSR1212_CPU_TO_BE32(((hscan) & \ | ||
490 | CSR1212_ICON_DESCRIPTOR_LEAF_HSCAN_MASK) << \ | ||
491 | CSR1212_ICON_DESCRIPTOR_LEAF_HSCAN_SHIFT)) | ||
492 | |||
493 | #define CSR1212_ICON_DESCRIPTOR_LEAF_SET_VSCAN(kv, vscan) \ | ||
494 | ((kv)->value.leaf.data[4] = \ | ||
495 | (((kv)->value.leaf.data[4] & \ | ||
496 | CSR1212_CPU_TO_BE32(~CSR1212_ICON_DESCRIPTOR_LEAF_VSCAN_MASK))) | \ | ||
497 | CSR1212_CPU_TO_BE32(((vscan) & \ | ||
498 | CSR1212_ICON_DESCRIPTOR_LEAF_VSCAN_MASK))) | ||
499 | |||
500 | |||
501 | /* Modifiable Descriptor Leaf manipulation macros */ | ||
502 | #define CSR1212_MODIFIABLE_DESCRIPTOR_LEAF_MAX_SIZE_SHIFT 16 | ||
503 | #define CSR1212_MODIFIABLE_DESCRIPTOR_LEAF_MAX_SIZE_MASK 0xffff | ||
504 | #define CSR1212_MODIFIABLE_DESCRIPTOR_LEAF_ADDR_HI_SHIFT 32 | ||
505 | #define CSR1212_MODIFIABLE_DESCRIPTOR_LEAF_ADDR_HI_MASK 0xffff | ||
506 | #define CSR1212_MODIFIABLE_DESCRIPTOR_LEAF_ADDR_LO_MASK 0xffffffffULL | ||
507 | |||
508 | #define CSR1212_MODIFIABLE_DESCRIPTOR_MAX_SIZE(kv) \ | ||
509 | CSR1212_BE16_TO_CPU((kv)->value.leaf.data[0] >> CSR1212_MODIFIABLE_DESCRIPTOR_MAX_SIZE_SHIFT) | ||
510 | |||
511 | #define CSR1212_MODIFIABLE_DESCRIPTOR_ADDRESS(kv) \ | ||
512 | (CSR1212_BE16_TO_CPU(((u_int64_t)((kv)->value.leaf.data[0])) << \ | ||
513 | CSR1212_MODIFIABLE_DESCRIPTOR_ADDR_HI_SHIFT) | \ | ||
514 | CSR1212_BE32_TO_CPU((kv)->value.leaf.data[1])) | ||
515 | |||
516 | #define CSR1212_MODIFIABLE_DESCRIPTOR_SET_MAX_SIZE(kv, size) \ | ||
517 | ((kv)->value.leaf.data[0] = \ | ||
518 | ((kv)->value.leaf.data[0] & \ | ||
519 | CSR1212_CPU_TO_BE32(~(CSR1212_MODIFIABLE_DESCRIPTOR_LEAF_MAX_SIZE_MASK << \ | ||
520 | CSR1212_MODIFIABLE_DESCRIPTOR_LEAF_MAX_SIZE_SHIFT))) | \ | ||
521 | CSR1212_CPU_TO_BE32(((size) & \ | ||
522 | CSR1212_MODIFIABLE_DESCRIPTOR_LEAF_MAX_SIZE_MASK) << \ | ||
523 | CSR1212_MODIFIABLE_DESCRIPTOR_LEAF_MAX_SIZE_SHIFT)) | ||
524 | |||
525 | #define CSR1212_MODIFIABLE_DESCRIPTOR_SET_ADDRESS_HI(kv, addr) \ | ||
526 | ((kv)->value.leaf.data[0] = \ | ||
527 | ((kv)->value.leaf.data[0] & \ | ||
528 | CSR1212_CPU_TO_BE32(~(CSR1212_MODIFIABLE_DESCRIPTOR_LEAF_ADDR_HI_MASK))) | \ | ||
529 | CSR1212_CPU_TO_BE32(((addr) & \ | ||
530 | CSR1212_MODIFIABLE_DESCRIPTOR_LEAF_ADDR_HI_MASK))) | ||
531 | |||
532 | #define CSR1212_MODIFIABLE_DESCRIPTOR_SET_ADDRESS_LO(kv, addr) \ | ||
533 | ((kv)->value.leaf.data[1] = \ | ||
534 | CSR1212_CPU_TO_BE32(addr & CSR1212_MODIFIABLE_DESCRIPTOR_LEAF_ADDR_LO_MASK)) | ||
535 | |||
536 | |||
537 | |||
538 | /* The following 2 function are for creating new Configuration ROM trees. The | ||
539 | * first function is used for both creating local trees and parsing remote | ||
540 | * trees. The second function adds pertinent information to local Configuration | ||
541 | * ROM trees - namely data for the bus information block. */ | ||
542 | extern struct csr1212_csr *csr1212_create_csr(struct csr1212_bus_ops *ops, | ||
543 | size_t bus_info_size, | ||
544 | void *private); | ||
545 | extern void csr1212_init_local_csr(struct csr1212_csr *csr, | ||
546 | const u_int32_t *bus_info_data, int max_rom); | ||
547 | |||
548 | |||
549 | /* The following function destroys a Configuration ROM tree and release all | ||
550 | * memory taken by the tree. */ | ||
551 | extern void csr1212_destroy_csr(struct csr1212_csr *csr); | ||
552 | |||
553 | |||
554 | /* The following set of functions are fore creating new keyvals for placement in | ||
555 | * a Configuration ROM tree. Code that creates new keyvals with these functions | ||
556 | * must release those keyvals with csr1212_release_keyval() when they are no | ||
557 | * longer needed. */ | ||
558 | extern struct csr1212_keyval *csr1212_new_immediate(u_int8_t key, u_int32_t value); | ||
559 | extern struct csr1212_keyval *csr1212_new_leaf(u_int8_t key, const void *data, | ||
560 | size_t data_len); | ||
561 | extern struct csr1212_keyval *csr1212_new_csr_offset(u_int8_t key, | ||
562 | u_int32_t csr_offset); | ||
563 | extern struct csr1212_keyval *csr1212_new_directory(u_int8_t key); | ||
564 | extern struct csr1212_keyval *csr1212_new_extended_immediate(u_int32_t spec, | ||
565 | u_int32_t key, | ||
566 | u_int32_t value); | ||
567 | extern struct csr1212_keyval *csr1212_new_extended_leaf(u_int32_t spec, | ||
568 | u_int32_t key, | ||
569 | const void *data, | ||
570 | size_t data_len); | ||
571 | extern struct csr1212_keyval *csr1212_new_descriptor_leaf(u_int8_t dtype, | ||
572 | u_int32_t specifier_id, | ||
573 | const void *data, | ||
574 | size_t data_len); | ||
575 | extern struct csr1212_keyval *csr1212_new_textual_descriptor_leaf(u_int8_t cwidth, | ||
576 | u_int16_t cset, | ||
577 | u_int16_t language, | ||
578 | const void *data, | ||
579 | size_t data_len); | ||
580 | extern struct csr1212_keyval *csr1212_new_string_descriptor_leaf(const char *s); | ||
581 | extern struct csr1212_keyval *csr1212_new_icon_descriptor_leaf(u_int32_t version, | ||
582 | u_int8_t palette_depth, | ||
583 | u_int8_t color_space, | ||
584 | u_int16_t language, | ||
585 | u_int16_t hscan, | ||
586 | u_int16_t vscan, | ||
587 | u_int32_t *palette, | ||
588 | u_int32_t *pixels); | ||
589 | extern struct csr1212_keyval *csr1212_new_modifiable_descriptor_leaf(u_int16_t max_size, | ||
590 | u_int64_t address); | ||
591 | extern struct csr1212_keyval *csr1212_new_keyword_leaf(int strc, | ||
592 | const char *strv[]); | ||
593 | |||
594 | |||
595 | /* The following functions manage association between keyvals. Typically, | ||
596 | * Descriptor Leaves and Directories will be associated with another keyval and | ||
597 | * it is desirable for the Descriptor keyval to be place immediately after the | ||
598 | * keyval that it is associated with.*/ | ||
599 | extern int csr1212_associate_keyval(struct csr1212_keyval *kv, | ||
600 | struct csr1212_keyval *associate); | ||
601 | extern void csr1212_disassociate_keyval(struct csr1212_keyval *kv); | ||
602 | |||
603 | |||
604 | /* The following functions manage the association of a keyval and directories. | ||
605 | * A keyval may be attached to more than one directory. */ | ||
606 | extern int csr1212_attach_keyval_to_directory(struct csr1212_keyval *dir, | ||
607 | struct csr1212_keyval *kv); | ||
608 | extern void csr1212_detach_keyval_from_directory(struct csr1212_keyval *dir, | ||
609 | struct csr1212_keyval *kv); | ||
610 | |||
611 | |||
612 | /* The following functions create a Configuration ROM image from the tree of | ||
613 | * keyvals provided. csr1212_generate_csr_image() creates a complete image in | ||
614 | * the list of caches available via csr->cache_head. The other functions are | ||
615 | * provided should there be a need to create a flat image without restrictions | ||
616 | * placed by IEEE 1212. */ | ||
617 | extern struct csr1212_keyval *csr1212_generate_positions(struct csr1212_csr_rom_cache *cache, | ||
618 | struct csr1212_keyval *start_kv, | ||
619 | int start_pos); | ||
620 | extern size_t csr1212_generate_layout_order(struct csr1212_keyval *kv); | ||
621 | extern void csr1212_fill_cache(struct csr1212_csr_rom_cache *cache); | ||
622 | extern int csr1212_generate_csr_image(struct csr1212_csr *csr); | ||
623 | |||
624 | |||
625 | /* This is a convience function for reading a block of data out of one of the | ||
626 | * caches in the csr->cache_head list. */ | ||
627 | extern int csr1212_read(struct csr1212_csr *csr, u_int32_t offset, void *buffer, | ||
628 | u_int32_t len); | ||
629 | |||
630 | |||
631 | /* The following functions are in place for parsing Configuration ROM images. | ||
632 | * csr1212_parse_keyval() is used should there be a need to directly parse a | ||
633 | * Configuration ROM directly. */ | ||
634 | extern int csr1212_parse_keyval(struct csr1212_keyval *kv, | ||
635 | struct csr1212_csr_rom_cache *cache); | ||
636 | extern int csr1212_parse_csr(struct csr1212_csr *csr); | ||
637 | |||
638 | /* These are internal functions referenced by inline functions below. */ | ||
639 | extern int _csr1212_read_keyval(struct csr1212_csr *csr, struct csr1212_keyval *kv); | ||
640 | extern void _csr1212_destroy_keyval(struct csr1212_keyval *kv); | ||
641 | |||
642 | |||
643 | /* This function allocates a new cache which may be used for either parsing or | ||
644 | * generating sub-sets of Configuration ROM images. */ | ||
645 | static inline struct csr1212_csr_rom_cache *csr1212_rom_cache_malloc(u_int32_t offset, | ||
646 | size_t size) | ||
647 | { | ||
648 | struct csr1212_csr_rom_cache *cache; | ||
649 | |||
650 | cache = CSR1212_MALLOC(sizeof(struct csr1212_csr_rom_cache) + size); | ||
651 | if (!cache) | ||
652 | return NULL; | ||
653 | |||
654 | cache->next = NULL; | ||
655 | cache->prev = NULL; | ||
656 | cache->filled_head = NULL; | ||
657 | cache->filled_tail = NULL; | ||
658 | cache->layout_head = NULL; | ||
659 | cache->layout_tail = NULL; | ||
660 | cache->offset = offset; | ||
661 | cache->size = size; | ||
662 | cache->ext_rom = NULL; | ||
663 | |||
664 | return cache; | ||
665 | } | ||
666 | |||
667 | |||
668 | /* This function ensures that a keyval contains data when referencing a keyval | ||
669 | * created by parsing a Configuration ROM. */ | ||
670 | static inline struct csr1212_keyval *csr1212_get_keyval(struct csr1212_csr *csr, | ||
671 | struct csr1212_keyval *kv) | ||
672 | { | ||
673 | if (!kv) | ||
674 | return NULL; | ||
675 | if (!kv->valid) | ||
676 | if (_csr1212_read_keyval(csr, kv) != CSR1212_SUCCESS) | ||
677 | return NULL; | ||
678 | return kv; | ||
679 | } | ||
680 | |||
681 | |||
682 | /* This function increments the reference count for a keyval should there be a | ||
683 | * need for code to retain a keyval that has been parsed. */ | ||
684 | static inline void csr1212_keep_keyval(struct csr1212_keyval *kv) | ||
685 | { | ||
686 | kv->refcnt++; | ||
687 | } | ||
688 | |||
689 | |||
690 | /* This function decrements a keyval's reference count and will destroy the | ||
691 | * keyval when there are no more users of the keyval. This should be called by | ||
692 | * any code that calls csr1212_keep_keyval() or any of the keyval creation | ||
693 | * routines csr1212_new_*(). */ | ||
694 | static inline void csr1212_release_keyval(struct csr1212_keyval *kv) | ||
695 | { | ||
696 | if (kv->refcnt > 1) | ||
697 | kv->refcnt--; | ||
698 | else | ||
699 | _csr1212_destroy_keyval(kv); | ||
700 | } | ||
701 | |||
702 | |||
703 | /* | ||
704 | * This macro allows for looping over the keyval entries in a directory and it | ||
705 | * ensures that keyvals from remote ConfigROMs are parsed properly. | ||
706 | * | ||
707 | * _csr is a struct csr1212_csr * that points to CSR associated with dir. | ||
708 | * _kv is a struct csr1212_keyval * that'll point to the current keyval (loop index). | ||
709 | * _dir is a struct csr1212_keyval * that points to the directory to be looped. | ||
710 | * _pos is a struct csr1212_dentry * that is used internally for indexing. | ||
711 | * | ||
712 | * kv will be NULL upon exit of the loop. | ||
713 | */ | ||
714 | #define csr1212_for_each_dir_entry(_csr, _kv, _dir, _pos) \ | ||
715 | for (csr1212_get_keyval((_csr), (_dir)), \ | ||
716 | _pos = (_dir)->value.directory.dentries_head, \ | ||
717 | _kv = (_pos) ? csr1212_get_keyval((_csr), _pos->kv) : NULL; \ | ||
718 | (_kv) && (_pos); \ | ||
719 | (_kv->associate == NULL) ? \ | ||
720 | ((_pos = _pos->next), \ | ||
721 | (_kv = (_pos) ? csr1212_get_keyval((_csr), _pos->kv) : \ | ||
722 | NULL)) : \ | ||
723 | (_kv = csr1212_get_keyval((_csr), _kv->associate))) | ||
724 | |||
725 | |||
726 | |||
727 | #endif /* __CSR1212_H__ */ | ||