source: freewrt/package/broadcom-mmc/src/mmc.c@ d6d2007

freewrt_1_0 freewrt_2_0
Last change on this file since d6d2007 was d6d2007, checked in by Waldemar Brodkorb <wbx@…>, 19 years ago

add mmc driver for linksys wrt54g mmc hack, contibuted by ulmen, thx

git-svn-id: ​svn://www.freewrt.org/branches/freewrt_1_0@865 afb5a338-a214-0410-bd46-81f09a774fd1
  • Property mode set to 100644
File size: 12.6 KB
Line 
1#include <linux/delay.h>
2#include <linux/timer.h>
3
4#include <linux/module.h>
5#include <linux/mm.h>
6#include <linux/init.h>
7#include <linux/fs.h>
8#include <linux/blkpg.h>
9#include <linux/hdreg.h>
10#include <linux/major.h>
11#include <asm/uaccess.h>
12#include <asm/io.h>
13
14#define DEVICE_NAME "mmc"
15#define DEVICE_NR(device) (MINOR(device))
16#define DEVICE_ON(device)
17#define DEVICE_OFF(device)
18#define MAJOR_NR 121
19
20#include <linux/blk.h>
21
22MODULE_AUTHOR("Madsuk/Rohde");
23MODULE_DESCRIPTION("Driver MMC/SD-Cards");
24MODULE_SUPPORTED_DEVICE("WRT54G");
25MODULE_LICENSE("GPL");
26
27#define SD_DI 0x20
28#define SD_DO 0x10
29#define SD_CLK 0x08
30#define SD_CS 0x80
31
32/* we have only one device */
33static int hd_sizes[1<<6];
34static int hd_blocksizes[1<<6];
35static int hd_hardsectsizes[1<<6];
36static int hd_maxsect[1<<6];
37static struct hd_struct hd[1<<6];
38
39static struct timer_list mmc_timer;
40static int mmc_media_detect = 0;
41static int mmc_media_changed = 1;
42
43typedef unsigned int uint32;
44
45static unsigned char port_state = 0x00;
46static volatile uint32 *gpioaddr_input = (uint32 *)0xb8000060;
47static volatile uint32 *gpioaddr_output = (uint32 *)0xb8000064;
48static volatile uint32 *gpioaddr_enable = (uint32 *)0xb8000068;
49static volatile uint32 *gpioaddr_control = (uint32 *)0xb800006c;
50
51static void mmc_spi_cs_low(void)
52{
53 port_state &= ~(SD_CS);
54 *gpioaddr_output = port_state;
55}
56
57static void mmc_spi_cs_high(void)
58{
59 port_state |= SD_CS;
60 *gpioaddr_output = port_state;
61}
62
63static unsigned char mmc_spi_io(unsigned char data_out)
64{
65 int i;
66 unsigned char result = 0, tmp_data = 0;
67
68 for(i=0; i<8; i++) {
69 if(data_out & (0x01 << (7-i)))
70 port_state |= SD_DI;
71 else
72 port_state &= ~SD_DI;
73
74 *gpioaddr_output = port_state;
75 port_state |= SD_CLK;
76 *gpioaddr_output = port_state;
77
78 tmp_data = *gpioaddr_input;
79
80 port_state &= ~SD_CLK;
81 *gpioaddr_output = port_state;
82
83 result <<= 1;
84
85 if(tmp_data & SD_DO)
86 result |= 1;
87 }
88
89 return(result);
90}
91
92static int mmc_write_block(unsigned int dest_addr, unsigned char *data)
93{
94 unsigned int address;
95 unsigned char r = 0;
96 unsigned char ab0, ab1, ab2, ab3;
97 int i;
98
99 address = dest_addr;
100
101 ab3 = 0xff & (address >> 24);
102 ab2 = 0xff & (address >> 16);
103 ab1 = 0xff & (address >> 8);
104 ab0 = 0xff & address;
105 mmc_spi_cs_low();
106 for (i = 0; i < 4; i++) mmc_spi_io(0xff);
107 mmc_spi_io(0x58);
108 mmc_spi_io(ab3); /* msb */
109 mmc_spi_io(ab2);
110 mmc_spi_io(ab1);
111 mmc_spi_io(ab0); /* lsb */
112 mmc_spi_io(0xff);
113 for (i = 0; i < 8; i++)
114 {
115 r = mmc_spi_io(0xff);
116 if (r == 0x00) break;
117 }
118 if (r != 0x00)
119 {
120 mmc_spi_cs_high();
121 mmc_spi_io(0xff);
122 return(1);
123 }
124
125 mmc_spi_io(0xfe);
126 for (i = 0; i < 512; i++) mmc_spi_io(data[i]);
127 for (i = 0; i < 2; i++) mmc_spi_io(0xff);
128
129 for (i = 0; i < 1000000; i++)
130 {
131 r = mmc_spi_io(0xff);
132 if (r == 0xff) break;
133 }
134 if (r != 0xff)
135 {
136 mmc_spi_cs_high();
137 mmc_spi_io(0xff);
138 return(3);
139 }
140 mmc_spi_cs_high();
141 mmc_spi_io(0xff);
142 return(0);
143}
144
145static int mmc_read_block(unsigned char *data, unsigned int src_addr)
146{
147 unsigned int address;
148 unsigned char r = 0;
149 unsigned char ab0, ab1, ab2, ab3;
150 int i;
151
152 address = src_addr;
153
154 ab3 = 0xff & (address >> 24);
155 ab2 = 0xff & (address >> 16);
156 ab1 = 0xff & (address >> 8);
157 ab0 = 0xff & address;
158
159 mmc_spi_cs_low();
160 for (i = 0; i < 4; i++) mmc_spi_io(0xff);
161 mmc_spi_io(0x51);
162 mmc_spi_io(ab3); /* msb */
163 mmc_spi_io(ab2);
164 mmc_spi_io(ab1);
165 mmc_spi_io(ab0); /* lsb */
166
167 mmc_spi_io(0xff);
168 for (i = 0; i < 8; i++)
169 {
170 r = mmc_spi_io(0xff);
171 if (r == 0x00) break;
172 }
173 if (r != 0x00)
174 {
175 mmc_spi_cs_high();
176 mmc_spi_io(0xff);
177 return(1);
178 }
179 for (i = 0; i < 100000; i++)
180 {
181 r = mmc_spi_io(0xff);
182 if (r == 0xfe) break;
183 }
184 if (r != 0xfe)
185 {
186 mmc_spi_cs_high();
187 mmc_spi_io(0xff);
188 return(2);
189 }
190 for (i = 0; i < 512; i++)
191 {
192 r = mmc_spi_io(0xff);
193 data[i] = r;
194 }
195 for (i = 0; i < 2; i++)
196 {
197 r = mmc_spi_io(0xff);
198 }
199 mmc_spi_cs_high();
200 mmc_spi_io(0xff);
201
202 return(0);
203}
204
205static void mmc_request(request_queue_t *q)
206{
207 unsigned int mmc_address;
208 unsigned char *buffer_address;
209 int nr_sectors;
210 int i;
211 int cmd;
212 int rc, code;
213
214 (void)q;
215 while (1)
216 {
217 code = 1; // Default is success
218 INIT_REQUEST;
219 mmc_address = (CURRENT->sector + hd[MINOR(CURRENT->rq_dev)].start_sect) * hd_hardsectsizes[0];
220 buffer_address = CURRENT->buffer;
221 nr_sectors = CURRENT->current_nr_sectors;
222 cmd = CURRENT->cmd;
223 if (((CURRENT->sector + CURRENT->current_nr_sectors + hd[MINOR(CURRENT->rq_dev)].start_sect) > hd[0].nr_sects) || (mmc_media_detect == 0))
224 {
225 code = 0;
226 }
227 else if (cmd == READ)
228 {
229 spin_unlock_irq(&io_request_lock);
230 for (i = 0; i < nr_sectors; i++)
231 {
232 rc = mmc_read_block(buffer_address, mmc_address);
233 if (rc != 0)
234 {
235 printk("mmc: error in mmc_read_block (%d)\n", rc);
236 code = 0;
237 break;
238 }
239 else
240 {
241 mmc_address += hd_hardsectsizes[0];
242 buffer_address += hd_hardsectsizes[0];
243 }
244 }
245 spin_lock_irq(&io_request_lock);
246 }
247 else if (cmd == WRITE)
248 {
249 spin_unlock_irq(&io_request_lock);
250 for (i = 0; i < nr_sectors; i++)
251 {
252 rc = mmc_write_block(mmc_address, buffer_address);
253 if (rc != 0)
254 {
255 printk("mmc: error in mmc_write_block (%d)\n", rc);
256 code = 0;
257 break;
258 }
259 else
260 {
261 mmc_address += hd_hardsectsizes[0];
262 buffer_address += hd_hardsectsizes[0];
263 }
264 }
265 spin_lock_irq(&io_request_lock);
266 }
267 else
268 {
269 code = 0;
270 }
271 end_request(code);
272 }
273}
274
275
276static int mmc_open(struct inode *inode, struct file *filp)
277{
278 int device;
279 (void)filp;
280
281 if (mmc_media_detect == 0) return -ENODEV;
282
283#if defined(MODULE)
284 MOD_INC_USE_COUNT;
285#endif
286 return 0;
287}
288
289static int mmc_release(struct inode *inode, struct file *filp)
290{
291 (void)filp;
292 fsync_dev(inode->i_rdev);
293 invalidate_buffers(inode->i_rdev);
294
295#if defined(MODULE)
296 MOD_DEC_USE_COUNT;
297#endif
298 return 0;
299}
300
301extern struct gendisk hd_gendisk;
302static int mmc_revalidate(kdev_t dev)
303{
304 int target, max_p, start, i;
305 if (mmc_media_detect == 0) return -ENODEV;
306
307 target = DEVICE_NR(dev);
308
309 max_p = hd_gendisk.max_p;
310 start = target << 6;
311 for (i = max_p - 1; i >= 0; i--) {
312 int minor = start + i;
313 invalidate_device(MKDEV(MAJOR_NR, minor), 1);
314 hd_gendisk.part[minor].start_sect = 0;
315 hd_gendisk.part[minor].nr_sects = 0;
316 }
317
318 grok_partitions(&hd_gendisk, target, 1 << 6,
319 hd_sizes[0] * 2);
320
321 return 0;
322}
323
324static int mmc_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
325{
326 if (!inode || !inode->i_rdev)
327 return -EINVAL;
328
329 switch(cmd) {
330 case BLKGETSIZE:
331 return put_user(hd[MINOR(inode->i_rdev)].nr_sects, (unsigned long *)arg);
332 case BLKGETSIZE64:
333 return put_user((u64)hd[MINOR(inode->i_rdev)].
334 nr_sects, (u64 *) arg);
335 case BLKRRPART:
336 if (!capable(CAP_SYS_ADMIN))
337 return -EACCES;
338
339 return mmc_revalidate(inode->i_rdev);
340 case HDIO_GETGEO:
341 {
342 struct hd_geometry *loc, g;
343 loc = (struct hd_geometry *) arg;
344 if (!loc)
345 return -EINVAL;
346 g.heads = 4;
347 g.sectors = 16;
348 g.cylinders = hd[0].nr_sects / (4 * 16);
349 g.start = hd[MINOR(inode->i_rdev)].start_sect;
350 return copy_to_user(loc, &g, sizeof(g)) ? -EFAULT : 0;
351 }
352 default:
353 return blk_ioctl(inode->i_rdev, cmd, arg);
354 }
355}
356
357static int mmc_card_init(void)
358{
359 unsigned char r = 0;
360 short i, j;
361 unsigned long flags;
362
363 save_flags(flags);
364 cli();
365
366 printk("mmc Card init\n");
367 mmc_spi_cs_high();
368 for (i = 0; i < 20; i++) mmc_spi_io(0xff);
369
370 mmc_spi_cs_low();
371
372 mmc_spi_io(0x40);
373 for (i = 0; i < 4; i++) mmc_spi_io(0x00);
374 mmc_spi_io(0x95);
375 for (i = 0; i < 8; i++)
376 {
377 r = mmc_spi_io(0xff);
378 if (r == 0x01) break;
379 }
380 mmc_spi_cs_high();
381 mmc_spi_io(0xff);
382 if (r != 0x01)
383 {
384 restore_flags(flags);
385 return(1);
386 }
387
388 printk("mmc Card init *1*\n");
389 for (j = 0; j < 10000; j++)
390 {
391 mmc_spi_cs_low();
392
393 mmc_spi_io(0x41);
394 for (i = 0; i < 4; i++) mmc_spi_io(0x00);
395 mmc_spi_io(0xff);
396 for (i = 0; i < 8; i++)
397 {
398 r = mmc_spi_io(0xff);
399 if (r == 0x00) break;
400 }
401 mmc_spi_cs_high();
402 mmc_spi_io(0xff);
403 if (r == 0x00)
404 {
405 restore_flags(flags);
406 printk("mmc Card init *2*\n");
407 return(0);
408 }
409 }
410 restore_flags(flags);
411
412 return(2);
413}
414
415static int mmc_card_config(void)
416{
417 unsigned char r = 0;
418 short i;
419 unsigned char csd[32];
420 unsigned int c_size;
421 unsigned int c_size_mult;
422 unsigned int mult;
423 unsigned int read_bl_len;
424 unsigned int blocknr = 0;
425 unsigned int block_len = 0;
426 unsigned int size = 0;
427
428 mmc_spi_cs_low();
429 for (i = 0; i < 4; i++) mmc_spi_io(0xff);
430 mmc_spi_io(0x49);
431 for (i = 0; i < 4; i++) mmc_spi_io(0x00);
432 mmc_spi_io(0xff);
433 for (i = 0; i < 8; i++)
434 {
435 r = mmc_spi_io(0xff);
436 if (r == 0x00) break;
437 }
438 if (r != 0x00)
439 {
440 mmc_spi_cs_high();
441 mmc_spi_io(0xff);
442 return(1);
443 }
444 for (i = 0; i < 8; i++)
445 {
446 r = mmc_spi_io(0xff);
447 if (r == 0xfe) break;
448 }
449 if (r != 0xfe)
450 {
451 mmc_spi_cs_high();
452 mmc_spi_io(0xff);
453 return(2);
454 }
455 for (i = 0; i < 16; i++)
456 {
457 r = mmc_spi_io(0xff);
458 csd[i] = r;
459 }
460 for (i = 0; i < 2; i++)
461 {
462 r = mmc_spi_io(0xff);
463 }
464 mmc_spi_cs_high();
465 mmc_spi_io(0xff);
466 if (r == 0x00) return(3);
467
468 c_size = csd[8] + csd[7] * 256 + (csd[6] & 0x03) * 256 * 256;
469 c_size >>= 6;
470 c_size_mult = csd[10] + (csd[9] & 0x03) * 256;
471 c_size_mult >>= 7;
472 read_bl_len = csd[5] & 0x0f;
473 mult = 1;
474 mult <<= c_size_mult + 2;
475 blocknr = (c_size + 1) * mult;
476 block_len = 1;
477 block_len <<= read_bl_len;
478 size = block_len * blocknr;
479 size >>= 10;
480
481 for(i=0; i<(1<<6); i++) {
482 hd_blocksizes[i] = 1024;
483 hd_hardsectsizes[i] = block_len;
484 hd_maxsect[i] = 256;
485 }
486 hd_sizes[0] = size;
487 hd[0].nr_sects = blocknr;
488
489
490 printk("Size = %d, hardsectsize = %d, sectors = %d\n",
491 size, block_len, blocknr);
492
493 return 0;
494}
495
496static int mmc_hardware_init(void)
497{
498 unsigned char gpio_outen;
499
500 // Set inputs/outputs here
501 printk("mmc Hardware init\n");
502 gpio_outen = *gpioaddr_enable;
503
504 gpio_outen = (gpio_outen | SD_DI | SD_CLK | SD_CS) & ~SD_DO;
505 *gpioaddr_enable = gpio_outen;
506
507 port_state = *gpioaddr_input;
508
509 // Clock low
510 port_state &= ~(SD_CLK | SD_DI | SD_CS);
511 *gpioaddr_output = port_state;
512
513 return 0;
514}
515
516static int mmc_check_media_change(kdev_t dev)
517{
518 (void)dev;
519 if (mmc_media_changed == 1)
520 {
521 mmc_media_changed = 0;
522 return 1;
523 }
524 else return 0;
525}
526
527static struct block_device_operations mmc_bdops =
528{
529 open: mmc_open,
530 release: mmc_release,
531 ioctl: mmc_ioctl,
532#if 0
533 check_media_change: mmc_check_media_change,
534 revalidate: mmc_revalidate,
535#endif
536};
537
538static struct gendisk hd_gendisk = {
539 major: MAJOR_NR,
540 major_name: DEVICE_NAME,
541 minor_shift: 6,
542 max_p: 1 << 6,
543 part: hd,
544 sizes: hd_sizes,
545 fops: &mmc_bdops,
546};
547
548static int mmc_init(void)
549{
550 int rc;
551
552 rc = mmc_hardware_init();
553
554 if ( rc != 0)
555 {
556 printk("mmc: error in mmc_hardware_init (%d)\n", rc);
557 return -1;
558 }
559
560 rc = mmc_card_init();
561 if ( rc != 0)
562 {
563 // Give it an extra shot
564 rc = mmc_card_init();
565 if ( rc != 0)
566 {
567 printk("mmc: error in mmc_card_init (%d)\n", rc);
568 return -1;
569 }
570 }
571
572 memset(hd_sizes, 0, sizeof(hd_sizes));
573 rc = mmc_card_config();
574 if ( rc != 0)
575 {
576 printk("mmc: error in mmc_card_config (%d)\n", rc);
577 return -1;
578 }
579
580
581 blk_size[MAJOR_NR] = hd_sizes;
582
583 memset(hd, 0, sizeof(hd));
584 hd[0].nr_sects = hd_sizes[0]*2;
585
586 blksize_size[MAJOR_NR] = hd_blocksizes;
587 hardsect_size[MAJOR_NR] = hd_hardsectsizes;
588 max_sectors[MAJOR_NR] = hd_maxsect;
589
590 hd_gendisk.nr_real = 1;
591
592 register_disk(&hd_gendisk, MKDEV(MAJOR_NR,0), 1<<6,
593 &mmc_bdops, hd_sizes[0]*2);
594
595 return 0;
596}
597
598static void mmc_exit(void)
599{
600 blk_size[MAJOR_NR] = NULL;
601 blksize_size[MAJOR_NR] = NULL;
602 hardsect_size[MAJOR_NR] = NULL;
603 max_sectors[MAJOR_NR] = NULL;
604 hd[0].nr_sects = 0;
605}
606
607static void mmc_check_media(void)
608{
609 int old_state;
610 int rc;
611
612 old_state = mmc_media_detect;
613
614 // TODO: Add card detection here
615 mmc_media_detect = 1;
616 if (old_state != mmc_media_detect)
617 {
618 mmc_media_changed = 1;
619 if (mmc_media_detect == 1)
620 {
621 rc = mmc_init();
622 if (rc != 0) printk("mmc: error in mmc_init (%d)\n", rc);
623 }
624 else
625 {
626 mmc_exit();
627 }
628 }
629
630 /* del_timer(&mmc_timer);
631 mmc_timer.expires = jiffies + 10*HZ;
632 add_timer(&mmc_timer); */
633}
634
635static int __init mmc_driver_init(void)
636{
637 int rc;
638
639 rc = devfs_register_blkdev(MAJOR_NR, DEVICE_NAME, &mmc_bdops);
640 if (rc < 0)
641 {
642 printk(KERN_WARNING "mmc: can't get major %d\n", MAJOR_NR);
643 return rc;
644 }
645
646 blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), mmc_request);
647
648 read_ahead[MAJOR_NR] = 8;
649 add_gendisk(&hd_gendisk);
650
651 mmc_check_media();
652
653 /*init_timer(&mmc_timer);
654 mmc_timer.expires = jiffies + HZ;
655 mmc_timer.function = (void *)mmc_check_media;
656 add_timer(&mmc_timer);*/
657
658 return 0;
659}
660
661static void __exit mmc_driver_exit(void)
662{
663 int i;
664 del_timer(&mmc_timer);
665
666 for (i = 0; i < (1 << 6); i++)
667 fsync_dev(MKDEV(MAJOR_NR, i));
668
669 blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
670 del_gendisk(&hd_gendisk);
671 devfs_unregister_blkdev(MAJOR_NR, DEVICE_NAME);
672 mmc_exit();
673}
674
675module_init(mmc_driver_init);
676module_exit(mmc_driver_exit);
Note: See TracBrowser for help on using the repository browser.