| 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;
|
| 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,
|
| 81 | DIR_READ = 1
|
| 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, "%s:%u: bio %u: %u sectors from %lu\n",
|
| 105 | __func__, __LINE__, i, bio_sectors(iter.bio),
|
| 106 | iter.bio->bi_iter.bi_sector);
|
| 107 |
|
| 108 | size = bvec.bv_len;
|
| 109 | buf = bvec_kmap_irq(&bvec, &flags);
|
| 110 | if (gather)
|
| 111 | memcpy(dev->bounce_buf+offset, buf, size);
|
| 112 | else
|
| 113 | memcpy(buf, dev->bounce_buf+offset, size);
|
| 114 | offset += size;
|
| 115 | flush_kernel_dcache_page(bvec.bv_page);
|
| 116 | bvec_kunmap_irq(buf, &flags);
|
| 117 | i++;
|
| 118 | }
|
| 119 | }
|
| 120 |
|
| 121 | static int ps3disk_submit_request_sg(struct ps3_storage_device *dev,
|
| 122 | struct request *req)
|
| 123 | {
|
| 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;
|
| 129 |
|
| 130 | #ifdef DEBUG
|
| 131 | unsigned int n = 0;
|
| 132 | struct bio_vec bv;
|
| 133 | struct req_iterator iter;
|
| 134 |
|
| 135 | rq_for_each_segment(bv, req, iter)
|
| 136 | n++;
|
| 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));
|
| 140 | #endif
|
| 141 |
|
| 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);
|
| 146 |
|
| 147 | if (write) {
|
| 148 | ps3disk_scatter_gather(dev, req, 1);
|
| 149 |
|
| 150 | res = lv1_storage_write(dev->sbd.dev_id, region_id,
|
| 151 | start_sector, sectors, 0,
|
| 152 | dev->bounce_lpar, &dev->tag);
|
| 153 | } else {
|
| 154 | res = lv1_storage_read(dev->sbd.dev_id, region_id,
|
| 155 | start_sector, sectors, 0,
|
| 156 | dev->bounce_lpar, &dev->tag);
|
| 157 | }
|
| 158 | if (res) {
|
| 159 | dev_err(&dev->sbd.core, "%s:%u: %s failed %d\n", __func__,
|
| 160 | __LINE__, op, res);
|
| 161 | __blk_end_request_all(req, BLK_STS_IOERR);
|
| 162 | return 0;
|
| 163 | }
|
| 164 |
|
| 165 | priv->req = req;
|
| 166 | return 1;
|
| 167 | }
|
| 168 |
|
| 169 | static int ps3disk_submit_flush_request(struct ps3_storage_device *dev,
|
| 170 | struct request *req)
|
| 171 | {
|
| 172 | struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
|
| 173 | u64 res;
|
| 174 |
|
| 175 | dev_dbg(&dev->sbd.core, "%s:%u: flush request\n", __func__, __LINE__);
|
| 176 |
|
| 177 | res = lv1_storage_send_device_command(dev->sbd.dev_id,
|
| 178 | LV1_STORAGE_ATA_HDDOUT, 0, 0, 0,
|
| 179 | 0, &dev->tag);
|
| 180 | if (res) {
|
| 181 | dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%llx\n",
|
| 182 | __func__, __LINE__, res);
|
| 183 | __blk_end_request_all(req, BLK_STS_IOERR);
|
| 184 | return 0;
|
| 185 | }
|
| 186 |
|
| 187 | priv->req = req;
|
| 188 | return 1;
|
| 189 | }
|
| 190 |
|
| 191 | static void ps3disk_do_request(struct ps3_storage_device *dev,
|
| 192 | struct request_queue *q)
|
| 193 | {
|
| 194 | struct request *req;
|
| 195 |
|
| 196 | dev_dbg(&dev->sbd.core, "%s:%u\n", __func__, __LINE__);
|
| 197 |
|
| 198 | while ((req = blk_fetch_request(q))) {
|
| 199 | switch (req_op(req)) {
|
| 200 | case REQ_OP_FLUSH:
|
| 201 | if (ps3disk_submit_flush_request(dev, req))
|
| 202 | return;
|
| 203 | break;
|
| 204 | case REQ_OP_READ:
|
| 205 | case REQ_OP_WRITE:
|
| 206 | if (ps3disk_submit_request_sg(dev, req))
|
| 207 | return;
|
| 208 | break;
|
| 209 | default:
|
| 210 | blk_dump_rq_flags(req, DEVICE_NAME " bad request");
|
| 211 | __blk_end_request_all(req, BLK_STS_IOERR);
|
| 212 | }
|
| 213 | }
|
| 214 | }
|
| 215 |
|
| 216 | static void ps3disk_request(struct request_queue *q)
|
| 217 | {
|
| 218 | struct ps3_storage_device *dev = q->queuedata;
|
| 219 | struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
|
| 220 |
|
| 221 | if (priv->req) {
|
| 222 | dev_dbg(&dev->sbd.core, "%s:%u busy\n", __func__, __LINE__);
|
| 223 | return;
|
| 224 | }
|
| 225 |
|
| 226 | ps3disk_do_request(dev, q);
|
| 227 | }
|
| 228 |
|
| 229 | static irqreturn_t ps3disk_interrupt(int irq, void *data)
|
| 230 | {
|
| 231 | struct ps3_storage_device *dev = data;
|
| 232 | struct ps3disk_private *priv;
|
| 233 | struct request *req;
|
| 234 | int res, read;
|
| 235 | blk_status_t error;
|
| 236 | u64 tag, status;
|
| 237 | const char *op;
|
| 238 |
|
| 239 | res = lv1_storage_get_async_status(dev->sbd.dev_id, &tag, &status);
|
| 240 |
|
| 241 | if (tag != dev->tag)
|
| 242 | dev_err(&dev->sbd.core,
|
| 243 | "%s:%u: tag mismatch, got %llx, expected %llx\n",
|
| 244 | __func__, __LINE__, tag, dev->tag);
|
| 245 |
|
| 246 | if (res) {
|
| 247 | dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%llx\n",
|
| 248 | __func__, __LINE__, res, status);
|
| 249 | return IRQ_HANDLED;
|
| 250 | }
|
| 251 |
|
| 252 | priv = ps3_system_bus_get_drvdata(&dev->sbd);
|
| 253 | req = priv->req;
|
| 254 | if (!req) {
|
| 255 | dev_dbg(&dev->sbd.core,
|
| 256 | "%s:%u non-block layer request completed\n", __func__,
|
| 257 | __LINE__);
|
| 258 | dev->lv1_status = status;
|
| 259 | complete(&dev->done);
|
| 260 | return IRQ_HANDLED;
|
| 261 | }
|
| 262 |
|
| 263 | if (req_op(req) == REQ_OP_FLUSH) {
|
| 264 | read = 0;
|
| 265 | op = "flush";
|
| 266 | } else {
|
| 267 | read = !rq_data_dir(req);
|
| 268 | op = read ? "read" : "write";
|
| 269 | }
|
| 270 | if (status) {
|
| 271 | dev_dbg(&dev->sbd.core, "%s:%u: %s failed 0x%llx\n", __func__,
|
| 272 | __LINE__, op, status);
|
| 273 | error = BLK_STS_IOERR;
|
| 274 | } else {
|
| 275 | dev_dbg(&dev->sbd.core, "%s:%u: %s completed\n", __func__,
|
| 276 | __LINE__, op);
|
| 277 | error = 0;
|
| 278 | if (read)
|
| 279 | ps3disk_scatter_gather(dev, req, 0);
|
| 280 | }
|
| 281 |
|
| 282 | spin_lock(&priv->lock);
|
| 283 | __blk_end_request_all(req, error);
|
| 284 | priv->req = NULL;
|
| 285 | ps3disk_do_request(dev, priv->queue);
|
| 286 | spin_unlock(&priv->lock);
|
| 287 |
|
| 288 | return IRQ_HANDLED;
|
| 289 | }
|
| 290 |
|
| 291 | static int ps3disk_sync_cache(struct ps3_storage_device *dev)
|
| 292 | {
|
| 293 | u64 res;
|
| 294 |
|
| 295 | dev_dbg(&dev->sbd.core, "%s:%u: sync cache\n", __func__, __LINE__);
|
| 296 |
|
| 297 | res = ps3stor_send_command(dev, LV1_STORAGE_ATA_HDDOUT, 0, 0, 0, 0);
|
| 298 | if (res) {
|
| 299 | dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%llx\n",
|
| 300 | __func__, __LINE__, res);
|
| 301 | return -EIO;
|
| 302 | }
|
| 303 | return 0;
|
| 304 | }
|
| 305 |
|
| 306 |
|
| 307 |
|
| 308 |
|
| 309 | static void swap_buf_le16(u16 *buf, unsigned int buf_words)
|
| 310 | {
|
| 311 | #ifdef __BIG_ENDIAN
|
| 312 | unsigned int i;
|
| 313 |
|
| 314 | for (i = 0; i < buf_words; i++)
|
| 315 | buf[i] = le16_to_cpu(buf[i]);
|
| 316 | #endif
|
| 317 | }
|
| 318 |
|
| 319 | static u64 ata_id_n_sectors(const u16 *id)
|
| 320 | {
|
| 321 | if (ata_id_has_lba(id)) {
|
| 322 | if (ata_id_has_lba48(id))
|
| 323 | return ata_id_u64(id, 100);
|
| 324 | else
|
| 325 | return ata_id_u32(id, 60);
|
| 326 | } else {
|
| 327 | if (ata_id_current_chs_valid(id))
|
| 328 | return ata_id_u32(id, 57);
|
| 329 | else
|
| 330 | return id[1] * id[3] * id[6];
|
| 331 | }
|
| 332 | }
|
| 333 |
|
| 334 | static void ata_id_string(const u16 *id, unsigned char *s, unsigned int ofs,
|
| 335 | unsigned int len)
|
| 336 | {
|
| 337 | unsigned int c;
|
| 338 |
|
| 339 | while (len > 0) {
|
| 340 | c = id[ofs] >> 8;
|
| 341 | *s = c;
|
| 342 | s++;
|
| 343 |
|
| 344 | c = id[ofs] & 0xff;
|
| 345 | *s = c;
|
| 346 | s++;
|
| 347 |
|
| 348 | ofs++;
|
| 349 | len -= 2;
|
| 350 | }
|
| 351 | }
|
| 352 |
|
| 353 | static void ata_id_c_string(const u16 *id, unsigned char *s, unsigned int ofs,
|
| 354 | unsigned int len)
|
| 355 | {
|
| 356 | unsigned char *p;
|
| 357 |
|
| 358 | WARN_ON(!(len & 1));
|
| 359 |
|
| 360 | ata_id_string(id, s, ofs, len - 1);
|
| 361 |
|
| 362 | p = s + strnlen(s, len - 1);
|
| 363 | while (p > s && p[-1] == ' ')
|
| 364 | p--;
|
| 365 | *p = '\0';
|
| 366 | }
|
| 367 |
|
| 368 | static int ps3disk_identify(struct ps3_storage_device *dev)
|
| 369 | {
|
| 370 | struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
|
| 371 | struct lv1_ata_cmnd_block ata_cmnd;
|
| 372 | u16 *id = dev->bounce_buf;
|
| 373 | u64 res;
|
| 374 |
|
| 375 | dev_dbg(&dev->sbd.core, "%s:%u: identify disk\n", __func__, __LINE__);
|
| 376 |
|
| 377 | memset(&ata_cmnd, 0, sizeof(struct lv1_ata_cmnd_block));
|
| 378 | ata_cmnd.command = ATA_CMD_ID_ATA;
|
| 379 | ata_cmnd.sector_count = 1;
|
| 380 | ata_cmnd.size = ata_cmnd.arglen = ATA_ID_WORDS * 2;
|
| 381 | ata_cmnd.buffer = dev->bounce_lpar;
|
| 382 | ata_cmnd.proto = PIO_DATA_IN_PROTO;
|
| 383 | ata_cmnd.in_out = DIR_READ;
|
| 384 |
|
| 385 | res = ps3stor_send_command(dev, LV1_STORAGE_SEND_ATA_COMMAND,
|
| 386 | ps3_mm_phys_to_lpar(__pa(&ata_cmnd)),
|
| 387 | sizeof(ata_cmnd), ata_cmnd.buffer,
|
| 388 | ata_cmnd.arglen);
|
| 389 | if (res) {
|
| 390 | dev_err(&dev->sbd.core, "%s:%u: identify disk failed 0x%llx\n",
|
| 391 | __func__, __LINE__, res);
|
| 392 | return -EIO;
|
| 393 | }
|
| 394 |
|
| 395 | swap_buf_le16(id, ATA_ID_WORDS);
|
| 396 |
|
| 397 |
|
| 398 | priv->raw_capacity = ata_id_n_sectors(id);
|
| 399 | ata_id_c_string(id, priv->model, ATA_ID_PROD, sizeof(priv->model));
|
| 400 | return 0;
|
| 401 | }
|
| 402 |
|
| 403 | static unsigned long ps3disk_mask;
|
| 404 |
|
| 405 | static DEFINE_MUTEX(ps3disk_mask_mutex);
|
| 406 |
|
| 407 | static int ps3disk_probe(struct ps3_system_bus_device *_dev)
|
| 408 | {
|
| 409 | struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
|
| 410 | struct ps3disk_private *priv;
|
| 411 | int error;
|
| 412 | unsigned int devidx;
|
| 413 | struct request_queue *queue;
|
| 414 | struct gendisk *gendisk;
|
| 415 |
|
| 416 | if (dev->blk_size < 512) {
|
| 417 | dev_err(&dev->sbd.core,
|
| 418 | "%s:%u: cannot handle block size %llu\n", __func__,
|
| 419 | __LINE__, dev->blk_size);
|
| 420 | return -EINVAL;
|
| 421 | }
|
| 422 |
|
| 423 | BUILD_BUG_ON(PS3DISK_MAX_DISKS > BITS_PER_LONG);
|
| 424 | mutex_lock(&ps3disk_mask_mutex);
|
| 425 | devidx = find_first_zero_bit(&ps3disk_mask, PS3DISK_MAX_DISKS);
|
| 426 | if (devidx >= PS3DISK_MAX_DISKS) {
|
| 427 | dev_err(&dev->sbd.core, "%s:%u: Too many disks\n", __func__,
|
| 428 | __LINE__);
|
| 429 | mutex_unlock(&ps3disk_mask_mutex);
|
| 430 | return -ENOSPC;
|
| 431 | }
|
| 432 | __set_bit(devidx, &ps3disk_mask);
|
| 433 | mutex_unlock(&ps3disk_mask_mutex);
|
| 434 |
|
| 435 | priv = kzalloc(sizeof(*priv), GFP_KERNEL);
|
| 436 | if (!priv) {
|
| 437 | error = -ENOMEM;
|
| 438 | goto fail;
|
| 439 | }
|
| 440 |
|
| 441 | ps3_system_bus_set_drvdata(_dev, priv);
|
| 442 | spin_lock_init(&priv->lock);
|
| 443 |
|
| 444 | dev->bounce_size = BOUNCE_SIZE;
|
| 445 | dev->bounce_buf = kmalloc(BOUNCE_SIZE, GFP_DMA);
|
| 446 | if (!dev->bounce_buf) {
|
| 447 | error = -ENOMEM;
|
| 448 | goto fail_free_priv;
|
| 449 | }
|
| 450 |
|
| 451 | error = ps3stor_setup(dev, ps3disk_interrupt);
|
| 452 | if (error)
|
| 453 | goto fail_free_bounce;
|
| 454 |
|
| 455 | ps3disk_identify(dev);
|
| 456 |
|
| 457 | queue = blk_init_queue(ps3disk_request, &priv->lock);
|
| 458 | if (!queue) {
|
| 459 | dev_err(&dev->sbd.core, "%s:%u: blk_init_queue failed\n",
|
| 460 | __func__, __LINE__);
|
| 461 | error = -ENOMEM;
|
| 462 | goto fail_teardown;
|
| 463 | }
|
| 464 |
|
| 465 | priv->queue = queue;
|
| 466 | queue->queuedata = dev;
|
| 467 |
|
| 468 | blk_queue_bounce_limit(queue, BLK_BOUNCE_HIGH);
|
| 469 |
|
| 470 | blk_queue_max_hw_sectors(queue, dev->bounce_size >> 9);
|
| 471 | blk_queue_segment_boundary(queue, -1UL);
|
| 472 | blk_queue_dma_alignment(queue, dev->blk_size-1);
|
| 473 | blk_queue_logical_block_size(queue, dev->blk_size);
|
| 474 |
|
| 475 | blk_queue_write_cache(queue, true, false);
|
| 476 |
|
| 477 | blk_queue_max_segments(queue, -1);
|
| 478 | blk_queue_max_segment_size(queue, dev->bounce_size);
|
| 479 |
|
| 480 | gendisk = alloc_disk(PS3DISK_MINORS);
|
| 481 | if (!gendisk) {
|
| 482 | dev_err(&dev->sbd.core, "%s:%u: alloc_disk failed\n", __func__,
|
| 483 | __LINE__);
|
| 484 | error = -ENOMEM;
|
| 485 | goto fail_cleanup_queue;
|
| 486 | }
|
| 487 |
|
| 488 | priv->gendisk = gendisk;
|
| 489 | gendisk->major = ps3disk_major;
|
| 490 | gendisk->first_minor = devidx * PS3DISK_MINORS;
|
| 491 | gendisk->fops = &ps3disk_fops;
|
| 492 | gendisk->queue = queue;
|
| 493 | gendisk->private_data = dev;
|
| 494 | snprintf(gendisk->disk_name, sizeof(gendisk->disk_name), PS3DISK_NAME,
|
| 495 | devidx+'a');
|
| 496 | priv->blocking_factor = dev->blk_size >> 9;
|
| 497 | set_capacity(gendisk,
|
| 498 | dev->regions[dev->region_idx].size*priv->blocking_factor);
|
| 499 |
|
| 500 | dev_info(&dev->sbd.core,
|
| 501 | "%s is a %s (%llu MiB total, %lu MiB for OtherOS)\n",
|
| 502 | gendisk->disk_name, priv->model, priv->raw_capacity >> 11,
|
| 503 | get_capacity(gendisk) >> 11);
|
| 504 |
|
| 505 | device_add_disk(&dev->sbd.core, gendisk);
|
| 506 | return 0;
|
| 507 |
|
| 508 | fail_cleanup_queue:
|
| 509 | blk_cleanup_queue(queue);
|
| 510 | fail_teardown:
|
| 511 | ps3stor_teardown(dev);
|
| 512 | fail_free_bounce:
|
| 513 | kfree(dev->bounce_buf);
|
| 514 | fail_free_priv:
|
| 515 | kfree(priv);
|
| 516 | ps3_system_bus_set_drvdata(_dev, NULL);
|
| 517 | fail:
|
| 518 | mutex_lock(&ps3disk_mask_mutex);
|
| 519 | __clear_bit(devidx, &ps3disk_mask);
|
| 520 | mutex_unlock(&ps3disk_mask_mutex);
|
| 521 | return error;
|
| 522 | }
|
| 523 |
|
| 524 | static int ps3disk_remove(struct ps3_system_bus_device *_dev)
|
| 525 | {
|
| 526 | struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
|
| 527 | struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
|
| 528 |
|
| 529 | mutex_lock(&ps3disk_mask_mutex);
|
| 530 | __clear_bit(MINOR(disk_devt(priv->gendisk)) / PS3DISK_MINORS,
|
| 531 | &ps3disk_mask);
|
| 532 | mutex_unlock(&ps3disk_mask_mutex);
|
| 533 | del_gendisk(priv->gendisk);
|
| 534 | blk_cleanup_queue(priv->queue);
|
| 535 | put_disk(priv->gendisk);
|
| 536 | dev_notice(&dev->sbd.core, "Synchronizing disk cache\n");
|
| 537 | ps3disk_sync_cache(dev);
|
| 538 | ps3stor_teardown(dev);
|
| 539 | kfree(dev->bounce_buf);
|
| 540 | kfree(priv);
|
| 541 | ps3_system_bus_set_drvdata(_dev, NULL);
|
| 542 | return 0;
|
| 543 | }
|
| 544 |
|
| 545 | static struct ps3_system_bus_driver ps3disk = {
|
| 546 | .match_id = PS3_MATCH_ID_STOR_DISK,
|
| 547 | .core.name = DEVICE_NAME,
|
| 548 | .core.owner = THIS_MODULE,
|
| 549 | .probe = ps3disk_probe,
|
| 550 | .remove = ps3disk_remove,
|
| 551 | .shutdown = ps3disk_remove,
|
| 552 | };
|
| 553 |
|
| 554 |
|
| 555 | static int __init ps3disk_init(void)
|
| 556 | {
|
| 557 | int error;
|
| 558 |
|
| 559 | if (!firmware_has_feature(FW_FEATURE_PS3_LV1))
|
| 560 | return -ENODEV;
|
| 561 |
|
| 562 | error = register_blkdev(0, DEVICE_NAME);
|
| 563 | if (error <= 0) {
|
| 564 | printk(KERN_ERR "%s:%u: register_blkdev failed %d\n", __func__,
|
| 565 | __LINE__, error);
|
| 566 | return error;
|
| 567 | }
|
| 568 | ps3disk_major = error;
|
| 569 |
|
| 570 | pr_info("%s:%u: registered block device major %d\n", __func__,
|
| 571 | __LINE__, ps3disk_major);
|
| 572 |
|
| 573 | error = ps3_system_bus_driver_register(&ps3disk);
|
| 574 | if (error)
|
| 575 | unregister_blkdev(ps3disk_major, DEVICE_NAME);
|
| 576 |
|
| 577 | return error;
|
| 578 | }
|
| 579 |
|
| 580 | static void __exit ps3disk_exit(void)
|
| 581 | {
|
| 582 | ps3_system_bus_driver_unregister(&ps3disk);
|
| 583 | unregister_blkdev(ps3disk_major, DEVICE_NAME);
|
| 584 | }
|
| 585 |
|
| 586 | module_init(ps3disk_init);
|
| 587 | module_exit(ps3disk_exit);
|
| 588 |
|
| 589 | MODULE_LICENSE("GPL");
|
| 590 | MODULE_DESCRIPTION("PS3 Disk Storage Driver");
|
| 591 | MODULE_AUTHOR("Sony Corporation");
|
| 592 | MODULE_ALIAS(PS3_MODULE_ALIAS_STOR_DISK);
|