Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Block driver for media (i.e., flash cards) |
| 3 | * |
| 4 | * Copyright 2002 Hewlett-Packard Company |
Pierre Ossman | 979ce72 | 2008-06-29 12:19:47 +0200 | [diff] [blame] | 5 | * Copyright 2005-2008 Pierre Ossman |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | #include <linux/kernel.h> |
| 25 | #include <linux/fs.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 26 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | #include <linux/errno.h> |
| 28 | #include <linux/hdreg.h> |
| 29 | #include <linux/kdev_t.h> |
| 30 | #include <linux/blkdev.h> |
Arjan van de Ven | a621aae | 2006-01-12 18:43:35 +0000 | [diff] [blame] | 31 | #include <linux/mutex.h> |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 32 | #include <linux/scatterlist.h> |
Pierre Ossman | a7bbb57 | 2008-09-06 10:57:57 +0200 | [diff] [blame] | 33 | #include <linux/string_helpers.h> |
John Calixto | cb87ea2 | 2011-04-26 18:56:29 -0400 | [diff] [blame] | 34 | #include <linux/delay.h> |
| 35 | #include <linux/capability.h> |
| 36 | #include <linux/compat.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | |
John Calixto | cb87ea2 | 2011-04-26 18:56:29 -0400 | [diff] [blame] | 38 | #include <linux/mmc/ioctl.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | #include <linux/mmc/card.h> |
Pierre Ossman | 385e322 | 2006-06-18 14:34:37 +0200 | [diff] [blame] | 40 | #include <linux/mmc/host.h> |
Pierre Ossman | da7fbe5 | 2006-12-24 22:46:55 +0100 | [diff] [blame] | 41 | #include <linux/mmc/mmc.h> |
| 42 | #include <linux/mmc/sd.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | |
| 44 | #include <asm/system.h> |
| 45 | #include <asm/uaccess.h> |
| 46 | |
Pierre Ossman | 98ac216 | 2006-12-23 20:03:02 +0100 | [diff] [blame] | 47 | #include "queue.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | |
Andy Whitcroft | 6b0b628 | 2009-02-23 12:38:41 +0000 | [diff] [blame] | 49 | MODULE_ALIAS("mmc:block"); |
Olof Johansson | 5e71b7a | 2010-09-17 21:19:57 -0400 | [diff] [blame] | 50 | #ifdef MODULE_PARAM_PREFIX |
| 51 | #undef MODULE_PARAM_PREFIX |
| 52 | #endif |
| 53 | #define MODULE_PARAM_PREFIX "mmcblk." |
David Woodhouse | 1dff314 | 2007-11-21 18:45:12 +0100 | [diff] [blame] | 54 | |
Andrei Warkentin | 6a7a6b4 | 2011-04-12 15:06:53 -0500 | [diff] [blame] | 55 | #define INAND_CMD38_ARG_EXT_CSD 113 |
| 56 | #define INAND_CMD38_ARG_ERASE 0x00 |
| 57 | #define INAND_CMD38_ARG_TRIM 0x01 |
| 58 | #define INAND_CMD38_ARG_SECERASE 0x80 |
| 59 | #define INAND_CMD38_ARG_SECTRIM1 0x81 |
| 60 | #define INAND_CMD38_ARG_SECTRIM2 0x88 |
| 61 | |
Arnd Bergmann | 2a48fc0 | 2010-06-02 14:28:52 +0200 | [diff] [blame] | 62 | static DEFINE_MUTEX(block_mutex); |
Olof Johansson | 5e71b7a | 2010-09-17 21:19:57 -0400 | [diff] [blame] | 63 | |
| 64 | /* |
| 65 | * The defaults come from config options but can be overriden by module |
| 66 | * or bootarg options. |
| 67 | */ |
| 68 | static int perdev_minors = CONFIG_MMC_BLOCK_MINORS; |
| 69 | |
| 70 | /* |
| 71 | * We've only got one major, so number of mmcblk devices is |
| 72 | * limited to 256 / number of minors per device. |
| 73 | */ |
| 74 | static int max_devices; |
| 75 | |
| 76 | /* 256 minors, so at most 256 separate devices */ |
| 77 | static DECLARE_BITMAP(dev_use, 256); |
Andrei Warkentin | f06c915 | 2011-04-21 22:46:13 -0500 | [diff] [blame] | 78 | static DECLARE_BITMAP(name_use, 256); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | /* |
| 81 | * There is one mmc_blk_data per slot. |
| 82 | */ |
| 83 | struct mmc_blk_data { |
| 84 | spinlock_t lock; |
| 85 | struct gendisk *disk; |
| 86 | struct mmc_queue queue; |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 87 | struct list_head part; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 88 | |
Andrei Warkentin | d0c97cf | 2011-05-23 15:06:36 -0500 | [diff] [blame] | 89 | unsigned int flags; |
| 90 | #define MMC_BLK_CMD23 (1 << 0) /* Can do SET_BLOCK_COUNT for multiblock */ |
| 91 | #define MMC_BLK_REL_WR (1 << 1) /* MMC Reliable write support */ |
| 92 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | unsigned int usage; |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 94 | unsigned int read_only; |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 95 | unsigned int part_type; |
Andrei Warkentin | f06c915 | 2011-04-21 22:46:13 -0500 | [diff] [blame] | 96 | unsigned int name_idx; |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 97 | |
| 98 | /* |
| 99 | * Only set in main mmc_blk_data associated |
| 100 | * with mmc_card with mmc_set_drvdata, and keeps |
| 101 | * track of the current selected device partition. |
| 102 | */ |
| 103 | unsigned int part_curr; |
| 104 | struct device_attribute force_ro; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | }; |
| 106 | |
Arjan van de Ven | a621aae | 2006-01-12 18:43:35 +0000 | [diff] [blame] | 107 | static DEFINE_MUTEX(open_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 108 | |
Olof Johansson | 5e71b7a | 2010-09-17 21:19:57 -0400 | [diff] [blame] | 109 | module_param(perdev_minors, int, 0444); |
| 110 | MODULE_PARM_DESC(perdev_minors, "Minors numbers to allocate per device"); |
| 111 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk) |
| 113 | { |
| 114 | struct mmc_blk_data *md; |
| 115 | |
Arjan van de Ven | a621aae | 2006-01-12 18:43:35 +0000 | [diff] [blame] | 116 | mutex_lock(&open_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | md = disk->private_data; |
| 118 | if (md && md->usage == 0) |
| 119 | md = NULL; |
| 120 | if (md) |
| 121 | md->usage++; |
Arjan van de Ven | a621aae | 2006-01-12 18:43:35 +0000 | [diff] [blame] | 122 | mutex_unlock(&open_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 123 | |
| 124 | return md; |
| 125 | } |
| 126 | |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 127 | static inline int mmc_get_devidx(struct gendisk *disk) |
| 128 | { |
Colin Cross | fa746fa | 2010-09-03 12:41:21 -0700 | [diff] [blame^] | 129 | int devidx = disk->first_minor / perdev_minors; |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 130 | return devidx; |
| 131 | } |
| 132 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | static void mmc_blk_put(struct mmc_blk_data *md) |
| 134 | { |
Arjan van de Ven | a621aae | 2006-01-12 18:43:35 +0000 | [diff] [blame] | 135 | mutex_lock(&open_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 136 | md->usage--; |
| 137 | if (md->usage == 0) { |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 138 | int devidx = mmc_get_devidx(md->disk); |
Adrian Hunter | 5fa83ce | 2010-01-08 14:43:00 -0800 | [diff] [blame] | 139 | blk_cleanup_queue(md->queue.queue); |
| 140 | |
David Woodhouse | 1dff314 | 2007-11-21 18:45:12 +0100 | [diff] [blame] | 141 | __clear_bit(devidx, dev_use); |
| 142 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | put_disk(md->disk); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | kfree(md); |
| 145 | } |
Arjan van de Ven | a621aae | 2006-01-12 18:43:35 +0000 | [diff] [blame] | 146 | mutex_unlock(&open_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 147 | } |
| 148 | |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 149 | static ssize_t force_ro_show(struct device *dev, struct device_attribute *attr, |
| 150 | char *buf) |
| 151 | { |
| 152 | int ret; |
| 153 | struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev)); |
| 154 | |
| 155 | ret = snprintf(buf, PAGE_SIZE, "%d", |
| 156 | get_disk_ro(dev_to_disk(dev)) ^ |
| 157 | md->read_only); |
| 158 | mmc_blk_put(md); |
| 159 | return ret; |
| 160 | } |
| 161 | |
| 162 | static ssize_t force_ro_store(struct device *dev, struct device_attribute *attr, |
| 163 | const char *buf, size_t count) |
| 164 | { |
| 165 | int ret; |
| 166 | char *end; |
| 167 | struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev)); |
| 168 | unsigned long set = simple_strtoul(buf, &end, 0); |
| 169 | if (end == buf) { |
| 170 | ret = -EINVAL; |
| 171 | goto out; |
| 172 | } |
| 173 | |
| 174 | set_disk_ro(dev_to_disk(dev), set || md->read_only); |
| 175 | ret = count; |
| 176 | out: |
| 177 | mmc_blk_put(md); |
| 178 | return ret; |
| 179 | } |
| 180 | |
Al Viro | a5a1561 | 2008-03-02 10:33:30 -0500 | [diff] [blame] | 181 | static int mmc_blk_open(struct block_device *bdev, fmode_t mode) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | { |
Al Viro | a5a1561 | 2008-03-02 10:33:30 -0500 | [diff] [blame] | 183 | struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 184 | int ret = -ENXIO; |
| 185 | |
Arnd Bergmann | 2a48fc0 | 2010-06-02 14:28:52 +0200 | [diff] [blame] | 186 | mutex_lock(&block_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 187 | if (md) { |
| 188 | if (md->usage == 2) |
Al Viro | a5a1561 | 2008-03-02 10:33:30 -0500 | [diff] [blame] | 189 | check_disk_change(bdev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | ret = 0; |
Pierre Ossman | a00fc09 | 2005-09-06 15:18:52 -0700 | [diff] [blame] | 191 | |
Al Viro | a5a1561 | 2008-03-02 10:33:30 -0500 | [diff] [blame] | 192 | if ((mode & FMODE_WRITE) && md->read_only) { |
Andrew Morton | 70bb089 | 2008-09-05 14:00:24 -0700 | [diff] [blame] | 193 | mmc_blk_put(md); |
Pierre Ossman | a00fc09 | 2005-09-06 15:18:52 -0700 | [diff] [blame] | 194 | ret = -EROFS; |
Andrew Morton | 70bb089 | 2008-09-05 14:00:24 -0700 | [diff] [blame] | 195 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | } |
Arnd Bergmann | 2a48fc0 | 2010-06-02 14:28:52 +0200 | [diff] [blame] | 197 | mutex_unlock(&block_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 198 | |
| 199 | return ret; |
| 200 | } |
| 201 | |
Al Viro | a5a1561 | 2008-03-02 10:33:30 -0500 | [diff] [blame] | 202 | static int mmc_blk_release(struct gendisk *disk, fmode_t mode) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 203 | { |
Al Viro | a5a1561 | 2008-03-02 10:33:30 -0500 | [diff] [blame] | 204 | struct mmc_blk_data *md = disk->private_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 205 | |
Arnd Bergmann | 2a48fc0 | 2010-06-02 14:28:52 +0200 | [diff] [blame] | 206 | mutex_lock(&block_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 207 | mmc_blk_put(md); |
Arnd Bergmann | 2a48fc0 | 2010-06-02 14:28:52 +0200 | [diff] [blame] | 208 | mutex_unlock(&block_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 209 | return 0; |
| 210 | } |
| 211 | |
| 212 | static int |
Christoph Hellwig | a885c8c | 2006-01-08 01:02:50 -0800 | [diff] [blame] | 213 | mmc_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 214 | { |
Christoph Hellwig | a885c8c | 2006-01-08 01:02:50 -0800 | [diff] [blame] | 215 | geo->cylinders = get_capacity(bdev->bd_disk) / (4 * 16); |
| 216 | geo->heads = 4; |
| 217 | geo->sectors = 16; |
| 218 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 219 | } |
| 220 | |
John Calixto | cb87ea2 | 2011-04-26 18:56:29 -0400 | [diff] [blame] | 221 | struct mmc_blk_ioc_data { |
| 222 | struct mmc_ioc_cmd ic; |
| 223 | unsigned char *buf; |
| 224 | u64 buf_bytes; |
| 225 | }; |
| 226 | |
| 227 | static struct mmc_blk_ioc_data *mmc_blk_ioctl_copy_from_user( |
| 228 | struct mmc_ioc_cmd __user *user) |
| 229 | { |
| 230 | struct mmc_blk_ioc_data *idata; |
| 231 | int err; |
| 232 | |
| 233 | idata = kzalloc(sizeof(*idata), GFP_KERNEL); |
| 234 | if (!idata) { |
| 235 | err = -ENOMEM; |
Vladimir Motyka | aea253e | 2011-05-11 00:00:43 -0400 | [diff] [blame] | 236 | goto out; |
John Calixto | cb87ea2 | 2011-04-26 18:56:29 -0400 | [diff] [blame] | 237 | } |
| 238 | |
| 239 | if (copy_from_user(&idata->ic, user, sizeof(idata->ic))) { |
| 240 | err = -EFAULT; |
Vladimir Motyka | aea253e | 2011-05-11 00:00:43 -0400 | [diff] [blame] | 241 | goto idata_err; |
John Calixto | cb87ea2 | 2011-04-26 18:56:29 -0400 | [diff] [blame] | 242 | } |
| 243 | |
| 244 | idata->buf_bytes = (u64) idata->ic.blksz * idata->ic.blocks; |
| 245 | if (idata->buf_bytes > MMC_IOC_MAX_BYTES) { |
| 246 | err = -EOVERFLOW; |
Vladimir Motyka | aea253e | 2011-05-11 00:00:43 -0400 | [diff] [blame] | 247 | goto idata_err; |
John Calixto | cb87ea2 | 2011-04-26 18:56:29 -0400 | [diff] [blame] | 248 | } |
| 249 | |
| 250 | idata->buf = kzalloc(idata->buf_bytes, GFP_KERNEL); |
| 251 | if (!idata->buf) { |
| 252 | err = -ENOMEM; |
Vladimir Motyka | aea253e | 2011-05-11 00:00:43 -0400 | [diff] [blame] | 253 | goto idata_err; |
John Calixto | cb87ea2 | 2011-04-26 18:56:29 -0400 | [diff] [blame] | 254 | } |
| 255 | |
| 256 | if (copy_from_user(idata->buf, (void __user *)(unsigned long) |
| 257 | idata->ic.data_ptr, idata->buf_bytes)) { |
| 258 | err = -EFAULT; |
| 259 | goto copy_err; |
| 260 | } |
| 261 | |
| 262 | return idata; |
| 263 | |
| 264 | copy_err: |
| 265 | kfree(idata->buf); |
Vladimir Motyka | aea253e | 2011-05-11 00:00:43 -0400 | [diff] [blame] | 266 | idata_err: |
John Calixto | cb87ea2 | 2011-04-26 18:56:29 -0400 | [diff] [blame] | 267 | kfree(idata); |
Vladimir Motyka | aea253e | 2011-05-11 00:00:43 -0400 | [diff] [blame] | 268 | out: |
John Calixto | cb87ea2 | 2011-04-26 18:56:29 -0400 | [diff] [blame] | 269 | return ERR_PTR(err); |
John Calixto | cb87ea2 | 2011-04-26 18:56:29 -0400 | [diff] [blame] | 270 | } |
| 271 | |
| 272 | static int mmc_blk_ioctl_cmd(struct block_device *bdev, |
| 273 | struct mmc_ioc_cmd __user *ic_ptr) |
| 274 | { |
| 275 | struct mmc_blk_ioc_data *idata; |
| 276 | struct mmc_blk_data *md; |
| 277 | struct mmc_card *card; |
| 278 | struct mmc_command cmd = {0}; |
| 279 | struct mmc_data data = {0}; |
| 280 | struct mmc_request mrq = {0}; |
| 281 | struct scatterlist sg; |
| 282 | int err; |
| 283 | |
| 284 | /* |
| 285 | * The caller must have CAP_SYS_RAWIO, and must be calling this on the |
| 286 | * whole block device, not on a partition. This prevents overspray |
| 287 | * between sibling partitions. |
| 288 | */ |
| 289 | if ((!capable(CAP_SYS_RAWIO)) || (bdev != bdev->bd_contains)) |
| 290 | return -EPERM; |
| 291 | |
| 292 | idata = mmc_blk_ioctl_copy_from_user(ic_ptr); |
| 293 | if (IS_ERR(idata)) |
| 294 | return PTR_ERR(idata); |
| 295 | |
| 296 | cmd.opcode = idata->ic.opcode; |
| 297 | cmd.arg = idata->ic.arg; |
| 298 | cmd.flags = idata->ic.flags; |
| 299 | |
| 300 | data.sg = &sg; |
| 301 | data.sg_len = 1; |
| 302 | data.blksz = idata->ic.blksz; |
| 303 | data.blocks = idata->ic.blocks; |
| 304 | |
| 305 | sg_init_one(data.sg, idata->buf, idata->buf_bytes); |
| 306 | |
| 307 | if (idata->ic.write_flag) |
| 308 | data.flags = MMC_DATA_WRITE; |
| 309 | else |
| 310 | data.flags = MMC_DATA_READ; |
| 311 | |
| 312 | mrq.cmd = &cmd; |
| 313 | mrq.data = &data; |
| 314 | |
| 315 | md = mmc_blk_get(bdev->bd_disk); |
| 316 | if (!md) { |
| 317 | err = -EINVAL; |
| 318 | goto cmd_done; |
| 319 | } |
| 320 | |
| 321 | card = md->queue.card; |
| 322 | if (IS_ERR(card)) { |
| 323 | err = PTR_ERR(card); |
| 324 | goto cmd_done; |
| 325 | } |
| 326 | |
| 327 | mmc_claim_host(card->host); |
| 328 | |
| 329 | if (idata->ic.is_acmd) { |
| 330 | err = mmc_app_cmd(card->host, card); |
| 331 | if (err) |
| 332 | goto cmd_rel_host; |
| 333 | } |
| 334 | |
| 335 | /* data.flags must already be set before doing this. */ |
| 336 | mmc_set_data_timeout(&data, card); |
| 337 | /* Allow overriding the timeout_ns for empirical tuning. */ |
| 338 | if (idata->ic.data_timeout_ns) |
| 339 | data.timeout_ns = idata->ic.data_timeout_ns; |
| 340 | |
| 341 | if ((cmd.flags & MMC_RSP_R1B) == MMC_RSP_R1B) { |
| 342 | /* |
| 343 | * Pretend this is a data transfer and rely on the host driver |
| 344 | * to compute timeout. When all host drivers support |
| 345 | * cmd.cmd_timeout for R1B, this can be changed to: |
| 346 | * |
| 347 | * mrq.data = NULL; |
| 348 | * cmd.cmd_timeout = idata->ic.cmd_timeout_ms; |
| 349 | */ |
| 350 | data.timeout_ns = idata->ic.cmd_timeout_ms * 1000000; |
| 351 | } |
| 352 | |
| 353 | mmc_wait_for_req(card->host, &mrq); |
| 354 | |
| 355 | if (cmd.error) { |
| 356 | dev_err(mmc_dev(card->host), "%s: cmd error %d\n", |
| 357 | __func__, cmd.error); |
| 358 | err = cmd.error; |
| 359 | goto cmd_rel_host; |
| 360 | } |
| 361 | if (data.error) { |
| 362 | dev_err(mmc_dev(card->host), "%s: data error %d\n", |
| 363 | __func__, data.error); |
| 364 | err = data.error; |
| 365 | goto cmd_rel_host; |
| 366 | } |
| 367 | |
| 368 | /* |
| 369 | * According to the SD specs, some commands require a delay after |
| 370 | * issuing the command. |
| 371 | */ |
| 372 | if (idata->ic.postsleep_min_us) |
| 373 | usleep_range(idata->ic.postsleep_min_us, idata->ic.postsleep_max_us); |
| 374 | |
| 375 | if (copy_to_user(&(ic_ptr->response), cmd.resp, sizeof(cmd.resp))) { |
| 376 | err = -EFAULT; |
| 377 | goto cmd_rel_host; |
| 378 | } |
| 379 | |
| 380 | if (!idata->ic.write_flag) { |
| 381 | if (copy_to_user((void __user *)(unsigned long) idata->ic.data_ptr, |
| 382 | idata->buf, idata->buf_bytes)) { |
| 383 | err = -EFAULT; |
| 384 | goto cmd_rel_host; |
| 385 | } |
| 386 | } |
| 387 | |
| 388 | cmd_rel_host: |
| 389 | mmc_release_host(card->host); |
| 390 | |
| 391 | cmd_done: |
| 392 | mmc_blk_put(md); |
| 393 | kfree(idata->buf); |
| 394 | kfree(idata); |
| 395 | return err; |
| 396 | } |
| 397 | |
| 398 | static int mmc_blk_ioctl(struct block_device *bdev, fmode_t mode, |
| 399 | unsigned int cmd, unsigned long arg) |
| 400 | { |
| 401 | int ret = -EINVAL; |
| 402 | if (cmd == MMC_IOC_CMD) |
| 403 | ret = mmc_blk_ioctl_cmd(bdev, (struct mmc_ioc_cmd __user *)arg); |
| 404 | return ret; |
| 405 | } |
| 406 | |
| 407 | #ifdef CONFIG_COMPAT |
| 408 | static int mmc_blk_compat_ioctl(struct block_device *bdev, fmode_t mode, |
| 409 | unsigned int cmd, unsigned long arg) |
| 410 | { |
| 411 | return mmc_blk_ioctl(bdev, mode, cmd, (unsigned long) compat_ptr(arg)); |
| 412 | } |
| 413 | #endif |
| 414 | |
Alexey Dobriyan | 83d5cde | 2009-09-21 17:01:13 -0700 | [diff] [blame] | 415 | static const struct block_device_operations mmc_bdops = { |
Al Viro | a5a1561 | 2008-03-02 10:33:30 -0500 | [diff] [blame] | 416 | .open = mmc_blk_open, |
| 417 | .release = mmc_blk_release, |
Christoph Hellwig | a885c8c | 2006-01-08 01:02:50 -0800 | [diff] [blame] | 418 | .getgeo = mmc_blk_getgeo, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 419 | .owner = THIS_MODULE, |
John Calixto | cb87ea2 | 2011-04-26 18:56:29 -0400 | [diff] [blame] | 420 | .ioctl = mmc_blk_ioctl, |
| 421 | #ifdef CONFIG_COMPAT |
| 422 | .compat_ioctl = mmc_blk_compat_ioctl, |
| 423 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 424 | }; |
| 425 | |
| 426 | struct mmc_blk_request { |
| 427 | struct mmc_request mrq; |
Andrei Warkentin | d0c97cf | 2011-05-23 15:06:36 -0500 | [diff] [blame] | 428 | struct mmc_command sbc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 429 | struct mmc_command cmd; |
| 430 | struct mmc_command stop; |
| 431 | struct mmc_data data; |
| 432 | }; |
| 433 | |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 434 | static inline int mmc_blk_part_switch(struct mmc_card *card, |
| 435 | struct mmc_blk_data *md) |
| 436 | { |
| 437 | int ret; |
| 438 | struct mmc_blk_data *main_md = mmc_get_drvdata(card); |
| 439 | if (main_md->part_curr == md->part_type) |
| 440 | return 0; |
| 441 | |
| 442 | if (mmc_card_mmc(card)) { |
| 443 | card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK; |
| 444 | card->ext_csd.part_config |= md->part_type; |
| 445 | |
| 446 | ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, |
| 447 | EXT_CSD_PART_CONFIG, card->ext_csd.part_config, |
| 448 | card->ext_csd.part_time); |
| 449 | if (ret) |
| 450 | return ret; |
| 451 | } |
| 452 | |
| 453 | main_md->part_curr = md->part_type; |
| 454 | return 0; |
| 455 | } |
| 456 | |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 457 | static u32 mmc_sd_num_wr_blocks(struct mmc_card *card) |
| 458 | { |
| 459 | int err; |
Ben Dooks | 051913d | 2009-06-08 23:33:57 +0100 | [diff] [blame] | 460 | u32 result; |
| 461 | __be32 *blocks; |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 462 | |
Chris Ball | 24f5b53 | 2011-04-13 23:49:45 -0400 | [diff] [blame] | 463 | struct mmc_request mrq = {0}; |
Chris Ball | 1278dba | 2011-04-13 23:40:30 -0400 | [diff] [blame] | 464 | struct mmc_command cmd = {0}; |
Chris Ball | a61ad2b | 2011-04-13 23:46:05 -0400 | [diff] [blame] | 465 | struct mmc_data data = {0}; |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 466 | unsigned int timeout_us; |
| 467 | |
| 468 | struct scatterlist sg; |
| 469 | |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 470 | cmd.opcode = MMC_APP_CMD; |
| 471 | cmd.arg = card->rca << 16; |
David Brownell | 7213d17 | 2007-08-08 09:10:23 -0700 | [diff] [blame] | 472 | cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 473 | |
| 474 | err = mmc_wait_for_cmd(card->host, &cmd, 0); |
David Brownell | 7213d17 | 2007-08-08 09:10:23 -0700 | [diff] [blame] | 475 | if (err) |
| 476 | return (u32)-1; |
| 477 | if (!mmc_host_is_spi(card->host) && !(cmd.resp[0] & R1_APP_CMD)) |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 478 | return (u32)-1; |
| 479 | |
| 480 | memset(&cmd, 0, sizeof(struct mmc_command)); |
| 481 | |
| 482 | cmd.opcode = SD_APP_SEND_NUM_WR_BLKS; |
| 483 | cmd.arg = 0; |
David Brownell | 7213d17 | 2007-08-08 09:10:23 -0700 | [diff] [blame] | 484 | cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 485 | |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 486 | data.timeout_ns = card->csd.tacc_ns * 100; |
| 487 | data.timeout_clks = card->csd.tacc_clks * 100; |
| 488 | |
| 489 | timeout_us = data.timeout_ns / 1000; |
| 490 | timeout_us += data.timeout_clks * 1000 / |
| 491 | (card->host->ios.clock / 1000); |
| 492 | |
| 493 | if (timeout_us > 100000) { |
| 494 | data.timeout_ns = 100000000; |
| 495 | data.timeout_clks = 0; |
| 496 | } |
| 497 | |
| 498 | data.blksz = 4; |
| 499 | data.blocks = 1; |
| 500 | data.flags = MMC_DATA_READ; |
| 501 | data.sg = &sg; |
| 502 | data.sg_len = 1; |
| 503 | |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 504 | mrq.cmd = &cmd; |
| 505 | mrq.data = &data; |
| 506 | |
Ben Dooks | 051913d | 2009-06-08 23:33:57 +0100 | [diff] [blame] | 507 | blocks = kmalloc(4, GFP_KERNEL); |
| 508 | if (!blocks) |
| 509 | return (u32)-1; |
| 510 | |
| 511 | sg_init_one(&sg, blocks, 4); |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 512 | |
| 513 | mmc_wait_for_req(card->host, &mrq); |
| 514 | |
Ben Dooks | 051913d | 2009-06-08 23:33:57 +0100 | [diff] [blame] | 515 | result = ntohl(*blocks); |
| 516 | kfree(blocks); |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 517 | |
Ben Dooks | 051913d | 2009-06-08 23:33:57 +0100 | [diff] [blame] | 518 | if (cmd.error || data.error) |
| 519 | result = (u32)-1; |
| 520 | |
| 521 | return result; |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 522 | } |
| 523 | |
Adrian Hunter | 504f191 | 2008-10-16 12:55:25 +0300 | [diff] [blame] | 524 | static u32 get_card_status(struct mmc_card *card, struct request *req) |
| 525 | { |
Chris Ball | 1278dba | 2011-04-13 23:40:30 -0400 | [diff] [blame] | 526 | struct mmc_command cmd = {0}; |
Adrian Hunter | 504f191 | 2008-10-16 12:55:25 +0300 | [diff] [blame] | 527 | int err; |
| 528 | |
Adrian Hunter | 504f191 | 2008-10-16 12:55:25 +0300 | [diff] [blame] | 529 | cmd.opcode = MMC_SEND_STATUS; |
| 530 | if (!mmc_host_is_spi(card->host)) |
| 531 | cmd.arg = card->rca << 16; |
| 532 | cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC; |
| 533 | err = mmc_wait_for_cmd(card->host, &cmd, 0); |
| 534 | if (err) |
Uwe Kleine-König | b595076 | 2010-11-01 15:38:34 -0400 | [diff] [blame] | 535 | printk(KERN_ERR "%s: error %d sending status command", |
Adrian Hunter | 504f191 | 2008-10-16 12:55:25 +0300 | [diff] [blame] | 536 | req->rq_disk->disk_name, err); |
| 537 | return cmd.resp[0]; |
| 538 | } |
| 539 | |
Adrian Hunter | bd788c9 | 2010-08-11 14:17:47 -0700 | [diff] [blame] | 540 | static int mmc_blk_issue_discard_rq(struct mmc_queue *mq, struct request *req) |
| 541 | { |
| 542 | struct mmc_blk_data *md = mq->data; |
| 543 | struct mmc_card *card = md->queue.card; |
| 544 | unsigned int from, nr, arg; |
| 545 | int err = 0; |
| 546 | |
Adrian Hunter | bd788c9 | 2010-08-11 14:17:47 -0700 | [diff] [blame] | 547 | if (!mmc_can_erase(card)) { |
| 548 | err = -EOPNOTSUPP; |
| 549 | goto out; |
| 550 | } |
| 551 | |
| 552 | from = blk_rq_pos(req); |
| 553 | nr = blk_rq_sectors(req); |
| 554 | |
| 555 | if (mmc_can_trim(card)) |
| 556 | arg = MMC_TRIM_ARG; |
| 557 | else |
| 558 | arg = MMC_ERASE_ARG; |
| 559 | |
Andrei Warkentin | 6a7a6b4 | 2011-04-12 15:06:53 -0500 | [diff] [blame] | 560 | if (card->quirks & MMC_QUIRK_INAND_CMD38) { |
| 561 | err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, |
| 562 | INAND_CMD38_ARG_EXT_CSD, |
| 563 | arg == MMC_TRIM_ARG ? |
| 564 | INAND_CMD38_ARG_TRIM : |
| 565 | INAND_CMD38_ARG_ERASE, |
| 566 | 0); |
| 567 | if (err) |
| 568 | goto out; |
| 569 | } |
Adrian Hunter | bd788c9 | 2010-08-11 14:17:47 -0700 | [diff] [blame] | 570 | err = mmc_erase(card, from, nr, arg); |
| 571 | out: |
| 572 | spin_lock_irq(&md->lock); |
| 573 | __blk_end_request(req, err, blk_rq_bytes(req)); |
| 574 | spin_unlock_irq(&md->lock); |
| 575 | |
Adrian Hunter | bd788c9 | 2010-08-11 14:17:47 -0700 | [diff] [blame] | 576 | return err ? 0 : 1; |
| 577 | } |
| 578 | |
Adrian Hunter | 4980454 | 2010-08-11 14:17:50 -0700 | [diff] [blame] | 579 | static int mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq, |
| 580 | struct request *req) |
| 581 | { |
| 582 | struct mmc_blk_data *md = mq->data; |
| 583 | struct mmc_card *card = md->queue.card; |
| 584 | unsigned int from, nr, arg; |
| 585 | int err = 0; |
| 586 | |
Adrian Hunter | 4980454 | 2010-08-11 14:17:50 -0700 | [diff] [blame] | 587 | if (!mmc_can_secure_erase_trim(card)) { |
| 588 | err = -EOPNOTSUPP; |
| 589 | goto out; |
| 590 | } |
| 591 | |
| 592 | from = blk_rq_pos(req); |
| 593 | nr = blk_rq_sectors(req); |
| 594 | |
| 595 | if (mmc_can_trim(card) && !mmc_erase_group_aligned(card, from, nr)) |
| 596 | arg = MMC_SECURE_TRIM1_ARG; |
| 597 | else |
| 598 | arg = MMC_SECURE_ERASE_ARG; |
| 599 | |
Andrei Warkentin | 6a7a6b4 | 2011-04-12 15:06:53 -0500 | [diff] [blame] | 600 | if (card->quirks & MMC_QUIRK_INAND_CMD38) { |
| 601 | err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, |
| 602 | INAND_CMD38_ARG_EXT_CSD, |
| 603 | arg == MMC_SECURE_TRIM1_ARG ? |
| 604 | INAND_CMD38_ARG_SECTRIM1 : |
| 605 | INAND_CMD38_ARG_SECERASE, |
| 606 | 0); |
| 607 | if (err) |
| 608 | goto out; |
| 609 | } |
Adrian Hunter | 4980454 | 2010-08-11 14:17:50 -0700 | [diff] [blame] | 610 | err = mmc_erase(card, from, nr, arg); |
Andrei Warkentin | 6a7a6b4 | 2011-04-12 15:06:53 -0500 | [diff] [blame] | 611 | if (!err && arg == MMC_SECURE_TRIM1_ARG) { |
| 612 | if (card->quirks & MMC_QUIRK_INAND_CMD38) { |
| 613 | err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, |
| 614 | INAND_CMD38_ARG_EXT_CSD, |
| 615 | INAND_CMD38_ARG_SECTRIM2, |
| 616 | 0); |
| 617 | if (err) |
| 618 | goto out; |
| 619 | } |
Adrian Hunter | 4980454 | 2010-08-11 14:17:50 -0700 | [diff] [blame] | 620 | err = mmc_erase(card, from, nr, MMC_SECURE_TRIM2_ARG); |
Andrei Warkentin | 6a7a6b4 | 2011-04-12 15:06:53 -0500 | [diff] [blame] | 621 | } |
Adrian Hunter | 4980454 | 2010-08-11 14:17:50 -0700 | [diff] [blame] | 622 | out: |
| 623 | spin_lock_irq(&md->lock); |
| 624 | __blk_end_request(req, err, blk_rq_bytes(req)); |
| 625 | spin_unlock_irq(&md->lock); |
| 626 | |
Adrian Hunter | 4980454 | 2010-08-11 14:17:50 -0700 | [diff] [blame] | 627 | return err ? 0 : 1; |
| 628 | } |
| 629 | |
Andrei Warkentin | f4c5522 | 2011-03-31 18:40:00 -0500 | [diff] [blame] | 630 | static int mmc_blk_issue_flush(struct mmc_queue *mq, struct request *req) |
| 631 | { |
| 632 | struct mmc_blk_data *md = mq->data; |
| 633 | |
| 634 | /* |
| 635 | * No-op, only service this because we need REQ_FUA for reliable |
| 636 | * writes. |
| 637 | */ |
| 638 | spin_lock_irq(&md->lock); |
| 639 | __blk_end_request_all(req, 0); |
| 640 | spin_unlock_irq(&md->lock); |
| 641 | |
| 642 | return 1; |
| 643 | } |
| 644 | |
| 645 | /* |
| 646 | * Reformat current write as a reliable write, supporting |
| 647 | * both legacy and the enhanced reliable write MMC cards. |
| 648 | * In each transfer we'll handle only as much as a single |
| 649 | * reliable write can handle, thus finish the request in |
| 650 | * partial completions. |
| 651 | */ |
Andrei Warkentin | d0c97cf | 2011-05-23 15:06:36 -0500 | [diff] [blame] | 652 | static inline void mmc_apply_rel_rw(struct mmc_blk_request *brq, |
| 653 | struct mmc_card *card, |
| 654 | struct request *req) |
Andrei Warkentin | f4c5522 | 2011-03-31 18:40:00 -0500 | [diff] [blame] | 655 | { |
Andrei Warkentin | f4c5522 | 2011-03-31 18:40:00 -0500 | [diff] [blame] | 656 | if (!(card->ext_csd.rel_param & EXT_CSD_WR_REL_PARAM_EN)) { |
| 657 | /* Legacy mode imposes restrictions on transfers. */ |
| 658 | if (!IS_ALIGNED(brq->cmd.arg, card->ext_csd.rel_sectors)) |
| 659 | brq->data.blocks = 1; |
| 660 | |
| 661 | if (brq->data.blocks > card->ext_csd.rel_sectors) |
| 662 | brq->data.blocks = card->ext_csd.rel_sectors; |
| 663 | else if (brq->data.blocks < card->ext_csd.rel_sectors) |
| 664 | brq->data.blocks = 1; |
| 665 | } |
Andrei Warkentin | f4c5522 | 2011-03-31 18:40:00 -0500 | [diff] [blame] | 666 | } |
| 667 | |
Adrian Hunter | bd788c9 | 2010-08-11 14:17:47 -0700 | [diff] [blame] | 668 | static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *req) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 669 | { |
| 670 | struct mmc_blk_data *md = mq->data; |
| 671 | struct mmc_card *card = md->queue.card; |
Pierre Ossman | 176f00f | 2006-10-04 02:15:41 -0700 | [diff] [blame] | 672 | struct mmc_blk_request brq; |
Adrian Hunter | 6a79e39 | 2008-12-31 18:21:17 +0100 | [diff] [blame] | 673 | int ret = 1, disable_multi = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 674 | |
Andrei Warkentin | f4c5522 | 2011-03-31 18:40:00 -0500 | [diff] [blame] | 675 | /* |
| 676 | * Reliable writes are used to implement Forced Unit Access and |
| 677 | * REQ_META accesses, and are supported only on MMCs. |
| 678 | */ |
| 679 | bool do_rel_wr = ((req->cmd_flags & REQ_FUA) || |
| 680 | (req->cmd_flags & REQ_META)) && |
| 681 | (rq_data_dir(req) == WRITE) && |
Andrei Warkentin | d0c97cf | 2011-05-23 15:06:36 -0500 | [diff] [blame] | 682 | (md->flags & MMC_BLK_REL_WR); |
Andrei Warkentin | f4c5522 | 2011-03-31 18:40:00 -0500 | [diff] [blame] | 683 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 684 | do { |
Chris Ball | 1278dba | 2011-04-13 23:40:30 -0400 | [diff] [blame] | 685 | struct mmc_command cmd = {0}; |
Adrian Hunter | 504f191 | 2008-10-16 12:55:25 +0300 | [diff] [blame] | 686 | u32 readcmd, writecmd, status = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 687 | |
| 688 | memset(&brq, 0, sizeof(struct mmc_blk_request)); |
| 689 | brq.mrq.cmd = &brq.cmd; |
| 690 | brq.mrq.data = &brq.data; |
| 691 | |
Tejun Heo | 83096eb | 2009-05-07 22:24:39 +0900 | [diff] [blame] | 692 | brq.cmd.arg = blk_rq_pos(req); |
Philip Langdale | fba68bd | 2007-01-04 06:57:32 -0800 | [diff] [blame] | 693 | if (!mmc_card_blockaddr(card)) |
| 694 | brq.cmd.arg <<= 9; |
David Brownell | 7213d17 | 2007-08-08 09:10:23 -0700 | [diff] [blame] | 695 | brq.cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; |
Pierre Ossman | 0884669 | 2008-08-31 14:10:08 +0200 | [diff] [blame] | 696 | brq.data.blksz = 512; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 697 | brq.stop.opcode = MMC_STOP_TRANSMISSION; |
| 698 | brq.stop.arg = 0; |
David Brownell | 7213d17 | 2007-08-08 09:10:23 -0700 | [diff] [blame] | 699 | brq.stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC; |
Tejun Heo | 83096eb | 2009-05-07 22:24:39 +0900 | [diff] [blame] | 700 | brq.data.blocks = blk_rq_sectors(req); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 701 | |
Adrian Hunter | 6a79e39 | 2008-12-31 18:21:17 +0100 | [diff] [blame] | 702 | /* |
Pierre Ossman | 548d2de | 2009-04-10 17:52:57 +0200 | [diff] [blame] | 703 | * The block layer doesn't support all sector count |
| 704 | * restrictions, so we need to be prepared for too big |
| 705 | * requests. |
| 706 | */ |
| 707 | if (brq.data.blocks > card->host->max_blk_count) |
| 708 | brq.data.blocks = card->host->max_blk_count; |
| 709 | |
| 710 | /* |
Adrian Hunter | 6a79e39 | 2008-12-31 18:21:17 +0100 | [diff] [blame] | 711 | * After a read error, we redo the request one sector at a time |
| 712 | * in order to accurately determine which sectors can be read |
| 713 | * successfully. |
| 714 | */ |
| 715 | if (disable_multi && brq.data.blocks > 1) |
| 716 | brq.data.blocks = 1; |
| 717 | |
Andrei Warkentin | f4c5522 | 2011-03-31 18:40:00 -0500 | [diff] [blame] | 718 | if (brq.data.blocks > 1 || do_rel_wr) { |
David Brownell | 7213d17 | 2007-08-08 09:10:23 -0700 | [diff] [blame] | 719 | /* SPI multiblock writes terminate using a special |
Andrei Warkentin | d0c97cf | 2011-05-23 15:06:36 -0500 | [diff] [blame] | 720 | * token, not a STOP_TRANSMISSION request. |
David Brownell | 7213d17 | 2007-08-08 09:10:23 -0700 | [diff] [blame] | 721 | */ |
Andrei Warkentin | d0c97cf | 2011-05-23 15:06:36 -0500 | [diff] [blame] | 722 | if (!mmc_host_is_spi(card->host) || |
Andrei Warkentin | f4c5522 | 2011-03-31 18:40:00 -0500 | [diff] [blame] | 723 | rq_data_dir(req) == READ) |
David Brownell | 7213d17 | 2007-08-08 09:10:23 -0700 | [diff] [blame] | 724 | brq.mrq.stop = &brq.stop; |
Russell King | db53f28 | 2006-08-30 15:14:56 +0100 | [diff] [blame] | 725 | readcmd = MMC_READ_MULTIPLE_BLOCK; |
| 726 | writecmd = MMC_WRITE_MULTIPLE_BLOCK; |
Russell King | 788ee7b | 2006-01-09 21:12:17 +0000 | [diff] [blame] | 727 | } else { |
| 728 | brq.mrq.stop = NULL; |
Russell King | db53f28 | 2006-08-30 15:14:56 +0100 | [diff] [blame] | 729 | readcmd = MMC_READ_SINGLE_BLOCK; |
| 730 | writecmd = MMC_WRITE_BLOCK; |
| 731 | } |
Russell King | db53f28 | 2006-08-30 15:14:56 +0100 | [diff] [blame] | 732 | if (rq_data_dir(req) == READ) { |
| 733 | brq.cmd.opcode = readcmd; |
| 734 | brq.data.flags |= MMC_DATA_READ; |
| 735 | } else { |
| 736 | brq.cmd.opcode = writecmd; |
| 737 | brq.data.flags |= MMC_DATA_WRITE; |
Russell King | 788ee7b | 2006-01-09 21:12:17 +0000 | [diff] [blame] | 738 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 739 | |
Andrei Warkentin | d0c97cf | 2011-05-23 15:06:36 -0500 | [diff] [blame] | 740 | if (do_rel_wr) |
| 741 | mmc_apply_rel_rw(&brq, card, req); |
| 742 | |
| 743 | /* |
| 744 | * Pre-defined multi-block transfers are preferable to |
| 745 | * open ended-ones (and necessary for reliable writes). |
| 746 | * However, it is not sufficient to just send CMD23, |
| 747 | * and avoid the final CMD12, as on an error condition |
| 748 | * CMD12 (stop) needs to be sent anyway. This, coupled |
| 749 | * with Auto-CMD23 enhancements provided by some |
| 750 | * hosts, means that the complexity of dealing |
| 751 | * with this is best left to the host. If CMD23 is |
| 752 | * supported by card and host, we'll fill sbc in and let |
| 753 | * the host deal with handling it correctly. This means |
| 754 | * that for hosts that don't expose MMC_CAP_CMD23, no |
| 755 | * change of behavior will be observed. |
| 756 | * |
| 757 | * N.B: Some MMC cards experience perf degradation. |
| 758 | * We'll avoid using CMD23-bounded multiblock writes for |
| 759 | * these, while retaining features like reliable writes. |
| 760 | */ |
| 761 | |
| 762 | if ((md->flags & MMC_BLK_CMD23) && |
| 763 | mmc_op_multi(brq.cmd.opcode) && |
| 764 | (do_rel_wr || !(card->quirks & MMC_QUIRK_BLK_NO_CMD23))) { |
| 765 | brq.sbc.opcode = MMC_SET_BLOCK_COUNT; |
| 766 | brq.sbc.arg = brq.data.blocks | |
| 767 | (do_rel_wr ? (1 << 31) : 0); |
| 768 | brq.sbc.flags = MMC_RSP_R1 | MMC_CMD_AC; |
| 769 | brq.mrq.sbc = &brq.sbc; |
| 770 | } |
Andrei Warkentin | f4c5522 | 2011-03-31 18:40:00 -0500 | [diff] [blame] | 771 | |
Pierre Ossman | b146d26 | 2007-07-24 19:16:54 +0200 | [diff] [blame] | 772 | mmc_set_data_timeout(&brq.data, card); |
| 773 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 774 | brq.data.sg = mq->sg; |
Pierre Ossman | 98ccf14 | 2007-05-12 00:26:16 +0200 | [diff] [blame] | 775 | brq.data.sg_len = mmc_queue_map_sg(mq); |
| 776 | |
Adrian Hunter | 6a79e39 | 2008-12-31 18:21:17 +0100 | [diff] [blame] | 777 | /* |
| 778 | * Adjust the sg list so it is the same size as the |
| 779 | * request. |
| 780 | */ |
Tejun Heo | 83096eb | 2009-05-07 22:24:39 +0900 | [diff] [blame] | 781 | if (brq.data.blocks != blk_rq_sectors(req)) { |
Adrian Hunter | 6a79e39 | 2008-12-31 18:21:17 +0100 | [diff] [blame] | 782 | int i, data_size = brq.data.blocks << 9; |
| 783 | struct scatterlist *sg; |
| 784 | |
| 785 | for_each_sg(brq.data.sg, sg, brq.data.sg_len, i) { |
| 786 | data_size -= sg->length; |
| 787 | if (data_size <= 0) { |
| 788 | sg->length += data_size; |
| 789 | i++; |
| 790 | break; |
| 791 | } |
| 792 | } |
| 793 | brq.data.sg_len = i; |
| 794 | } |
| 795 | |
Pierre Ossman | 98ccf14 | 2007-05-12 00:26:16 +0200 | [diff] [blame] | 796 | mmc_queue_bounce_pre(mq); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 797 | |
| 798 | mmc_wait_for_req(card->host, &brq.mrq); |
Pierre Ossman | 98ccf14 | 2007-05-12 00:26:16 +0200 | [diff] [blame] | 799 | |
| 800 | mmc_queue_bounce_post(mq); |
| 801 | |
Pierre Ossman | 979ce72 | 2008-06-29 12:19:47 +0200 | [diff] [blame] | 802 | /* |
| 803 | * Check for errors here, but don't jump to cmd_err |
| 804 | * until later as we need to wait for the card to leave |
| 805 | * programming mode even when things go wrong. |
| 806 | */ |
Andrei Warkentin | d0c97cf | 2011-05-23 15:06:36 -0500 | [diff] [blame] | 807 | if (brq.sbc.error || brq.cmd.error || |
| 808 | brq.data.error || brq.stop.error) { |
Adrian Hunter | 6a79e39 | 2008-12-31 18:21:17 +0100 | [diff] [blame] | 809 | if (brq.data.blocks > 1 && rq_data_dir(req) == READ) { |
| 810 | /* Redo read one sector at a time */ |
| 811 | printk(KERN_WARNING "%s: retrying using single " |
| 812 | "block read\n", req->rq_disk->disk_name); |
| 813 | disable_multi = 1; |
| 814 | continue; |
| 815 | } |
Adrian Hunter | 504f191 | 2008-10-16 12:55:25 +0300 | [diff] [blame] | 816 | status = get_card_status(card, req); |
David Ding | 9da9109 | 2009-10-09 06:38:10 -0700 | [diff] [blame] | 817 | } else if (disable_multi == 1) { |
| 818 | disable_multi = 0; |
Adrian Hunter | 6a79e39 | 2008-12-31 18:21:17 +0100 | [diff] [blame] | 819 | } |
Adrian Hunter | 504f191 | 2008-10-16 12:55:25 +0300 | [diff] [blame] | 820 | |
Andrei Warkentin | d0c97cf | 2011-05-23 15:06:36 -0500 | [diff] [blame] | 821 | if (brq.sbc.error) { |
| 822 | printk(KERN_ERR "%s: error %d sending SET_BLOCK_COUNT " |
| 823 | "command, response %#x, card status %#x\n", |
| 824 | req->rq_disk->disk_name, brq.sbc.error, |
| 825 | brq.sbc.resp[0], status); |
| 826 | } |
| 827 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 828 | if (brq.cmd.error) { |
Adrian Hunter | 504f191 | 2008-10-16 12:55:25 +0300 | [diff] [blame] | 829 | printk(KERN_ERR "%s: error %d sending read/write " |
| 830 | "command, response %#x, card status %#x\n", |
| 831 | req->rq_disk->disk_name, brq.cmd.error, |
| 832 | brq.cmd.resp[0], status); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 833 | } |
| 834 | |
| 835 | if (brq.data.error) { |
Adrian Hunter | 504f191 | 2008-10-16 12:55:25 +0300 | [diff] [blame] | 836 | if (brq.data.error == -ETIMEDOUT && brq.mrq.stop) |
| 837 | /* 'Stop' response contains card status */ |
| 838 | status = brq.mrq.stop->resp[0]; |
| 839 | printk(KERN_ERR "%s: error %d transferring data," |
| 840 | " sector %u, nr %u, card status %#x\n", |
| 841 | req->rq_disk->disk_name, brq.data.error, |
Tejun Heo | 83096eb | 2009-05-07 22:24:39 +0900 | [diff] [blame] | 842 | (unsigned)blk_rq_pos(req), |
| 843 | (unsigned)blk_rq_sectors(req), status); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 844 | } |
| 845 | |
| 846 | if (brq.stop.error) { |
Adrian Hunter | 504f191 | 2008-10-16 12:55:25 +0300 | [diff] [blame] | 847 | printk(KERN_ERR "%s: error %d sending stop command, " |
| 848 | "response %#x, card status %#x\n", |
| 849 | req->rq_disk->disk_name, brq.stop.error, |
| 850 | brq.stop.resp[0], status); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 851 | } |
| 852 | |
David Brownell | 7213d17 | 2007-08-08 09:10:23 -0700 | [diff] [blame] | 853 | if (!mmc_host_is_spi(card->host) && rq_data_dir(req) != READ) { |
Russell King | 2ed6d22 | 2006-09-24 10:46:43 +0100 | [diff] [blame] | 854 | do { |
| 855 | int err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 856 | |
Russell King | 2ed6d22 | 2006-09-24 10:46:43 +0100 | [diff] [blame] | 857 | cmd.opcode = MMC_SEND_STATUS; |
| 858 | cmd.arg = card->rca << 16; |
| 859 | cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; |
| 860 | err = mmc_wait_for_cmd(card->host, &cmd, 5); |
| 861 | if (err) { |
| 862 | printk(KERN_ERR "%s: error %d requesting status\n", |
| 863 | req->rq_disk->disk_name, err); |
| 864 | goto cmd_err; |
| 865 | } |
Pierre Ossman | d198f10 | 2007-11-02 18:21:13 +0100 | [diff] [blame] | 866 | /* |
| 867 | * Some cards mishandle the status bits, |
| 868 | * so make sure to check both the busy |
| 869 | * indication and the card state. |
| 870 | */ |
| 871 | } while (!(cmd.resp[0] & R1_READY_FOR_DATA) || |
| 872 | (R1_CURRENT_STATE(cmd.resp[0]) == 7)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 873 | |
| 874 | #if 0 |
Russell King | 2ed6d22 | 2006-09-24 10:46:43 +0100 | [diff] [blame] | 875 | if (cmd.resp[0] & ~0x00000900) |
| 876 | printk(KERN_ERR "%s: status = %08x\n", |
| 877 | req->rq_disk->disk_name, cmd.resp[0]); |
| 878 | if (mmc_decode_status(cmd.resp)) |
| 879 | goto cmd_err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 880 | #endif |
Russell King | 2ed6d22 | 2006-09-24 10:46:43 +0100 | [diff] [blame] | 881 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 882 | |
Adrian Hunter | 6a79e39 | 2008-12-31 18:21:17 +0100 | [diff] [blame] | 883 | if (brq.cmd.error || brq.stop.error || brq.data.error) { |
| 884 | if (rq_data_dir(req) == READ) { |
| 885 | /* |
| 886 | * After an error, we redo I/O one sector at a |
| 887 | * time, so we only reach here after trying to |
| 888 | * read a single sector. |
| 889 | */ |
| 890 | spin_lock_irq(&md->lock); |
| 891 | ret = __blk_end_request(req, -EIO, brq.data.blksz); |
| 892 | spin_unlock_irq(&md->lock); |
| 893 | continue; |
| 894 | } |
Pierre Ossman | 979ce72 | 2008-06-29 12:19:47 +0200 | [diff] [blame] | 895 | goto cmd_err; |
Adrian Hunter | 6a79e39 | 2008-12-31 18:21:17 +0100 | [diff] [blame] | 896 | } |
Pierre Ossman | 979ce72 | 2008-06-29 12:19:47 +0200 | [diff] [blame] | 897 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 898 | /* |
| 899 | * A block was successfully transferred. |
| 900 | */ |
| 901 | spin_lock_irq(&md->lock); |
Kiyoshi Ueda | fd53983 | 2007-12-11 17:48:29 -0500 | [diff] [blame] | 902 | ret = __blk_end_request(req, 0, brq.data.bytes_xfered); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 903 | spin_unlock_irq(&md->lock); |
| 904 | } while (ret); |
| 905 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 906 | return 1; |
| 907 | |
| 908 | cmd_err: |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 909 | /* |
| 910 | * If this is an SD card and we're writing, we can first |
| 911 | * mark the known good sectors as ok. |
| 912 | * |
| 913 | * If the card is not SD, we can still ok written sectors |
Pierre Ossman | 23af603 | 2008-07-06 01:10:27 +0200 | [diff] [blame] | 914 | * as reported by the controller (which might be less than |
| 915 | * the real number of written sectors, but never more). |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 916 | */ |
Adrian Hunter | 6a79e39 | 2008-12-31 18:21:17 +0100 | [diff] [blame] | 917 | if (mmc_card_sd(card)) { |
| 918 | u32 blocks; |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 919 | |
Adrian Hunter | 6a79e39 | 2008-12-31 18:21:17 +0100 | [diff] [blame] | 920 | blocks = mmc_sd_num_wr_blocks(card); |
| 921 | if (blocks != (u32)-1) { |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 922 | spin_lock_irq(&md->lock); |
Adrian Hunter | 6a79e39 | 2008-12-31 18:21:17 +0100 | [diff] [blame] | 923 | ret = __blk_end_request(req, 0, blocks << 9); |
Pierre Ossman | ec5a19d | 2006-10-06 00:44:03 -0700 | [diff] [blame] | 924 | spin_unlock_irq(&md->lock); |
| 925 | } |
Adrian Hunter | 6a79e39 | 2008-12-31 18:21:17 +0100 | [diff] [blame] | 926 | } else { |
| 927 | spin_lock_irq(&md->lock); |
| 928 | ret = __blk_end_request(req, 0, brq.data.bytes_xfered); |
| 929 | spin_unlock_irq(&md->lock); |
Pierre Ossman | 176f00f | 2006-10-04 02:15:41 -0700 | [diff] [blame] | 930 | } |
| 931 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 932 | spin_lock_irq(&md->lock); |
Kiyoshi Ueda | fd53983 | 2007-12-11 17:48:29 -0500 | [diff] [blame] | 933 | while (ret) |
| 934 | ret = __blk_end_request(req, -EIO, blk_rq_cur_bytes(req)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 935 | spin_unlock_irq(&md->lock); |
| 936 | |
| 937 | return 0; |
| 938 | } |
| 939 | |
San Mehat | c87f8d4 | 2009-07-30 08:21:19 -0700 | [diff] [blame] | 940 | static int |
| 941 | mmc_blk_set_blksize(struct mmc_blk_data *md, struct mmc_card *card); |
| 942 | |
Adrian Hunter | bd788c9 | 2010-08-11 14:17:47 -0700 | [diff] [blame] | 943 | static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req) |
| 944 | { |
Andrei Warkentin | 1a258db | 2011-04-11 18:10:24 -0500 | [diff] [blame] | 945 | int ret; |
| 946 | struct mmc_blk_data *md = mq->data; |
| 947 | struct mmc_card *card = md->queue.card; |
| 948 | |
San Mehat | c87f8d4 | 2009-07-30 08:21:19 -0700 | [diff] [blame] | 949 | #ifdef CONFIG_MMC_BLOCK_DEFERRED_RESUME |
| 950 | if (mmc_bus_needs_resume(card->host)) { |
| 951 | mmc_resume_bus(card->host); |
| 952 | mmc_blk_set_blksize(md, card); |
| 953 | } |
| 954 | #endif |
| 955 | |
Andrei Warkentin | 1a258db | 2011-04-11 18:10:24 -0500 | [diff] [blame] | 956 | mmc_claim_host(card->host); |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 957 | ret = mmc_blk_part_switch(card, md); |
| 958 | if (ret) { |
| 959 | ret = 0; |
| 960 | goto out; |
| 961 | } |
Andrei Warkentin | 1a258db | 2011-04-11 18:10:24 -0500 | [diff] [blame] | 962 | |
Adrian Hunter | 4980454 | 2010-08-11 14:17:50 -0700 | [diff] [blame] | 963 | if (req->cmd_flags & REQ_DISCARD) { |
| 964 | if (req->cmd_flags & REQ_SECURE) |
Andrei Warkentin | 1a258db | 2011-04-11 18:10:24 -0500 | [diff] [blame] | 965 | ret = mmc_blk_issue_secdiscard_rq(mq, req); |
Adrian Hunter | 4980454 | 2010-08-11 14:17:50 -0700 | [diff] [blame] | 966 | else |
Andrei Warkentin | 1a258db | 2011-04-11 18:10:24 -0500 | [diff] [blame] | 967 | ret = mmc_blk_issue_discard_rq(mq, req); |
Andrei Warkentin | f4c5522 | 2011-03-31 18:40:00 -0500 | [diff] [blame] | 968 | } else if (req->cmd_flags & REQ_FLUSH) { |
Andrei Warkentin | 1a258db | 2011-04-11 18:10:24 -0500 | [diff] [blame] | 969 | ret = mmc_blk_issue_flush(mq, req); |
Adrian Hunter | 4980454 | 2010-08-11 14:17:50 -0700 | [diff] [blame] | 970 | } else { |
Andrei Warkentin | 1a258db | 2011-04-11 18:10:24 -0500 | [diff] [blame] | 971 | ret = mmc_blk_issue_rw_rq(mq, req); |
Adrian Hunter | 4980454 | 2010-08-11 14:17:50 -0700 | [diff] [blame] | 972 | } |
Andrei Warkentin | 1a258db | 2011-04-11 18:10:24 -0500 | [diff] [blame] | 973 | |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 974 | out: |
Andrei Warkentin | 1a258db | 2011-04-11 18:10:24 -0500 | [diff] [blame] | 975 | mmc_release_host(card->host); |
| 976 | return ret; |
Adrian Hunter | bd788c9 | 2010-08-11 14:17:47 -0700 | [diff] [blame] | 977 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 978 | |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 979 | static inline int mmc_blk_readonly(struct mmc_card *card) |
| 980 | { |
| 981 | return mmc_card_readonly(card) || |
| 982 | !(card->csd.cmdclass & CCC_BLOCK_WRITE); |
| 983 | } |
| 984 | |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 985 | static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card, |
| 986 | struct device *parent, |
| 987 | sector_t size, |
| 988 | bool default_ro, |
| 989 | const char *subname) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 990 | { |
| 991 | struct mmc_blk_data *md; |
| 992 | int devidx, ret; |
| 993 | |
Olof Johansson | 5e71b7a | 2010-09-17 21:19:57 -0400 | [diff] [blame] | 994 | devidx = find_first_zero_bit(dev_use, max_devices); |
| 995 | if (devidx >= max_devices) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 996 | return ERR_PTR(-ENOSPC); |
| 997 | __set_bit(devidx, dev_use); |
| 998 | |
Yoann Padioleau | dd00cc4 | 2007-07-19 01:49:03 -0700 | [diff] [blame] | 999 | md = kzalloc(sizeof(struct mmc_blk_data), GFP_KERNEL); |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 1000 | if (!md) { |
| 1001 | ret = -ENOMEM; |
| 1002 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1003 | } |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 1004 | |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 1005 | /* |
Andrei Warkentin | f06c915 | 2011-04-21 22:46:13 -0500 | [diff] [blame] | 1006 | * !subname implies we are creating main mmc_blk_data that will be |
| 1007 | * associated with mmc_card with mmc_set_drvdata. Due to device |
| 1008 | * partitions, devidx will not coincide with a per-physical card |
| 1009 | * index anymore so we keep track of a name index. |
| 1010 | */ |
| 1011 | if (!subname) { |
| 1012 | md->name_idx = find_first_zero_bit(name_use, max_devices); |
| 1013 | __set_bit(md->name_idx, name_use); |
| 1014 | } |
| 1015 | else |
| 1016 | md->name_idx = ((struct mmc_blk_data *) |
| 1017 | dev_to_disk(parent)->private_data)->name_idx; |
| 1018 | |
| 1019 | /* |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 1020 | * Set the read-only status based on the supported commands |
| 1021 | * and the write protect switch. |
| 1022 | */ |
| 1023 | md->read_only = mmc_blk_readonly(card); |
| 1024 | |
Olof Johansson | 5e71b7a | 2010-09-17 21:19:57 -0400 | [diff] [blame] | 1025 | md->disk = alloc_disk(perdev_minors); |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 1026 | if (md->disk == NULL) { |
| 1027 | ret = -ENOMEM; |
| 1028 | goto err_kfree; |
| 1029 | } |
| 1030 | |
| 1031 | spin_lock_init(&md->lock); |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1032 | INIT_LIST_HEAD(&md->part); |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 1033 | md->usage = 1; |
| 1034 | |
| 1035 | ret = mmc_init_queue(&md->queue, card, &md->lock); |
| 1036 | if (ret) |
| 1037 | goto err_putdisk; |
| 1038 | |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 1039 | md->queue.issue_fn = mmc_blk_issue_rq; |
| 1040 | md->queue.data = md; |
| 1041 | |
Pierre Ossman | fe6b4c8 | 2007-05-14 17:27:29 +0200 | [diff] [blame] | 1042 | md->disk->major = MMC_BLOCK_MAJOR; |
Olof Johansson | 5e71b7a | 2010-09-17 21:19:57 -0400 | [diff] [blame] | 1043 | md->disk->first_minor = devidx * perdev_minors; |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 1044 | md->disk->fops = &mmc_bdops; |
| 1045 | md->disk->private_data = md; |
| 1046 | md->disk->queue = md->queue.queue; |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1047 | md->disk->driverfs_dev = parent; |
| 1048 | set_disk_ro(md->disk, md->read_only || default_ro); |
Colin Cross | fa746fa | 2010-09-03 12:41:21 -0700 | [diff] [blame^] | 1049 | md->disk->flags = GENHD_FL_EXT_DEVT; |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 1050 | |
| 1051 | /* |
| 1052 | * As discussed on lkml, GENHD_FL_REMOVABLE should: |
| 1053 | * |
| 1054 | * - be set for removable media with permanent block devices |
| 1055 | * - be unset for removable block devices with permanent media |
| 1056 | * |
| 1057 | * Since MMC block devices clearly fall under the second |
| 1058 | * case, we do not set GENHD_FL_REMOVABLE. Userspace |
| 1059 | * should use the block device creation/destruction hotplug |
| 1060 | * messages to tell when the card is present. |
| 1061 | */ |
| 1062 | |
Andrei Warkentin | f06c915 | 2011-04-21 22:46:13 -0500 | [diff] [blame] | 1063 | snprintf(md->disk->disk_name, sizeof(md->disk->disk_name), |
| 1064 | "mmcblk%d%s", md->name_idx, subname ? subname : ""); |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 1065 | |
Martin K. Petersen | e1defc4 | 2009-05-22 17:17:49 -0400 | [diff] [blame] | 1066 | blk_queue_logical_block_size(md->queue.queue, 512); |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1067 | set_capacity(md->disk, size); |
Andrei Warkentin | d0c97cf | 2011-05-23 15:06:36 -0500 | [diff] [blame] | 1068 | |
Andrei Warkentin | f0d8997 | 2011-05-23 15:06:38 -0500 | [diff] [blame] | 1069 | if (mmc_host_cmd23(card->host)) { |
| 1070 | if (mmc_card_mmc(card) || |
| 1071 | (mmc_card_sd(card) && |
| 1072 | card->scr.cmds & SD_SCR_CMD23_SUPPORT)) |
| 1073 | md->flags |= MMC_BLK_CMD23; |
| 1074 | } |
Andrei Warkentin | d0c97cf | 2011-05-23 15:06:36 -0500 | [diff] [blame] | 1075 | |
| 1076 | if (mmc_card_mmc(card) && |
| 1077 | md->flags & MMC_BLK_CMD23 && |
| 1078 | ((card->ext_csd.rel_param & EXT_CSD_WR_REL_PARAM_EN) || |
| 1079 | card->ext_csd.rel_sectors)) { |
| 1080 | md->flags |= MMC_BLK_REL_WR; |
| 1081 | blk_queue_flush(md->queue.queue, REQ_FLUSH | REQ_FUA); |
| 1082 | } |
| 1083 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1084 | return md; |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 1085 | |
| 1086 | err_putdisk: |
| 1087 | put_disk(md->disk); |
| 1088 | err_kfree: |
| 1089 | kfree(md); |
| 1090 | out: |
| 1091 | return ERR_PTR(ret); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1092 | } |
| 1093 | |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1094 | static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card) |
| 1095 | { |
| 1096 | sector_t size; |
| 1097 | struct mmc_blk_data *md; |
| 1098 | |
| 1099 | if (!mmc_card_sd(card) && mmc_card_blockaddr(card)) { |
| 1100 | /* |
| 1101 | * The EXT_CSD sector count is in number or 512 byte |
| 1102 | * sectors. |
| 1103 | */ |
| 1104 | size = card->ext_csd.sectors; |
| 1105 | } else { |
| 1106 | /* |
| 1107 | * The CSD capacity field is in units of read_blkbits. |
| 1108 | * set_capacity takes units of 512 bytes. |
| 1109 | */ |
| 1110 | size = card->csd.capacity << (card->csd.read_blkbits - 9); |
| 1111 | } |
| 1112 | |
| 1113 | md = mmc_blk_alloc_req(card, &card->dev, size, false, NULL); |
| 1114 | return md; |
| 1115 | } |
| 1116 | |
| 1117 | static int mmc_blk_alloc_part(struct mmc_card *card, |
| 1118 | struct mmc_blk_data *md, |
| 1119 | unsigned int part_type, |
| 1120 | sector_t size, |
| 1121 | bool default_ro, |
| 1122 | const char *subname) |
| 1123 | { |
| 1124 | char cap_str[10]; |
| 1125 | struct mmc_blk_data *part_md; |
| 1126 | |
| 1127 | part_md = mmc_blk_alloc_req(card, disk_to_dev(md->disk), size, default_ro, |
| 1128 | subname); |
| 1129 | if (IS_ERR(part_md)) |
| 1130 | return PTR_ERR(part_md); |
| 1131 | part_md->part_type = part_type; |
| 1132 | list_add(&part_md->part, &md->part); |
| 1133 | |
| 1134 | string_get_size((u64)get_capacity(part_md->disk) << 9, STRING_UNITS_2, |
| 1135 | cap_str, sizeof(cap_str)); |
| 1136 | printk(KERN_INFO "%s: %s %s partition %u %s\n", |
| 1137 | part_md->disk->disk_name, mmc_card_id(card), |
| 1138 | mmc_card_name(card), part_md->part_type, cap_str); |
| 1139 | return 0; |
| 1140 | } |
| 1141 | |
| 1142 | static int mmc_blk_alloc_parts(struct mmc_card *card, struct mmc_blk_data *md) |
| 1143 | { |
| 1144 | int ret = 0; |
| 1145 | |
| 1146 | if (!mmc_card_mmc(card)) |
| 1147 | return 0; |
| 1148 | |
| 1149 | if (card->ext_csd.boot_size) { |
| 1150 | ret = mmc_blk_alloc_part(card, md, EXT_CSD_PART_CONFIG_ACC_BOOT0, |
| 1151 | card->ext_csd.boot_size >> 9, |
| 1152 | true, |
| 1153 | "boot0"); |
| 1154 | if (ret) |
| 1155 | return ret; |
| 1156 | ret = mmc_blk_alloc_part(card, md, EXT_CSD_PART_CONFIG_ACC_BOOT1, |
| 1157 | card->ext_csd.boot_size >> 9, |
| 1158 | true, |
| 1159 | "boot1"); |
| 1160 | if (ret) |
| 1161 | return ret; |
| 1162 | } |
| 1163 | |
| 1164 | return ret; |
| 1165 | } |
| 1166 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1167 | static int |
| 1168 | mmc_blk_set_blksize(struct mmc_blk_data *md, struct mmc_card *card) |
| 1169 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1170 | int err; |
| 1171 | |
Pierre Ossman | b855885 | 2007-01-03 19:47:29 +0100 | [diff] [blame] | 1172 | mmc_claim_host(card->host); |
Adrian Hunter | 0f8d8ea | 2010-08-24 13:20:26 +0300 | [diff] [blame] | 1173 | err = mmc_set_blocklen(card, 512); |
Pierre Ossman | b855885 | 2007-01-03 19:47:29 +0100 | [diff] [blame] | 1174 | mmc_release_host(card->host); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1175 | |
| 1176 | if (err) { |
Adrian Hunter | 0f8d8ea | 2010-08-24 13:20:26 +0300 | [diff] [blame] | 1177 | printk(KERN_ERR "%s: unable to set block size to 512: %d\n", |
| 1178 | md->disk->disk_name, err); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1179 | return -EINVAL; |
| 1180 | } |
| 1181 | |
| 1182 | return 0; |
| 1183 | } |
| 1184 | |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1185 | static void mmc_blk_remove_req(struct mmc_blk_data *md) |
| 1186 | { |
| 1187 | if (md) { |
| 1188 | if (md->disk->flags & GENHD_FL_UP) { |
| 1189 | device_remove_file(disk_to_dev(md->disk), &md->force_ro); |
| 1190 | |
| 1191 | /* Stop new requests from getting into the queue */ |
| 1192 | del_gendisk(md->disk); |
| 1193 | } |
| 1194 | |
| 1195 | /* Then flush out any already in there */ |
| 1196 | mmc_cleanup_queue(&md->queue); |
| 1197 | mmc_blk_put(md); |
| 1198 | } |
| 1199 | } |
| 1200 | |
| 1201 | static void mmc_blk_remove_parts(struct mmc_card *card, |
| 1202 | struct mmc_blk_data *md) |
| 1203 | { |
| 1204 | struct list_head *pos, *q; |
| 1205 | struct mmc_blk_data *part_md; |
| 1206 | |
Andrei Warkentin | f06c915 | 2011-04-21 22:46:13 -0500 | [diff] [blame] | 1207 | __clear_bit(md->name_idx, name_use); |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1208 | list_for_each_safe(pos, q, &md->part) { |
| 1209 | part_md = list_entry(pos, struct mmc_blk_data, part); |
| 1210 | list_del(pos); |
| 1211 | mmc_blk_remove_req(part_md); |
| 1212 | } |
| 1213 | } |
| 1214 | |
| 1215 | static int mmc_add_disk(struct mmc_blk_data *md) |
| 1216 | { |
| 1217 | int ret; |
| 1218 | |
| 1219 | add_disk(md->disk); |
| 1220 | md->force_ro.show = force_ro_show; |
| 1221 | md->force_ro.store = force_ro_store; |
Rabin Vincent | 641c318 | 2011-04-23 20:52:58 +0530 | [diff] [blame] | 1222 | sysfs_attr_init(&md->force_ro.attr); |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1223 | md->force_ro.attr.name = "force_ro"; |
| 1224 | md->force_ro.attr.mode = S_IRUGO | S_IWUSR; |
| 1225 | ret = device_create_file(disk_to_dev(md->disk), &md->force_ro); |
| 1226 | if (ret) |
| 1227 | del_gendisk(md->disk); |
| 1228 | |
| 1229 | return ret; |
| 1230 | } |
| 1231 | |
Andrei Warkentin | 6f60c22 | 2011-04-11 19:11:04 -0400 | [diff] [blame] | 1232 | static const struct mmc_fixup blk_fixups[] = |
| 1233 | { |
Andrei Warkentin | 6a7a6b4 | 2011-04-12 15:06:53 -0500 | [diff] [blame] | 1234 | MMC_FIXUP("SEM02G", 0x2, 0x100, add_quirk, MMC_QUIRK_INAND_CMD38), |
| 1235 | MMC_FIXUP("SEM04G", 0x2, 0x100, add_quirk, MMC_QUIRK_INAND_CMD38), |
| 1236 | MMC_FIXUP("SEM08G", 0x2, 0x100, add_quirk, MMC_QUIRK_INAND_CMD38), |
| 1237 | MMC_FIXUP("SEM16G", 0x2, 0x100, add_quirk, MMC_QUIRK_INAND_CMD38), |
| 1238 | MMC_FIXUP("SEM32G", 0x2, 0x100, add_quirk, MMC_QUIRK_INAND_CMD38), |
Andrei Warkentin | d0c97cf | 2011-05-23 15:06:36 -0500 | [diff] [blame] | 1239 | |
| 1240 | /* |
| 1241 | * Some MMC cards experience performance degradation with CMD23 |
| 1242 | * instead of CMD12-bounded multiblock transfers. For now we'll |
| 1243 | * black list what's bad... |
| 1244 | * - Certain Toshiba cards. |
| 1245 | * |
| 1246 | * N.B. This doesn't affect SD cards. |
| 1247 | */ |
| 1248 | MMC_FIXUP("MMC08G", 0x11, CID_OEMID_ANY, add_quirk_mmc, |
| 1249 | MMC_QUIRK_BLK_NO_CMD23), |
| 1250 | MMC_FIXUP("MMC16G", 0x11, CID_OEMID_ANY, add_quirk_mmc, |
| 1251 | MMC_QUIRK_BLK_NO_CMD23), |
| 1252 | MMC_FIXUP("MMC32G", 0x11, CID_OEMID_ANY, add_quirk_mmc, |
| 1253 | MMC_QUIRK_BLK_NO_CMD23), |
Andrei Warkentin | 6f60c22 | 2011-04-11 19:11:04 -0400 | [diff] [blame] | 1254 | END_FIXUP |
| 1255 | }; |
| 1256 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1257 | static int mmc_blk_probe(struct mmc_card *card) |
| 1258 | { |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1259 | struct mmc_blk_data *md, *part_md; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1260 | int err; |
Pierre Ossman | a7bbb57 | 2008-09-06 10:57:57 +0200 | [diff] [blame] | 1261 | char cap_str[10]; |
| 1262 | |
Pierre Ossman | 912490d | 2005-05-21 10:27:02 +0100 | [diff] [blame] | 1263 | /* |
| 1264 | * Check that the card supports the command class(es) we need. |
| 1265 | */ |
| 1266 | if (!(card->csd.cmdclass & CCC_BLOCK_READ)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1267 | return -ENODEV; |
| 1268 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1269 | md = mmc_blk_alloc(card); |
| 1270 | if (IS_ERR(md)) |
| 1271 | return PTR_ERR(md); |
| 1272 | |
| 1273 | err = mmc_blk_set_blksize(md, card); |
| 1274 | if (err) |
| 1275 | goto out; |
| 1276 | |
Yi Li | 444122f | 2009-02-05 15:31:57 +0800 | [diff] [blame] | 1277 | string_get_size((u64)get_capacity(md->disk) << 9, STRING_UNITS_2, |
Pierre Ossman | a7bbb57 | 2008-09-06 10:57:57 +0200 | [diff] [blame] | 1278 | cap_str, sizeof(cap_str)); |
| 1279 | printk(KERN_INFO "%s: %s %s %s %s\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1280 | md->disk->disk_name, mmc_card_id(card), mmc_card_name(card), |
Pierre Ossman | a7bbb57 | 2008-09-06 10:57:57 +0200 | [diff] [blame] | 1281 | cap_str, md->read_only ? "(ro)" : ""); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1282 | |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1283 | if (mmc_blk_alloc_parts(card, md)) |
| 1284 | goto out; |
| 1285 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1286 | mmc_set_drvdata(card, md); |
Andrei Warkentin | 6f60c22 | 2011-04-11 19:11:04 -0400 | [diff] [blame] | 1287 | mmc_fixup_device(card, blk_fixups); |
| 1288 | |
San Mehat | c87f8d4 | 2009-07-30 08:21:19 -0700 | [diff] [blame] | 1289 | #ifdef CONFIG_MMC_BLOCK_DEFERRED_RESUME |
| 1290 | mmc_set_bus_resume_policy(card->host, 1); |
| 1291 | #endif |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1292 | if (mmc_add_disk(md)) |
| 1293 | goto out; |
| 1294 | |
| 1295 | list_for_each_entry(part_md, &md->part, part) { |
| 1296 | if (mmc_add_disk(part_md)) |
| 1297 | goto out; |
| 1298 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1299 | return 0; |
| 1300 | |
| 1301 | out: |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1302 | mmc_blk_remove_parts(card, md); |
| 1303 | mmc_blk_remove_req(md); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1304 | return err; |
| 1305 | } |
| 1306 | |
| 1307 | static void mmc_blk_remove(struct mmc_card *card) |
| 1308 | { |
| 1309 | struct mmc_blk_data *md = mmc_get_drvdata(card); |
| 1310 | |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1311 | mmc_blk_remove_parts(card, md); |
| 1312 | mmc_blk_remove_req(md); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1313 | mmc_set_drvdata(card, NULL); |
San Mehat | c87f8d4 | 2009-07-30 08:21:19 -0700 | [diff] [blame] | 1314 | #ifdef CONFIG_MMC_BLOCK_DEFERRED_RESUME |
| 1315 | mmc_set_bus_resume_policy(card->host, 0); |
| 1316 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1317 | } |
| 1318 | |
| 1319 | #ifdef CONFIG_PM |
| 1320 | static int mmc_blk_suspend(struct mmc_card *card, pm_message_t state) |
| 1321 | { |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1322 | struct mmc_blk_data *part_md; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1323 | struct mmc_blk_data *md = mmc_get_drvdata(card); |
| 1324 | |
| 1325 | if (md) { |
| 1326 | mmc_queue_suspend(&md->queue); |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1327 | list_for_each_entry(part_md, &md->part, part) { |
| 1328 | mmc_queue_suspend(&part_md->queue); |
| 1329 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1330 | } |
| 1331 | return 0; |
| 1332 | } |
| 1333 | |
| 1334 | static int mmc_blk_resume(struct mmc_card *card) |
| 1335 | { |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1336 | struct mmc_blk_data *part_md; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1337 | struct mmc_blk_data *md = mmc_get_drvdata(card); |
| 1338 | |
| 1339 | if (md) { |
San Mehat | c87f8d4 | 2009-07-30 08:21:19 -0700 | [diff] [blame] | 1340 | #ifndef CONFIG_MMC_BLOCK_DEFERRED_RESUME |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1341 | mmc_blk_set_blksize(md, card); |
San Mehat | c87f8d4 | 2009-07-30 08:21:19 -0700 | [diff] [blame] | 1342 | #endif |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1343 | |
| 1344 | /* |
| 1345 | * Resume involves the card going into idle state, |
| 1346 | * so current partition is always the main one. |
| 1347 | */ |
| 1348 | md->part_curr = md->part_type; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1349 | mmc_queue_resume(&md->queue); |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 1350 | list_for_each_entry(part_md, &md->part, part) { |
| 1351 | mmc_queue_resume(&part_md->queue); |
| 1352 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1353 | } |
| 1354 | return 0; |
| 1355 | } |
| 1356 | #else |
| 1357 | #define mmc_blk_suspend NULL |
| 1358 | #define mmc_blk_resume NULL |
| 1359 | #endif |
| 1360 | |
| 1361 | static struct mmc_driver mmc_driver = { |
| 1362 | .drv = { |
| 1363 | .name = "mmcblk", |
| 1364 | }, |
| 1365 | .probe = mmc_blk_probe, |
| 1366 | .remove = mmc_blk_remove, |
| 1367 | .suspend = mmc_blk_suspend, |
| 1368 | .resume = mmc_blk_resume, |
| 1369 | }; |
| 1370 | |
| 1371 | static int __init mmc_blk_init(void) |
| 1372 | { |
Akinobu Mita | 9d4e98e | 2008-09-13 19:02:07 +0900 | [diff] [blame] | 1373 | int res; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1374 | |
Olof Johansson | 5e71b7a | 2010-09-17 21:19:57 -0400 | [diff] [blame] | 1375 | if (perdev_minors != CONFIG_MMC_BLOCK_MINORS) |
| 1376 | pr_info("mmcblk: using %d minors per device\n", perdev_minors); |
| 1377 | |
| 1378 | max_devices = 256 / perdev_minors; |
| 1379 | |
Pierre Ossman | fe6b4c8 | 2007-05-14 17:27:29 +0200 | [diff] [blame] | 1380 | res = register_blkdev(MMC_BLOCK_MAJOR, "mmc"); |
| 1381 | if (res) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1382 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1383 | |
Akinobu Mita | 9d4e98e | 2008-09-13 19:02:07 +0900 | [diff] [blame] | 1384 | res = mmc_register_driver(&mmc_driver); |
| 1385 | if (res) |
| 1386 | goto out2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1387 | |
Akinobu Mita | 9d4e98e | 2008-09-13 19:02:07 +0900 | [diff] [blame] | 1388 | return 0; |
| 1389 | out2: |
| 1390 | unregister_blkdev(MMC_BLOCK_MAJOR, "mmc"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1391 | out: |
| 1392 | return res; |
| 1393 | } |
| 1394 | |
| 1395 | static void __exit mmc_blk_exit(void) |
| 1396 | { |
| 1397 | mmc_unregister_driver(&mmc_driver); |
Pierre Ossman | fe6b4c8 | 2007-05-14 17:27:29 +0200 | [diff] [blame] | 1398 | unregister_blkdev(MMC_BLOCK_MAJOR, "mmc"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1399 | } |
| 1400 | |
| 1401 | module_init(mmc_blk_init); |
| 1402 | module_exit(mmc_blk_exit); |
| 1403 | |
| 1404 | MODULE_LICENSE("GPL"); |
| 1405 | MODULE_DESCRIPTION("Multimedia Card (MMC) block device driver"); |
| 1406 | |