Linux-2.6.12-rc2
[linux-2.6.git] / drivers / block / swim_iop.c
1 /*
2  * Driver for the SWIM (Super Woz Integrated Machine) IOP
3  * floppy controller on the Macintosh IIfx and Quadra 900/950
4  *
5  * Written by Joshua M. Thompson (funaho@jurai.org)
6  * based on the SWIM3 driver (c) 1996 by Paul Mackerras.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version
11  * 2 of the License, or (at your option) any later version.
12  *
13  * 1999-06-12 (jmt) - Initial implementation.
14  */
15
16 /*
17  * -------------------
18  * Theory of Operation
19  * -------------------
20  *
21  * Since the SWIM IOP is message-driven we implement a simple request queue
22  * system.  One outstanding request may be queued at any given time (this is
23  * an IOP limitation); only when that request has completed can a new request
24  * be sent.
25  */
26
27 #include <linux/stddef.h>
28 #include <linux/kernel.h>
29 #include <linux/sched.h>
30 #include <linux/timer.h>
31 #include <linux/delay.h>
32 #include <linux/fd.h>
33 #include <linux/ioctl.h>
34 #include <linux/blkdev.h>
35 #include <asm/io.h>
36 #include <asm/uaccess.h>
37 #include <asm/mac_iop.h>
38 #include <asm/swim_iop.h>
39
40 #define DRIVER_VERSION "Version 0.1 (1999-06-12)"
41
42 #define MAX_FLOPPIES    4
43
44 enum swim_state {
45         idle,
46         available,
47         revalidating,
48         transferring,
49         ejecting
50 };
51
52 struct floppy_state {
53         enum swim_state state;
54         int     drive_num;      /* device number */
55         int     secpercyl;      /* disk geometry information */
56         int     secpertrack;
57         int     total_secs;
58         int     write_prot;     /* 1 if write-protected, 0 if not, -1 dunno */
59         int     ref_count;
60         struct timer_list timeout;
61         int     ejected;
62         struct wait_queue *wait;
63         int     wanted;
64         int     timeout_pending;
65 };
66
67 struct swim_iop_req {
68         int     sent;
69         int     complete;
70         __u8    command[32];
71         struct floppy_state *fs;
72         void    (*done)(struct swim_iop_req *);
73 };
74
75 static struct swim_iop_req *current_req;
76 static int floppy_count;
77
78 static struct floppy_state floppy_states[MAX_FLOPPIES];
79 static DEFINE_SPINLOCK(swim_iop_lock);
80
81 #define CURRENT elv_next_request(swim_queue)
82
83 static char *drive_names[7] = {
84         "not installed",        /* DRV_NONE    */
85         "unknown (1)",          /* DRV_UNKNOWN */
86         "a 400K drive",         /* DRV_400K    */
87         "an 800K drive"         /* DRV_800K    */
88         "unknown (4)",          /* ????        */
89         "an FDHD",              /* DRV_FDHD    */
90         "unknown (6)",          /* ????        */
91         "an Apple HD20"         /* DRV_HD20    */
92 };
93
94 int swimiop_init(void);
95 static void swimiop_init_request(struct swim_iop_req *);
96 static int swimiop_send_request(struct swim_iop_req *);
97 static void swimiop_receive(struct iop_msg *, struct pt_regs *);
98 static void swimiop_status_update(int, struct swim_drvstatus *);
99 static int swimiop_eject(struct floppy_state *fs);
100
101 static int floppy_ioctl(struct inode *inode, struct file *filp,
102                         unsigned int cmd, unsigned long param);
103 static int floppy_open(struct inode *inode, struct file *filp);
104 static int floppy_release(struct inode *inode, struct file *filp);
105 static int floppy_check_change(struct gendisk *disk);
106 static int floppy_revalidate(struct gendisk *disk);
107 static int grab_drive(struct floppy_state *fs, enum swim_state state,
108                       int interruptible);
109 static void release_drive(struct floppy_state *fs);
110 static void set_timeout(struct floppy_state *fs, int nticks,
111                         void (*proc)(unsigned long));
112 static void fd_request_timeout(unsigned long);
113 static void do_fd_request(request_queue_t * q);
114 static void start_request(struct floppy_state *fs);
115
116 static struct block_device_operations floppy_fops = {
117         .open           = floppy_open,
118         .release        = floppy_release,
119         .ioctl          = floppy_ioctl,
120         .media_changed  = floppy_check_change,
121         .revalidate_disk= floppy_revalidate,
122 };
123
124 static struct request_queue *swim_queue;
125 /*
126  * SWIM IOP initialization
127  */
128
129 int swimiop_init(void)
130 {
131         volatile struct swim_iop_req req;
132         struct swimcmd_status *cmd = (struct swimcmd_status *) &req.command[0];
133         struct swim_drvstatus *ds = &cmd->status;
134         struct floppy_state *fs;
135         int i;
136
137         current_req = NULL;
138         floppy_count = 0;
139
140         if (!iop_ism_present)
141                 return -ENODEV;
142
143         if (register_blkdev(FLOPPY_MAJOR, "fd"))
144                 return -EBUSY;
145
146         swim_queue = blk_init_queue(do_fd_request, &swim_iop_lock);
147         if (!swim_queue) {
148                 unregister_blkdev(FLOPPY_MAJOR, "fd");
149                 return -ENOMEM;
150         }
151
152         printk("SWIM-IOP: %s by Joshua M. Thompson (funaho@jurai.org)\n",
153                 DRIVER_VERSION);
154
155         if (iop_listen(SWIM_IOP, SWIM_CHAN, swimiop_receive, "SWIM") != 0) {
156                 printk(KERN_ERR "SWIM-IOP: IOP channel already in use; can't initialize.\n");
157                 unregister_blkdev(FLOPPY_MAJOR, "fd");
158                 blk_cleanup_queue(swim_queue);
159                 return -EBUSY;
160         }
161
162         printk(KERN_ERR "SWIM_IOP: probing for installed drives.\n");
163
164         for (i = 0 ; i < MAX_FLOPPIES ; i++) {
165                 memset(&floppy_states[i], 0, sizeof(struct floppy_state));
166                 fs = &floppy_states[floppy_count];
167
168                 swimiop_init_request(&req);
169                 cmd->code = CMD_STATUS;
170                 cmd->drive_num = i + 1;
171                 if (swimiop_send_request(&req) != 0) continue;
172                 while (!req.complete);
173                 if (cmd->error != 0) {
174                         printk(KERN_ERR "SWIM-IOP: probe on drive %d returned error %d\n", i, (uint) cmd->error);
175                         continue;
176                 }
177                 if (ds->installed != 0x01) continue;
178                 printk("SWIM-IOP: drive %d is %s (%s, %s, %s, %s)\n", i,
179                         drive_names[ds->info.type],
180                         ds->info.external? "ext" : "int",
181                         ds->info.scsi? "scsi" : "floppy",
182                         ds->info.fixed? "fixed" : "removable",
183                         ds->info.secondary? "secondary" : "primary");
184                 swimiop_status_update(floppy_count, ds);
185                 fs->state = idle;
186
187                 init_timer(&fs->timeout);
188                 floppy_count++;
189         }
190         printk("SWIM-IOP: detected %d installed drives.\n", floppy_count);
191
192         for (i = 0; i < floppy_count; i++) {
193                 struct gendisk *disk = alloc_disk(1);
194                 if (!disk)
195                         continue;
196                 disk->major = FLOPPY_MAJOR;
197                 disk->first_minor = i;
198                 disk->fops = &floppy_fops;
199                 sprintf(disk->disk_name, "fd%d", i);
200                 disk->private_data = &floppy_states[i];
201                 disk->queue = swim_queue;
202                 set_capacity(disk, 2880 * 2);
203                 add_disk(disk);
204         }
205
206         return 0;
207 }
208
209 static void swimiop_init_request(struct swim_iop_req *req)
210 {
211         req->sent = 0;
212         req->complete = 0;
213         req->done = NULL;
214 }
215
216 static int swimiop_send_request(struct swim_iop_req *req)
217 {
218         unsigned long flags;
219         int err;
220
221         /* It's doubtful an interrupt routine would try to send */
222         /* a SWIM request, but I'd rather play it safe here.    */
223
224         local_irq_save(flags);
225
226         if (current_req != NULL) {
227                 local_irq_restore(flags);
228                 return -ENOMEM;
229         }
230
231         current_req = req;
232
233         /* Interrupts should be back on for iop_send_message() */
234
235         local_irq_restore(flags);
236
237         err = iop_send_message(SWIM_IOP, SWIM_CHAN, (void *) req,
238                                 sizeof(req->command), (__u8 *) &req->command[0],
239                                 swimiop_receive);
240
241         /* No race condition here; we own current_req at this point */
242
243         if (err) {
244                 current_req = NULL;
245         } else {
246                 req->sent = 1;
247         }
248         return err;
249 }
250
251 /*
252  * Receive a SWIM message from the IOP.
253  *
254  * This will be called in two cases:
255  *
256  * 1. A message has been successfully sent to the IOP.
257  * 2. An unsolicited message was received from the IOP.
258  */
259
260 void swimiop_receive(struct iop_msg *msg, struct pt_regs *regs)
261 {
262         struct swim_iop_req *req;
263         struct swimmsg_status *sm;
264         struct swim_drvstatus *ds;
265
266         req = current_req;
267
268         switch(msg->status) {
269                 case IOP_MSGSTATUS_COMPLETE:
270                         memcpy(&req->command[0], &msg->reply[0], sizeof(req->command));
271                         req->complete = 1;
272                         if (req->done) (*req->done)(req);
273                         current_req = NULL;
274                         break;
275                 case IOP_MSGSTATUS_UNSOL:
276                         sm = (struct swimmsg_status *) &msg->message[0];
277                         ds = &sm->status;
278                         swimiop_status_update(sm->drive_num, ds);
279                         iop_complete_message(msg);
280                         break;
281         }
282 }
283
284 static void swimiop_status_update(int drive_num, struct swim_drvstatus *ds)
285 {
286         struct floppy_state *fs = &floppy_states[drive_num];
287
288         fs->write_prot = (ds->write_prot == 0x80);
289         if ((ds->disk_in_drive != 0x01) && (ds->disk_in_drive != 0x02)) {
290                 fs->ejected = 1;
291         } else {
292                 fs->ejected = 0;
293         }
294         switch(ds->info.type) {
295                 case DRV_400K:
296                         fs->secpercyl = 10;
297                         fs->secpertrack = 10;
298                         fs->total_secs = 800;
299                         break;
300                 case DRV_800K:
301                         fs->secpercyl = 20;
302                         fs->secpertrack = 10;
303                         fs->total_secs = 1600;
304                         break;
305                 case DRV_FDHD:
306                         fs->secpercyl = 36;
307                         fs->secpertrack = 18;
308                         fs->total_secs = 2880;
309                         break;
310                 default:
311                         fs->secpercyl = 0;
312                         fs->secpertrack = 0;
313                         fs->total_secs = 0;
314                         break;
315         }
316 }
317
318 static int swimiop_eject(struct floppy_state *fs)
319 {
320         int err, n;
321         struct swim_iop_req req;
322         struct swimcmd_eject *cmd = (struct swimcmd_eject *) &req.command[0];
323
324         err = grab_drive(fs, ejecting, 1);
325         if (err) return err;
326
327         swimiop_init_request(&req);
328         cmd->code = CMD_EJECT;
329         cmd->drive_num = fs->drive_num;
330         err = swimiop_send_request(&req);
331         if (err) {
332                 release_drive(fs);
333                 return err;
334         }
335         for (n = 2*HZ; n > 0; --n) {
336                 if (req.complete) break;
337                 if (signal_pending(current)) {
338                         err = -EINTR;
339                         break;
340                 }
341                 current->state = TASK_INTERRUPTIBLE;
342                 schedule_timeout(1);
343         }
344         release_drive(fs);
345         return cmd->error;
346 }
347
348 static struct floppy_struct floppy_type =
349         { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,NULL };    /*  7 1.44MB 3.5"   */
350
351 static int floppy_ioctl(struct inode *inode, struct file *filp,
352                         unsigned int cmd, unsigned long param)
353 {
354         struct floppy_state *fs = inode->i_bdev->bd_disk->private_data;
355         int err;
356
357         if ((cmd & 0x80) && !capable(CAP_SYS_ADMIN))
358                 return -EPERM;
359
360         switch (cmd) {
361         case FDEJECT:
362                 if (fs->ref_count != 1)
363                         return -EBUSY;
364                 err = swimiop_eject(fs);
365                 return err;
366         case FDGETPRM:
367                 if (copy_to_user((void *) param, (void *) &floppy_type,
368                                  sizeof(struct floppy_struct)))
369                         return -EFAULT;
370                 return 0;
371         }
372         return -ENOTTY;
373 }
374
375 static int floppy_open(struct inode *inode, struct file *filp)
376 {
377         struct floppy_state *fs = inode->i_bdev->bd_disk->private_data;
378
379         if (fs->ref_count == -1 || filp->f_flags & O_EXCL)
380                 return -EBUSY;
381
382         if ((filp->f_flags & O_NDELAY) == 0 && (filp->f_mode & 3)) {
383                 check_disk_change(inode->i_bdev);
384                 if (fs->ejected)
385                         return -ENXIO;
386         }
387
388         if ((filp->f_mode & 2) && fs->write_prot)
389                 return -EROFS;
390
391         if (filp->f_flags & O_EXCL)
392                 fs->ref_count = -1;
393         else
394                 ++fs->ref_count;
395
396         return 0;
397 }
398
399 static int floppy_release(struct inode *inode, struct file *filp)
400 {
401         struct floppy_state *fs = inode->i_bdev->bd_disk->private_data;
402         if (fs->ref_count > 0)
403                 fs->ref_count--;
404         return 0;
405 }
406
407 static int floppy_check_change(struct gendisk *disk)
408 {
409         struct floppy_state *fs = disk->private_data;
410         return fs->ejected;
411 }
412
413 static int floppy_revalidate(struct gendisk *disk)
414 {
415         struct floppy_state *fs = disk->private_data;
416         grab_drive(fs, revalidating, 0);
417         /* yadda, yadda */
418         release_drive(fs);
419         return 0;
420 }
421
422 static void floppy_off(unsigned int nr)
423 {
424 }
425
426 static int grab_drive(struct floppy_state *fs, enum swim_state state,
427                       int interruptible)
428 {
429         unsigned long flags;
430
431         local_irq_save(flags);
432         if (fs->state != idle) {
433                 ++fs->wanted;
434                 while (fs->state != available) {
435                         if (interruptible && signal_pending(current)) {
436                                 --fs->wanted;
437                                 local_irq_restore(flags);
438                                 return -EINTR;
439                         }
440                         interruptible_sleep_on(&fs->wait);
441                 }
442                 --fs->wanted;
443         }
444         fs->state = state;
445         local_irq_restore(flags);
446         return 0;
447 }
448
449 static void release_drive(struct floppy_state *fs)
450 {
451         unsigned long flags;
452
453         local_irq_save(flags);
454         fs->state = idle;
455         start_request(fs);
456         local_irq_restore(flags);
457 }
458
459 static void set_timeout(struct floppy_state *fs, int nticks,
460                         void (*proc)(unsigned long))
461 {
462         unsigned long flags;
463
464         local_irq_save(flags);
465         if (fs->timeout_pending)
466                 del_timer(&fs->timeout);
467         init_timer(&fs->timeout);
468         fs->timeout.expires = jiffies + nticks;
469         fs->timeout.function = proc;
470         fs->timeout.data = (unsigned long) fs;
471         add_timer(&fs->timeout);
472         fs->timeout_pending = 1;
473         local_irq_restore(flags);
474 }
475
476 static void do_fd_request(request_queue_t * q)
477 {
478         int i;
479
480         for (i = 0 ; i < floppy_count ; i++) {
481                 start_request(&floppy_states[i]);
482         }
483 }
484
485 static void fd_request_complete(struct swim_iop_req *req)
486 {
487         struct floppy_state *fs = req->fs;
488         struct swimcmd_rw *cmd = (struct swimcmd_rw *) &req->command[0];
489
490         del_timer(&fs->timeout);
491         fs->timeout_pending = 0;
492         fs->state = idle;
493         if (cmd->error) {
494                 printk(KERN_ERR "SWIM-IOP: error %d on read/write request.\n", cmd->error);
495                 end_request(CURRENT, 0);
496         } else {
497                 CURRENT->sector += cmd->num_blocks;
498                 CURRENT->current_nr_sectors -= cmd->num_blocks;
499                 if (CURRENT->current_nr_sectors <= 0) {
500                         end_request(CURRENT, 1);
501                         return;
502                 }
503         }
504         start_request(fs);
505 }
506
507 static void fd_request_timeout(unsigned long data)
508 {
509         struct floppy_state *fs = (struct floppy_state *) data;
510
511         fs->timeout_pending = 0;
512         end_request(CURRENT, 0);
513         fs->state = idle;
514 }
515
516 static void start_request(struct floppy_state *fs)
517 {
518         volatile struct swim_iop_req req;
519         struct swimcmd_rw *cmd = (struct swimcmd_rw *) &req.command[0];
520
521         if (fs->state == idle && fs->wanted) {
522                 fs->state = available;
523                 wake_up(&fs->wait);
524                 return;
525         }
526         while (CURRENT && fs->state == idle) {
527                 if (CURRENT->bh && !buffer_locked(CURRENT->bh))
528                         panic("floppy: block not locked");
529 #if 0
530                 printk("do_fd_req: dev=%s cmd=%d sec=%ld nr_sec=%ld buf=%p\n",
531                        CURRENT->rq_disk->disk_name, CURRENT->cmd,
532                        CURRENT->sector, CURRENT->nr_sectors, CURRENT->buffer);
533                 printk("           rq_status=%d errors=%d current_nr_sectors=%ld\n",
534                        CURRENT->rq_status, CURRENT->errors, CURRENT->current_nr_sectors);
535 #endif
536
537                 if (CURRENT->sector < 0 || CURRENT->sector >= fs->total_secs) {
538                         end_request(CURRENT, 0);
539                         continue;
540                 }
541                 if (CURRENT->current_nr_sectors == 0) {
542                         end_request(CURRENT, 1);
543                         continue;
544                 }
545                 if (fs->ejected) {
546                         end_request(CURRENT, 0);
547                         continue;
548                 }
549
550                 swimiop_init_request(&req);
551                 req.fs = fs;
552                 req.done = fd_request_complete;
553
554                 if (CURRENT->cmd == WRITE) {
555                         if (fs->write_prot) {
556                                 end_request(CURRENT, 0);
557                                 continue;
558                         }
559                         cmd->code = CMD_WRITE;
560                 } else {
561                         cmd->code = CMD_READ;
562
563                 }
564                 cmd->drive_num = fs->drive_num;
565                 cmd->buffer = CURRENT->buffer;
566                 cmd->first_block = CURRENT->sector;
567                 cmd->num_blocks = CURRENT->current_nr_sectors;
568
569                 if (swimiop_send_request(&req)) {
570                         end_request(CURRENT, 0);
571                         continue;
572                 }
573
574                 set_timeout(fs, HZ*CURRENT->current_nr_sectors,
575                                 fd_request_timeout);
576
577                 fs->state = transferring;
578         }
579 }