v2.5.0.7 -> v2.5.0.8
[opensuse:kernel.git] / drivers / sbus / char / jsflash.c
1 /*
2  * drivers/sbus/char/jsflash.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds    (drivers/char/mem.c)
5  *  Copyright (C) 1997  Eddie C. Dost           (drivers/sbus/char/flash.c)
6  *  Copyright (C) 1997-2000 Pavel Machek <pavel@ucw.cz>   (drivers/block/nbd.c)
7  *  Copyright (C) 1999-2000 Pete Zaitcev
8  *
9  * This driver is used to program OS into a Flash SIMM on
10  * Krups and Espresso platforms.
11  *
12  * TODO: do not allow erase/programming if file systems are mounted.
13  * TODO: Erase/program both banks of a 8MB SIMM.
14  *
15  * It is anticipated that programming an OS Flash will be a routine
16  * procedure. In the same time it is exeedingly dangerous because
17  * a user can program its OBP flash with OS image and effectively
18  * kill the machine.
19  *
20  * This driver uses an interface different from Eddie's flash.c
21  * as a silly safeguard.
22  *
23  * XXX The flash.c manipulates page caching characteristics in a certain
24  * dubious way; also it assumes that remap_page_range() can remap
25  * PCI bus locations, which may be false. ioremap() must be used
26  * instead. We should discuss this.
27  */
28
29 #include <linux/module.h>
30 #include <linux/types.h>
31 #include <linux/errno.h>
32 #include <linux/miscdevice.h>
33 #include <linux/slab.h>
34 #include <linux/fcntl.h>
35 #include <linux/poll.h>
36 #include <linux/init.h>
37 #include <linux/string.h>
38 #include <linux/smp_lock.h>
39
40 /*
41  * <linux/blk.h> is controlled from the outside with these definitions.
42  */
43 #define MAJOR_NR        JSFD_MAJOR
44
45 #define DEVICE_NAME "jsfd"
46 #define DEVICE_REQUEST jsfd_do_request
47 #define DEVICE_NR(device) (MINOR(device))
48 #define DEVICE_ON(device)
49 #define DEVICE_OFF(device)
50 #define DEVICE_NO_RANDOM
51
52 #include <linux/blk.h>
53
54
55 #include <asm/uaccess.h>
56 #include <asm/pgtable.h>
57 #include <asm/io.h>
58 #include <asm/pcic.h>
59 #include <asm/oplib.h>
60
61 #include <asm/jsflash.h>                /* ioctl arguments. <linux/> ?? */
62 #define JSFIDSZ         (sizeof(struct jsflash_ident_arg))
63 #define JSFPRGSZ        (sizeof(struct jsflash_program_arg))
64
65 /*
66  * Our device numbers have no business in system headers.
67  * The only thing a user knows is the device name /dev/jsflash.
68  *
69  * Block devices are laid out like this:
70  *   minor+0    - Bootstrap, for 8MB SIMM 0x20400000[0x800000]
71  *   minor+1    - Filesystem to mount, normally 0x20400400[0x7ffc00]
72  *   minor+2    - Whole flash area for any case... 0x20000000[0x01000000]
73  * Total 3 minors per flash device.
74  *
75  * It is easier to have static size vectors, so we define
76  * a total minor range JSF_MAX, which must cover all minors.
77  */
78 /* character device */
79 #define JSF_MINOR       178     /* 178 is registered with hpa */
80 /* block device */
81 #define JSF_MAX          3      /* 3 minors wasted total so far. */
82 #define JSF_NPART        3      /* 3 minors per flash device */
83 #define JSF_PART_BITS    2      /* 2 bits of minors to cover JSF_NPART */
84 #define JSF_PART_MASK    0x3    /* 2 bits mask */
85
86 /*
87  * Access functions.
88  * We could ioremap(), but it's easier this way.
89  */
90 static unsigned int jsf_inl(unsigned long addr)
91 {
92         unsigned long retval;
93
94         __asm__ __volatile__("lda [%1] %2, %0\n\t" :
95                                 "=r" (retval) :
96                                 "r" (addr), "i" (ASI_M_BYPASS));
97         return retval;
98 }
99
100 static void jsf_outl(unsigned long addr, __u32 data)
101 {
102
103         __asm__ __volatile__("sta %0, [%1] %2\n\t" : :
104                                 "r" (data), "r" (addr), "i" (ASI_M_BYPASS) :
105                                 "memory");
106 }
107
108 /*
109  * soft carrier
110  */
111
112 struct jsfd_part {
113         unsigned long dbase;
114         unsigned long dsize;
115         int refcnt;
116 };
117
118 struct jsflash {
119         unsigned long base;
120         unsigned long size;
121         unsigned long busy;             /* In use? */
122         struct jsflash_ident_arg id;
123         /* int mbase; */                /* Minor base, typically zero */
124         struct jsfd_part dv[JSF_NPART];
125 };
126
127 /*
128  * We do not map normal memory or obio as a safety precaution.
129  * But offsets are real, for ease of userland programming.
130  */
131 #define JSF_BASE_TOP    0x30000000
132 #define JSF_BASE_ALL    0x20000000
133
134 #define JSF_BASE_JK     0x20400000
135
136 /*
137  */
138 static int jsfd_blksizes[JSF_MAX];
139 static int jsfd_sizes[JSF_MAX];
140 static u64 jsfd_bytesizes[JSF_MAX];
141
142 /*
143  * Let's pretend we may have several of these...
144  */
145 static struct jsflash jsf0;
146
147 /*
148  * Wait for AMD to finish its embedded algorithm.
149  * We use the Toggle bit DQ6 (0x40) because it does not
150  * depend on the data value as /DATA bit DQ7 does.
151  *
152  * XXX Do we need any timeout here? So far it never hanged, beware broken hw.
153  */
154 static void jsf_wait(unsigned long p) {
155         unsigned int x1, x2;
156
157         for (;;) {
158                 x1 = jsf_inl(p);
159                 x2 = jsf_inl(p);
160                 if ((x1 & 0x40404040) == (x2 & 0x40404040)) return;
161         }
162 }
163
164 /*
165  * Programming will only work if Flash is clean,
166  * we leave it to the programmer application.
167  *
168  * AMD must be programmed one byte at a time;
169  * thus, Simple Tech SIMM must be written 4 bytes at a time.
170  *
171  * Write waits for the chip to become ready after the write
172  * was finished. This is done so that application would read
173  * consistent data after the write is done.
174  */
175 static void jsf_write4(unsigned long fa, u32 data) {
176
177         jsf_outl(fa, 0xAAAAAAAA);               /* Unlock 1 Write 1 */
178         jsf_outl(fa, 0x55555555);               /* Unlock 1 Write 2 */
179         jsf_outl(fa, 0xA0A0A0A0);               /* Byte Program */
180         jsf_outl(fa, data);
181
182         jsf_wait(fa);
183 }
184
185 /*
186  */
187 static void jsfd_read(char *buf, unsigned long p, size_t togo) {
188         union byte4 {
189                 char s[4];
190                 unsigned int n;
191         } b;
192
193         while (togo >= 4) {
194                 togo -= 4;
195                 b.n = jsf_inl(p);
196                 memcpy(buf, b.s, 4);
197                 p += 4;
198                 buf += 4;
199         }
200 }
201
202 static void jsfd_do_request(request_queue_t *q)
203 {
204         struct request *req;
205         int dev;
206         struct jsfd_part *jdp;
207         unsigned long offset;
208         size_t len;
209
210         for (;;) {
211                 INIT_REQUEST;   /* if (QUEUE_EMPTY) return; */
212                 req = CURRENT;
213
214                 dev = MINOR(req->rq_dev);
215                 if (dev >= JSF_MAX || (dev & JSF_PART_MASK) >= JSF_NPART) {
216                         end_request(0);
217                         continue;
218                 }
219                 jdp = &jsf0.dv[dev & JSF_PART_MASK];
220
221                 offset = req->sector << 9;
222                 len = req->current_nr_sectors << 9;
223                 if ((offset + len) > jdp->dsize) {
224                         end_request(0);
225                         continue;
226                 }
227
228                 if (req->cmd == WRITE) {
229                         printk(KERN_ERR "jsfd: write\n");
230                         end_request(0);
231                         continue;
232                 }
233                 if (req->cmd != READ) {
234                         printk(KERN_ERR "jsfd: bad req->cmd %d\n", req->cmd);
235                         end_request(0);
236                         continue;
237                 }
238
239                 if ((jdp->dbase & 0xff000000) != 0x20000000) {
240                         printk(KERN_ERR "jsfd: bad base %x\n", (int)jdp->dbase);
241                         end_request(0);
242                         continue;
243                 }
244
245 /* printk("jsfd%d: read buf %p off %x len %x\n", dev, req->buffer, (int)offset, (int)len); */ /* P3 */
246                 jsfd_read(req->buffer, jdp->dbase + offset, len);
247
248                 end_request(1);
249         }
250 }
251
252 /*
253  * The memory devices use the full 32/64 bits of the offset, and so we cannot
254  * check against negative addresses: they are ok. The return value is weird,
255  * though, in that case (0).
256  *
257  * also note that seeking relative to the "end of file" isn't supported:
258  * it has no meaning, so it returns -EINVAL.
259  */
260 static loff_t jsf_lseek(struct file * file, loff_t offset, int orig)
261 {
262         switch (orig) {
263                 case 0:
264                         file->f_pos = offset;
265                         return file->f_pos;
266                 case 1:
267                         file->f_pos += offset;
268                         return file->f_pos;
269                 default:
270                         return -EINVAL;
271         }
272 }
273
274 /*
275  * OS SIMM Cannot be read in other size but a 32bits word.
276  */
277 static ssize_t jsf_read(struct file * file, char * buf, 
278     size_t togo, loff_t *ppos)
279 {
280         unsigned long p = *ppos;
281         char *tmp = buf;
282
283         union byte4 {
284                 char s[4];
285                 unsigned int n;
286         } b;
287
288         if (verify_area(VERIFY_WRITE, buf, togo))
289                 return -EFAULT; 
290
291         if (p < JSF_BASE_ALL || p >= JSF_BASE_TOP) {
292                 return 0;
293         }
294
295         if ((p + togo) < p      /* wrap */
296            || (p + togo) >= JSF_BASE_TOP) {
297                 togo = JSF_BASE_TOP - p;
298         }
299
300         if (p < JSF_BASE_ALL && togo != 0) {
301 #if 0 /* __bzero XXX */
302                 size_t x = JSF_BASE_ALL - p;
303                 if (x > togo) x = togo;
304                 clear_user(tmp, x);
305                 tmp += x;
306                 p += x;
307                 togo -= x;
308 #else
309                 /*
310                  * Implementation of clear_user() calls __bzero
311                  * without regard to modversions,
312                  * so we cannot build a module.
313                  */
314                 return 0;
315 #endif
316         }
317
318         while (togo >= 4) {
319                 togo -= 4;
320                 b.n = jsf_inl(p);
321                 copy_to_user(tmp, b.s, 4);
322                 tmp += 4;
323                 p += 4;
324         }
325
326         /*
327          * XXX Small togo may remain if 1 byte is ordered.
328          * It would be nice if we did a word size read and unpacked it.
329          */
330
331         *ppos = p;
332         return tmp-buf;
333 }
334
335 static ssize_t jsf_write(struct file * file, const char * buf,
336     size_t count, loff_t *ppos)
337 {
338         return -ENOSPC;
339 }
340
341 /*
342  */
343 static int jsf_ioctl_erase(unsigned long arg)
344 {
345         unsigned long p;
346
347         /* p = jsf0.base;       hits wrong bank */
348         p = 0x20400000;
349
350         jsf_outl(p, 0xAAAAAAAA);                /* Unlock 1 Write 1 */
351         jsf_outl(p, 0x55555555);                /* Unlock 1 Write 2 */
352         jsf_outl(p, 0x80808080);                /* Erase setup */
353         jsf_outl(p, 0xAAAAAAAA);                /* Unlock 2 Write 1 */
354         jsf_outl(p, 0x55555555);                /* Unlock 2 Write 2 */
355         jsf_outl(p, 0x10101010);                /* Chip erase */
356
357 #if 0
358         /*
359          * This code is ok, except that counter based timeout
360          * has no place in this world. Let's just drop timeouts...
361          */
362         {
363                 int i;
364                 __u32 x;
365                 for (i = 0; i < 1000000; i++) {
366                         x = jsf_inl(p);
367                         if ((x & 0x80808080) == 0x80808080) break;
368                 }
369                 if ((x & 0x80808080) != 0x80808080) {
370                         printk("jsf0: erase timeout with 0x%08x\n", x);
371                 } else {
372                         printk("jsf0: erase done with 0x%08x\n", x);
373                 }
374         }
375 #else
376         jsf_wait(p);
377 #endif
378
379         return 0;
380 }
381
382 /*
383  * Program a block of flash.
384  * Very simple because we can do it byte by byte anyway.
385  */
386 static int jsf_ioctl_program(unsigned long arg)
387 {
388         struct jsflash_program_arg abuf;
389         char *uptr;
390         unsigned long p;
391         unsigned int togo;
392         union {
393                 unsigned int n;
394                 char s[4];
395         } b;
396
397         if (verify_area(VERIFY_READ, (void *)arg, JSFPRGSZ))
398                 return -EFAULT; 
399         copy_from_user(&abuf, (char *)arg, JSFPRGSZ);
400         p = abuf.off;
401         togo = abuf.size;
402         if ((togo & 3) || (p & 3)) return -EINVAL;
403
404         uptr = (char *) (unsigned long) abuf.data;
405         if (verify_area(VERIFY_READ, uptr, togo))
406                 return -EFAULT;
407         while (togo != 0) {
408                 togo -= 4;
409                 copy_from_user(&b.s[0], uptr, 4);
410                 jsf_write4(p, b.n);
411                 p += 4;
412                 uptr += 4;
413         }
414
415         return 0;
416 }
417
418 static int jsf_ioctl(struct inode *inode, struct file *f, unsigned int cmd,
419     unsigned long arg)
420 {
421         int error = -ENOTTY;
422
423         if (!capable(CAP_SYS_ADMIN))
424                 return -EPERM;
425         switch (cmd) {
426         case JSFLASH_IDENT:
427                 if (verify_area(VERIFY_WRITE, (void *)arg, JSFIDSZ))
428                         return -EFAULT; 
429                 copy_to_user(arg, &jsf0.id, JSFIDSZ);
430                 error = 0;
431                 break;
432         case JSFLASH_ERASE:
433                 error = jsf_ioctl_erase(arg);
434                 break;
435         case JSFLASH_PROGRAM:
436                 error = jsf_ioctl_program(arg);
437                 break;
438         }
439
440         return error;
441 }
442
443 static int jsfd_ioctl(struct inode *inode, struct file *file,
444     unsigned int cmd, unsigned long arg)
445 {
446         int dev;
447
448         if (!capable(CAP_SYS_ADMIN))
449                 return -EPERM;
450         if (!inode)
451                 return -EINVAL;
452         if ((dev = MINOR(inode->i_rdev)) >= JSF_MAX) return -ENODEV;
453
454         switch (cmd) {
455         case BLKGETSIZE:
456                 return put_user(jsfd_bytesizes[dev] >> 9, (unsigned long *) arg);
457         case BLKGETSIZE64:
458                 return put_user(jsfd_bytesizes[dev], (u64 *) arg);
459
460 #if 0
461         case BLKROSET:
462         case BLKROGET:
463         case BLKSSZGET:
464                 return blk_ioctl(inode->i_rdev, cmd, arg);
465 #endif
466
467         /* case BLKFLSBUF: */   /* Program, then read, what happens? Stale? */
468         default: ;
469         }
470         return -ENOTTY;
471 }
472
473 static int jsf_mmap(struct file * file, struct vm_area_struct * vma)
474 {
475         return -ENXIO;
476 }
477
478 static int jsf_open(struct inode * inode, struct file * filp)
479 {
480
481         if (jsf0.base == 0) return -ENXIO;
482         if (test_and_set_bit(0, (void *)&jsf0.busy) != 0)
483                 return -EBUSY;
484
485         return 0;       /* XXX What security? */
486 }
487
488 static int jsfd_open(struct inode *inode, struct file *file)
489 {
490         struct jsfd_part *jdp;
491         int dev;
492
493         if (!inode)
494                 return -EINVAL;
495         dev = MINOR(inode->i_rdev);
496         if (dev >= JSF_MAX || (dev & JSF_PART_MASK) >= JSF_NPART) {
497                 printk(KERN_ALERT "jsfd_open: illegal minor %d\n", dev);
498                 return -ENODEV;
499         }
500
501         jdp = &jsf0.dv[dev];
502         jdp->refcnt++;
503
504         return 0;
505 }
506
507 static int jsf_release(struct inode *inode, struct file *file)
508 {
509         jsf0.busy = 0;
510         return 0;
511 }
512
513 static int jsfd_release(struct inode *inode, struct file *file)
514 {
515         struct jsfd_part *jdp;
516         int dev;
517
518         if (!inode)
519                 return -ENODEV;
520         dev = MINOR(inode->i_rdev);
521         if (dev >= JSF_MAX || (dev & JSF_PART_MASK) >= JSF_NPART) {
522                 printk(KERN_ALERT "jsfd_release: illegal minor %d\n", dev);
523                 return -ENODEV;
524         }
525
526         jdp = &jsf0.dv[dev];
527         if (jdp->refcnt <= 0) {
528                 printk(KERN_ALERT "jsfd_release: bad ref on minor %d\n", dev);
529         } else {
530                 --jdp->refcnt;
531         }
532         /* N.B. Doesn't lo->file need an fput?? */
533         return 0;
534 }
535
536 static struct file_operations jsf_fops = {
537         owner:          THIS_MODULE,
538         llseek:         jsf_lseek,
539         read:           jsf_read,
540         write:          jsf_write,
541         ioctl:          jsf_ioctl,
542         mmap:           jsf_mmap,
543         open:           jsf_open,
544         release:        jsf_release,
545 };
546
547 static struct miscdevice jsf_dev = { JSF_MINOR, "jsflash", &jsf_fops };
548
549 static struct block_device_operations jsfd_fops = {
550         owner:          THIS_MODULE,
551         open:           jsfd_open,
552         release:        jsfd_release,
553         ioctl:          jsfd_ioctl,
554 };
555
556 EXPORT_NO_SYMBOLS;
557
558 int jsflash_init(void)
559 {
560         int rc;
561         struct jsflash *jsf;
562         int node;
563         char banner[128];
564         struct linux_prom_registers reg0;
565
566         node = prom_getchild(prom_root_node);
567         node = prom_searchsiblings(node, "flash-memory");
568         if (node != 0 && node != -1) {
569                 if (prom_getproperty(node, "reg",
570                     (char *)&reg0, sizeof(reg0)) == -1) {
571                         printk("jsflash: no \"reg\" property\n");
572                         return -ENXIO;
573                 }
574                 if (reg0.which_io != 0) {
575                         printk("jsflash: bus number nonzero: 0x%x:%x\n",
576                             reg0.which_io, reg0.phys_addr);
577                         return -ENXIO;
578                 }
579                 /*
580                  * Flash may be somewhere else, for instance on Ebus.
581                  * So, don't do the following check for IIep flash space.
582                  */
583 #if 0
584                 if ((reg0.phys_addr >> 24) != 0x20) {
585                         printk("jsflash: suspicious address: 0x%x:%x\n",
586                             reg0.which_io, reg0.phys_addr);
587                         return -ENXIO;
588                 }
589 #endif
590                 if ((int)reg0.reg_size <= 0) {
591                         printk("jsflash: bad size 0x%x\n", (int)reg0.reg_size);
592                         return -ENXIO;
593                 }
594         } else {
595                 /* XXX Remove this code once PROLL ID12 got widespread */
596                 printk("jsflash: no /flash-memory node, use PROLL >= 12\n");
597                 prom_getproperty(prom_root_node, "banner-name", banner, 128);
598                 if (strcmp (banner, "JavaStation-NC") != 0 &&
599                     strcmp (banner, "JavaStation-E") != 0) {
600                         return -ENXIO;
601                 }
602                 reg0.which_io = 0;
603                 reg0.phys_addr = 0x20400000;
604                 reg0.reg_size  = 0x00800000;
605         }
606
607         /* Let us be really paranoid for modifications to probing code. */
608         /* extern enum sparc_cpu sparc_cpu_model; */ /* in <asm/system.h> */
609         if (sparc_cpu_model != sun4m) {
610                 /* We must be on sun4m because we use MMU Bypass ASI. */
611                 return -ENXIO;
612         }
613
614         if (jsf0.base == 0) {
615                 jsf = &jsf0;
616
617                 jsf->base = reg0.phys_addr;
618                 jsf->size = reg0.reg_size;
619
620                 /* XXX Redo the userland interface. */
621                 jsf->id.off = JSF_BASE_ALL;
622                 jsf->id.size = 0x01000000;      /* 16M - all segments */
623                 strcpy(jsf->id.name, "Krups_all");
624
625                 jsf->dv[0].dbase = jsf->base;
626                 jsf->dv[0].dsize = jsf->size;
627                 jsf->dv[1].dbase = jsf->base + 1024;
628                 jsf->dv[1].dsize = jsf->size - 1024;
629                 jsf->dv[2].dbase = JSF_BASE_ALL;
630                 jsf->dv[2].dsize = 0x01000000;
631
632                 printk("Espresso Flash @0x%lx [%d MB]\n", jsf->base,
633                     (int) (jsf->size / (1024*1024)));
634         }
635
636         if ((rc = misc_register(&jsf_dev)) != 0) {
637                 printk(KERN_ERR "jsf: unable to get misc minor %d\n",
638                     JSF_MINOR);
639                 jsf0.base = 0;
640                 return rc;
641         }
642
643         return 0;
644 }
645
646 int jsfd_init(void) {
647         struct jsflash *jsf;
648         struct jsfd_part *jdp;
649         int i;
650
651         if (jsf0.base == 0) {
652                 return -ENXIO;
653         }
654
655         if (register_blkdev(JSFD_MAJOR, "jsfd", &jsfd_fops)) {
656                 printk("jsfd_init: unable to get major number %d\n",
657                     JSFD_MAJOR);
658                 return -EIO;
659         }
660
661         blksize_size[JSFD_MAJOR] = jsfd_blksizes;
662         blk_size[JSFD_MAJOR] = jsfd_sizes;
663
664         blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), DEVICE_REQUEST);
665         for (i = 0; i < JSF_MAX; i++) {
666                 if ((i & JSF_PART_MASK) >= JSF_NPART) continue;
667                 jsf = &jsf0;    /* actually, &jsfv[i >> JSF_PART_BITS] */
668                 jdp = &jsf->dv[i&JSF_PART_MASK];
669
670                 jdp->refcnt = 0;
671
672                 jsfd_blksizes[i] = 1024;
673                 jsfd_bytesizes[i] = jdp->dsize;
674                 jsfd_sizes[i] = jsfd_bytesizes[i] >> 10;
675                 register_disk(NULL, MKDEV(JSFD_MAJOR, i), 1, &jsfd_fops,
676                                 jsfd_bytesizes[i] >> 9);
677                 set_device_ro(MKDEV(JSFD_MAJOR, i), 1);
678         }
679         return 0;
680 }
681
682 #ifdef MODULE
683 MODULE_LICENSE("GPL");
684
685 int init_module(void) {
686         int rc;
687
688         if ((rc = jsflash_init()) == 0) {
689                 jsfd_init();
690                 return 0;
691         }
692         return rc;
693 }
694
695 void cleanup_module(void) {
696
697         /* for (all probed units) {  } */
698         if (jsf0.busy)
699                 printk("jsf0: cleaning busy unit\n");
700         jsf0.base = 0;
701         jsf0.busy = 0;
702
703         misc_deregister(&jsf_dev);
704         if (unregister_blkdev(JSFD_MAJOR, "jsfd") != 0)
705                 printk("jsfd: cleanup_module failed\n");
706         blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
707 }
708 #endif