mmc_block.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579
  1. /*
  2. * Block driver for media (i.e., flash cards)
  3. *
  4. * Copyright 2002 Hewlett-Packard Company
  5. *
  6. * Use consistent with the GNU GPL is permitted,
  7. * provided that this copyright notice is
  8. * preserved in its entirety in all copies and derived works.
  9. *
  10. * HEWLETT-PACKARD COMPANY MAKES NO WARRANTIES, EXPRESSED OR IMPLIED,
  11. * AS TO THE USEFULNESS OR CORRECTNESS OF THIS CODE OR ITS
  12. * FITNESS FOR ANY PARTICULAR PURPOSE.
  13. *
  14. * Many thanks to Alessandro Rubini and Jonathan Corbet!
  15. *
  16. * Author: Andrew Christian
  17. * 28 May 2002
  18. */
  19. #include <linux/moduleparam.h>
  20. #include <linux/module.h>
  21. #include <linux/init.h>
  22. #include <linux/sched.h>
  23. #include <linux/kernel.h>
  24. #include <linux/fs.h>
  25. #include <linux/errno.h>
  26. #include <linux/hdreg.h>
  27. #include <linux/kdev_t.h>
  28. #include <linux/blkdev.h>
  29. #include <linux/devfs_fs_kernel.h>
  30. #include <linux/mutex.h>
  31. #include <linux/mmc/card.h>
  32. #include <linux/mmc/protocol.h>
  33. #include <asm/system.h>
  34. #include <asm/uaccess.h>
  35. #include "mmc_queue.h"
  36. /*
  37. * max 8 partitions per card
  38. */
  39. #define MMC_SHIFT 3
  40. static int major;
  41. /*
  42. * There is one mmc_blk_data per slot.
  43. */
  44. struct mmc_blk_data {
  45. spinlock_t lock;
  46. struct gendisk *disk;
  47. struct mmc_queue queue;
  48. unsigned int usage;
  49. unsigned int block_bits;
  50. unsigned int read_only;
  51. };
  52. static DEFINE_MUTEX(open_lock);
  53. static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk)
  54. {
  55. struct mmc_blk_data *md;
  56. mutex_lock(&open_lock);
  57. md = disk->private_data;
  58. if (md && md->usage == 0)
  59. md = NULL;
  60. if (md)
  61. md->usage++;
  62. mutex_unlock(&open_lock);
  63. return md;
  64. }
  65. static void mmc_blk_put(struct mmc_blk_data *md)
  66. {
  67. mutex_lock(&open_lock);
  68. md->usage--;
  69. if (md->usage == 0) {
  70. put_disk(md->disk);
  71. mmc_cleanup_queue(&md->queue);
  72. kfree(md);
  73. }
  74. mutex_unlock(&open_lock);
  75. }
  76. static int mmc_blk_open(struct inode *inode, struct file *filp)
  77. {
  78. struct mmc_blk_data *md;
  79. int ret = -ENXIO;
  80. md = mmc_blk_get(inode->i_bdev->bd_disk);
  81. if (md) {
  82. if (md->usage == 2)
  83. check_disk_change(inode->i_bdev);
  84. ret = 0;
  85. if ((filp->f_mode & FMODE_WRITE) && md->read_only)
  86. ret = -EROFS;
  87. }
  88. return ret;
  89. }
  90. static int mmc_blk_release(struct inode *inode, struct file *filp)
  91. {
  92. struct mmc_blk_data *md = inode->i_bdev->bd_disk->private_data;
  93. mmc_blk_put(md);
  94. return 0;
  95. }
  96. static int
  97. mmc_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
  98. {
  99. geo->cylinders = get_capacity(bdev->bd_disk) / (4 * 16);
  100. geo->heads = 4;
  101. geo->sectors = 16;
  102. return 0;
  103. }
  104. static struct block_device_operations mmc_bdops = {
  105. .open = mmc_blk_open,
  106. .release = mmc_blk_release,
  107. .getgeo = mmc_blk_getgeo,
  108. .owner = THIS_MODULE,
  109. };
  110. struct mmc_blk_request {
  111. struct mmc_request mrq;
  112. struct mmc_command cmd;
  113. struct mmc_command stop;
  114. struct mmc_data data;
  115. };
  116. static int mmc_blk_prep_rq(struct mmc_queue *mq, struct request *req)
  117. {
  118. struct mmc_blk_data *md = mq->data;
  119. int stat = BLKPREP_OK;
  120. /*
  121. * If we have no device, we haven't finished initialising.
  122. */
  123. if (!md || !mq->card) {
  124. printk(KERN_ERR "%s: killing request - no device/host\n",
  125. req->rq_disk->disk_name);
  126. stat = BLKPREP_KILL;
  127. }
  128. return stat;
  129. }
  130. static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
  131. {
  132. struct mmc_blk_data *md = mq->data;
  133. struct mmc_card *card = md->queue.card;
  134. int ret;
  135. if (mmc_card_claim_host(card))
  136. goto cmd_err;
  137. do {
  138. struct mmc_blk_request brq;
  139. struct mmc_command cmd;
  140. memset(&brq, 0, sizeof(struct mmc_blk_request));
  141. brq.mrq.cmd = &brq.cmd;
  142. brq.mrq.data = &brq.data;
  143. brq.cmd.arg = req->sector << 9;
  144. brq.cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
  145. brq.data.timeout_ns = card->csd.tacc_ns * 10;
  146. brq.data.timeout_clks = card->csd.tacc_clks * 10;
  147. brq.data.blksz_bits = md->block_bits;
  148. brq.data.blksz = 1 << md->block_bits;
  149. brq.data.blocks = req->nr_sectors >> (md->block_bits - 9);
  150. brq.stop.opcode = MMC_STOP_TRANSMISSION;
  151. brq.stop.arg = 0;
  152. brq.stop.flags = MMC_RSP_R1B | MMC_CMD_AC;
  153. if (rq_data_dir(req) == READ) {
  154. brq.cmd.opcode = brq.data.blocks > 1 ? MMC_READ_MULTIPLE_BLOCK : MMC_READ_SINGLE_BLOCK;
  155. brq.data.flags |= MMC_DATA_READ;
  156. } else {
  157. brq.cmd.opcode = MMC_WRITE_BLOCK;
  158. brq.data.flags |= MMC_DATA_WRITE;
  159. brq.data.blocks = 1;
  160. /*
  161. * Scale up the timeout by the r2w factor
  162. */
  163. brq.data.timeout_ns <<= card->csd.r2w_factor;
  164. brq.data.timeout_clks <<= card->csd.r2w_factor;
  165. }
  166. if (brq.data.blocks > 1) {
  167. brq.data.flags |= MMC_DATA_MULTI;
  168. brq.mrq.stop = &brq.stop;
  169. } else {
  170. brq.mrq.stop = NULL;
  171. }
  172. brq.data.sg = mq->sg;
  173. brq.data.sg_len = blk_rq_map_sg(req->q, req, brq.data.sg);
  174. mmc_wait_for_req(card->host, &brq.mrq);
  175. if (brq.cmd.error) {
  176. printk(KERN_ERR "%s: error %d sending read/write command\n",
  177. req->rq_disk->disk_name, brq.cmd.error);
  178. goto cmd_err;
  179. }
  180. if (brq.data.error) {
  181. printk(KERN_ERR "%s: error %d transferring data\n",
  182. req->rq_disk->disk_name, brq.data.error);
  183. goto cmd_err;
  184. }
  185. if (brq.stop.error) {
  186. printk(KERN_ERR "%s: error %d sending stop command\n",
  187. req->rq_disk->disk_name, brq.stop.error);
  188. goto cmd_err;
  189. }
  190. do {
  191. int err;
  192. cmd.opcode = MMC_SEND_STATUS;
  193. cmd.arg = card->rca << 16;
  194. cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
  195. err = mmc_wait_for_cmd(card->host, &cmd, 5);
  196. if (err) {
  197. printk(KERN_ERR "%s: error %d requesting status\n",
  198. req->rq_disk->disk_name, err);
  199. goto cmd_err;
  200. }
  201. } while (!(cmd.resp[0] & R1_READY_FOR_DATA));
  202. #if 0
  203. if (cmd.resp[0] & ~0x00000900)
  204. printk(KERN_ERR "%s: status = %08x\n",
  205. req->rq_disk->disk_name, cmd.resp[0]);
  206. if (mmc_decode_status(cmd.resp))
  207. goto cmd_err;
  208. #endif
  209. /*
  210. * A block was successfully transferred.
  211. */
  212. spin_lock_irq(&md->lock);
  213. ret = end_that_request_chunk(req, 1, brq.data.bytes_xfered);
  214. if (!ret) {
  215. /*
  216. * The whole request completed successfully.
  217. */
  218. add_disk_randomness(req->rq_disk);
  219. blkdev_dequeue_request(req);
  220. end_that_request_last(req, 1);
  221. }
  222. spin_unlock_irq(&md->lock);
  223. } while (ret);
  224. mmc_card_release_host(card);
  225. return 1;
  226. cmd_err:
  227. mmc_card_release_host(card);
  228. /*
  229. * This is a little draconian, but until we get proper
  230. * error handling sorted out here, its the best we can
  231. * do - especially as some hosts have no idea how much
  232. * data was transferred before the error occurred.
  233. */
  234. spin_lock_irq(&md->lock);
  235. do {
  236. ret = end_that_request_chunk(req, 0,
  237. req->current_nr_sectors << 9);
  238. } while (ret);
  239. add_disk_randomness(req->rq_disk);
  240. blkdev_dequeue_request(req);
  241. end_that_request_last(req, 0);
  242. spin_unlock_irq(&md->lock);
  243. return 0;
  244. }
  245. #define MMC_NUM_MINORS (256 >> MMC_SHIFT)
  246. static unsigned long dev_use[MMC_NUM_MINORS/(8*sizeof(unsigned long))];
  247. static inline int mmc_blk_readonly(struct mmc_card *card)
  248. {
  249. return mmc_card_readonly(card) ||
  250. !(card->csd.cmdclass & CCC_BLOCK_WRITE);
  251. }
  252. static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
  253. {
  254. struct mmc_blk_data *md;
  255. int devidx, ret;
  256. devidx = find_first_zero_bit(dev_use, MMC_NUM_MINORS);
  257. if (devidx >= MMC_NUM_MINORS)
  258. return ERR_PTR(-ENOSPC);
  259. __set_bit(devidx, dev_use);
  260. md = kmalloc(sizeof(struct mmc_blk_data), GFP_KERNEL);
  261. if (!md) {
  262. ret = -ENOMEM;
  263. goto out;
  264. }
  265. memset(md, 0, sizeof(struct mmc_blk_data));
  266. /*
  267. * Set the read-only status based on the supported commands
  268. * and the write protect switch.
  269. */
  270. md->read_only = mmc_blk_readonly(card);
  271. /*
  272. * Figure out a workable block size. MMC cards have:
  273. * - two block sizes, one for read and one for write.
  274. * - may support partial reads and/or writes
  275. * (allows block sizes smaller than specified)
  276. */
  277. md->block_bits = card->csd.read_blkbits;
  278. if (card->csd.write_blkbits != card->csd.read_blkbits) {
  279. if (card->csd.write_blkbits < card->csd.read_blkbits &&
  280. card->csd.read_partial) {
  281. /*
  282. * write block size is smaller than read block
  283. * size, but we support partial reads, so choose
  284. * the smaller write block size.
  285. */
  286. md->block_bits = card->csd.write_blkbits;
  287. } else if (card->csd.write_blkbits > card->csd.read_blkbits &&
  288. card->csd.write_partial) {
  289. /*
  290. * read block size is smaller than write block
  291. * size, but we support partial writes. Use read
  292. * block size.
  293. */
  294. } else {
  295. /*
  296. * We don't support this configuration for writes.
  297. */
  298. printk(KERN_ERR "%s: unable to select block size for "
  299. "writing (rb%u wb%u rp%u wp%u)\n",
  300. md->disk->disk_name,
  301. 1 << card->csd.read_blkbits,
  302. 1 << card->csd.write_blkbits,
  303. card->csd.read_partial,
  304. card->csd.write_partial);
  305. md->read_only = 1;
  306. }
  307. }
  308. /*
  309. * Refuse to allow block sizes smaller than 512 bytes.
  310. */
  311. if (md->block_bits < 9) {
  312. printk(KERN_ERR "%s: unable to support block size %u\n",
  313. mmc_card_id(card), 1 << md->block_bits);
  314. ret = -EINVAL;
  315. goto err_kfree;
  316. }
  317. md->disk = alloc_disk(1 << MMC_SHIFT);
  318. if (md->disk == NULL) {
  319. ret = -ENOMEM;
  320. goto err_kfree;
  321. }
  322. spin_lock_init(&md->lock);
  323. md->usage = 1;
  324. ret = mmc_init_queue(&md->queue, card, &md->lock);
  325. if (ret)
  326. goto err_putdisk;
  327. md->queue.prep_fn = mmc_blk_prep_rq;
  328. md->queue.issue_fn = mmc_blk_issue_rq;
  329. md->queue.data = md;
  330. md->disk->major = major;
  331. md->disk->first_minor = devidx << MMC_SHIFT;
  332. md->disk->fops = &mmc_bdops;
  333. md->disk->private_data = md;
  334. md->disk->queue = md->queue.queue;
  335. md->disk->driverfs_dev = &card->dev;
  336. /*
  337. * As discussed on lkml, GENHD_FL_REMOVABLE should:
  338. *
  339. * - be set for removable media with permanent block devices
  340. * - be unset for removable block devices with permanent media
  341. *
  342. * Since MMC block devices clearly fall under the second
  343. * case, we do not set GENHD_FL_REMOVABLE. Userspace
  344. * should use the block device creation/destruction hotplug
  345. * messages to tell when the card is present.
  346. */
  347. sprintf(md->disk->disk_name, "mmcblk%d", devidx);
  348. sprintf(md->disk->devfs_name, "mmc/blk%d", devidx);
  349. blk_queue_hardsect_size(md->queue.queue, 1 << md->block_bits);
  350. /*
  351. * The CSD capacity field is in units of read_blkbits.
  352. * set_capacity takes units of 512 bytes.
  353. */
  354. set_capacity(md->disk, card->csd.capacity << (card->csd.read_blkbits - 9));
  355. return md;
  356. err_putdisk:
  357. put_disk(md->disk);
  358. err_kfree:
  359. kfree(md);
  360. out:
  361. return ERR_PTR(ret);
  362. }
  363. static int
  364. mmc_blk_set_blksize(struct mmc_blk_data *md, struct mmc_card *card)
  365. {
  366. struct mmc_command cmd;
  367. int err;
  368. mmc_card_claim_host(card);
  369. cmd.opcode = MMC_SET_BLOCKLEN;
  370. cmd.arg = 1 << md->block_bits;
  371. cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
  372. err = mmc_wait_for_cmd(card->host, &cmd, 5);
  373. mmc_card_release_host(card);
  374. if (err) {
  375. printk(KERN_ERR "%s: unable to set block size to %d: %d\n",
  376. md->disk->disk_name, cmd.arg, err);
  377. return -EINVAL;
  378. }
  379. return 0;
  380. }
  381. static int mmc_blk_probe(struct mmc_card *card)
  382. {
  383. struct mmc_blk_data *md;
  384. int err;
  385. /*
  386. * Check that the card supports the command class(es) we need.
  387. */
  388. if (!(card->csd.cmdclass & CCC_BLOCK_READ))
  389. return -ENODEV;
  390. md = mmc_blk_alloc(card);
  391. if (IS_ERR(md))
  392. return PTR_ERR(md);
  393. err = mmc_blk_set_blksize(md, card);
  394. if (err)
  395. goto out;
  396. printk(KERN_INFO "%s: %s %s %lluKiB %s\n",
  397. md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
  398. (unsigned long long)(get_capacity(md->disk) >> 1),
  399. md->read_only ? "(ro)" : "");
  400. mmc_set_drvdata(card, md);
  401. add_disk(md->disk);
  402. return 0;
  403. out:
  404. mmc_blk_put(md);
  405. return err;
  406. }
  407. static void mmc_blk_remove(struct mmc_card *card)
  408. {
  409. struct mmc_blk_data *md = mmc_get_drvdata(card);
  410. if (md) {
  411. int devidx;
  412. del_gendisk(md->disk);
  413. /*
  414. * I think this is needed.
  415. */
  416. md->disk->queue = NULL;
  417. devidx = md->disk->first_minor >> MMC_SHIFT;
  418. __clear_bit(devidx, dev_use);
  419. mmc_blk_put(md);
  420. }
  421. mmc_set_drvdata(card, NULL);
  422. }
  423. #ifdef CONFIG_PM
  424. static int mmc_blk_suspend(struct mmc_card *card, pm_message_t state)
  425. {
  426. struct mmc_blk_data *md = mmc_get_drvdata(card);
  427. if (md) {
  428. mmc_queue_suspend(&md->queue);
  429. }
  430. return 0;
  431. }
  432. static int mmc_blk_resume(struct mmc_card *card)
  433. {
  434. struct mmc_blk_data *md = mmc_get_drvdata(card);
  435. if (md) {
  436. mmc_blk_set_blksize(md, card);
  437. mmc_queue_resume(&md->queue);
  438. }
  439. return 0;
  440. }
  441. #else
  442. #define mmc_blk_suspend NULL
  443. #define mmc_blk_resume NULL
  444. #endif
  445. static struct mmc_driver mmc_driver = {
  446. .drv = {
  447. .name = "mmcblk",
  448. },
  449. .probe = mmc_blk_probe,
  450. .remove = mmc_blk_remove,
  451. .suspend = mmc_blk_suspend,
  452. .resume = mmc_blk_resume,
  453. };
  454. static int __init mmc_blk_init(void)
  455. {
  456. int res = -ENOMEM;
  457. res = register_blkdev(major, "mmc");
  458. if (res < 0) {
  459. printk(KERN_WARNING "Unable to get major %d for MMC media: %d\n",
  460. major, res);
  461. goto out;
  462. }
  463. if (major == 0)
  464. major = res;
  465. devfs_mk_dir("mmc");
  466. return mmc_register_driver(&mmc_driver);
  467. out:
  468. return res;
  469. }
  470. static void __exit mmc_blk_exit(void)
  471. {
  472. mmc_unregister_driver(&mmc_driver);
  473. devfs_remove("mmc");
  474. unregister_blkdev(major, "mmc");
  475. }
  476. module_init(mmc_blk_init);
  477. module_exit(mmc_blk_exit);
  478. MODULE_LICENSE("GPL");
  479. MODULE_DESCRIPTION("Multimedia Card (MMC) block device driver");
  480. module_param(major, int, 0444);
  481. MODULE_PARM_DESC(major, "specify the major device number for MMC block driver");