Root/
1 | |
2 | #include <linux/device.h> |
3 | #include <linux/io.h> |
4 | #include <linux/ioport.h> |
5 | #include <linux/module.h> |
6 | #include <linux/of_address.h> |
7 | #include <linux/pci_regs.h> |
8 | #include <linux/string.h> |
9 | |
10 | /* Max address size we deal with */ |
11 | #define OF_MAX_ADDR_CELLS 4 |
12 | #define OF_CHECK_ADDR_COUNT(na) ((na) > 0 && (na) <= OF_MAX_ADDR_CELLS) |
13 | #define OF_CHECK_COUNTS(na, ns) (OF_CHECK_ADDR_COUNT(na) && (ns) > 0) |
14 | |
15 | static struct of_bus *of_match_bus(struct device_node *np); |
16 | static int __of_address_to_resource(struct device_node *dev, |
17 | const __be32 *addrp, u64 size, unsigned int flags, |
18 | const char *name, struct resource *r); |
19 | |
20 | /* Debug utility */ |
21 | #ifdef DEBUG |
22 | static void of_dump_addr(const char *s, const __be32 *addr, int na) |
23 | { |
24 | printk(KERN_DEBUG "%s", s); |
25 | while (na--) |
26 | printk(" %08x", be32_to_cpu(*(addr++))); |
27 | printk("\n"); |
28 | } |
29 | #else |
30 | static void of_dump_addr(const char *s, const __be32 *addr, int na) { } |
31 | #endif |
32 | |
33 | /* Callbacks for bus specific translators */ |
34 | struct of_bus { |
35 | const char *name; |
36 | const char *addresses; |
37 | int (*match)(struct device_node *parent); |
38 | void (*count_cells)(struct device_node *child, |
39 | int *addrc, int *sizec); |
40 | u64 (*map)(__be32 *addr, const __be32 *range, |
41 | int na, int ns, int pna); |
42 | int (*translate)(__be32 *addr, u64 offset, int na); |
43 | unsigned int (*get_flags)(const __be32 *addr); |
44 | }; |
45 | |
46 | /* |
47 | * Default translator (generic bus) |
48 | */ |
49 | |
50 | static void of_bus_default_count_cells(struct device_node *dev, |
51 | int *addrc, int *sizec) |
52 | { |
53 | if (addrc) |
54 | *addrc = of_n_addr_cells(dev); |
55 | if (sizec) |
56 | *sizec = of_n_size_cells(dev); |
57 | } |
58 | |
59 | static u64 of_bus_default_map(__be32 *addr, const __be32 *range, |
60 | int na, int ns, int pna) |
61 | { |
62 | u64 cp, s, da; |
63 | |
64 | cp = of_read_number(range, na); |
65 | s = of_read_number(range + na + pna, ns); |
66 | da = of_read_number(addr, na); |
67 | |
68 | pr_debug("OF: default map, cp=%llx, s=%llx, da=%llx\n", |
69 | (unsigned long long)cp, (unsigned long long)s, |
70 | (unsigned long long)da); |
71 | |
72 | /* |
73 | * If the number of address cells is larger than 2 we assume the |
74 | * mapping doesn't specify a physical address. Rather, the address |
75 | * specifies an identifier that must match exactly. |
76 | */ |
77 | if (na > 2 && memcmp(range, addr, na * 4) != 0) |
78 | return OF_BAD_ADDR; |
79 | |
80 | if (da < cp || da >= (cp + s)) |
81 | return OF_BAD_ADDR; |
82 | return da - cp; |
83 | } |
84 | |
85 | static int of_bus_default_translate(__be32 *addr, u64 offset, int na) |
86 | { |
87 | u64 a = of_read_number(addr, na); |
88 | memset(addr, 0, na * 4); |
89 | a += offset; |
90 | if (na > 1) |
91 | addr[na - 2] = cpu_to_be32(a >> 32); |
92 | addr[na - 1] = cpu_to_be32(a & 0xffffffffu); |
93 | |
94 | return 0; |
95 | } |
96 | |
97 | static unsigned int of_bus_default_get_flags(const __be32 *addr) |
98 | { |
99 | return IORESOURCE_MEM; |
100 | } |
101 | |
102 | #ifdef CONFIG_PCI |
103 | /* |
104 | * PCI bus specific translator |
105 | */ |
106 | |
107 | static int of_bus_pci_match(struct device_node *np) |
108 | { |
109 | /* "vci" is for the /chaos bridge on 1st-gen PCI powermacs */ |
110 | return !strcmp(np->type, "pci") || !strcmp(np->type, "vci"); |
111 | } |
112 | |
113 | static void of_bus_pci_count_cells(struct device_node *np, |
114 | int *addrc, int *sizec) |
115 | { |
116 | if (addrc) |
117 | *addrc = 3; |
118 | if (sizec) |
119 | *sizec = 2; |
120 | } |
121 | |
122 | static unsigned int of_bus_pci_get_flags(const __be32 *addr) |
123 | { |
124 | unsigned int flags = 0; |
125 | u32 w = be32_to_cpup(addr); |
126 | |
127 | switch((w >> 24) & 0x03) { |
128 | case 0x01: |
129 | flags |= IORESOURCE_IO; |
130 | break; |
131 | case 0x02: /* 32 bits */ |
132 | case 0x03: /* 64 bits */ |
133 | flags |= IORESOURCE_MEM; |
134 | break; |
135 | } |
136 | if (w & 0x40000000) |
137 | flags |= IORESOURCE_PREFETCH; |
138 | return flags; |
139 | } |
140 | |
141 | static u64 of_bus_pci_map(__be32 *addr, const __be32 *range, int na, int ns, |
142 | int pna) |
143 | { |
144 | u64 cp, s, da; |
145 | unsigned int af, rf; |
146 | |
147 | af = of_bus_pci_get_flags(addr); |
148 | rf = of_bus_pci_get_flags(range); |
149 | |
150 | /* Check address type match */ |
151 | if ((af ^ rf) & (IORESOURCE_MEM | IORESOURCE_IO)) |
152 | return OF_BAD_ADDR; |
153 | |
154 | /* Read address values, skipping high cell */ |
155 | cp = of_read_number(range + 1, na - 1); |
156 | s = of_read_number(range + na + pna, ns); |
157 | da = of_read_number(addr + 1, na - 1); |
158 | |
159 | pr_debug("OF: PCI map, cp=%llx, s=%llx, da=%llx\n", |
160 | (unsigned long long)cp, (unsigned long long)s, |
161 | (unsigned long long)da); |
162 | |
163 | if (da < cp || da >= (cp + s)) |
164 | return OF_BAD_ADDR; |
165 | return da - cp; |
166 | } |
167 | |
168 | static int of_bus_pci_translate(__be32 *addr, u64 offset, int na) |
169 | { |
170 | return of_bus_default_translate(addr + 1, offset, na - 1); |
171 | } |
172 | |
173 | const __be32 *of_get_pci_address(struct device_node *dev, int bar_no, u64 *size, |
174 | unsigned int *flags) |
175 | { |
176 | const __be32 *prop; |
177 | unsigned int psize; |
178 | struct device_node *parent; |
179 | struct of_bus *bus; |
180 | int onesize, i, na, ns; |
181 | |
182 | /* Get parent & match bus type */ |
183 | parent = of_get_parent(dev); |
184 | if (parent == NULL) |
185 | return NULL; |
186 | bus = of_match_bus(parent); |
187 | if (strcmp(bus->name, "pci")) { |
188 | of_node_put(parent); |
189 | return NULL; |
190 | } |
191 | bus->count_cells(dev, &na, &ns); |
192 | of_node_put(parent); |
193 | if (!OF_CHECK_ADDR_COUNT(na)) |
194 | return NULL; |
195 | |
196 | /* Get "reg" or "assigned-addresses" property */ |
197 | prop = of_get_property(dev, bus->addresses, &psize); |
198 | if (prop == NULL) |
199 | return NULL; |
200 | psize /= 4; |
201 | |
202 | onesize = na + ns; |
203 | for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) { |
204 | u32 val = be32_to_cpu(prop[0]); |
205 | if ((val & 0xff) == ((bar_no * 4) + PCI_BASE_ADDRESS_0)) { |
206 | if (size) |
207 | *size = of_read_number(prop + na, ns); |
208 | if (flags) |
209 | *flags = bus->get_flags(prop); |
210 | return prop; |
211 | } |
212 | } |
213 | return NULL; |
214 | } |
215 | EXPORT_SYMBOL(of_get_pci_address); |
216 | |
217 | int of_pci_address_to_resource(struct device_node *dev, int bar, |
218 | struct resource *r) |
219 | { |
220 | const __be32 *addrp; |
221 | u64 size; |
222 | unsigned int flags; |
223 | |
224 | addrp = of_get_pci_address(dev, bar, &size, &flags); |
225 | if (addrp == NULL) |
226 | return -EINVAL; |
227 | return __of_address_to_resource(dev, addrp, size, flags, NULL, r); |
228 | } |
229 | EXPORT_SYMBOL_GPL(of_pci_address_to_resource); |
230 | #endif /* CONFIG_PCI */ |
231 | |
232 | /* |
233 | * ISA bus specific translator |
234 | */ |
235 | |
236 | static int of_bus_isa_match(struct device_node *np) |
237 | { |
238 | return !strcmp(np->name, "isa"); |
239 | } |
240 | |
241 | static void of_bus_isa_count_cells(struct device_node *child, |
242 | int *addrc, int *sizec) |
243 | { |
244 | if (addrc) |
245 | *addrc = 2; |
246 | if (sizec) |
247 | *sizec = 1; |
248 | } |
249 | |
250 | static u64 of_bus_isa_map(__be32 *addr, const __be32 *range, int na, int ns, |
251 | int pna) |
252 | { |
253 | u64 cp, s, da; |
254 | |
255 | /* Check address type match */ |
256 | if ((addr[0] ^ range[0]) & cpu_to_be32(1)) |
257 | return OF_BAD_ADDR; |
258 | |
259 | /* Read address values, skipping high cell */ |
260 | cp = of_read_number(range + 1, na - 1); |
261 | s = of_read_number(range + na + pna, ns); |
262 | da = of_read_number(addr + 1, na - 1); |
263 | |
264 | pr_debug("OF: ISA map, cp=%llx, s=%llx, da=%llx\n", |
265 | (unsigned long long)cp, (unsigned long long)s, |
266 | (unsigned long long)da); |
267 | |
268 | if (da < cp || da >= (cp + s)) |
269 | return OF_BAD_ADDR; |
270 | return da - cp; |
271 | } |
272 | |
273 | static int of_bus_isa_translate(__be32 *addr, u64 offset, int na) |
274 | { |
275 | return of_bus_default_translate(addr + 1, offset, na - 1); |
276 | } |
277 | |
278 | static unsigned int of_bus_isa_get_flags(const __be32 *addr) |
279 | { |
280 | unsigned int flags = 0; |
281 | u32 w = be32_to_cpup(addr); |
282 | |
283 | if (w & 1) |
284 | flags |= IORESOURCE_IO; |
285 | else |
286 | flags |= IORESOURCE_MEM; |
287 | return flags; |
288 | } |
289 | |
290 | /* |
291 | * Array of bus specific translators |
292 | */ |
293 | |
294 | static struct of_bus of_busses[] = { |
295 | #ifdef CONFIG_PCI |
296 | /* PCI */ |
297 | { |
298 | .name = "pci", |
299 | .addresses = "assigned-addresses", |
300 | .match = of_bus_pci_match, |
301 | .count_cells = of_bus_pci_count_cells, |
302 | .map = of_bus_pci_map, |
303 | .translate = of_bus_pci_translate, |
304 | .get_flags = of_bus_pci_get_flags, |
305 | }, |
306 | #endif /* CONFIG_PCI */ |
307 | /* ISA */ |
308 | { |
309 | .name = "isa", |
310 | .addresses = "reg", |
311 | .match = of_bus_isa_match, |
312 | .count_cells = of_bus_isa_count_cells, |
313 | .map = of_bus_isa_map, |
314 | .translate = of_bus_isa_translate, |
315 | .get_flags = of_bus_isa_get_flags, |
316 | }, |
317 | /* Default */ |
318 | { |
319 | .name = "default", |
320 | .addresses = "reg", |
321 | .match = NULL, |
322 | .count_cells = of_bus_default_count_cells, |
323 | .map = of_bus_default_map, |
324 | .translate = of_bus_default_translate, |
325 | .get_flags = of_bus_default_get_flags, |
326 | }, |
327 | }; |
328 | |
329 | static struct of_bus *of_match_bus(struct device_node *np) |
330 | { |
331 | int i; |
332 | |
333 | for (i = 0; i < ARRAY_SIZE(of_busses); i++) |
334 | if (!of_busses[i].match || of_busses[i].match(np)) |
335 | return &of_busses[i]; |
336 | BUG(); |
337 | return NULL; |
338 | } |
339 | |
340 | static int of_translate_one(struct device_node *parent, struct of_bus *bus, |
341 | struct of_bus *pbus, __be32 *addr, |
342 | int na, int ns, int pna, const char *rprop) |
343 | { |
344 | const __be32 *ranges; |
345 | unsigned int rlen; |
346 | int rone; |
347 | u64 offset = OF_BAD_ADDR; |
348 | |
349 | /* Normally, an absence of a "ranges" property means we are |
350 | * crossing a non-translatable boundary, and thus the addresses |
351 | * below the current not cannot be converted to CPU physical ones. |
352 | * Unfortunately, while this is very clear in the spec, it's not |
353 | * what Apple understood, and they do have things like /uni-n or |
354 | * /ht nodes with no "ranges" property and a lot of perfectly |
355 | * useable mapped devices below them. Thus we treat the absence of |
356 | * "ranges" as equivalent to an empty "ranges" property which means |
357 | * a 1:1 translation at that level. It's up to the caller not to try |
358 | * to translate addresses that aren't supposed to be translated in |
359 | * the first place. --BenH. |
360 | * |
361 | * As far as we know, this damage only exists on Apple machines, so |
362 | * This code is only enabled on powerpc. --gcl |
363 | */ |
364 | ranges = of_get_property(parent, rprop, &rlen); |
365 | #if !defined(CONFIG_PPC) |
366 | if (ranges == NULL) { |
367 | pr_err("OF: no ranges; cannot translate\n"); |
368 | return 1; |
369 | } |
370 | #endif /* !defined(CONFIG_PPC) */ |
371 | if (ranges == NULL || rlen == 0) { |
372 | offset = of_read_number(addr, na); |
373 | memset(addr, 0, pna * 4); |
374 | pr_debug("OF: empty ranges; 1:1 translation\n"); |
375 | goto finish; |
376 | } |
377 | |
378 | pr_debug("OF: walking ranges...\n"); |
379 | |
380 | /* Now walk through the ranges */ |
381 | rlen /= 4; |
382 | rone = na + pna + ns; |
383 | for (; rlen >= rone; rlen -= rone, ranges += rone) { |
384 | offset = bus->map(addr, ranges, na, ns, pna); |
385 | if (offset != OF_BAD_ADDR) |
386 | break; |
387 | } |
388 | if (offset == OF_BAD_ADDR) { |
389 | pr_debug("OF: not found !\n"); |
390 | return 1; |
391 | } |
392 | memcpy(addr, ranges + na, 4 * pna); |
393 | |
394 | finish: |
395 | of_dump_addr("OF: parent translation for:", addr, pna); |
396 | pr_debug("OF: with offset: %llx\n", (unsigned long long)offset); |
397 | |
398 | /* Translate it into parent bus space */ |
399 | return pbus->translate(addr, offset, pna); |
400 | } |
401 | |
402 | /* |
403 | * Translate an address from the device-tree into a CPU physical address, |
404 | * this walks up the tree and applies the various bus mappings on the |
405 | * way. |
406 | * |
407 | * Note: We consider that crossing any level with #size-cells == 0 to mean |
408 | * that translation is impossible (that is we are not dealing with a value |
409 | * that can be mapped to a cpu physical address). This is not really specified |
410 | * that way, but this is traditionally the way IBM at least do things |
411 | */ |
412 | static u64 __of_translate_address(struct device_node *dev, |
413 | const __be32 *in_addr, const char *rprop) |
414 | { |
415 | struct device_node *parent = NULL; |
416 | struct of_bus *bus, *pbus; |
417 | __be32 addr[OF_MAX_ADDR_CELLS]; |
418 | int na, ns, pna, pns; |
419 | u64 result = OF_BAD_ADDR; |
420 | |
421 | pr_debug("OF: ** translation for device %s **\n", dev->full_name); |
422 | |
423 | /* Increase refcount at current level */ |
424 | of_node_get(dev); |
425 | |
426 | /* Get parent & match bus type */ |
427 | parent = of_get_parent(dev); |
428 | if (parent == NULL) |
429 | goto bail; |
430 | bus = of_match_bus(parent); |
431 | |
432 | /* Count address cells & copy address locally */ |
433 | bus->count_cells(dev, &na, &ns); |
434 | if (!OF_CHECK_COUNTS(na, ns)) { |
435 | printk(KERN_ERR "prom_parse: Bad cell count for %s\n", |
436 | dev->full_name); |
437 | goto bail; |
438 | } |
439 | memcpy(addr, in_addr, na * 4); |
440 | |
441 | pr_debug("OF: bus is %s (na=%d, ns=%d) on %s\n", |
442 | bus->name, na, ns, parent->full_name); |
443 | of_dump_addr("OF: translating address:", addr, na); |
444 | |
445 | /* Translate */ |
446 | for (;;) { |
447 | /* Switch to parent bus */ |
448 | of_node_put(dev); |
449 | dev = parent; |
450 | parent = of_get_parent(dev); |
451 | |
452 | /* If root, we have finished */ |
453 | if (parent == NULL) { |
454 | pr_debug("OF: reached root node\n"); |
455 | result = of_read_number(addr, na); |
456 | break; |
457 | } |
458 | |
459 | /* Get new parent bus and counts */ |
460 | pbus = of_match_bus(parent); |
461 | pbus->count_cells(dev, &pna, &pns); |
462 | if (!OF_CHECK_COUNTS(pna, pns)) { |
463 | printk(KERN_ERR "prom_parse: Bad cell count for %s\n", |
464 | dev->full_name); |
465 | break; |
466 | } |
467 | |
468 | pr_debug("OF: parent bus is %s (na=%d, ns=%d) on %s\n", |
469 | pbus->name, pna, pns, parent->full_name); |
470 | |
471 | /* Apply bus translation */ |
472 | if (of_translate_one(dev, bus, pbus, addr, na, ns, pna, rprop)) |
473 | break; |
474 | |
475 | /* Complete the move up one level */ |
476 | na = pna; |
477 | ns = pns; |
478 | bus = pbus; |
479 | |
480 | of_dump_addr("OF: one level translation:", addr, na); |
481 | } |
482 | bail: |
483 | of_node_put(parent); |
484 | of_node_put(dev); |
485 | |
486 | return result; |
487 | } |
488 | |
489 | u64 of_translate_address(struct device_node *dev, const __be32 *in_addr) |
490 | { |
491 | return __of_translate_address(dev, in_addr, "ranges"); |
492 | } |
493 | EXPORT_SYMBOL(of_translate_address); |
494 | |
495 | u64 of_translate_dma_address(struct device_node *dev, const __be32 *in_addr) |
496 | { |
497 | return __of_translate_address(dev, in_addr, "dma-ranges"); |
498 | } |
499 | EXPORT_SYMBOL(of_translate_dma_address); |
500 | |
501 | bool of_can_translate_address(struct device_node *dev) |
502 | { |
503 | struct device_node *parent; |
504 | struct of_bus *bus; |
505 | int na, ns; |
506 | |
507 | parent = of_get_parent(dev); |
508 | if (parent == NULL) |
509 | return false; |
510 | |
511 | bus = of_match_bus(parent); |
512 | bus->count_cells(dev, &na, &ns); |
513 | |
514 | of_node_put(parent); |
515 | |
516 | return OF_CHECK_COUNTS(na, ns); |
517 | } |
518 | EXPORT_SYMBOL(of_can_translate_address); |
519 | |
520 | const __be32 *of_get_address(struct device_node *dev, int index, u64 *size, |
521 | unsigned int *flags) |
522 | { |
523 | const __be32 *prop; |
524 | unsigned int psize; |
525 | struct device_node *parent; |
526 | struct of_bus *bus; |
527 | int onesize, i, na, ns; |
528 | |
529 | /* Get parent & match bus type */ |
530 | parent = of_get_parent(dev); |
531 | if (parent == NULL) |
532 | return NULL; |
533 | bus = of_match_bus(parent); |
534 | bus->count_cells(dev, &na, &ns); |
535 | of_node_put(parent); |
536 | if (!OF_CHECK_ADDR_COUNT(na)) |
537 | return NULL; |
538 | |
539 | /* Get "reg" or "assigned-addresses" property */ |
540 | prop = of_get_property(dev, bus->addresses, &psize); |
541 | if (prop == NULL) |
542 | return NULL; |
543 | psize /= 4; |
544 | |
545 | onesize = na + ns; |
546 | for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) |
547 | if (i == index) { |
548 | if (size) |
549 | *size = of_read_number(prop + na, ns); |
550 | if (flags) |
551 | *flags = bus->get_flags(prop); |
552 | return prop; |
553 | } |
554 | return NULL; |
555 | } |
556 | EXPORT_SYMBOL(of_get_address); |
557 | |
558 | static int __of_address_to_resource(struct device_node *dev, |
559 | const __be32 *addrp, u64 size, unsigned int flags, |
560 | const char *name, struct resource *r) |
561 | { |
562 | u64 taddr; |
563 | |
564 | if ((flags & (IORESOURCE_IO | IORESOURCE_MEM)) == 0) |
565 | return -EINVAL; |
566 | taddr = of_translate_address(dev, addrp); |
567 | if (taddr == OF_BAD_ADDR) |
568 | return -EINVAL; |
569 | memset(r, 0, sizeof(struct resource)); |
570 | if (flags & IORESOURCE_IO) { |
571 | unsigned long port; |
572 | port = pci_address_to_pio(taddr); |
573 | if (port == (unsigned long)-1) |
574 | return -EINVAL; |
575 | r->start = port; |
576 | r->end = port + size - 1; |
577 | } else { |
578 | r->start = taddr; |
579 | r->end = taddr + size - 1; |
580 | } |
581 | r->flags = flags; |
582 | r->name = name ? name : dev->full_name; |
583 | |
584 | return 0; |
585 | } |
586 | |
587 | /** |
588 | * of_address_to_resource - Translate device tree address and return as resource |
589 | * |
590 | * Note that if your address is a PIO address, the conversion will fail if |
591 | * the physical address can't be internally converted to an IO token with |
592 | * pci_address_to_pio(), that is because it's either called to early or it |
593 | * can't be matched to any host bridge IO space |
594 | */ |
595 | int of_address_to_resource(struct device_node *dev, int index, |
596 | struct resource *r) |
597 | { |
598 | const __be32 *addrp; |
599 | u64 size; |
600 | unsigned int flags; |
601 | const char *name = NULL; |
602 | |
603 | addrp = of_get_address(dev, index, &size, &flags); |
604 | if (addrp == NULL) |
605 | return -EINVAL; |
606 | |
607 | /* Get optional "reg-names" property to add a name to a resource */ |
608 | of_property_read_string_index(dev, "reg-names", index, &name); |
609 | |
610 | return __of_address_to_resource(dev, addrp, size, flags, name, r); |
611 | } |
612 | EXPORT_SYMBOL_GPL(of_address_to_resource); |
613 | |
614 | struct device_node *of_find_matching_node_by_address(struct device_node *from, |
615 | const struct of_device_id *matches, |
616 | u64 base_address) |
617 | { |
618 | struct device_node *dn = of_find_matching_node(from, matches); |
619 | struct resource res; |
620 | |
621 | while (dn) { |
622 | if (of_address_to_resource(dn, 0, &res)) |
623 | continue; |
624 | if (res.start == base_address) |
625 | return dn; |
626 | dn = of_find_matching_node(dn, matches); |
627 | } |
628 | |
629 | return NULL; |
630 | } |
631 | |
632 | |
633 | /** |
634 | * of_iomap - Maps the memory mapped IO for a given device_node |
635 | * @device: the device whose io range will be mapped |
636 | * @index: index of the io range |
637 | * |
638 | * Returns a pointer to the mapped memory |
639 | */ |
640 | void __iomem *of_iomap(struct device_node *np, int index) |
641 | { |
642 | struct resource res; |
643 | |
644 | if (of_address_to_resource(np, index, &res)) |
645 | return NULL; |
646 | |
647 | return ioremap(res.start, resource_size(&res)); |
648 | } |
649 | EXPORT_SYMBOL(of_iomap); |
650 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9