1 /*
2 * Block driver for media (i.e., flash cards)
3 *
4 * Copyright 2002 Hewlett-Packard Company
5 * Copyright 2005-2008 Pierre Ossman
6 *
7 * Use consistent with the GNU GPL is permitted,
8 * provided that this copyright notice is
9 * preserved in its entirety in all copies and derived works.
10 *
11 * HEWLETT-PACKARD COMPANY MAKES NO WARRANTIES, EXPRESSED OR IMPLIED,
12 * AS TO THE USEFULNESS OR CORRECTNESS OF THIS CODE OR ITS
13 * FITNESS FOR ANY PARTICULAR PURPOSE.
14 *
15 * Many thanks to Alessandro Rubini and Jonathan Corbet!
16 *
17 * Author: Andrew Christian
18 * 28 May 2002
19 */
20 #include <linux/moduleparam.h>
21 #include <linux/module.h>
22 #include <linux/init.h>
23
24 #include <linux/kernel.h>
25 #include <linux/fs.h>
26 #include <linux/errno.h>
27 #include <linux/hdreg.h>
28 #include <linux/kdev_t.h>
29 #include <linux/blkdev.h>
30 #include <linux/mutex.h>
31 #include <linux/scatterlist.h>
32 #include <linux/string_helpers.h>
33
34 #include <linux/mmc/card.h>
35 #include <linux/mmc/host.h>
36 #include <linux/mmc/mmc.h>
37 #include <linux/mmc/sd.h>
38
39 #include <asm/system.h>
40 #include <asm/uaccess.h>
41
42 #include "queue.h"
43
44 MODULE_ALIAS("mmc:block");
45
46 /*
47 * max 8 partitions per card
48 */
49 #define MMC_SHIFT 3
50 #define MMC_NUM_MINORS (256 >> MMC_SHIFT)
51
52 static DECLARE_BITMAP(dev_use, MMC_NUM_MINORS);
53
54 /*
55 * There is one mmc_blk_data per slot.
56 */
57 struct mmc_blk_data {
58 spinlock_t lock;
59 struct gendisk *disk;
60 struct mmc_queue queue;
61
62 unsigned int usage;
63 unsigned int read_only;
64 };
65
66 static DEFINE_MUTEX(open_lock);
67
mmc_blk_get(struct gendisk * disk)68 static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk)
69 {
70 struct mmc_blk_data *md;
71
72 mutex_lock(&open_lock);
73 md = disk->private_data;
74 if (md && md->usage == 0)
75 md = NULL;
76 if (md)
77 md->usage++;
78 mutex_unlock(&open_lock);
79
80 return md;
81 }
82
mmc_blk_put(struct mmc_blk_data * md)83 static void mmc_blk_put(struct mmc_blk_data *md)
84 {
85 mutex_lock(&open_lock);
86 md->usage--;
87 if (md->usage == 0) {
88 int devidx = MINOR(disk_devt(md->disk)) >> MMC_SHIFT;
89 __clear_bit(devidx, dev_use);
90
91 put_disk(md->disk);
92 kfree(md);
93 }
94 mutex_unlock(&open_lock);
95 }
96
mmc_blk_open(struct block_device * bdev,fmode_t mode)97 static int mmc_blk_open(struct block_device *bdev, fmode_t mode)
98 {
99 struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk);
100 int ret = -ENXIO;
101
102 if (md) {
103 if (md->usage == 2)
104 check_disk_change(bdev);
105 ret = 0;
106
107 if ((mode & FMODE_WRITE) && md->read_only) {
108 mmc_blk_put(md);
109 ret = -EROFS;
110 }
111 }
112
113 return ret;
114 }
115
mmc_blk_release(struct gendisk * disk,fmode_t mode)116 static int mmc_blk_release(struct gendisk *disk, fmode_t mode)
117 {
118 struct mmc_blk_data *md = disk->private_data;
119
120 mmc_blk_put(md);
121 return 0;
122 }
123
124 static int
mmc_blk_getgeo(struct block_device * bdev,struct hd_geometry * geo)125 mmc_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
126 {
127 geo->cylinders = get_capacity(bdev->bd_disk) / (4 * 16);
128 geo->heads = 4;
129 geo->sectors = 16;
130 return 0;
131 }
132
133 static struct block_device_operations mmc_bdops = {
134 .open = mmc_blk_open,
135 .release = mmc_blk_release,
136 .getgeo = mmc_blk_getgeo,
137 .owner = THIS_MODULE,
138 };
139
140 struct mmc_blk_request {
141 struct mmc_request mrq;
142 struct mmc_command cmd;
143 struct mmc_command stop;
144 struct mmc_data data;
145 };
146
mmc_sd_num_wr_blocks(struct mmc_card * card)147 static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
148 {
149 int err;
150 u32 result;
151 __be32 *blocks;
152
153 struct mmc_request mrq;
154 struct mmc_command cmd;
155 struct mmc_data data;
156 unsigned int timeout_us;
157
158 struct scatterlist sg;
159
160 memset(&cmd, 0, sizeof(struct mmc_command));
161
162 cmd.opcode = MMC_APP_CMD;
163 cmd.arg = card->rca << 16;
164 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
165
166 err = mmc_wait_for_cmd(card->host, &cmd, 0);
167 if (err)
168 return (u32)-1;
169 if (!mmc_host_is_spi(card->host) && !(cmd.resp[0] & R1_APP_CMD))
170 return (u32)-1;
171
172 memset(&cmd, 0, sizeof(struct mmc_command));
173
174 cmd.opcode = SD_APP_SEND_NUM_WR_BLKS;
175 cmd.arg = 0;
176 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
177
178 memset(&data, 0, sizeof(struct mmc_data));
179
180 data.timeout_ns = card->csd.tacc_ns * 100;
181 data.timeout_clks = card->csd.tacc_clks * 100;
182
183 timeout_us = data.timeout_ns / 1000;
184 timeout_us += data.timeout_clks * 1000 /
185 (card->host->ios.clock / 1000);
186
187 if (timeout_us > 100000) {
188 data.timeout_ns = 100000000;
189 data.timeout_clks = 0;
190 }
191
192 data.blksz = 4;
193 data.blocks = 1;
194 data.flags = MMC_DATA_READ;
195 data.sg = &sg;
196 data.sg_len = 1;
197
198 memset(&mrq, 0, sizeof(struct mmc_request));
199
200 mrq.cmd = &cmd;
201 mrq.data = &data;
202
203 blocks = kmalloc(4, GFP_KERNEL);
204 if (!blocks)
205 return (u32)-1;
206
207 sg_init_one(&sg, blocks, 4);
208
209 mmc_wait_for_req(card->host, &mrq);
210
211 result = ntohl(*blocks);
212 kfree(blocks);
213
214 if (cmd.error || data.error)
215 result = (u32)-1;
216
217 return result;
218 }
219
get_card_status(struct mmc_card * card,struct request * req)220 static u32 get_card_status(struct mmc_card *card, struct request *req)
221 {
222 struct mmc_command cmd;
223 int err;
224
225 memset(&cmd, 0, sizeof(struct mmc_command));
226 cmd.opcode = MMC_SEND_STATUS;
227 if (!mmc_host_is_spi(card->host))
228 cmd.arg = card->rca << 16;
229 cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
230 err = mmc_wait_for_cmd(card->host, &cmd, 0);
231 if (err)
232 printk(KERN_ERR "%s: error %d sending status comand",
233 req->rq_disk->disk_name, err);
234 return cmd.resp[0];
235 }
236
237 static int
mmc_blk_set_blksize(struct mmc_blk_data * md,struct mmc_card * card)238 mmc_blk_set_blksize(struct mmc_blk_data *md, struct mmc_card *card)
239 {
240 struct mmc_command cmd;
241 int err;
242
243 /* Block-addressed cards ignore MMC_SET_BLOCKLEN. */
244 if (mmc_card_blockaddr(card))
245 return 0;
246
247 mmc_claim_host(card->host);
248 cmd.opcode = MMC_SET_BLOCKLEN;
249 cmd.arg = 512;
250 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
251 err = mmc_wait_for_cmd(card->host, &cmd, 5);
252 mmc_release_host(card->host);
253
254 if (err) {
255 printk(KERN_ERR "%s: unable to set block size to %d: %d\n",
256 md->disk->disk_name, cmd.arg, err);
257 return -EINVAL;
258 }
259
260 return 0;
261 }
262
263
mmc_blk_issue_rq(struct mmc_queue * mq,struct request * req)264 static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
265 {
266 struct mmc_blk_data *md = mq->data;
267 struct mmc_card *card = md->queue.card;
268 struct mmc_blk_request brq;
269 int ret = 1, disable_multi = 0;
270
271 #ifdef CONFIG_MMC_BLOCK_DEFERRED_RESUME
272 if (mmc_bus_needs_resume(card->host)) {
273 mmc_resume_bus(card->host);
274 mmc_blk_set_blksize(md, card);
275 }
276 #endif
277
278 mmc_claim_host(card->host);
279
280 do {
281 struct mmc_command cmd;
282 u32 readcmd, writecmd, status = 0;
283
284 memset(&brq, 0, sizeof(struct mmc_blk_request));
285 brq.mrq.cmd = &brq.cmd;
286 brq.mrq.data = &brq.data;
287
288 brq.cmd.arg = req->sector;
289 if (!mmc_card_blockaddr(card))
290 brq.cmd.arg <<= 9;
291 brq.cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
292 brq.data.blksz = 512;
293 brq.stop.opcode = MMC_STOP_TRANSMISSION;
294 brq.stop.arg = 0;
295 brq.stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
296 brq.data.blocks = req->nr_sectors;
297
298 /*
299 * The block layer doesn't support all sector count
300 * restrictions, so we need to be prepared for too big
301 * requests.
302 */
303 if (brq.data.blocks > card->host->max_blk_count)
304 brq.data.blocks = card->host->max_blk_count;
305
306 /*
307 * After a read error, we redo the request one sector at a time
308 * in order to accurately determine which sectors can be read
309 * successfully.
310 */
311 if (disable_multi && brq.data.blocks > 1)
312 brq.data.blocks = 1;
313
314 if (brq.data.blocks > 1) {
315 /* SPI multiblock writes terminate using a special
316 * token, not a STOP_TRANSMISSION request.
317 */
318 if (!mmc_host_is_spi(card->host)
319 || rq_data_dir(req) == READ)
320 brq.mrq.stop = &brq.stop;
321 readcmd = MMC_READ_MULTIPLE_BLOCK;
322 writecmd = MMC_WRITE_MULTIPLE_BLOCK;
323 } else {
324 brq.mrq.stop = NULL;
325 readcmd = MMC_READ_SINGLE_BLOCK;
326 writecmd = MMC_WRITE_BLOCK;
327 }
328
329 if (rq_data_dir(req) == READ) {
330 brq.cmd.opcode = readcmd;
331 brq.data.flags |= MMC_DATA_READ;
332 } else {
333 brq.cmd.opcode = writecmd;
334 brq.data.flags |= MMC_DATA_WRITE;
335 }
336
337 mmc_set_data_timeout(&brq.data, card);
338
339 brq.data.sg = mq->sg;
340 brq.data.sg_len = mmc_queue_map_sg(mq);
341
342 /*
343 * Adjust the sg list so it is the same size as the
344 * request.
345 */
346 if (brq.data.blocks != req->nr_sectors) {
347 int i, data_size = brq.data.blocks << 9;
348 struct scatterlist *sg;
349
350 for_each_sg(brq.data.sg, sg, brq.data.sg_len, i) {
351 data_size -= sg->length;
352 if (data_size <= 0) {
353 sg->length += data_size;
354 i++;
355 break;
356 }
357 }
358 brq.data.sg_len = i;
359 }
360
361 mmc_queue_bounce_pre(mq);
362
363 mmc_wait_for_req(card->host, &brq.mrq);
364
365 mmc_queue_bounce_post(mq);
366
367 /*
368 * Check for errors here, but don't jump to cmd_err
369 * until later as we need to wait for the card to leave
370 * programming mode even when things go wrong.
371 */
372 if (brq.cmd.error || brq.data.error || brq.stop.error) {
373 if (brq.data.blocks > 1 && rq_data_dir(req) == READ) {
374 /* Redo read one sector at a time */
375 printk(KERN_WARNING "%s: retrying using single "
376 "block read\n", req->rq_disk->disk_name);
377 disable_multi = 1;
378 continue;
379 }
380 status = get_card_status(card, req);
381 } else if (disable_multi == 1) {
382 disable_multi = 0;
383 }
384
385 if (brq.cmd.error) {
386 printk(KERN_ERR "%s: error %d sending read/write "
387 "command, response %#x, card status %#x\n",
388 req->rq_disk->disk_name, brq.cmd.error,
389 brq.cmd.resp[0], status);
390 }
391
392 if (brq.data.error) {
393 if (brq.data.error == -ETIMEDOUT && brq.mrq.stop)
394 /* 'Stop' response contains card status */
395 status = brq.mrq.stop->resp[0];
396 printk(KERN_ERR "%s: error %d transferring data,"
397 " sector %u, nr %u, card status %#x\n",
398 req->rq_disk->disk_name, brq.data.error,
399 (unsigned)req->sector,
400 (unsigned)req->nr_sectors, status);
401 }
402
403 if (brq.stop.error) {
404 printk(KERN_ERR "%s: error %d sending stop command, "
405 "response %#x, card status %#x\n",
406 req->rq_disk->disk_name, brq.stop.error,
407 brq.stop.resp[0], status);
408 }
409
410 if (!mmc_host_is_spi(card->host) && rq_data_dir(req) != READ) {
411 do {
412 int err;
413
414 cmd.opcode = MMC_SEND_STATUS;
415 cmd.arg = card->rca << 16;
416 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
417 err = mmc_wait_for_cmd(card->host, &cmd, 5);
418 if (err) {
419 printk(KERN_ERR "%s: error %d requesting status\n",
420 req->rq_disk->disk_name, err);
421 goto cmd_err;
422 }
423 /*
424 * Some cards mishandle the status bits,
425 * so make sure to check both the busy
426 * indication and the card state.
427 */
428 } while (!(cmd.resp[0] & R1_READY_FOR_DATA) ||
429 (R1_CURRENT_STATE(cmd.resp[0]) == 7));
430
431 #if 0
432 if (cmd.resp[0] & ~0x00000900)
433 printk(KERN_ERR "%s: status = %08x\n",
434 req->rq_disk->disk_name, cmd.resp[0]);
435 if (mmc_decode_status(cmd.resp))
436 goto cmd_err;
437 #endif
438 }
439
440 if (brq.cmd.error || brq.stop.error || brq.data.error) {
441 if (rq_data_dir(req) == READ) {
442 /*
443 * After an error, we redo I/O one sector at a
444 * time, so we only reach here after trying to
445 * read a single sector.
446 */
447 spin_lock_irq(&md->lock);
448 ret = __blk_end_request(req, -EIO, brq.data.blksz);
449 spin_unlock_irq(&md->lock);
450 continue;
451 }
452 goto cmd_err;
453 }
454
455 /*
456 * A block was successfully transferred.
457 */
458 spin_lock_irq(&md->lock);
459 ret = __blk_end_request(req, 0, brq.data.bytes_xfered);
460 spin_unlock_irq(&md->lock);
461 } while (ret);
462
463 mmc_release_host(card->host);
464
465 return 1;
466
467 cmd_err:
468 /*
469 * If this is an SD card and we're writing, we can first
470 * mark the known good sectors as ok.
471 *
472 * If the card is not SD, we can still ok written sectors
473 * as reported by the controller (which might be less than
474 * the real number of written sectors, but never more).
475 */
476 if (mmc_card_sd(card)) {
477 u32 blocks;
478
479 blocks = mmc_sd_num_wr_blocks(card);
480 if (blocks != (u32)-1) {
481 spin_lock_irq(&md->lock);
482 ret = __blk_end_request(req, 0, blocks << 9);
483 spin_unlock_irq(&md->lock);
484 }
485 } else {
486 spin_lock_irq(&md->lock);
487 ret = __blk_end_request(req, 0, brq.data.bytes_xfered);
488 spin_unlock_irq(&md->lock);
489 }
490
491 mmc_release_host(card->host);
492
493 spin_lock_irq(&md->lock);
494 while (ret)
495 ret = __blk_end_request(req, -EIO, blk_rq_cur_bytes(req));
496 spin_unlock_irq(&md->lock);
497
498 return 0;
499 }
500
501
mmc_blk_readonly(struct mmc_card * card)502 static inline int mmc_blk_readonly(struct mmc_card *card)
503 {
504 return mmc_card_readonly(card) ||
505 !(card->csd.cmdclass & CCC_BLOCK_WRITE);
506 }
507
mmc_blk_alloc(struct mmc_card * card)508 static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
509 {
510 struct mmc_blk_data *md;
511 int devidx, ret;
512
513 devidx = find_first_zero_bit(dev_use, MMC_NUM_MINORS);
514 if (devidx >= MMC_NUM_MINORS)
515 return ERR_PTR(-ENOSPC);
516 __set_bit(devidx, dev_use);
517
518 md = kzalloc(sizeof(struct mmc_blk_data), GFP_KERNEL);
519 if (!md) {
520 ret = -ENOMEM;
521 goto out;
522 }
523
524
525 /*
526 * Set the read-only status based on the supported commands
527 * and the write protect switch.
528 */
529 md->read_only = mmc_blk_readonly(card);
530
531 md->disk = alloc_disk(1 << MMC_SHIFT);
532 if (md->disk == NULL) {
533 ret = -ENOMEM;
534 goto err_kfree;
535 }
536
537 spin_lock_init(&md->lock);
538 md->usage = 1;
539
540 ret = mmc_init_queue(&md->queue, card, &md->lock);
541 if (ret)
542 goto err_putdisk;
543
544 md->queue.issue_fn = mmc_blk_issue_rq;
545 md->queue.data = md;
546
547 md->disk->major = MMC_BLOCK_MAJOR;
548 md->disk->first_minor = devidx << MMC_SHIFT;
549 md->disk->fops = &mmc_bdops;
550 md->disk->private_data = md;
551 md->disk->queue = md->queue.queue;
552 md->disk->driverfs_dev = &card->dev;
553
554 /*
555 * As discussed on lkml, GENHD_FL_REMOVABLE should:
556 *
557 * - be set for removable media with permanent block devices
558 * - be unset for removable block devices with permanent media
559 *
560 * Since MMC block devices clearly fall under the second
561 * case, we do not set GENHD_FL_REMOVABLE. Userspace
562 * should use the block device creation/destruction hotplug
563 * messages to tell when the card is present.
564 */
565
566 sprintf(md->disk->disk_name, "mmcblk%d", devidx);
567
568 blk_queue_hardsect_size(md->queue.queue, 512);
569
570 if (!mmc_card_sd(card) && mmc_card_blockaddr(card)) {
571 /*
572 * The EXT_CSD sector count is in number or 512 byte
573 * sectors.
574 */
575 set_capacity(md->disk, card->ext_csd.sectors);
576 } else {
577 /*
578 * The CSD capacity field is in units of read_blkbits.
579 * set_capacity takes units of 512 bytes.
580 */
581 set_capacity(md->disk,
582 card->csd.capacity << (card->csd.read_blkbits - 9));
583 }
584 return md;
585
586 err_putdisk:
587 put_disk(md->disk);
588 err_kfree:
589 kfree(md);
590 out:
591 return ERR_PTR(ret);
592 }
593
mmc_blk_probe(struct mmc_card * card)594 static int mmc_blk_probe(struct mmc_card *card)
595 {
596 struct mmc_blk_data *md;
597 int err;
598
599 char cap_str[10];
600
601 /*
602 * Check that the card supports the command class(es) we need.
603 */
604 if (!(card->csd.cmdclass & CCC_BLOCK_READ))
605 return -ENODEV;
606
607 md = mmc_blk_alloc(card);
608 if (IS_ERR(md))
609 return PTR_ERR(md);
610
611 err = mmc_blk_set_blksize(md, card);
612 if (err)
613 goto out;
614
615 string_get_size((u64)get_capacity(md->disk) << 9, STRING_UNITS_2,
616 cap_str, sizeof(cap_str));
617 printk(KERN_INFO "%s: %s %s %s %s\n",
618 md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
619 cap_str, md->read_only ? "(ro)" : "");
620
621 mmc_set_drvdata(card, md);
622 #ifdef CONFIG_MMC_BLOCK_DEFERRED_RESUME
623 mmc_set_bus_resume_policy(card->host, 1);
624 #endif
625 add_disk(md->disk);
626 return 0;
627
628 out:
629 mmc_blk_put(md);
630
631 return err;
632 }
633
mmc_blk_remove(struct mmc_card * card)634 static void mmc_blk_remove(struct mmc_card *card)
635 {
636 struct mmc_blk_data *md = mmc_get_drvdata(card);
637
638 if (md) {
639 /* Stop new requests from getting into the queue */
640 del_gendisk(md->disk);
641
642 /* Then flush out any already in there */
643 mmc_cleanup_queue(&md->queue);
644
645 mmc_blk_put(md);
646 }
647 mmc_set_drvdata(card, NULL);
648 #ifdef CONFIG_MMC_BLOCK_DEFERRED_RESUME
649 mmc_set_bus_resume_policy(card->host, 0);
650 #endif
651 }
652
653 #ifdef CONFIG_PM
mmc_blk_suspend(struct mmc_card * card,pm_message_t state)654 static int mmc_blk_suspend(struct mmc_card *card, pm_message_t state)
655 {
656 struct mmc_blk_data *md = mmc_get_drvdata(card);
657
658 if (md) {
659 mmc_queue_suspend(&md->queue);
660 }
661 return 0;
662 }
663
mmc_blk_resume(struct mmc_card * card)664 static int mmc_blk_resume(struct mmc_card *card)
665 {
666 struct mmc_blk_data *md = mmc_get_drvdata(card);
667
668 if (md) {
669 #ifndef CONFIG_MMC_BLOCK_DEFERRED_RESUME
670 mmc_blk_set_blksize(md, card);
671 #endif
672 mmc_queue_resume(&md->queue);
673 }
674 return 0;
675 }
676 #else
677 #define mmc_blk_suspend NULL
678 #define mmc_blk_resume NULL
679 #endif
680
681 static struct mmc_driver mmc_driver = {
682 .drv = {
683 .name = "mmcblk",
684 },
685 .probe = mmc_blk_probe,
686 .remove = mmc_blk_remove,
687 .suspend = mmc_blk_suspend,
688 .resume = mmc_blk_resume,
689 };
690
mmc_blk_init(void)691 static int __init mmc_blk_init(void)
692 {
693 int res;
694
695 res = register_blkdev(MMC_BLOCK_MAJOR, "mmc");
696 if (res)
697 goto out;
698
699 res = mmc_register_driver(&mmc_driver);
700 if (res)
701 goto out2;
702
703 return 0;
704 out2:
705 unregister_blkdev(MMC_BLOCK_MAJOR, "mmc");
706 out:
707 return res;
708 }
709
mmc_blk_exit(void)710 static void __exit mmc_blk_exit(void)
711 {
712 mmc_unregister_driver(&mmc_driver);
713 unregister_blkdev(MMC_BLOCK_MAJOR, "mmc");
714 }
715
716 module_init(mmc_blk_init);
717 module_exit(mmc_blk_exit);
718
719 MODULE_LICENSE("GPL");
720 MODULE_DESCRIPTION("Multimedia Card (MMC) block device driver");
721
722