Root/
1 | /* |
2 | * PS3 Disk Storage Driver |
3 | * |
4 | * Copyright (C) 2007 Sony Computer Entertainment Inc. |
5 | * Copyright 2007 Sony Corp. |
6 | * |
7 | * This program is free software; you can redistribute it and/or modify it |
8 | * under the terms of the GNU General Public License as published |
9 | * by the Free Software Foundation; version 2 of the License. |
10 | * |
11 | * This program is distributed in the hope that it will be useful, but |
12 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 | * General Public License for more details. |
15 | * |
16 | * You should have received a copy of the GNU General Public License along |
17 | * with this program; if not, write to the Free Software Foundation, Inc., |
18 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
19 | */ |
20 | |
21 | #include <linux/ata.h> |
22 | #include <linux/blkdev.h> |
23 | #include <linux/slab.h> |
24 | #include <linux/module.h> |
25 | |
26 | #include <asm/lv1call.h> |
27 | #include <asm/ps3stor.h> |
28 | #include <asm/firmware.h> |
29 | |
30 | |
31 | #define DEVICE_NAME "ps3disk" |
32 | |
33 | #define BOUNCE_SIZE (64*1024) |
34 | |
35 | #define PS3DISK_MAX_DISKS 16 |
36 | #define PS3DISK_MINORS 16 |
37 | |
38 | |
39 | #define PS3DISK_NAME "ps3d%c" |
40 | |
41 | |
42 | struct ps3disk_private { |
43 | spinlock_t lock; /* Request queue spinlock */ |
44 | struct request_queue *queue; |
45 | struct gendisk *gendisk; |
46 | unsigned int blocking_factor; |
47 | struct request *req; |
48 | u64 raw_capacity; |
49 | unsigned char model[ATA_ID_PROD_LEN+1]; |
50 | }; |
51 | |
52 | |
53 | #define LV1_STORAGE_SEND_ATA_COMMAND (2) |
54 | #define LV1_STORAGE_ATA_HDDOUT (0x23) |
55 | |
56 | struct lv1_ata_cmnd_block { |
57 | u16 features; |
58 | u16 sector_count; |
59 | u16 LBA_low; |
60 | u16 LBA_mid; |
61 | u16 LBA_high; |
62 | u8 device; |
63 | u8 command; |
64 | u32 is_ext; |
65 | u32 proto; |
66 | u32 in_out; |
67 | u32 size; |
68 | u64 buffer; |
69 | u32 arglen; |
70 | }; |
71 | |
72 | enum lv1_ata_proto { |
73 | NON_DATA_PROTO = 0, |
74 | PIO_DATA_IN_PROTO = 1, |
75 | PIO_DATA_OUT_PROTO = 2, |
76 | DMA_PROTO = 3 |
77 | }; |
78 | |
79 | enum lv1_ata_in_out { |
80 | DIR_WRITE = 0, /* memory -> device */ |
81 | DIR_READ = 1 /* device -> memory */ |
82 | }; |
83 | |
84 | static int ps3disk_major; |
85 | |
86 | |
87 | static const struct block_device_operations ps3disk_fops = { |
88 | .owner = THIS_MODULE, |
89 | }; |
90 | |
91 | |
92 | static void ps3disk_scatter_gather(struct ps3_storage_device *dev, |
93 | struct request *req, int gather) |
94 | { |
95 | unsigned int offset = 0; |
96 | struct req_iterator iter; |
97 | struct bio_vec *bvec; |
98 | unsigned int i = 0; |
99 | size_t size; |
100 | void *buf; |
101 | |
102 | rq_for_each_segment(bvec, req, iter) { |
103 | unsigned long flags; |
104 | dev_dbg(&dev->sbd.core, |
105 | "%s:%u: bio %u: %u segs %u sectors from %lu\n", |
106 | __func__, __LINE__, i, bio_segments(iter.bio), |
107 | bio_sectors(iter.bio), iter.bio->bi_sector); |
108 | |
109 | size = bvec->bv_len; |
110 | buf = bvec_kmap_irq(bvec, &flags); |
111 | if (gather) |
112 | memcpy(dev->bounce_buf+offset, buf, size); |
113 | else |
114 | memcpy(buf, dev->bounce_buf+offset, size); |
115 | offset += size; |
116 | flush_kernel_dcache_page(bvec->bv_page); |
117 | bvec_kunmap_irq(buf, &flags); |
118 | i++; |
119 | } |
120 | } |
121 | |
122 | static int ps3disk_submit_request_sg(struct ps3_storage_device *dev, |
123 | struct request *req) |
124 | { |
125 | struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd); |
126 | int write = rq_data_dir(req), res; |
127 | const char *op = write ? "write" : "read"; |
128 | u64 start_sector, sectors; |
129 | unsigned int region_id = dev->regions[dev->region_idx].id; |
130 | |
131 | #ifdef DEBUG |
132 | unsigned int n = 0; |
133 | struct bio_vec *bv; |
134 | struct req_iterator iter; |
135 | |
136 | rq_for_each_segment(bv, req, iter) |
137 | n++; |
138 | dev_dbg(&dev->sbd.core, |
139 | "%s:%u: %s req has %u bvecs for %u sectors\n", |
140 | __func__, __LINE__, op, n, blk_rq_sectors(req)); |
141 | #endif |
142 | |
143 | start_sector = blk_rq_pos(req) * priv->blocking_factor; |
144 | sectors = blk_rq_sectors(req) * priv->blocking_factor; |
145 | dev_dbg(&dev->sbd.core, "%s:%u: %s %llu sectors starting at %llu\n", |
146 | __func__, __LINE__, op, sectors, start_sector); |
147 | |
148 | if (write) { |
149 | ps3disk_scatter_gather(dev, req, 1); |
150 | |
151 | res = lv1_storage_write(dev->sbd.dev_id, region_id, |
152 | start_sector, sectors, 0, |
153 | dev->bounce_lpar, &dev->tag); |
154 | } else { |
155 | res = lv1_storage_read(dev->sbd.dev_id, region_id, |
156 | start_sector, sectors, 0, |
157 | dev->bounce_lpar, &dev->tag); |
158 | } |
159 | if (res) { |
160 | dev_err(&dev->sbd.core, "%s:%u: %s failed %d\n", __func__, |
161 | __LINE__, op, res); |
162 | __blk_end_request_all(req, -EIO); |
163 | return 0; |
164 | } |
165 | |
166 | priv->req = req; |
167 | return 1; |
168 | } |
169 | |
170 | static int ps3disk_submit_flush_request(struct ps3_storage_device *dev, |
171 | struct request *req) |
172 | { |
173 | struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd); |
174 | u64 res; |
175 | |
176 | dev_dbg(&dev->sbd.core, "%s:%u: flush request\n", __func__, __LINE__); |
177 | |
178 | res = lv1_storage_send_device_command(dev->sbd.dev_id, |
179 | LV1_STORAGE_ATA_HDDOUT, 0, 0, 0, |
180 | 0, &dev->tag); |
181 | if (res) { |
182 | dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%llx\n", |
183 | __func__, __LINE__, res); |
184 | __blk_end_request_all(req, -EIO); |
185 | return 0; |
186 | } |
187 | |
188 | priv->req = req; |
189 | return 1; |
190 | } |
191 | |
192 | static void ps3disk_do_request(struct ps3_storage_device *dev, |
193 | struct request_queue *q) |
194 | { |
195 | struct request *req; |
196 | |
197 | dev_dbg(&dev->sbd.core, "%s:%u\n", __func__, __LINE__); |
198 | |
199 | while ((req = blk_fetch_request(q))) { |
200 | if (req->cmd_flags & REQ_FLUSH) { |
201 | if (ps3disk_submit_flush_request(dev, req)) |
202 | break; |
203 | } else if (req->cmd_type == REQ_TYPE_FS) { |
204 | if (ps3disk_submit_request_sg(dev, req)) |
205 | break; |
206 | } else { |
207 | blk_dump_rq_flags(req, DEVICE_NAME " bad request"); |
208 | __blk_end_request_all(req, -EIO); |
209 | continue; |
210 | } |
211 | } |
212 | } |
213 | |
214 | static void ps3disk_request(struct request_queue *q) |
215 | { |
216 | struct ps3_storage_device *dev = q->queuedata; |
217 | struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd); |
218 | |
219 | if (priv->req) { |
220 | dev_dbg(&dev->sbd.core, "%s:%u busy\n", __func__, __LINE__); |
221 | return; |
222 | } |
223 | |
224 | ps3disk_do_request(dev, q); |
225 | } |
226 | |
227 | static irqreturn_t ps3disk_interrupt(int irq, void *data) |
228 | { |
229 | struct ps3_storage_device *dev = data; |
230 | struct ps3disk_private *priv; |
231 | struct request *req; |
232 | int res, read, error; |
233 | u64 tag, status; |
234 | const char *op; |
235 | |
236 | res = lv1_storage_get_async_status(dev->sbd.dev_id, &tag, &status); |
237 | |
238 | if (tag != dev->tag) |
239 | dev_err(&dev->sbd.core, |
240 | "%s:%u: tag mismatch, got %llx, expected %llx\n", |
241 | __func__, __LINE__, tag, dev->tag); |
242 | |
243 | if (res) { |
244 | dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%llx\n", |
245 | __func__, __LINE__, res, status); |
246 | return IRQ_HANDLED; |
247 | } |
248 | |
249 | priv = ps3_system_bus_get_drvdata(&dev->sbd); |
250 | req = priv->req; |
251 | if (!req) { |
252 | dev_dbg(&dev->sbd.core, |
253 | "%s:%u non-block layer request completed\n", __func__, |
254 | __LINE__); |
255 | dev->lv1_status = status; |
256 | complete(&dev->done); |
257 | return IRQ_HANDLED; |
258 | } |
259 | |
260 | if (req->cmd_flags & REQ_FLUSH) { |
261 | read = 0; |
262 | op = "flush"; |
263 | } else { |
264 | read = !rq_data_dir(req); |
265 | op = read ? "read" : "write"; |
266 | } |
267 | if (status) { |
268 | dev_dbg(&dev->sbd.core, "%s:%u: %s failed 0x%llx\n", __func__, |
269 | __LINE__, op, status); |
270 | error = -EIO; |
271 | } else { |
272 | dev_dbg(&dev->sbd.core, "%s:%u: %s completed\n", __func__, |
273 | __LINE__, op); |
274 | error = 0; |
275 | if (read) |
276 | ps3disk_scatter_gather(dev, req, 0); |
277 | } |
278 | |
279 | spin_lock(&priv->lock); |
280 | __blk_end_request_all(req, error); |
281 | priv->req = NULL; |
282 | ps3disk_do_request(dev, priv->queue); |
283 | spin_unlock(&priv->lock); |
284 | |
285 | return IRQ_HANDLED; |
286 | } |
287 | |
288 | static int ps3disk_sync_cache(struct ps3_storage_device *dev) |
289 | { |
290 | u64 res; |
291 | |
292 | dev_dbg(&dev->sbd.core, "%s:%u: sync cache\n", __func__, __LINE__); |
293 | |
294 | res = ps3stor_send_command(dev, LV1_STORAGE_ATA_HDDOUT, 0, 0, 0, 0); |
295 | if (res) { |
296 | dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%llx\n", |
297 | __func__, __LINE__, res); |
298 | return -EIO; |
299 | } |
300 | return 0; |
301 | } |
302 | |
303 | |
304 | /* ATA helpers copied from drivers/ata/libata-core.c */ |
305 | |
306 | static void swap_buf_le16(u16 *buf, unsigned int buf_words) |
307 | { |
308 | #ifdef __BIG_ENDIAN |
309 | unsigned int i; |
310 | |
311 | for (i = 0; i < buf_words; i++) |
312 | buf[i] = le16_to_cpu(buf[i]); |
313 | #endif /* __BIG_ENDIAN */ |
314 | } |
315 | |
316 | static u64 ata_id_n_sectors(const u16 *id) |
317 | { |
318 | if (ata_id_has_lba(id)) { |
319 | if (ata_id_has_lba48(id)) |
320 | return ata_id_u64(id, 100); |
321 | else |
322 | return ata_id_u32(id, 60); |
323 | } else { |
324 | if (ata_id_current_chs_valid(id)) |
325 | return ata_id_u32(id, 57); |
326 | else |
327 | return id[1] * id[3] * id[6]; |
328 | } |
329 | } |
330 | |
331 | static void ata_id_string(const u16 *id, unsigned char *s, unsigned int ofs, |
332 | unsigned int len) |
333 | { |
334 | unsigned int c; |
335 | |
336 | while (len > 0) { |
337 | c = id[ofs] >> 8; |
338 | *s = c; |
339 | s++; |
340 | |
341 | c = id[ofs] & 0xff; |
342 | *s = c; |
343 | s++; |
344 | |
345 | ofs++; |
346 | len -= 2; |
347 | } |
348 | } |
349 | |
350 | static void ata_id_c_string(const u16 *id, unsigned char *s, unsigned int ofs, |
351 | unsigned int len) |
352 | { |
353 | unsigned char *p; |
354 | |
355 | WARN_ON(!(len & 1)); |
356 | |
357 | ata_id_string(id, s, ofs, len - 1); |
358 | |
359 | p = s + strnlen(s, len - 1); |
360 | while (p > s && p[-1] == ' ') |
361 | p--; |
362 | *p = '\0'; |
363 | } |
364 | |
365 | static int ps3disk_identify(struct ps3_storage_device *dev) |
366 | { |
367 | struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd); |
368 | struct lv1_ata_cmnd_block ata_cmnd; |
369 | u16 *id = dev->bounce_buf; |
370 | u64 res; |
371 | |
372 | dev_dbg(&dev->sbd.core, "%s:%u: identify disk\n", __func__, __LINE__); |
373 | |
374 | memset(&ata_cmnd, 0, sizeof(struct lv1_ata_cmnd_block)); |
375 | ata_cmnd.command = ATA_CMD_ID_ATA; |
376 | ata_cmnd.sector_count = 1; |
377 | ata_cmnd.size = ata_cmnd.arglen = ATA_ID_WORDS * 2; |
378 | ata_cmnd.buffer = dev->bounce_lpar; |
379 | ata_cmnd.proto = PIO_DATA_IN_PROTO; |
380 | ata_cmnd.in_out = DIR_READ; |
381 | |
382 | res = ps3stor_send_command(dev, LV1_STORAGE_SEND_ATA_COMMAND, |
383 | ps3_mm_phys_to_lpar(__pa(&ata_cmnd)), |
384 | sizeof(ata_cmnd), ata_cmnd.buffer, |
385 | ata_cmnd.arglen); |
386 | if (res) { |
387 | dev_err(&dev->sbd.core, "%s:%u: identify disk failed 0x%llx\n", |
388 | __func__, __LINE__, res); |
389 | return -EIO; |
390 | } |
391 | |
392 | swap_buf_le16(id, ATA_ID_WORDS); |
393 | |
394 | /* All we're interested in are raw capacity and model name */ |
395 | priv->raw_capacity = ata_id_n_sectors(id); |
396 | ata_id_c_string(id, priv->model, ATA_ID_PROD, sizeof(priv->model)); |
397 | return 0; |
398 | } |
399 | |
400 | static unsigned long ps3disk_mask; |
401 | |
402 | static DEFINE_MUTEX(ps3disk_mask_mutex); |
403 | |
404 | static int ps3disk_probe(struct ps3_system_bus_device *_dev) |
405 | { |
406 | struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core); |
407 | struct ps3disk_private *priv; |
408 | int error; |
409 | unsigned int devidx; |
410 | struct request_queue *queue; |
411 | struct gendisk *gendisk; |
412 | |
413 | if (dev->blk_size < 512) { |
414 | dev_err(&dev->sbd.core, |
415 | "%s:%u: cannot handle block size %llu\n", __func__, |
416 | __LINE__, dev->blk_size); |
417 | return -EINVAL; |
418 | } |
419 | |
420 | BUILD_BUG_ON(PS3DISK_MAX_DISKS > BITS_PER_LONG); |
421 | mutex_lock(&ps3disk_mask_mutex); |
422 | devidx = find_first_zero_bit(&ps3disk_mask, PS3DISK_MAX_DISKS); |
423 | if (devidx >= PS3DISK_MAX_DISKS) { |
424 | dev_err(&dev->sbd.core, "%s:%u: Too many disks\n", __func__, |
425 | __LINE__); |
426 | mutex_unlock(&ps3disk_mask_mutex); |
427 | return -ENOSPC; |
428 | } |
429 | __set_bit(devidx, &ps3disk_mask); |
430 | mutex_unlock(&ps3disk_mask_mutex); |
431 | |
432 | priv = kzalloc(sizeof(*priv), GFP_KERNEL); |
433 | if (!priv) { |
434 | error = -ENOMEM; |
435 | goto fail; |
436 | } |
437 | |
438 | ps3_system_bus_set_drvdata(_dev, priv); |
439 | spin_lock_init(&priv->lock); |
440 | |
441 | dev->bounce_size = BOUNCE_SIZE; |
442 | dev->bounce_buf = kmalloc(BOUNCE_SIZE, GFP_DMA); |
443 | if (!dev->bounce_buf) { |
444 | error = -ENOMEM; |
445 | goto fail_free_priv; |
446 | } |
447 | |
448 | error = ps3stor_setup(dev, ps3disk_interrupt); |
449 | if (error) |
450 | goto fail_free_bounce; |
451 | |
452 | ps3disk_identify(dev); |
453 | |
454 | queue = blk_init_queue(ps3disk_request, &priv->lock); |
455 | if (!queue) { |
456 | dev_err(&dev->sbd.core, "%s:%u: blk_init_queue failed\n", |
457 | __func__, __LINE__); |
458 | error = -ENOMEM; |
459 | goto fail_teardown; |
460 | } |
461 | |
462 | priv->queue = queue; |
463 | queue->queuedata = dev; |
464 | |
465 | blk_queue_bounce_limit(queue, BLK_BOUNCE_HIGH); |
466 | |
467 | blk_queue_max_hw_sectors(queue, dev->bounce_size >> 9); |
468 | blk_queue_segment_boundary(queue, -1UL); |
469 | blk_queue_dma_alignment(queue, dev->blk_size-1); |
470 | blk_queue_logical_block_size(queue, dev->blk_size); |
471 | |
472 | blk_queue_flush(queue, REQ_FLUSH); |
473 | |
474 | blk_queue_max_segments(queue, -1); |
475 | blk_queue_max_segment_size(queue, dev->bounce_size); |
476 | |
477 | gendisk = alloc_disk(PS3DISK_MINORS); |
478 | if (!gendisk) { |
479 | dev_err(&dev->sbd.core, "%s:%u: alloc_disk failed\n", __func__, |
480 | __LINE__); |
481 | error = -ENOMEM; |
482 | goto fail_cleanup_queue; |
483 | } |
484 | |
485 | priv->gendisk = gendisk; |
486 | gendisk->major = ps3disk_major; |
487 | gendisk->first_minor = devidx * PS3DISK_MINORS; |
488 | gendisk->fops = &ps3disk_fops; |
489 | gendisk->queue = queue; |
490 | gendisk->private_data = dev; |
491 | gendisk->driverfs_dev = &dev->sbd.core; |
492 | snprintf(gendisk->disk_name, sizeof(gendisk->disk_name), PS3DISK_NAME, |
493 | devidx+'a'); |
494 | priv->blocking_factor = dev->blk_size >> 9; |
495 | set_capacity(gendisk, |
496 | dev->regions[dev->region_idx].size*priv->blocking_factor); |
497 | |
498 | dev_info(&dev->sbd.core, |
499 | "%s is a %s (%llu MiB total, %lu MiB for OtherOS)\n", |
500 | gendisk->disk_name, priv->model, priv->raw_capacity >> 11, |
501 | get_capacity(gendisk) >> 11); |
502 | |
503 | add_disk(gendisk); |
504 | return 0; |
505 | |
506 | fail_cleanup_queue: |
507 | blk_cleanup_queue(queue); |
508 | fail_teardown: |
509 | ps3stor_teardown(dev); |
510 | fail_free_bounce: |
511 | kfree(dev->bounce_buf); |
512 | fail_free_priv: |
513 | kfree(priv); |
514 | ps3_system_bus_set_drvdata(_dev, NULL); |
515 | fail: |
516 | mutex_lock(&ps3disk_mask_mutex); |
517 | __clear_bit(devidx, &ps3disk_mask); |
518 | mutex_unlock(&ps3disk_mask_mutex); |
519 | return error; |
520 | } |
521 | |
522 | static int ps3disk_remove(struct ps3_system_bus_device *_dev) |
523 | { |
524 | struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core); |
525 | struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd); |
526 | |
527 | mutex_lock(&ps3disk_mask_mutex); |
528 | __clear_bit(MINOR(disk_devt(priv->gendisk)) / PS3DISK_MINORS, |
529 | &ps3disk_mask); |
530 | mutex_unlock(&ps3disk_mask_mutex); |
531 | del_gendisk(priv->gendisk); |
532 | blk_cleanup_queue(priv->queue); |
533 | put_disk(priv->gendisk); |
534 | dev_notice(&dev->sbd.core, "Synchronizing disk cache\n"); |
535 | ps3disk_sync_cache(dev); |
536 | ps3stor_teardown(dev); |
537 | kfree(dev->bounce_buf); |
538 | kfree(priv); |
539 | ps3_system_bus_set_drvdata(_dev, NULL); |
540 | return 0; |
541 | } |
542 | |
543 | static struct ps3_system_bus_driver ps3disk = { |
544 | .match_id = PS3_MATCH_ID_STOR_DISK, |
545 | .core.name = DEVICE_NAME, |
546 | .core.owner = THIS_MODULE, |
547 | .probe = ps3disk_probe, |
548 | .remove = ps3disk_remove, |
549 | .shutdown = ps3disk_remove, |
550 | }; |
551 | |
552 | |
553 | static int __init ps3disk_init(void) |
554 | { |
555 | int error; |
556 | |
557 | if (!firmware_has_feature(FW_FEATURE_PS3_LV1)) |
558 | return -ENODEV; |
559 | |
560 | error = register_blkdev(0, DEVICE_NAME); |
561 | if (error <= 0) { |
562 | printk(KERN_ERR "%s:%u: register_blkdev failed %d\n", __func__, |
563 | __LINE__, error); |
564 | return error; |
565 | } |
566 | ps3disk_major = error; |
567 | |
568 | pr_info("%s:%u: registered block device major %d\n", __func__, |
569 | __LINE__, ps3disk_major); |
570 | |
571 | error = ps3_system_bus_driver_register(&ps3disk); |
572 | if (error) |
573 | unregister_blkdev(ps3disk_major, DEVICE_NAME); |
574 | |
575 | return error; |
576 | } |
577 | |
578 | static void __exit ps3disk_exit(void) |
579 | { |
580 | ps3_system_bus_driver_unregister(&ps3disk); |
581 | unregister_blkdev(ps3disk_major, DEVICE_NAME); |
582 | } |
583 | |
584 | module_init(ps3disk_init); |
585 | module_exit(ps3disk_exit); |
586 | |
587 | MODULE_LICENSE("GPL"); |
588 | MODULE_DESCRIPTION("PS3 Disk Storage Driver"); |
589 | MODULE_AUTHOR("Sony Corporation"); |
590 | MODULE_ALIAS(PS3_MODULE_ALIAS_STOR_DISK); |
591 |
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