1 /*
2 * Direct MTD block device access
3 *
4 * $Id: mtdblock.c,v 1.51 2001/11/20 11:42:33 dwmw2 Exp $
5 *
6 * 02-nov-2000 Nicolas Pitre Added read-modify-write with cache
7 */
8
9 #include <linux/config.h>
10 #include <linux/types.h>
11 #include <linux/module.h>
12 #include <linux/kernel.h>
13 #include <linux/slab.h>
14 #include <linux/mtd/mtd.h>
15 #include <linux/mtd/compatmac.h>
16
17 #define MAJOR_NR MTD_BLOCK_MAJOR
18 #define DEVICE_NAME "mtdblock"
19 #define DEVICE_REQUEST mtdblock_request
20 #define DEVICE_NR(device) (device)
21 #define DEVICE_ON(device)
22 #define DEVICE_OFF(device)
23 #define DEVICE_NO_RANDOM
24 #include <linux/blk.h>
25 /* for old kernels... */
26 #ifndef QUEUE_EMPTY
27 #define QUEUE_EMPTY (!CURRENT)
28 #endif
29 #if LINUX_VERSION_CODE < 0x20300
30 #define QUEUE_PLUGGED (blk_dev[MAJOR_NR].plug_tq.sync)
31 #else
32 #define QUEUE_PLUGGED (blk_dev[MAJOR_NR].request_queue.plugged)
33 #endif
34
35 #ifdef CONFIG_DEVFS_FS
36 #include <linux/devfs_fs_kernel.h>
37 static void mtd_notify_add(struct mtd_info* mtd);
38 static void mtd_notify_remove(struct mtd_info* mtd);
39 static struct mtd_notifier notifier = {
40 mtd_notify_add,
41 mtd_notify_remove,
42 NULL
43 };
44 static devfs_handle_t devfs_dir_handle = NULL;
45 static devfs_handle_t devfs_rw_handle[MAX_MTD_DEVICES];
46 #endif
47
48 static struct mtdblk_dev {
49 struct mtd_info *mtd; /* Locked */
50 int count;
51 struct semaphore cache_sem;
52 unsigned char *cache_data;
53 unsigned long cache_offset;
54 unsigned int cache_size;
55 enum { STATE_EMPTY, STATE_CLEAN, STATE_DIRTY } cache_state;
56 } *mtdblks[MAX_MTD_DEVICES];
57
58 static spinlock_t mtdblks_lock;
59
60 static int mtd_sizes[MAX_MTD_DEVICES];
61 static int mtd_blksizes[MAX_MTD_DEVICES];
62
63 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,14)
64 #define BLK_INC_USE_COUNT MOD_INC_USE_COUNT
65 #define BLK_DEC_USE_COUNT MOD_DEC_USE_COUNT
66 #else
67 #define BLK_INC_USE_COUNT do {} while(0)
68 #define BLK_DEC_USE_COUNT do {} while(0)
69 #endif
70
71 /*
72 * Cache stuff...
73 *
74 * Since typical flash erasable sectors are much larger than what Linux's
75 * buffer cache can handle, we must implement read-modify-write on flash
76 * sectors for each block write requests. To avoid over-erasing flash sectors
77 * and to speed things up, we locally cache a whole flash sector while it is
78 * being written to until a different sector is required.
79 */
80
erase_callback(struct erase_info * done)81 static void erase_callback(struct erase_info *done)
82 {
83 wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv;
84 wake_up(wait_q);
85 }
86
erase_write(struct mtd_info * mtd,unsigned long pos,int len,const char * buf)87 static int erase_write (struct mtd_info *mtd, unsigned long pos,
88 int len, const char *buf)
89 {
90 struct erase_info erase;
91 DECLARE_WAITQUEUE(wait, current);
92 wait_queue_head_t wait_q;
93 size_t retlen;
94 int ret;
95
96 /*
97 * First, let's erase the flash block.
98 */
99
100 init_waitqueue_head(&wait_q);
101 erase.mtd = mtd;
102 erase.callback = erase_callback;
103 erase.addr = pos;
104 erase.len = len;
105 erase.priv = (u_long)&wait_q;
106
107 set_current_state(TASK_INTERRUPTIBLE);
108 add_wait_queue(&wait_q, &wait);
109
110 ret = MTD_ERASE(mtd, &erase);
111 if (ret) {
112 set_current_state(TASK_RUNNING);
113 remove_wait_queue(&wait_q, &wait);
114 printk (KERN_WARNING "mtdblock: erase of region [0x%lx, 0x%x] "
115 "on \"%s\" failed\n",
116 pos, len, mtd->name);
117 return ret;
118 }
119
120 schedule(); /* Wait for erase to finish. */
121 remove_wait_queue(&wait_q, &wait);
122
123 /*
124 * Next, writhe data to flash.
125 */
126
127 ret = MTD_WRITE (mtd, pos, len, &retlen, buf);
128 if (ret)
129 return ret;
130 if (retlen != len)
131 return -EIO;
132 return 0;
133 }
134
135
write_cached_data(struct mtdblk_dev * mtdblk)136 static int write_cached_data (struct mtdblk_dev *mtdblk)
137 {
138 struct mtd_info *mtd = mtdblk->mtd;
139 int ret;
140
141 if (mtdblk->cache_state != STATE_DIRTY)
142 return 0;
143
144 DEBUG(MTD_DEBUG_LEVEL2, "mtdblock: writing cached data for \"%s\" "
145 "at 0x%lx, size 0x%x\n", mtd->name,
146 mtdblk->cache_offset, mtdblk->cache_size);
147
148 ret = erase_write (mtd, mtdblk->cache_offset,
149 mtdblk->cache_size, mtdblk->cache_data);
150 if (ret)
151 return ret;
152
153 /*
154 * Here we could argably set the cache state to STATE_CLEAN.
155 * However this could lead to inconsistency since we will not
156 * be notified if this content is altered on the flash by other
157 * means. Let's declare it empty and leave buffering tasks to
158 * the buffer cache instead.
159 */
160 mtdblk->cache_state = STATE_EMPTY;
161 return 0;
162 }
163
164
do_cached_write(struct mtdblk_dev * mtdblk,unsigned long pos,int len,const char * buf)165 static int do_cached_write (struct mtdblk_dev *mtdblk, unsigned long pos,
166 int len, const char *buf)
167 {
168 struct mtd_info *mtd = mtdblk->mtd;
169 unsigned int sect_size = mtdblk->cache_size;
170 size_t retlen;
171 int ret;
172
173 DEBUG(MTD_DEBUG_LEVEL2, "mtdblock: write on \"%s\" at 0x%lx, size 0x%x\n",
174 mtd->name, pos, len);
175
176 if (!sect_size)
177 return MTD_WRITE (mtd, pos, len, &retlen, buf);
178
179 while (len > 0) {
180 unsigned long sect_start = (pos/sect_size)*sect_size;
181 unsigned int offset = pos - sect_start;
182 unsigned int size = sect_size - offset;
183 if( size > len )
184 size = len;
185
186 if (size == sect_size) {
187 /*
188 * We are covering a whole sector. Thus there is no
189 * need to bother with the cache while it may still be
190 * useful for other partial writes.
191 */
192 ret = erase_write (mtd, pos, size, buf);
193 if (ret)
194 return ret;
195 } else {
196 /* Partial sector: need to use the cache */
197
198 if (mtdblk->cache_state == STATE_DIRTY &&
199 mtdblk->cache_offset != sect_start) {
200 ret = write_cached_data(mtdblk);
201 if (ret)
202 return ret;
203 }
204
205 if (mtdblk->cache_state == STATE_EMPTY ||
206 mtdblk->cache_offset != sect_start) {
207 /* fill the cache with the current sector */
208 mtdblk->cache_state = STATE_EMPTY;
209 ret = MTD_READ(mtd, sect_start, sect_size, &retlen, mtdblk->cache_data);
210 if (ret)
211 return ret;
212 if (retlen != sect_size)
213 return -EIO;
214
215 mtdblk->cache_offset = sect_start;
216 mtdblk->cache_size = sect_size;
217 mtdblk->cache_state = STATE_CLEAN;
218 }
219
220 /* write data to our local cache */
221 memcpy (mtdblk->cache_data + offset, buf, size);
222 mtdblk->cache_state = STATE_DIRTY;
223 }
224
225 buf += size;
226 pos += size;
227 len -= size;
228 }
229
230 return 0;
231 }
232
233
do_cached_read(struct mtdblk_dev * mtdblk,unsigned long pos,int len,char * buf)234 static int do_cached_read (struct mtdblk_dev *mtdblk, unsigned long pos,
235 int len, char *buf)
236 {
237 struct mtd_info *mtd = mtdblk->mtd;
238 unsigned int sect_size = mtdblk->cache_size;
239 size_t retlen;
240 int ret;
241
242 DEBUG(MTD_DEBUG_LEVEL2, "mtdblock: read on \"%s\" at 0x%lx, size 0x%x\n",
243 mtd->name, pos, len);
244
245 if (!sect_size)
246 return MTD_READ (mtd, pos, len, &retlen, buf);
247
248 while (len > 0) {
249 unsigned long sect_start = (pos/sect_size)*sect_size;
250 unsigned int offset = pos - sect_start;
251 unsigned int size = sect_size - offset;
252 if (size > len)
253 size = len;
254
255 /*
256 * Check if the requested data is already cached
257 * Read the requested amount of data from our internal cache if it
258 * contains what we want, otherwise we read the data directly
259 * from flash.
260 */
261 if (mtdblk->cache_state != STATE_EMPTY &&
262 mtdblk->cache_offset == sect_start) {
263 memcpy (buf, mtdblk->cache_data + offset, size);
264 } else {
265 ret = MTD_READ (mtd, pos, size, &retlen, buf);
266 if (ret)
267 return ret;
268 if (retlen != size)
269 return -EIO;
270 }
271
272 buf += size;
273 pos += size;
274 len -= size;
275 }
276
277 return 0;
278 }
279
280
281
mtdblock_open(struct inode * inode,struct file * file)282 static int mtdblock_open(struct inode *inode, struct file *file)
283 {
284 struct mtdblk_dev *mtdblk;
285 struct mtd_info *mtd;
286 int dev;
287
288 DEBUG(MTD_DEBUG_LEVEL1,"mtdblock_open\n");
289
290 if (!inode)
291 return -EINVAL;
292
293 dev = MINOR(inode->i_rdev);
294 if (dev >= MAX_MTD_DEVICES)
295 return -EINVAL;
296
297 BLK_INC_USE_COUNT;
298
299 mtd = get_mtd_device(NULL, dev);
300 if (!mtd)
301 return -ENODEV;
302 if (MTD_ABSENT == mtd->type) {
303 put_mtd_device(mtd);
304 BLK_DEC_USE_COUNT;
305 return -ENODEV;
306 }
307
308 spin_lock(&mtdblks_lock);
309
310 /* If it's already open, no need to piss about. */
311 if (mtdblks[dev]) {
312 mtdblks[dev]->count++;
313 spin_unlock(&mtdblks_lock);
314 put_mtd_device(mtd);
315 return 0;
316 }
317
318 /* OK, it's not open. Try to find it */
319
320 /* First we have to drop the lock, because we have to
321 to things which might sleep.
322 */
323 spin_unlock(&mtdblks_lock);
324
325 mtdblk = kmalloc(sizeof(struct mtdblk_dev), GFP_KERNEL);
326 if (!mtdblk) {
327 put_mtd_device(mtd);
328 BLK_DEC_USE_COUNT;
329 return -ENOMEM;
330 }
331 memset(mtdblk, 0, sizeof(*mtdblk));
332 mtdblk->count = 1;
333 mtdblk->mtd = mtd;
334
335 init_MUTEX (&mtdblk->cache_sem);
336 mtdblk->cache_state = STATE_EMPTY;
337 if ((mtdblk->mtd->flags & MTD_CAP_RAM) != MTD_CAP_RAM &&
338 mtdblk->mtd->erasesize) {
339 mtdblk->cache_size = mtdblk->mtd->erasesize;
340 mtdblk->cache_data = vmalloc(mtdblk->mtd->erasesize);
341 if (!mtdblk->cache_data) {
342 put_mtd_device(mtdblk->mtd);
343 kfree(mtdblk);
344 BLK_DEC_USE_COUNT;
345 return -ENOMEM;
346 }
347 }
348
349 /* OK, we've created a new one. Add it to the list. */
350
351 spin_lock(&mtdblks_lock);
352
353 if (mtdblks[dev]) {
354 /* Another CPU made one at the same time as us. */
355 mtdblks[dev]->count++;
356 spin_unlock(&mtdblks_lock);
357 put_mtd_device(mtdblk->mtd);
358 vfree(mtdblk->cache_data);
359 kfree(mtdblk);
360 return 0;
361 }
362
363 mtdblks[dev] = mtdblk;
364 mtd_sizes[dev] = mtdblk->mtd->size/1024;
365 if (mtdblk->mtd->erasesize)
366 mtd_blksizes[dev] = mtdblk->mtd->erasesize;
367 if (mtd_blksizes[dev] > PAGE_SIZE)
368 mtd_blksizes[dev] = PAGE_SIZE;
369 set_device_ro (inode->i_rdev, !(mtdblk->mtd->flags & MTD_WRITEABLE));
370
371 spin_unlock(&mtdblks_lock);
372
373 DEBUG(MTD_DEBUG_LEVEL1, "ok\n");
374
375 return 0;
376 }
377
mtdblock_release(struct inode * inode,struct file * file)378 static release_t mtdblock_release(struct inode *inode, struct file *file)
379 {
380 int dev;
381 struct mtdblk_dev *mtdblk;
382 DEBUG(MTD_DEBUG_LEVEL1, "mtdblock_release\n");
383
384 if (inode == NULL)
385 release_return(-ENODEV);
386
387 dev = MINOR(inode->i_rdev);
388 mtdblk = mtdblks[dev];
389
390 down(&mtdblk->cache_sem);
391 write_cached_data(mtdblk);
392 up(&mtdblk->cache_sem);
393
394 spin_lock(&mtdblks_lock);
395 if (!--mtdblk->count) {
396 /* It was the last usage. Free the device */
397 mtdblks[dev] = NULL;
398 spin_unlock(&mtdblks_lock);
399 if (mtdblk->mtd->sync)
400 mtdblk->mtd->sync(mtdblk->mtd);
401 put_mtd_device(mtdblk->mtd);
402 vfree(mtdblk->cache_data);
403 kfree(mtdblk);
404 } else {
405 spin_unlock(&mtdblks_lock);
406 }
407
408 DEBUG(MTD_DEBUG_LEVEL1, "ok\n");
409
410 BLK_DEC_USE_COUNT;
411 release_return(0);
412 }
413
414
415 /*
416 * This is a special request_fn because it is executed in a process context
417 * to be able to sleep independently of the caller. The io_request_lock
418 * is held upon entry and exit.
419 * The head of our request queue is considered active so there is no need
420 * to dequeue requests before we are done.
421 */
handle_mtdblock_request(void)422 static void handle_mtdblock_request(void)
423 {
424 struct request *req;
425 struct mtdblk_dev *mtdblk;
426 unsigned int res;
427
428 for (;;) {
429 INIT_REQUEST;
430 req = CURRENT;
431 spin_unlock_irq(&io_request_lock);
432 mtdblk = mtdblks[MINOR(req->rq_dev)];
433 res = 0;
434
435 if (MINOR(req->rq_dev) >= MAX_MTD_DEVICES)
436 panic("%s: minor out of bounds", __FUNCTION__);
437
438 if ((req->sector + req->current_nr_sectors) > (mtdblk->mtd->size >> 9))
439 goto end_req;
440
441 // Handle the request
442 switch (req->cmd)
443 {
444 int err;
445
446 case READ:
447 down(&mtdblk->cache_sem);
448 err = do_cached_read (mtdblk, req->sector << 9,
449 req->current_nr_sectors << 9,
450 req->buffer);
451 up(&mtdblk->cache_sem);
452 if (!err)
453 res = 1;
454 break;
455
456 case WRITE:
457 // Read only device
458 if ( !(mtdblk->mtd->flags & MTD_WRITEABLE) )
459 break;
460
461 // Do the write
462 down(&mtdblk->cache_sem);
463 err = do_cached_write (mtdblk, req->sector << 9,
464 req->current_nr_sectors << 9,
465 req->buffer);
466 up(&mtdblk->cache_sem);
467 if (!err)
468 res = 1;
469 break;
470 }
471
472 end_req:
473 spin_lock_irq(&io_request_lock);
474 end_request(res);
475 }
476 }
477
478 static volatile int leaving = 0;
479 static DECLARE_MUTEX_LOCKED(thread_sem);
480 static DECLARE_WAIT_QUEUE_HEAD(thr_wq);
481
mtdblock_thread(void * dummy)482 int mtdblock_thread(void *dummy)
483 {
484 struct task_struct *tsk = current;
485 DECLARE_WAITQUEUE(wait, tsk);
486
487 /* we might get involved when memory gets low, so use PF_MEMALLOC */
488 tsk->flags |= PF_MEMALLOC;
489 strcpy(tsk->comm, "mtdblockd");
490 spin_lock_irq(&tsk->sigmask_lock);
491 sigfillset(&tsk->blocked);
492 recalc_sigpending(tsk);
493 spin_unlock_irq(&tsk->sigmask_lock);
494 daemonize();
495
496 while (!leaving) {
497 add_wait_queue(&thr_wq, &wait);
498 set_current_state(TASK_INTERRUPTIBLE);
499 spin_lock_irq(&io_request_lock);
500 if (QUEUE_EMPTY || QUEUE_PLUGGED) {
501 spin_unlock_irq(&io_request_lock);
502 schedule();
503 remove_wait_queue(&thr_wq, &wait);
504 } else {
505 remove_wait_queue(&thr_wq, &wait);
506 set_current_state(TASK_RUNNING);
507 handle_mtdblock_request();
508 spin_unlock_irq(&io_request_lock);
509 }
510 }
511
512 up(&thread_sem);
513 return 0;
514 }
515
516 #if LINUX_VERSION_CODE < 0x20300
517 #define RQFUNC_ARG void
518 #else
519 #define RQFUNC_ARG request_queue_t *q
520 #endif
521
mtdblock_request(RQFUNC_ARG)522 static void mtdblock_request(RQFUNC_ARG)
523 {
524 /* Don't do anything, except wake the thread if necessary */
525 wake_up(&thr_wq);
526 }
527
528
mtdblock_ioctl(struct inode * inode,struct file * file,unsigned int cmd,unsigned long arg)529 static int mtdblock_ioctl(struct inode * inode, struct file * file,
530 unsigned int cmd, unsigned long arg)
531 {
532 struct mtdblk_dev *mtdblk;
533
534 mtdblk = mtdblks[MINOR(inode->i_rdev)];
535
536 #ifdef PARANOIA
537 if (!mtdblk)
538 BUG();
539 #endif
540
541 switch (cmd) {
542 case BLKGETSIZE: /* Return device size */
543 return put_user((mtdblk->mtd->size >> 9), (unsigned long *) arg);
544
545 #ifdef BLKGETSIZE64
546 case BLKGETSIZE64:
547 return put_user((u64)mtdblk->mtd->size, (u64 *)arg);
548 #endif
549
550 case BLKFLSBUF:
551 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
552 if(!capable(CAP_SYS_ADMIN))
553 return -EACCES;
554 #endif
555 fsync_dev(inode->i_rdev);
556 invalidate_buffers(inode->i_rdev);
557 down(&mtdblk->cache_sem);
558 write_cached_data(mtdblk);
559 up(&mtdblk->cache_sem);
560 if (mtdblk->mtd->sync)
561 mtdblk->mtd->sync(mtdblk->mtd);
562 return 0;
563
564 default:
565 return -EINVAL;
566 }
567 }
568
569 #if LINUX_VERSION_CODE < 0x20326
570 static struct file_operations mtd_fops =
571 {
572 open: mtdblock_open,
573 ioctl: mtdblock_ioctl,
574 release: mtdblock_release,
575 read: block_read,
576 write: block_write
577 };
578 #else
579 static struct block_device_operations mtd_fops =
580 {
581 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,14)
582 owner: THIS_MODULE,
583 #endif
584 open: mtdblock_open,
585 release: mtdblock_release,
586 ioctl: mtdblock_ioctl
587 };
588 #endif
589
590 #ifdef CONFIG_DEVFS_FS
591 /* Notification that a new device has been added. Create the devfs entry for
592 * it. */
593
mtd_notify_add(struct mtd_info * mtd)594 static void mtd_notify_add(struct mtd_info* mtd)
595 {
596 char name[8];
597
598 if (!mtd || mtd->type == MTD_ABSENT)
599 return;
600
601 sprintf(name, "%d", mtd->index);
602 devfs_rw_handle[mtd->index] = devfs_register(devfs_dir_handle, name,
603 DEVFS_FL_DEFAULT, MTD_BLOCK_MAJOR, mtd->index,
604 S_IFBLK | S_IRUGO | S_IWUGO,
605 &mtd_fops, NULL);
606 }
607
mtd_notify_remove(struct mtd_info * mtd)608 static void mtd_notify_remove(struct mtd_info* mtd)
609 {
610 if (!mtd || mtd->type == MTD_ABSENT)
611 return;
612
613 devfs_unregister(devfs_rw_handle[mtd->index]);
614 }
615 #endif
616
init_mtdblock(void)617 int __init init_mtdblock(void)
618 {
619 int i;
620
621 spin_lock_init(&mtdblks_lock);
622 #ifdef CONFIG_DEVFS_FS
623 if (devfs_register_blkdev(MTD_BLOCK_MAJOR, DEVICE_NAME, &mtd_fops))
624 {
625 printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices.\n",
626 MTD_BLOCK_MAJOR);
627 return -EAGAIN;
628 }
629
630 devfs_dir_handle = devfs_mk_dir(NULL, DEVICE_NAME, NULL);
631 register_mtd_user(¬ifier);
632 #else
633 if (register_blkdev(MAJOR_NR,DEVICE_NAME,&mtd_fops)) {
634 printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices.\n",
635 MTD_BLOCK_MAJOR);
636 return -EAGAIN;
637 }
638 #endif
639
640 /* We fill it in at open() time. */
641 for (i=0; i< MAX_MTD_DEVICES; i++) {
642 mtd_sizes[i] = 0;
643 mtd_blksizes[i] = BLOCK_SIZE;
644 }
645 init_waitqueue_head(&thr_wq);
646 /* Allow the block size to default to BLOCK_SIZE. */
647 blksize_size[MAJOR_NR] = mtd_blksizes;
648 blk_size[MAJOR_NR] = mtd_sizes;
649
650 blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), &mtdblock_request);
651 kernel_thread (mtdblock_thread, NULL, CLONE_FS|CLONE_FILES|CLONE_SIGHAND);
652 return 0;
653 }
654
cleanup_mtdblock(void)655 static void __exit cleanup_mtdblock(void)
656 {
657 leaving = 1;
658 wake_up(&thr_wq);
659 down(&thread_sem);
660 #ifdef CONFIG_DEVFS_FS
661 unregister_mtd_user(¬ifier);
662 devfs_unregister(devfs_dir_handle);
663 devfs_unregister_blkdev(MTD_BLOCK_MAJOR, DEVICE_NAME);
664 #else
665 unregister_blkdev(MAJOR_NR,DEVICE_NAME);
666 #endif
667 blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
668 blksize_size[MAJOR_NR] = NULL;
669 blk_size[MAJOR_NR] = NULL;
670 }
671
672 module_init(init_mtdblock);
673 module_exit(cleanup_mtdblock);
674
675
676 MODULE_LICENSE("GPL");
677 MODULE_AUTHOR("Nicolas Pitre <nico@cam.org> et al.");
678 MODULE_DESCRIPTION("Caching read/erase/writeback block device emulation access to MTD devices");
679