2 * PS3 Disk Storage Driver
4 * Copyright (C) 2007 Sony Computer Entertainment Inc.
5 * Copyright 2007 Sony Corp.
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.
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.
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.
21 #include <linux/ata.h>
22 #include <linux/blkdev.h>
23 #include <linux/slab.h>
24 #include <linux/module.h>
26 #include <asm/lv1call.h>
27 #include <asm/ps3stor.h>
28 #include <asm/firmware.h>
31 #define DEVICE_NAME "ps3disk"
33 #define BOUNCE_SIZE (64*1024)
35 #define PS3DISK_MAX_DISKS 16
36 #define PS3DISK_MINORS 16
39 #define PS3DISK_NAME "ps3d%c"
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
;
49 unsigned char model
[ATA_ID_PROD_LEN
+1];
53 #define LV1_STORAGE_SEND_ATA_COMMAND (2)
54 #define LV1_STORAGE_ATA_HDDOUT (0x23)
56 struct lv1_ata_cmnd_block
{
74 PIO_DATA_IN_PROTO
= 1,
75 PIO_DATA_OUT_PROTO
= 2,
80 DIR_WRITE
= 0, /* memory -> device */
81 DIR_READ
= 1 /* device -> memory */
84 static int ps3disk_major
;
87 static const struct block_device_operations ps3disk_fops
= {
92 static void ps3disk_scatter_gather(struct ps3_storage_device
*dev
,
93 struct request
*req
, int gather
)
95 unsigned int offset
= 0;
96 struct req_iterator iter
;
102 rq_for_each_segment(bvec
, req
, iter
) {
104 dev_dbg(&dev
->sbd
.core
, "%s:%u: bio %u: %u sectors from %lu\n",
105 __func__
, __LINE__
, i
, bio_sectors(iter
.bio
),
106 iter
.bio
->bi_iter
.bi_sector
);
109 buf
= bvec_kmap_irq(&bvec
, &flags
);
111 memcpy(dev
->bounce_buf
+offset
, buf
, size
);
113 memcpy(buf
, dev
->bounce_buf
+offset
, size
);
115 flush_kernel_dcache_page(bvec
.bv_page
);
116 bvec_kunmap_irq(buf
, &flags
);
121 static int ps3disk_submit_request_sg(struct ps3_storage_device
*dev
,
124 struct ps3disk_private
*priv
= ps3_system_bus_get_drvdata(&dev
->sbd
);
125 int write
= rq_data_dir(req
), res
;
126 const char *op
= write
? "write" : "read";
127 u64 start_sector
, sectors
;
128 unsigned int region_id
= dev
->regions
[dev
->region_idx
].id
;
133 struct req_iterator iter
;
135 rq_for_each_segment(bv
, req
, iter
)
137 dev_dbg(&dev
->sbd
.core
,
138 "%s:%u: %s req has %u bvecs for %u sectors\n",
139 __func__
, __LINE__
, op
, n
, blk_rq_sectors(req
));
142 start_sector
= blk_rq_pos(req
) * priv
->blocking_factor
;
143 sectors
= blk_rq_sectors(req
) * priv
->blocking_factor
;
144 dev_dbg(&dev
->sbd
.core
, "%s:%u: %s %llu sectors starting at %llu\n",
145 __func__
, __LINE__
, op
, sectors
, start_sector
);
148 ps3disk_scatter_gather(dev
, req
, 1);
150 res
= lv1_storage_write(dev
->sbd
.dev_id
, region_id
,
151 start_sector
, sectors
, 0,
152 dev
->bounce_lpar
, &dev
->tag
);
154 res
= lv1_storage_read(dev
->sbd
.dev_id
, region_id
,
155 start_sector
, sectors
, 0,
156 dev
->bounce_lpar
, &dev
->tag
);
159 dev_err(&dev
->sbd
.core
, "%s:%u: %s failed %d\n", __func__
,
161 __blk_end_request_all(req
, -EIO
);
169 static int ps3disk_submit_flush_request(struct ps3_storage_device
*dev
,
172 struct ps3disk_private
*priv
= ps3_system_bus_get_drvdata(&dev
->sbd
);
175 dev_dbg(&dev
->sbd
.core
, "%s:%u: flush request\n", __func__
, __LINE__
);
177 res
= lv1_storage_send_device_command(dev
->sbd
.dev_id
,
178 LV1_STORAGE_ATA_HDDOUT
, 0, 0, 0,
181 dev_err(&dev
->sbd
.core
, "%s:%u: sync cache failed 0x%llx\n",
182 __func__
, __LINE__
, res
);
183 __blk_end_request_all(req
, -EIO
);
191 static void ps3disk_do_request(struct ps3_storage_device
*dev
,
192 struct request_queue
*q
)
196 dev_dbg(&dev
->sbd
.core
, "%s:%u\n", __func__
, __LINE__
);
198 while ((req
= blk_fetch_request(q
))) {
199 if (req_op(req
) == REQ_OP_FLUSH
) {
200 if (ps3disk_submit_flush_request(dev
, req
))
202 } else if (req
->cmd_type
== REQ_TYPE_FS
) {
203 if (ps3disk_submit_request_sg(dev
, req
))
206 blk_dump_rq_flags(req
, DEVICE_NAME
" bad request");
207 __blk_end_request_all(req
, -EIO
);
213 static void ps3disk_request(struct request_queue
*q
)
215 struct ps3_storage_device
*dev
= q
->queuedata
;
216 struct ps3disk_private
*priv
= ps3_system_bus_get_drvdata(&dev
->sbd
);
219 dev_dbg(&dev
->sbd
.core
, "%s:%u busy\n", __func__
, __LINE__
);
223 ps3disk_do_request(dev
, q
);
226 static irqreturn_t
ps3disk_interrupt(int irq
, void *data
)
228 struct ps3_storage_device
*dev
= data
;
229 struct ps3disk_private
*priv
;
231 int res
, read
, error
;
235 res
= lv1_storage_get_async_status(dev
->sbd
.dev_id
, &tag
, &status
);
238 dev_err(&dev
->sbd
.core
,
239 "%s:%u: tag mismatch, got %llx, expected %llx\n",
240 __func__
, __LINE__
, tag
, dev
->tag
);
243 dev_err(&dev
->sbd
.core
, "%s:%u: res=%d status=0x%llx\n",
244 __func__
, __LINE__
, res
, status
);
248 priv
= ps3_system_bus_get_drvdata(&dev
->sbd
);
251 dev_dbg(&dev
->sbd
.core
,
252 "%s:%u non-block layer request completed\n", __func__
,
254 dev
->lv1_status
= status
;
255 complete(&dev
->done
);
259 if (req_op(req
) == REQ_OP_FLUSH
) {
263 read
= !rq_data_dir(req
);
264 op
= read
? "read" : "write";
267 dev_dbg(&dev
->sbd
.core
, "%s:%u: %s failed 0x%llx\n", __func__
,
268 __LINE__
, op
, status
);
271 dev_dbg(&dev
->sbd
.core
, "%s:%u: %s completed\n", __func__
,
275 ps3disk_scatter_gather(dev
, req
, 0);
278 spin_lock(&priv
->lock
);
279 __blk_end_request_all(req
, error
);
281 ps3disk_do_request(dev
, priv
->queue
);
282 spin_unlock(&priv
->lock
);
287 static int ps3disk_sync_cache(struct ps3_storage_device
*dev
)
291 dev_dbg(&dev
->sbd
.core
, "%s:%u: sync cache\n", __func__
, __LINE__
);
293 res
= ps3stor_send_command(dev
, LV1_STORAGE_ATA_HDDOUT
, 0, 0, 0, 0);
295 dev_err(&dev
->sbd
.core
, "%s:%u: sync cache failed 0x%llx\n",
296 __func__
, __LINE__
, res
);
303 /* ATA helpers copied from drivers/ata/libata-core.c */
305 static void swap_buf_le16(u16
*buf
, unsigned int buf_words
)
310 for (i
= 0; i
< buf_words
; i
++)
311 buf
[i
] = le16_to_cpu(buf
[i
]);
312 #endif /* __BIG_ENDIAN */
315 static u64
ata_id_n_sectors(const u16
*id
)
317 if (ata_id_has_lba(id
)) {
318 if (ata_id_has_lba48(id
))
319 return ata_id_u64(id
, 100);
321 return ata_id_u32(id
, 60);
323 if (ata_id_current_chs_valid(id
))
324 return ata_id_u32(id
, 57);
326 return id
[1] * id
[3] * id
[6];
330 static void ata_id_string(const u16
*id
, unsigned char *s
, unsigned int ofs
,
349 static void ata_id_c_string(const u16
*id
, unsigned char *s
, unsigned int ofs
,
356 ata_id_string(id
, s
, ofs
, len
- 1);
358 p
= s
+ strnlen(s
, len
- 1);
359 while (p
> s
&& p
[-1] == ' ')
364 static int ps3disk_identify(struct ps3_storage_device
*dev
)
366 struct ps3disk_private
*priv
= ps3_system_bus_get_drvdata(&dev
->sbd
);
367 struct lv1_ata_cmnd_block ata_cmnd
;
368 u16
*id
= dev
->bounce_buf
;
371 dev_dbg(&dev
->sbd
.core
, "%s:%u: identify disk\n", __func__
, __LINE__
);
373 memset(&ata_cmnd
, 0, sizeof(struct lv1_ata_cmnd_block
));
374 ata_cmnd
.command
= ATA_CMD_ID_ATA
;
375 ata_cmnd
.sector_count
= 1;
376 ata_cmnd
.size
= ata_cmnd
.arglen
= ATA_ID_WORDS
* 2;
377 ata_cmnd
.buffer
= dev
->bounce_lpar
;
378 ata_cmnd
.proto
= PIO_DATA_IN_PROTO
;
379 ata_cmnd
.in_out
= DIR_READ
;
381 res
= ps3stor_send_command(dev
, LV1_STORAGE_SEND_ATA_COMMAND
,
382 ps3_mm_phys_to_lpar(__pa(&ata_cmnd
)),
383 sizeof(ata_cmnd
), ata_cmnd
.buffer
,
386 dev_err(&dev
->sbd
.core
, "%s:%u: identify disk failed 0x%llx\n",
387 __func__
, __LINE__
, res
);
391 swap_buf_le16(id
, ATA_ID_WORDS
);
393 /* All we're interested in are raw capacity and model name */
394 priv
->raw_capacity
= ata_id_n_sectors(id
);
395 ata_id_c_string(id
, priv
->model
, ATA_ID_PROD
, sizeof(priv
->model
));
399 static unsigned long ps3disk_mask
;
401 static DEFINE_MUTEX(ps3disk_mask_mutex
);
403 static int ps3disk_probe(struct ps3_system_bus_device
*_dev
)
405 struct ps3_storage_device
*dev
= to_ps3_storage_device(&_dev
->core
);
406 struct ps3disk_private
*priv
;
409 struct request_queue
*queue
;
410 struct gendisk
*gendisk
;
412 if (dev
->blk_size
< 512) {
413 dev_err(&dev
->sbd
.core
,
414 "%s:%u: cannot handle block size %llu\n", __func__
,
415 __LINE__
, dev
->blk_size
);
419 BUILD_BUG_ON(PS3DISK_MAX_DISKS
> BITS_PER_LONG
);
420 mutex_lock(&ps3disk_mask_mutex
);
421 devidx
= find_first_zero_bit(&ps3disk_mask
, PS3DISK_MAX_DISKS
);
422 if (devidx
>= PS3DISK_MAX_DISKS
) {
423 dev_err(&dev
->sbd
.core
, "%s:%u: Too many disks\n", __func__
,
425 mutex_unlock(&ps3disk_mask_mutex
);
428 __set_bit(devidx
, &ps3disk_mask
);
429 mutex_unlock(&ps3disk_mask_mutex
);
431 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
437 ps3_system_bus_set_drvdata(_dev
, priv
);
438 spin_lock_init(&priv
->lock
);
440 dev
->bounce_size
= BOUNCE_SIZE
;
441 dev
->bounce_buf
= kmalloc(BOUNCE_SIZE
, GFP_DMA
);
442 if (!dev
->bounce_buf
) {
447 error
= ps3stor_setup(dev
, ps3disk_interrupt
);
449 goto fail_free_bounce
;
451 ps3disk_identify(dev
);
453 queue
= blk_init_queue(ps3disk_request
, &priv
->lock
);
455 dev_err(&dev
->sbd
.core
, "%s:%u: blk_init_queue failed\n",
462 queue
->queuedata
= dev
;
464 blk_queue_bounce_limit(queue
, BLK_BOUNCE_HIGH
);
466 blk_queue_max_hw_sectors(queue
, dev
->bounce_size
>> 9);
467 blk_queue_segment_boundary(queue
, -1UL);
468 blk_queue_dma_alignment(queue
, dev
->blk_size
-1);
469 blk_queue_logical_block_size(queue
, dev
->blk_size
);
471 blk_queue_write_cache(queue
, true, false);
473 blk_queue_max_segments(queue
, -1);
474 blk_queue_max_segment_size(queue
, dev
->bounce_size
);
476 gendisk
= alloc_disk(PS3DISK_MINORS
);
478 dev_err(&dev
->sbd
.core
, "%s:%u: alloc_disk failed\n", __func__
,
481 goto fail_cleanup_queue
;
484 priv
->gendisk
= gendisk
;
485 gendisk
->major
= ps3disk_major
;
486 gendisk
->first_minor
= devidx
* PS3DISK_MINORS
;
487 gendisk
->fops
= &ps3disk_fops
;
488 gendisk
->queue
= queue
;
489 gendisk
->private_data
= dev
;
490 gendisk
->driverfs_dev
= &dev
->sbd
.core
;
491 snprintf(gendisk
->disk_name
, sizeof(gendisk
->disk_name
), PS3DISK_NAME
,
493 priv
->blocking_factor
= dev
->blk_size
>> 9;
494 set_capacity(gendisk
,
495 dev
->regions
[dev
->region_idx
].size
*priv
->blocking_factor
);
497 dev_info(&dev
->sbd
.core
,
498 "%s is a %s (%llu MiB total, %lu MiB for OtherOS)\n",
499 gendisk
->disk_name
, priv
->model
, priv
->raw_capacity
>> 11,
500 get_capacity(gendisk
) >> 11);
506 blk_cleanup_queue(queue
);
508 ps3stor_teardown(dev
);
510 kfree(dev
->bounce_buf
);
513 ps3_system_bus_set_drvdata(_dev
, NULL
);
515 mutex_lock(&ps3disk_mask_mutex
);
516 __clear_bit(devidx
, &ps3disk_mask
);
517 mutex_unlock(&ps3disk_mask_mutex
);
521 static int ps3disk_remove(struct ps3_system_bus_device
*_dev
)
523 struct ps3_storage_device
*dev
= to_ps3_storage_device(&_dev
->core
);
524 struct ps3disk_private
*priv
= ps3_system_bus_get_drvdata(&dev
->sbd
);
526 mutex_lock(&ps3disk_mask_mutex
);
527 __clear_bit(MINOR(disk_devt(priv
->gendisk
)) / PS3DISK_MINORS
,
529 mutex_unlock(&ps3disk_mask_mutex
);
530 del_gendisk(priv
->gendisk
);
531 blk_cleanup_queue(priv
->queue
);
532 put_disk(priv
->gendisk
);
533 dev_notice(&dev
->sbd
.core
, "Synchronizing disk cache\n");
534 ps3disk_sync_cache(dev
);
535 ps3stor_teardown(dev
);
536 kfree(dev
->bounce_buf
);
538 ps3_system_bus_set_drvdata(_dev
, NULL
);
542 static struct ps3_system_bus_driver ps3disk
= {
543 .match_id
= PS3_MATCH_ID_STOR_DISK
,
544 .core
.name
= DEVICE_NAME
,
545 .core
.owner
= THIS_MODULE
,
546 .probe
= ps3disk_probe
,
547 .remove
= ps3disk_remove
,
548 .shutdown
= ps3disk_remove
,
552 static int __init
ps3disk_init(void)
556 if (!firmware_has_feature(FW_FEATURE_PS3_LV1
))
559 error
= register_blkdev(0, DEVICE_NAME
);
561 printk(KERN_ERR
"%s:%u: register_blkdev failed %d\n", __func__
,
565 ps3disk_major
= error
;
567 pr_info("%s:%u: registered block device major %d\n", __func__
,
568 __LINE__
, ps3disk_major
);
570 error
= ps3_system_bus_driver_register(&ps3disk
);
572 unregister_blkdev(ps3disk_major
, DEVICE_NAME
);
577 static void __exit
ps3disk_exit(void)
579 ps3_system_bus_driver_unregister(&ps3disk
);
580 unregister_blkdev(ps3disk_major
, DEVICE_NAME
);
583 module_init(ps3disk_init
);
584 module_exit(ps3disk_exit
);
586 MODULE_LICENSE("GPL");
587 MODULE_DESCRIPTION("PS3 Disk Storage Driver");
588 MODULE_AUTHOR("Sony Corporation");
589 MODULE_ALIAS(PS3_MODULE_ALIAS_STOR_DISK
);