2 * Block driver for media (i.e., flash cards)
4 * Copyright 2002 Hewlett-Packard Company
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.
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.
14 * Many thanks to Alessandro Rubini and Jonathan Corbet!
16 * Author: Andrew Christian
19 #include <linux/moduleparam.h>
20 #include <linux/module.h>
21 #include <linux/init.h>
23 #include <linux/sched.h>
24 #include <linux/kernel.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>
32 #include <linux/mmc/card.h>
33 #include <linux/mmc/protocol.h>
35 #include <asm/system.h>
36 #include <asm/uaccess.h>
38 #include "mmc_queue.h"
41 * max 8 partitions per card
48 * There is one mmc_blk_data per slot.
53 struct mmc_queue queue
;
56 unsigned int block_bits
;
57 unsigned int read_only
;
60 static DEFINE_MUTEX(open_lock
);
62 static struct mmc_blk_data
*mmc_blk_get(struct gendisk
*disk
)
64 struct mmc_blk_data
*md
;
66 mutex_lock(&open_lock
);
67 md
= disk
->private_data
;
68 if (md
&& md
->usage
== 0)
72 mutex_unlock(&open_lock
);
77 static void mmc_blk_put(struct mmc_blk_data
*md
)
79 mutex_lock(&open_lock
);
83 mmc_cleanup_queue(&md
->queue
);
86 mutex_unlock(&open_lock
);
89 static int mmc_blk_open(struct inode
*inode
, struct file
*filp
)
91 struct mmc_blk_data
*md
;
94 md
= mmc_blk_get(inode
->i_bdev
->bd_disk
);
97 check_disk_change(inode
->i_bdev
);
100 if ((filp
->f_mode
& FMODE_WRITE
) && md
->read_only
)
107 static int mmc_blk_release(struct inode
*inode
, struct file
*filp
)
109 struct mmc_blk_data
*md
= inode
->i_bdev
->bd_disk
->private_data
;
116 mmc_blk_getgeo(struct block_device
*bdev
, struct hd_geometry
*geo
)
118 geo
->cylinders
= get_capacity(bdev
->bd_disk
) / (4 * 16);
124 static struct block_device_operations mmc_bdops
= {
125 .open
= mmc_blk_open
,
126 .release
= mmc_blk_release
,
127 .getgeo
= mmc_blk_getgeo
,
128 .owner
= THIS_MODULE
,
131 struct mmc_blk_request
{
132 struct mmc_request mrq
;
133 struct mmc_command cmd
;
134 struct mmc_command stop
;
135 struct mmc_data data
;
138 static int mmc_blk_prep_rq(struct mmc_queue
*mq
, struct request
*req
)
140 struct mmc_blk_data
*md
= mq
->data
;
141 int stat
= BLKPREP_OK
;
144 * If we have no device, we haven't finished initialising.
146 if (!md
|| !mq
->card
) {
147 printk(KERN_ERR
"%s: killing request - no device/host\n",
148 req
->rq_disk
->disk_name
);
155 static int mmc_blk_issue_rq(struct mmc_queue
*mq
, struct request
*req
)
157 struct mmc_blk_data
*md
= mq
->data
;
158 struct mmc_card
*card
= md
->queue
.card
;
161 if (mmc_card_claim_host(card
))
165 struct mmc_blk_request brq
;
166 struct mmc_command cmd
;
168 memset(&brq
, 0, sizeof(struct mmc_blk_request
));
169 brq
.mrq
.cmd
= &brq
.cmd
;
170 brq
.mrq
.data
= &brq
.data
;
172 brq
.cmd
.arg
= req
->sector
<< 9;
173 brq
.cmd
.flags
= MMC_RSP_R1
| MMC_CMD_ADTC
;
174 brq
.data
.timeout_ns
= card
->csd
.tacc_ns
* 10;
175 brq
.data
.timeout_clks
= card
->csd
.tacc_clks
* 10;
176 brq
.data
.blksz_bits
= md
->block_bits
;
177 brq
.data
.blksz
= 1 << md
->block_bits
;
178 brq
.data
.blocks
= req
->nr_sectors
>> (md
->block_bits
- 9);
179 brq
.stop
.opcode
= MMC_STOP_TRANSMISSION
;
181 brq
.stop
.flags
= MMC_RSP_R1B
| MMC_CMD_AC
;
183 if (rq_data_dir(req
) == READ
) {
184 brq
.cmd
.opcode
= brq
.data
.blocks
> 1 ? MMC_READ_MULTIPLE_BLOCK
: MMC_READ_SINGLE_BLOCK
;
185 brq
.data
.flags
|= MMC_DATA_READ
;
187 brq
.cmd
.opcode
= MMC_WRITE_BLOCK
;
188 brq
.data
.flags
|= MMC_DATA_WRITE
;
192 * Scale up the timeout by the r2w factor
194 brq
.data
.timeout_ns
<<= card
->csd
.r2w_factor
;
195 brq
.data
.timeout_clks
<<= card
->csd
.r2w_factor
;
198 if (brq
.data
.blocks
> 1) {
199 brq
.data
.flags
|= MMC_DATA_MULTI
;
200 brq
.mrq
.stop
= &brq
.stop
;
205 brq
.data
.sg
= mq
->sg
;
206 brq
.data
.sg_len
= blk_rq_map_sg(req
->q
, req
, brq
.data
.sg
);
208 mmc_wait_for_req(card
->host
, &brq
.mrq
);
210 printk(KERN_ERR
"%s: error %d sending read/write command\n",
211 req
->rq_disk
->disk_name
, brq
.cmd
.error
);
215 if (brq
.data
.error
) {
216 printk(KERN_ERR
"%s: error %d transferring data\n",
217 req
->rq_disk
->disk_name
, brq
.data
.error
);
221 if (brq
.stop
.error
) {
222 printk(KERN_ERR
"%s: error %d sending stop command\n",
223 req
->rq_disk
->disk_name
, brq
.stop
.error
);
230 cmd
.opcode
= MMC_SEND_STATUS
;
231 cmd
.arg
= card
->rca
<< 16;
232 cmd
.flags
= MMC_RSP_R1
| MMC_CMD_AC
;
233 err
= mmc_wait_for_cmd(card
->host
, &cmd
, 5);
235 printk(KERN_ERR
"%s: error %d requesting status\n",
236 req
->rq_disk
->disk_name
, err
);
239 } while (!(cmd
.resp
[0] & R1_READY_FOR_DATA
));
242 if (cmd
.resp
[0] & ~0x00000900)
243 printk(KERN_ERR
"%s: status = %08x\n",
244 req
->rq_disk
->disk_name
, cmd
.resp
[0]);
245 if (mmc_decode_status(cmd
.resp
))
250 * A block was successfully transferred.
252 spin_lock_irq(&md
->lock
);
253 ret
= end_that_request_chunk(req
, 1, brq
.data
.bytes_xfered
);
256 * The whole request completed successfully.
258 add_disk_randomness(req
->rq_disk
);
259 blkdev_dequeue_request(req
);
260 end_that_request_last(req
, 1);
262 spin_unlock_irq(&md
->lock
);
265 mmc_card_release_host(card
);
270 mmc_card_release_host(card
);
273 * This is a little draconian, but until we get proper
274 * error handling sorted out here, its the best we can
275 * do - especially as some hosts have no idea how much
276 * data was transferred before the error occurred.
278 spin_lock_irq(&md
->lock
);
280 ret
= end_that_request_chunk(req
, 0,
281 req
->current_nr_sectors
<< 9);
284 add_disk_randomness(req
->rq_disk
);
285 blkdev_dequeue_request(req
);
286 end_that_request_last(req
, 0);
287 spin_unlock_irq(&md
->lock
);
292 #define MMC_NUM_MINORS (256 >> MMC_SHIFT)
294 static unsigned long dev_use
[MMC_NUM_MINORS
/(8*sizeof(unsigned long))];
296 static inline int mmc_blk_readonly(struct mmc_card
*card
)
298 return mmc_card_readonly(card
) ||
299 !(card
->csd
.cmdclass
& CCC_BLOCK_WRITE
);
302 static struct mmc_blk_data
*mmc_blk_alloc(struct mmc_card
*card
)
304 struct mmc_blk_data
*md
;
307 devidx
= find_first_zero_bit(dev_use
, MMC_NUM_MINORS
);
308 if (devidx
>= MMC_NUM_MINORS
)
309 return ERR_PTR(-ENOSPC
);
310 __set_bit(devidx
, dev_use
);
312 md
= kmalloc(sizeof(struct mmc_blk_data
), GFP_KERNEL
);
318 memset(md
, 0, sizeof(struct mmc_blk_data
));
321 * Set the read-only status based on the supported commands
322 * and the write protect switch.
324 md
->read_only
= mmc_blk_readonly(card
);
327 * Figure out a workable block size. MMC cards have:
328 * - two block sizes, one for read and one for write.
329 * - may support partial reads and/or writes
330 * (allows block sizes smaller than specified)
332 md
->block_bits
= card
->csd
.read_blkbits
;
333 if (card
->csd
.write_blkbits
!= card
->csd
.read_blkbits
) {
334 if (card
->csd
.write_blkbits
< card
->csd
.read_blkbits
&&
335 card
->csd
.read_partial
) {
337 * write block size is smaller than read block
338 * size, but we support partial reads, so choose
339 * the smaller write block size.
341 md
->block_bits
= card
->csd
.write_blkbits
;
342 } else if (card
->csd
.write_blkbits
> card
->csd
.read_blkbits
&&
343 card
->csd
.write_partial
) {
345 * read block size is smaller than write block
346 * size, but we support partial writes. Use read
351 * We don't support this configuration for writes.
353 printk(KERN_ERR
"%s: unable to select block size for "
354 "writing (rb%u wb%u rp%u wp%u)\n",
356 1 << card
->csd
.read_blkbits
,
357 1 << card
->csd
.write_blkbits
,
358 card
->csd
.read_partial
,
359 card
->csd
.write_partial
);
365 * Refuse to allow block sizes smaller than 512 bytes.
367 if (md
->block_bits
< 9) {
368 printk(KERN_ERR
"%s: unable to support block size %u\n",
369 mmc_card_id(card
), 1 << md
->block_bits
);
374 md
->disk
= alloc_disk(1 << MMC_SHIFT
);
375 if (md
->disk
== NULL
) {
380 spin_lock_init(&md
->lock
);
383 ret
= mmc_init_queue(&md
->queue
, card
, &md
->lock
);
387 md
->queue
.prep_fn
= mmc_blk_prep_rq
;
388 md
->queue
.issue_fn
= mmc_blk_issue_rq
;
391 md
->disk
->major
= major
;
392 md
->disk
->first_minor
= devidx
<< MMC_SHIFT
;
393 md
->disk
->fops
= &mmc_bdops
;
394 md
->disk
->private_data
= md
;
395 md
->disk
->queue
= md
->queue
.queue
;
396 md
->disk
->driverfs_dev
= &card
->dev
;
399 * As discussed on lkml, GENHD_FL_REMOVABLE should:
401 * - be set for removable media with permanent block devices
402 * - be unset for removable block devices with permanent media
404 * Since MMC block devices clearly fall under the second
405 * case, we do not set GENHD_FL_REMOVABLE. Userspace
406 * should use the block device creation/destruction hotplug
407 * messages to tell when the card is present.
410 sprintf(md
->disk
->disk_name
, "mmcblk%d", devidx
);
412 blk_queue_hardsect_size(md
->queue
.queue
, 1 << md
->block_bits
);
415 * The CSD capacity field is in units of read_blkbits.
416 * set_capacity takes units of 512 bytes.
418 set_capacity(md
->disk
, card
->csd
.capacity
<< (card
->csd
.read_blkbits
- 9));
430 mmc_blk_set_blksize(struct mmc_blk_data
*md
, struct mmc_card
*card
)
432 struct mmc_command cmd
;
435 mmc_card_claim_host(card
);
436 cmd
.opcode
= MMC_SET_BLOCKLEN
;
437 cmd
.arg
= 1 << md
->block_bits
;
438 cmd
.flags
= MMC_RSP_R1
| MMC_CMD_AC
;
439 err
= mmc_wait_for_cmd(card
->host
, &cmd
, 5);
440 mmc_card_release_host(card
);
443 printk(KERN_ERR
"%s: unable to set block size to %d: %d\n",
444 md
->disk
->disk_name
, cmd
.arg
, err
);
451 static int mmc_blk_probe(struct mmc_card
*card
)
453 struct mmc_blk_data
*md
;
457 * Check that the card supports the command class(es) we need.
459 if (!(card
->csd
.cmdclass
& CCC_BLOCK_READ
))
462 md
= mmc_blk_alloc(card
);
466 err
= mmc_blk_set_blksize(md
, card
);
470 printk(KERN_INFO
"%s: %s %s %lluKiB %s\n",
471 md
->disk
->disk_name
, mmc_card_id(card
), mmc_card_name(card
),
472 (unsigned long long)(get_capacity(md
->disk
) >> 1),
473 md
->read_only
? "(ro)" : "");
475 mmc_set_drvdata(card
, md
);
485 static void mmc_blk_remove(struct mmc_card
*card
)
487 struct mmc_blk_data
*md
= mmc_get_drvdata(card
);
492 del_gendisk(md
->disk
);
495 * I think this is needed.
497 md
->disk
->queue
= NULL
;
499 devidx
= md
->disk
->first_minor
>> MMC_SHIFT
;
500 __clear_bit(devidx
, dev_use
);
504 mmc_set_drvdata(card
, NULL
);
508 static int mmc_blk_suspend(struct mmc_card
*card
, pm_message_t state
)
510 struct mmc_blk_data
*md
= mmc_get_drvdata(card
);
513 mmc_queue_suspend(&md
->queue
);
518 static int mmc_blk_resume(struct mmc_card
*card
)
520 struct mmc_blk_data
*md
= mmc_get_drvdata(card
);
523 mmc_blk_set_blksize(md
, card
);
524 mmc_queue_resume(&md
->queue
);
529 #define mmc_blk_suspend NULL
530 #define mmc_blk_resume NULL
533 static struct mmc_driver mmc_driver
= {
537 .probe
= mmc_blk_probe
,
538 .remove
= mmc_blk_remove
,
539 .suspend
= mmc_blk_suspend
,
540 .resume
= mmc_blk_resume
,
543 static int __init
mmc_blk_init(void)
547 res
= register_blkdev(major
, "mmc");
549 printk(KERN_WARNING
"Unable to get major %d for MMC media: %d\n",
556 return mmc_register_driver(&mmc_driver
);
562 static void __exit
mmc_blk_exit(void)
564 mmc_unregister_driver(&mmc_driver
);
565 unregister_blkdev(major
, "mmc");
568 module_init(mmc_blk_init
);
569 module_exit(mmc_blk_exit
);
571 MODULE_LICENSE("GPL");
572 MODULE_DESCRIPTION("Multimedia Card (MMC) block device driver");
574 module_param(major
, int, 0444);
575 MODULE_PARM_DESC(major
, "specify the major device number for MMC block driver");