Merge git://git.infradead.org/hdrinstall-2.6
[linux-2.6] / drivers / block / ps2esdi.c
1 /* ps2esdi driver based on assembler code by Arindam Banerji,
2    written by Peter De Schrijver */
3 /* Reassuring note to IBM : This driver was NOT developed by vice-versa
4    engineering the PS/2's BIOS */
5 /* Dedicated to Wannes, Tofke, Ykke, Godot, Killroy and all those 
6    other lovely fish out there... */
7 /* This code was written during the long and boring WINA 
8    elections 1994 */
9 /* Thanks to Arindam Banerij for giving me the source of his driver */
10 /* This code may be freely distributed and modified in any way, 
11    as long as these notes remain intact */
12
13 /*  Revised: 05/07/94 by Arindam Banerji (axb@cse.nd.edu) */
14 /*  Revised: 09/08/94 by Peter De Schrijver (stud11@cc4.kuleuven.ac.be)
15    Thanks to Arindam Banerij for sending me the docs of the adapter */
16
17 /* BA Modified for ThinkPad 720 by Boris Ashkinazi */
18 /*                    (bash@vnet.ibm.com) 08/08/95 */
19
20 /* Modified further for ThinkPad-720C by Uri Blumenthal */
21 /*                    (uri@watson.ibm.com) Sep 11, 1995 */
22
23 /* TODO : 
24    + Timeouts
25    + Get disk parameters
26    + DMA above 16MB
27    + reset after read/write error
28  */
29
30 #define DEVICE_NAME "PS/2 ESDI"
31
32 #include <linux/major.h>
33 #include <linux/errno.h>
34 #include <linux/wait.h>
35 #include <linux/interrupt.h>
36 #include <linux/fs.h>
37 #include <linux/kernel.h>
38 #include <linux/genhd.h>
39 #include <linux/ps2esdi.h>
40 #include <linux/blkdev.h>
41 #include <linux/mca-legacy.h>
42 #include <linux/init.h>
43 #include <linux/ioport.h>
44 #include <linux/module.h>
45 #include <linux/hdreg.h>
46
47 #include <asm/system.h>
48 #include <asm/io.h>
49 #include <asm/dma.h>
50 #include <asm/mca_dma.h>
51 #include <asm/uaccess.h>
52
53 #define PS2ESDI_IRQ 14
54 #define MAX_HD 2
55 #define MAX_RETRIES 5
56 #define MAX_16BIT 65536
57 #define ESDI_TIMEOUT   0xf000
58 #define ESDI_STAT_TIMEOUT 4
59
60 #define TYPE_0_CMD_BLK_LENGTH 2
61 #define TYPE_1_CMD_BLK_LENGTH 4
62
63 static void reset_ctrl(void);
64
65 static int ps2esdi_geninit(void);
66
67 static void do_ps2esdi_request(request_queue_t * q);
68
69 static void ps2esdi_readwrite(int cmd, struct request *req);
70
71 static void ps2esdi_fill_cmd_block(u_short * cmd_blk, u_short cmd,
72 u_short cyl, u_short head, u_short sector, u_short length, u_char drive);
73
74 static int ps2esdi_out_cmd_blk(u_short * cmd_blk);
75
76 static void ps2esdi_prep_dma(char *buffer, u_short length, u_char dma_xmode);
77
78 static irqreturn_t ps2esdi_interrupt_handler(int irq, void *dev_id,
79                                       struct pt_regs *regs);
80 static void (*current_int_handler) (u_int) = NULL;
81 static void ps2esdi_normal_interrupt_handler(u_int);
82 static void ps2esdi_initial_reset_int_handler(u_int);
83 static void ps2esdi_geometry_int_handler(u_int);
84 static int ps2esdi_getgeo(struct block_device *bdev, struct hd_geometry *geo);
85
86 static int ps2esdi_read_status_words(int num_words, int max_words, u_short * buffer);
87
88 static void dump_cmd_complete_status(u_int int_ret_code);
89
90 static void ps2esdi_get_device_cfg(void);
91
92 static void ps2esdi_reset_timer(unsigned long unused);
93
94 static u_int dma_arb_level;             /* DMA arbitration level */
95
96 static DECLARE_WAIT_QUEUE_HEAD(ps2esdi_int);
97
98 static int no_int_yet;
99 static int ps2esdi_drives;
100 static u_short io_base;
101 static DEFINE_TIMER(esdi_timer, ps2esdi_reset_timer, 0, 0);
102 static int reset_status;
103 static int ps2esdi_slot = -1;
104 static int tp720esdi = 0;       /* Is it Integrated ESDI of ThinkPad-720? */
105 static int intg_esdi = 0;       /* If integrated adapter */
106 struct ps2esdi_i_struct {
107         unsigned int head, sect, cyl, wpcom, lzone, ctl;
108 };
109 static DEFINE_SPINLOCK(ps2esdi_lock);
110 static struct request_queue *ps2esdi_queue;
111 static struct request *current_req;
112
113 #if 0
114 #if 0                           /* try both - I don't know which one is better... UB */
115 static struct ps2esdi_i_struct ps2esdi_info[MAX_HD] =
116 {
117         {4, 48, 1553, 0, 0, 0},
118         {0, 0, 0, 0, 0, 0}};
119 #else
120 static struct ps2esdi_i_struct ps2esdi_info[MAX_HD] =
121 {
122         {64, 32, 161, 0, 0, 0},
123         {0, 0, 0, 0, 0, 0}};
124 #endif
125 #endif
126 static struct ps2esdi_i_struct ps2esdi_info[MAX_HD] =
127 {
128         {0, 0, 0, 0, 0, 0},
129         {0, 0, 0, 0, 0, 0}};
130
131 static struct block_device_operations ps2esdi_fops =
132 {
133         .owner          = THIS_MODULE,
134         .getgeo         = ps2esdi_getgeo,
135 };
136
137 static struct gendisk *ps2esdi_gendisk[2];
138
139 /* initialization routine called by ll_rw_blk.c   */
140 static int __init ps2esdi_init(void)
141 {
142
143         int error = 0;
144
145         /* register the device - pass the name and major number */
146         if (register_blkdev(PS2ESDI_MAJOR, "ed"))
147                 return -EBUSY;
148
149         /* set up some global information - indicating device specific info */
150         ps2esdi_queue = blk_init_queue(do_ps2esdi_request, &ps2esdi_lock);
151         if (!ps2esdi_queue) {
152                 unregister_blkdev(PS2ESDI_MAJOR, "ed");
153                 return -ENOMEM;
154         }
155
156         /* some minor housekeeping - setup the global gendisk structure */
157         error = ps2esdi_geninit();
158         if (error) {
159                 printk(KERN_WARNING "PS2ESDI: error initialising"
160                         " device, releasing resources\n");
161                 unregister_blkdev(PS2ESDI_MAJOR, "ed");
162                 blk_cleanup_queue(ps2esdi_queue);
163                 return error;
164         }
165         return 0;
166 }                               /* ps2esdi_init */
167
168 #ifndef MODULE
169
170 module_init(ps2esdi_init);
171
172 #else
173
174 static int cyl[MAX_HD] = {-1,-1};
175 static int head[MAX_HD] = {-1, -1};
176 static int sect[MAX_HD] = {-1, -1};
177
178 module_param(tp720esdi, bool, 0);
179 module_param_array(cyl, int, NULL, 0);
180 module_param_array(head, int, NULL, 0);
181 module_param_array(sect, int, NULL, 0);
182 MODULE_LICENSE("GPL");
183
184 int init_module(void) {
185         int drive;
186
187         for(drive = 0; drive < MAX_HD; drive++) {
188                 struct ps2esdi_i_struct *info = &ps2esdi_info[drive];
189
190                 if (cyl[drive] != -1) {
191                         info->cyl = info->lzone = cyl[drive];
192                         info->wpcom = 0;
193                 }
194                 if (head[drive] != -1) {
195                         info->head = head[drive];
196                         info->ctl = (head[drive] > 8 ? 8 : 0);
197                 }
198                 if (sect[drive] != -1) info->sect = sect[drive];
199         }
200         return ps2esdi_init();
201 }
202
203 void
204 cleanup_module(void) {
205         int i;
206         if(ps2esdi_slot) {
207                 mca_mark_as_unused(ps2esdi_slot);
208                 mca_set_adapter_procfn(ps2esdi_slot, NULL, NULL);
209         }
210         release_region(io_base, 4);
211         free_dma(dma_arb_level);
212         free_irq(PS2ESDI_IRQ, &ps2esdi_gendisk);
213         unregister_blkdev(PS2ESDI_MAJOR, "ed");
214         blk_cleanup_queue(ps2esdi_queue);
215         for (i = 0; i < ps2esdi_drives; i++) {
216                 del_gendisk(ps2esdi_gendisk[i]);
217                 put_disk(ps2esdi_gendisk[i]);
218         }
219 }
220 #endif /* MODULE */
221
222 /* handles boot time command line parameters */
223 void __init tp720_setup(char *str, int *ints)
224 {
225         /* no params, just sets the tp720esdi flag if it exists */
226
227         printk("%s: TP 720 ESDI flag set\n", DEVICE_NAME);
228         tp720esdi = 1;
229 }
230
231 void __init ed_setup(char *str, int *ints)
232 {
233         int hdind = 0;
234
235         /* handles 3 parameters only - corresponding to
236            1. Number of cylinders
237            2. Number of heads
238            3. Sectors/track
239          */
240
241         if (ints[0] != 3)
242                 return;
243
244         /* print out the information - seen at boot time */
245         printk("%s: ints[0]=%d ints[1]=%d ints[2]=%d ints[3]=%d\n",
246                DEVICE_NAME, ints[0], ints[1], ints[2], ints[3]);
247
248         /* set the index into device specific information table */
249         if (ps2esdi_info[0].head != 0)
250                 hdind = 1;
251
252         /* set up all the device information */
253         ps2esdi_info[hdind].head = ints[2];
254         ps2esdi_info[hdind].sect = ints[3];
255         ps2esdi_info[hdind].cyl = ints[1];
256         ps2esdi_info[hdind].wpcom = 0;
257         ps2esdi_info[hdind].lzone = ints[1];
258         ps2esdi_info[hdind].ctl = (ints[2] > 8 ? 8 : 0);
259 #if 0                           /* this may be needed for PS2/Mod.80, but it hurts ThinkPad! */
260         ps2esdi_drives = hdind + 1;     /* increment index for the next time */
261 #endif
262 }                               /* ed_setup */
263
264 static int ps2esdi_getinfo(char *buf, int slot, void *d)
265 {
266         int len = 0;
267
268         len += sprintf(buf + len, "DMA Arbitration Level: %d\n",
269                        dma_arb_level);
270         len += sprintf(buf + len, "IO Port: %x\n", io_base);
271         len += sprintf(buf + len, "IRQ: 14\n");
272         len += sprintf(buf + len, "Drives: %d\n", ps2esdi_drives);
273
274         return len;
275 }
276
277 /* ps2 esdi specific initialization - called thru the gendisk chain */
278 static int __init ps2esdi_geninit(void)
279 {
280         /*
281            The first part contains the initialization code
282            for the ESDI disk subsystem.  All we really do
283            is search for the POS registers of the controller
284            to do some simple setup operations.  First, we
285            must ensure that the controller is installed,
286            enabled, and configured as PRIMARY.  Then we must
287            determine the DMA arbitration level being used by
288            the controller so we can handle data transfer
289            operations properly.  If all of this works, then
290            we will set the INIT_FLAG to a non-zero value.
291          */
292
293         int slot = 0, i, reset_start, reset_end;
294         u_char status;
295         unsigned short adapterID;
296         int error = 0;
297
298         if ((slot = mca_find_adapter(INTG_ESDI_ID, 0)) != MCA_NOTFOUND) {
299                 adapterID = INTG_ESDI_ID;
300                 printk("%s: integrated ESDI adapter found in slot %d\n",
301                        DEVICE_NAME, slot+1);
302 #ifndef MODULE
303                 mca_set_adapter_name(slot, "PS/2 Integrated ESDI");
304 #endif
305         } else if ((slot = mca_find_adapter(NRML_ESDI_ID, 0)) != -1) {
306                 adapterID = NRML_ESDI_ID;
307                 printk("%s: normal ESDI adapter found in slot %d\n",
308                        DEVICE_NAME, slot+1);
309                 mca_set_adapter_name(slot, "PS/2 ESDI");
310         } else {
311                 return -ENODEV;
312         }
313
314         ps2esdi_slot = slot;
315         mca_mark_as_used(slot);
316         mca_set_adapter_procfn(slot, (MCA_ProcFn) ps2esdi_getinfo, NULL);
317
318         /* Found the slot - read the POS register 2 to get the necessary
319            configuration and status information.  POS register 2 has the
320            following information :
321            Bit           Function
322            7             reserved = 0
323            6             arbitration method
324            0 - fairness enabled
325            1 - fairness disabled, linear priority assignment
326            5-2           arbitration level
327            1             alternate address
328            1              alternate address
329            0 - use addresses 0x3510 - 0x3517
330            0             adapter enable
331          */
332
333         status = mca_read_stored_pos(slot, 2);
334         /* is it enabled ? */
335         if (!(status & STATUS_ENABLED)) {
336                 printk("%s: ESDI adapter disabled\n", DEVICE_NAME);
337                 error = -ENODEV;
338                 goto err_out1;
339         }
340         /* try to grab IRQ, and try to grab a slow IRQ if it fails, so we can
341            share with the SCSI driver */
342         if (request_irq(PS2ESDI_IRQ, ps2esdi_interrupt_handler,
343                   IRQF_DISABLED | IRQF_SHARED, "PS/2 ESDI", &ps2esdi_gendisk)
344             && request_irq(PS2ESDI_IRQ, ps2esdi_interrupt_handler,
345                            IRQF_SHARED, "PS/2 ESDI", &ps2esdi_gendisk)
346             ) {
347                 printk("%s: Unable to get IRQ %d\n", DEVICE_NAME, PS2ESDI_IRQ);
348                 error = -EBUSY;
349                 goto err_out1;
350         }
351         if (status & STATUS_ALTERNATE)
352                 io_base = ALT_IO_BASE;
353         else
354                 io_base = PRIMARY_IO_BASE;
355
356         if (!request_region(io_base, 4, "ed")) {
357                 printk(KERN_WARNING"Unable to request region 0x%x\n", io_base);
358                 error = -EBUSY;
359                 goto err_out2;
360         }
361         /* get the dma arbitration level */
362         dma_arb_level = (status >> 2) & 0xf;
363
364         /* BA */
365         printk("%s: DMA arbitration level : %d\n",
366                DEVICE_NAME, dma_arb_level);
367
368         LITE_ON;
369         current_int_handler = ps2esdi_initial_reset_int_handler;
370         reset_ctrl();
371         reset_status = 0;
372         reset_start = jiffies;
373         while (!reset_status) {
374                 init_timer(&esdi_timer);
375                 esdi_timer.expires = jiffies + HZ;
376                 esdi_timer.data = 0;
377                 add_timer(&esdi_timer);
378                 sleep_on(&ps2esdi_int);
379         }
380         reset_end = jiffies;
381         LITE_OFF;
382         printk("%s: reset interrupt after %d jiffies,  %u.%02u secs\n",
383                DEVICE_NAME, reset_end - reset_start, (reset_end - reset_start) / HZ,
384                (reset_end - reset_start) % HZ);
385
386
387         /* Integrated ESDI Disk and Controller has only one drive! */
388         if (adapterID == INTG_ESDI_ID) {/* if not "normal" PS2 ESDI adapter */
389                 ps2esdi_drives = 1;     /* then we have only one physical disk! */              intg_esdi = 1;
390         }
391
392
393
394         /* finally this part sets up some global data structures etc. */
395
396         ps2esdi_get_device_cfg();
397
398         /* some annoyance in the above routine returns TWO drives?
399          Is something else happining in the background?
400          Regaurdless we fix the # of drives again. AJK */
401         /* Integrated ESDI Disk and Controller has only one drive! */
402         if (adapterID == INTG_ESDI_ID)  /* if not "normal" PS2 ESDI adapter */
403                 ps2esdi_drives = 1;     /* Not three or two, ONE DAMNIT! */
404
405         current_int_handler = ps2esdi_normal_interrupt_handler;
406
407         if (request_dma(dma_arb_level, "ed") !=0) {
408                 printk(KERN_WARNING "PS2ESDI: Can't request dma-channel %d\n"
409                         ,(int) dma_arb_level);
410                 error = -EBUSY;
411                 goto err_out3;
412         }
413         blk_queue_max_sectors(ps2esdi_queue, 128);
414
415         error = -ENOMEM;
416         for (i = 0; i < ps2esdi_drives; i++) {
417                 struct gendisk *disk = alloc_disk(64);
418                 if (!disk)
419                         goto err_out4;
420                 disk->major = PS2ESDI_MAJOR;
421                 disk->first_minor = i<<6;
422                 sprintf(disk->disk_name, "ed%c", 'a'+i);
423                 disk->fops = &ps2esdi_fops;
424                 ps2esdi_gendisk[i] = disk;
425         }
426
427         for (i = 0; i < ps2esdi_drives; i++) {
428                 struct gendisk *disk = ps2esdi_gendisk[i];
429                 set_capacity(disk, ps2esdi_info[i].head * ps2esdi_info[i].sect *
430                                 ps2esdi_info[i].cyl);
431                 disk->queue = ps2esdi_queue;
432                 disk->private_data = &ps2esdi_info[i];
433                 add_disk(disk);
434         }
435         return 0;
436 err_out4:
437         while (i--)
438                 put_disk(ps2esdi_gendisk[i]);
439 err_out3:
440         release_region(io_base, 4);
441 err_out2:
442         free_irq(PS2ESDI_IRQ, &ps2esdi_gendisk);
443 err_out1:
444         if(ps2esdi_slot) {
445                 mca_mark_as_unused(ps2esdi_slot);
446                 mca_set_adapter_procfn(ps2esdi_slot, NULL, NULL);
447         }
448         return error;
449 }
450
451 static void __init ps2esdi_get_device_cfg(void)
452 {
453         u_short cmd_blk[TYPE_0_CMD_BLK_LENGTH];
454
455         /*BA */ printk("%s: Drive 0\n", DEVICE_NAME);
456         current_int_handler = ps2esdi_geometry_int_handler;
457         cmd_blk[0] = CMD_GET_DEV_CONFIG | 0x600;
458         cmd_blk[1] = 0;
459         no_int_yet = TRUE;
460         ps2esdi_out_cmd_blk(cmd_blk);
461         if (no_int_yet)
462                 sleep_on(&ps2esdi_int);
463
464         if (ps2esdi_drives > 1) {
465                 printk("%s: Drive 1\n", DEVICE_NAME);   /*BA */
466                 cmd_blk[0] = CMD_GET_DEV_CONFIG | (1 << 5) | 0x600;
467                 cmd_blk[1] = 0;
468                 no_int_yet = TRUE;
469                 ps2esdi_out_cmd_blk(cmd_blk);
470                 if (no_int_yet)
471                         sleep_on(&ps2esdi_int);
472         }                       /* if second physical drive is present */
473         return;
474 }
475
476 /* strategy routine that handles most of the IO requests */
477 static void do_ps2esdi_request(request_queue_t * q)
478 {
479         struct request *req;
480         /* since, this routine is called with interrupts cleared - they 
481            must be before it finishes  */
482
483         req = elv_next_request(q);
484         if (!req)
485                 return;
486
487 #if 0
488         printk("%s:got request. device : %s command : %d  sector : %ld count : %ld, buffer: %p\n",
489                DEVICE_NAME,
490                req->rq_disk->disk_name,
491                req->cmd, req->sector,
492                req->current_nr_sectors, req->buffer);
493 #endif
494
495         /* check for above 16Mb dmas */
496         if (isa_virt_to_bus(req->buffer + req->current_nr_sectors * 512) > 16 * MB) {
497                 printk("%s: DMA above 16MB not supported\n", DEVICE_NAME);
498                 end_request(req, FAIL);
499                 return;
500         }
501
502         if (req->sector+req->current_nr_sectors > get_capacity(req->rq_disk)) {
503                 printk("Grrr. error. ps2esdi_drives: %d, %llu %llu\n",
504                     ps2esdi_drives, req->sector,
505                     (unsigned long long)get_capacity(req->rq_disk));
506                 end_request(req, FAIL);
507                 return;
508         }
509
510         switch (rq_data_dir(req)) {
511         case READ:
512                 ps2esdi_readwrite(READ, req);
513                 break;
514         case WRITE:
515                 ps2esdi_readwrite(WRITE, req);
516                 break;
517         default:
518                 printk("%s: Unknown command\n", req->rq_disk->disk_name);
519                 end_request(req, FAIL);
520                 break;
521         }               /* handle different commands */
522 }                               /* main strategy routine */
523
524 /* resets the ESDI adapter */
525 static void reset_ctrl(void)
526 {
527
528         u_long expire;
529         u_short status;
530
531         /* enable interrupts on the controller */
532         status = inb(ESDI_INTRPT);
533         outb((status & 0xe0) | ATT_EOI, ESDI_ATTN);     /* to be sure we don't have
534                                                            any interrupt pending... */
535         outb_p(CTRL_ENABLE_INTR, ESDI_CONTROL);
536
537         /* read the ESDI status port - if the controller is not busy,
538            simply do a soft reset (fast) - otherwise we'll have to do a
539            hard (slow) reset.  */
540         if (!(inb_p(ESDI_STATUS) & STATUS_BUSY)) {
541                 /*BA */ printk("%s: soft reset...\n", DEVICE_NAME);
542                 outb_p(CTRL_SOFT_RESET, ESDI_ATTN);
543         }
544         /* soft reset */ 
545         else {
546                 /*BA */
547                 printk("%s: hard reset...\n", DEVICE_NAME);
548                 outb_p(CTRL_HARD_RESET, ESDI_CONTROL);
549                 expire = jiffies + 2*HZ;
550                 while (time_before(jiffies, expire));
551                 outb_p(1, ESDI_CONTROL);
552         }                       /* hard reset */
553
554
555 }                               /* reset the controller */
556
557 /* called by the strategy routine to handle read and write requests */
558 static void ps2esdi_readwrite(int cmd, struct request *req)
559 {
560         struct ps2esdi_i_struct *p = req->rq_disk->private_data;
561         unsigned block = req->sector;
562         unsigned count = req->current_nr_sectors;
563         int drive = p - ps2esdi_info;
564         u_short track, head, cylinder, sector;
565         u_short cmd_blk[TYPE_1_CMD_BLK_LENGTH];
566
567         /* do some relevant arithmatic */
568         track = block / p->sect;
569         head = track % p->head;
570         cylinder = track / p->head;
571         sector = block % p->sect;
572
573 #if 0
574         printk("%s: cyl=%d head=%d sect=%d\n", DEVICE_NAME, cylinder, head, sector);
575 #endif
576         /* call the routine that actually fills out a command block */
577         ps2esdi_fill_cmd_block
578             (cmd_blk,
579              (cmd == READ) ? CMD_READ : CMD_WRITE,
580              cylinder, head, sector, count, drive);
581
582         /* send the command block to the controller */
583         current_req = req;
584         spin_unlock_irq(&ps2esdi_lock);
585         if (ps2esdi_out_cmd_blk(cmd_blk)) {
586                 spin_lock_irq(&ps2esdi_lock);
587                 printk("%s: Controller failed\n", DEVICE_NAME);
588                 if ((++req->errors) >= MAX_RETRIES)
589                         end_request(req, FAIL);
590         }
591         /* check for failure to put out the command block */ 
592         else {
593                 spin_lock_irq(&ps2esdi_lock);
594 #if 0
595                 printk("%s: waiting for xfer\n", DEVICE_NAME);
596 #endif
597                 /* turn disk lights on */
598                 LITE_ON;
599         }
600
601 }                               /* ps2esdi_readwrite */
602
603 /* fill out the command block */
604 static void ps2esdi_fill_cmd_block(u_short * cmd_blk, u_short cmd,
605  u_short cyl, u_short head, u_short sector, u_short length, u_char drive)
606 {
607
608         cmd_blk[0] = (drive << 5) | cmd;
609         cmd_blk[1] = length;
610         cmd_blk[2] = ((cyl & 0x1f) << 11) | (head << 5) | sector;
611         cmd_blk[3] = (cyl & 0x3E0) >> 5;
612
613 }                               /* fill out the command block */
614
615 /* write a command block to the controller */
616 static int ps2esdi_out_cmd_blk(u_short * cmd_blk)
617 {
618
619         int i;
620         unsigned long jif;
621         u_char status;
622
623         /* enable interrupts */
624         outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
625
626         /* do not write to the controller, if it is busy */
627         for (jif = jiffies + ESDI_STAT_TIMEOUT;
628                 time_after(jif, jiffies) &&
629                         (inb(ESDI_STATUS) & STATUS_BUSY); )
630                 ;
631
632 #if 0
633         printk("%s: i(1)=%ld\n", DEVICE_NAME, jif);
634 #endif
635
636         /* if device is still busy - then just time out */
637         if (inb(ESDI_STATUS) & STATUS_BUSY) {
638                 printk("%s: ps2esdi_out_cmd timed out (1)\n", DEVICE_NAME);
639                 return ERROR;
640         }                       /* timeout ??? */
641         /* Set up the attention register in the controller */
642         outb(((*cmd_blk) & 0xE0) | 1, ESDI_ATTN);
643
644 #if 0
645         printk("%s: sending %d words to controller\n", DEVICE_NAME, (((*cmd_blk) >> 14) + 1) << 1);
646 #endif
647
648         /* one by one send each word out */
649         for (i = (((*cmd_blk) >> 14) + 1) << 1; i; i--) {
650                 status = inb(ESDI_STATUS);
651                 for (jif = jiffies + ESDI_STAT_TIMEOUT;
652                      time_after(jif, jiffies) && (status & STATUS_BUSY) &&
653                    (status & STATUS_CMD_INF); status = inb(ESDI_STATUS));
654                 if ((status & (STATUS_BUSY | STATUS_CMD_INF)) == STATUS_BUSY) {
655 #if 0
656                         printk("%s: sending %04X\n", DEVICE_NAME, *cmd_blk);
657 #endif
658                         outw(*cmd_blk++, ESDI_CMD_INT);
659                 } else {
660                         printk("%s: ps2esdi_out_cmd timed out while sending command (status=%02X)\n",
661                                DEVICE_NAME, status);
662                         return ERROR;
663                 }
664         }                       /* send all words out */
665         return OK;
666 }                               /* send out the commands */
667
668
669 /* prepare for dma - do all the necessary setup */
670 static void ps2esdi_prep_dma(char *buffer, u_short length, u_char dma_xmode)
671 {
672         unsigned long flags = claim_dma_lock();
673
674         mca_disable_dma(dma_arb_level);
675
676         mca_set_dma_addr(dma_arb_level, isa_virt_to_bus(buffer));
677
678         mca_set_dma_count(dma_arb_level, length * 512 / 2);
679
680         mca_set_dma_mode(dma_arb_level, dma_xmode);
681
682         mca_enable_dma(dma_arb_level);
683
684         release_dma_lock(flags);
685
686 }                               /* prepare for dma */
687
688
689
690 static irqreturn_t ps2esdi_interrupt_handler(int irq, void *dev_id,
691                                       struct pt_regs *regs)
692 {
693         u_int int_ret_code;
694
695         if (inb(ESDI_STATUS) & STATUS_INTR) {
696                 int_ret_code = inb(ESDI_INTRPT);
697                 if (current_int_handler) {
698                         /* Disable adapter interrupts till processing is finished */
699                         outb(CTRL_DISABLE_INTR, ESDI_CONTROL);
700                         current_int_handler(int_ret_code);
701                 } else
702                         printk("%s: help ! No interrupt handler.\n", DEVICE_NAME);
703         } else {
704                 return IRQ_NONE;
705         }
706         return IRQ_HANDLED;
707 }
708
709 static void ps2esdi_initial_reset_int_handler(u_int int_ret_code)
710 {
711
712         switch (int_ret_code & 0xf) {
713         case INT_RESET:
714                 /*BA */
715                 printk("%s: initial reset completed.\n", DEVICE_NAME);
716                 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
717                 wake_up(&ps2esdi_int);
718                 break;
719         case INT_ATTN_ERROR:
720                 printk("%s: Attention error. interrupt status : %02X\n", DEVICE_NAME,
721                        int_ret_code);
722                 printk("%s: status: %02x\n", DEVICE_NAME, inb(ESDI_STATUS));
723                 break;
724         default:
725                 printk("%s: initial reset handler received interrupt: %02X\n",
726                        DEVICE_NAME, int_ret_code);
727                 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
728                 break;
729         }
730         outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
731 }
732
733
734 static void ps2esdi_geometry_int_handler(u_int int_ret_code)
735 {
736         u_int status, drive_num;
737         unsigned long rba;
738         int i;
739
740         drive_num = int_ret_code >> 5;
741         switch (int_ret_code & 0xf) {
742         case INT_CMD_COMPLETE:
743                 for (i = ESDI_TIMEOUT; i && !(inb(ESDI_STATUS) & STATUS_STAT_AVAIL); i--);
744                 if (!(inb(ESDI_STATUS) & STATUS_STAT_AVAIL)) {
745                         printk("%s: timeout reading status word\n", DEVICE_NAME);
746                         outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
747                         break;
748                 }
749                 status = inw(ESDI_STT_INT);
750                 if ((status & 0x1F) == CMD_GET_DEV_CONFIG) {
751 #define REPLY_WORDS 5           /* we already read word 0 */
752                         u_short reply[REPLY_WORDS];
753
754                         if (ps2esdi_read_status_words((status >> 8) - 1, REPLY_WORDS, reply)) {
755                                 /*BA */
756                                 printk("%s: Device Configuration Status for drive %u\n",
757                                        DEVICE_NAME, drive_num);
758
759                                 printk("%s: Spares/cyls: %u", DEVICE_NAME, reply[0] >> 8);
760
761                                 printk
762                                     ("Config bits: %s%s%s%s%s\n",
763                                      (reply[0] & CONFIG_IS) ? "Invalid Secondary, " : "",
764                                      ((reply[0] & CONFIG_ZD) && !(reply[0] & CONFIG_IS))
765                                  ? "Zero Defect, " : "Defects Present, ",
766                                      (reply[0] & CONFIG_SF) ? "Skewed Format, " : "",
767                                      (reply[0] & CONFIG_FR) ? "Removable, " : "Non-Removable, ",
768                                      (reply[0] & CONFIG_RT) ? "No Retries" : "Retries");
769
770                                 rba = reply[1] | ((unsigned long) reply[2] << 16);
771                                 printk("%s: Number of RBA's: %lu\n", DEVICE_NAME, rba);
772
773                                 printk("%s: Physical number of cylinders: %u, Sectors/Track: %u, Heads: %u\n",
774                                        DEVICE_NAME, reply[3], reply[4] >> 8, reply[4] & 0xff);
775
776                                 if (!ps2esdi_info[drive_num].head) {
777                                         ps2esdi_info[drive_num].head = 64;
778                                         ps2esdi_info[drive_num].sect = 32;
779                                         ps2esdi_info[drive_num].cyl = rba / (64 * 32);
780                                         ps2esdi_info[drive_num].wpcom = 0;
781                                         ps2esdi_info[drive_num].lzone = ps2esdi_info[drive_num].cyl;
782                                         ps2esdi_info[drive_num].ctl = 8;
783                                         if (tp720esdi) {        /* store the retrieved parameters */
784                                                 ps2esdi_info[0].head = reply[4] & 0Xff;
785                                                 ps2esdi_info[0].sect = reply[4] >> 8;
786                                                 ps2esdi_info[0].cyl = reply[3];
787                                                 ps2esdi_info[0].wpcom = 0;
788                                                 ps2esdi_info[0].lzone = reply[3];
789                                         } else {
790                                                 if (!intg_esdi)
791                                                         ps2esdi_drives++;
792                                         }
793                                 }
794 #ifdef OBSOLETE
795                                 if (!ps2esdi_info[drive_num].head) {
796                                         ps2esdi_info[drive_num].head = reply[4] & 0Xff;
797                                         ps2esdi_info[drive_num].sect = reply[4] >> 8;
798                                         ps2esdi_info[drive_num].cyl = reply[3];
799                                         ps2esdi_info[drive_num].wpcom = 0;
800                                         ps2esdi_info[drive_num].lzone = reply[3];
801                                         if (tp720esdi) {        /* store the retrieved parameters */
802                                                 ps2esdi_info[0].head = reply[4] & 0Xff;
803                                                 ps2esdi_info[0].sect = reply[4] >> 8;
804                                                 ps2esdi_info[0].cyl = reply[3];
805                                                 ps2esdi_info[0].wpcom = 0;
806                                                 ps2esdi_info[0].lzone = reply[3];
807                                         } else {
808                                                 ps2esdi_drives++;
809                                         }
810                                 }
811 #endif
812
813                         } else
814                                 printk("%s: failed while getting device config\n", DEVICE_NAME);
815 #undef REPLY_WORDS
816                 } else
817                         printk("%s: command %02X unknown by geometry handler\n",
818                                DEVICE_NAME, status & 0x1f);
819
820                 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
821                 break;
822
823         case INT_ATTN_ERROR:
824                 printk("%s: Attention error. interrupt status : %02X\n", DEVICE_NAME,
825                        int_ret_code);
826                 printk("%s: Device not available\n", DEVICE_NAME);
827                 break;
828         case INT_CMD_ECC:
829         case INT_CMD_RETRY:
830         case INT_CMD_ECC_RETRY:
831         case INT_CMD_WARNING:
832         case INT_CMD_ABORT:
833         case INT_CMD_FAILED:
834         case INT_DMA_ERR:
835         case INT_CMD_BLK_ERR:
836                 /*BA */ printk("%s: Whaa. Error occurred...\n", DEVICE_NAME);
837                 dump_cmd_complete_status(int_ret_code);
838                 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
839                 break;
840         default:
841                 printk("%s: Unknown interrupt reason: %02X\n",
842                        DEVICE_NAME, int_ret_code & 0xf);
843                 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
844                 break;
845         }
846
847         wake_up(&ps2esdi_int);
848         no_int_yet = FALSE;
849         outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
850
851 }
852
853 static void ps2esdi_normal_interrupt_handler(u_int int_ret_code)
854 {
855         unsigned long flags;
856         u_int status;
857         u_int ending;
858         int i;
859
860         switch (int_ret_code & 0x0f) {
861         case INT_TRANSFER_REQ:
862                 ps2esdi_prep_dma(current_req->buffer,
863                                  current_req->current_nr_sectors,
864                     (rq_data_dir(current_req) == READ)
865                     ? MCA_DMA_MODE_16 | MCA_DMA_MODE_WRITE | MCA_DMA_MODE_XFER
866                     : MCA_DMA_MODE_16 | MCA_DMA_MODE_READ);
867                 outb(CTRL_ENABLE_DMA | CTRL_ENABLE_INTR, ESDI_CONTROL);
868                 ending = -1;
869                 break;
870
871         case INT_ATTN_ERROR:
872                 printk("%s: Attention error. interrupt status : %02X\n", DEVICE_NAME,
873                        int_ret_code);
874                 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
875                 ending = FAIL;
876                 break;
877
878         case INT_CMD_COMPLETE:
879                 for (i = ESDI_TIMEOUT; i && !(inb(ESDI_STATUS) & STATUS_STAT_AVAIL); i--);
880                 if (!(inb(ESDI_STATUS) & STATUS_STAT_AVAIL)) {
881                         printk("%s: timeout reading status word\n", DEVICE_NAME);
882                         outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
883                         outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
884                         if ((++current_req->errors) >= MAX_RETRIES)
885                                 ending = FAIL;
886                         else
887                                 ending = -1;
888                         break;
889                 }
890                 status = inw(ESDI_STT_INT);
891                 switch (status & 0x1F) {
892                 case (CMD_READ & 0xff):
893                 case (CMD_WRITE & 0xff):
894                         LITE_OFF;
895                         outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
896                         outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
897                         ending = SUCCES;
898                         break;
899                 default:
900                         printk("%s: interrupt for unknown command %02X\n",
901                                DEVICE_NAME, status & 0x1f);
902                         outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
903                         outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
904                         ending = -1;
905                         break;
906                 }
907                 break;
908         case INT_CMD_ECC:
909         case INT_CMD_RETRY:
910         case INT_CMD_ECC_RETRY:
911                 LITE_OFF;
912                 dump_cmd_complete_status(int_ret_code);
913                 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
914                 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
915                 ending = SUCCES;
916                 break;
917         case INT_CMD_WARNING:
918         case INT_CMD_ABORT:
919         case INT_CMD_FAILED:
920         case INT_DMA_ERR:
921                 LITE_OFF;
922                 dump_cmd_complete_status(int_ret_code);
923                 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
924                 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
925                 if ((++current_req->errors) >= MAX_RETRIES)
926                         ending = FAIL;
927                 else
928                         ending = -1;
929                 break;
930
931         case INT_CMD_BLK_ERR:
932                 dump_cmd_complete_status(int_ret_code);
933                 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
934                 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
935                 ending = FAIL;
936                 break;
937
938         case INT_CMD_FORMAT:
939                 printk("%s: huh ? Who issued this format command ?\n"
940                        ,DEVICE_NAME);
941                 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
942                 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
943                 ending = -1;
944                 break;
945
946         case INT_RESET:
947                 /* BA printk("%s: reset completed.\n", DEVICE_NAME) */ ;
948                 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
949                 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
950                 ending = -1;
951                 break;
952
953         default:
954                 printk("%s: Unknown interrupt reason: %02X\n",
955                        DEVICE_NAME, int_ret_code & 0xf);
956                 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
957                 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
958                 ending = -1;
959                 break;
960         }
961         if(ending != -1) {
962                 spin_lock_irqsave(&ps2esdi_lock, flags);
963                 end_request(current_req, ending);
964                 current_req = NULL;
965                 do_ps2esdi_request(ps2esdi_queue);
966                 spin_unlock_irqrestore(&ps2esdi_lock, flags);
967         }
968 }                               /* handle interrupts */
969
970
971
972 static int ps2esdi_read_status_words(int num_words,
973                                      int max_words,
974                                      u_short * buffer)
975 {
976         int i;
977
978         for (; max_words && num_words; max_words--, num_words--, buffer++) {
979                 for (i = ESDI_TIMEOUT; i && !(inb(ESDI_STATUS) & STATUS_STAT_AVAIL); i--);
980                 if (!(inb(ESDI_STATUS) & STATUS_STAT_AVAIL)) {
981                         printk("%s: timeout reading status word\n", DEVICE_NAME);
982                         return FAIL;
983                 }
984                 *buffer = inw(ESDI_STT_INT);
985         }
986         return SUCCES;
987 }
988
989
990
991
992 static void dump_cmd_complete_status(u_int int_ret_code)
993 {
994 #define WAIT_FOR_STATUS \
995   for(i=ESDI_TIMEOUT;i && !(inb(ESDI_STATUS) & STATUS_STAT_AVAIL);i--); \
996     if(!(inb(ESDI_STATUS) & STATUS_STAT_AVAIL)) { \
997     printk("%s: timeout reading status word\n",DEVICE_NAME); \
998     return; \
999     }
1000
1001         int i, word_count;
1002         u_short stat_word;
1003         u_long rba;
1004
1005         printk("%s: Device: %u, interrupt ID: %02X\n",
1006                DEVICE_NAME, int_ret_code >> 5,
1007                int_ret_code & 0xf);
1008
1009         WAIT_FOR_STATUS;
1010         stat_word = inw(ESDI_STT_INT);
1011         word_count = (stat_word >> 8) - 1;
1012         printk("%s: %u status words, command: %02X\n", DEVICE_NAME, word_count,
1013                stat_word & 0xff);
1014
1015         if (word_count--) {
1016                 WAIT_FOR_STATUS;
1017                 stat_word = inw(ESDI_STT_INT);
1018                 printk("%s: command status code: %02X, command error code: %02X\n",
1019                        DEVICE_NAME, stat_word >> 8, stat_word & 0xff);
1020         }
1021         if (word_count--) {
1022                 WAIT_FOR_STATUS;
1023                 stat_word = inw(ESDI_STT_INT);
1024                 printk("%s: device error code: %s%s%s%s%s,%02X\n", DEVICE_NAME,
1025                        (stat_word & 0x1000) ? "Ready, " : "Not Ready, ",
1026                   (stat_word & 0x0800) ? "Selected, " : "Not Selected, ",
1027                        (stat_word & 0x0400) ? "Write Fault, " : "",
1028                        (stat_word & 0x0200) ? "Track 0, " : "",
1029                 (stat_word & 0x0100) ? "Seek or command complete, " : "",
1030                        stat_word >> 8);
1031         }
1032         if (word_count--) {
1033                 WAIT_FOR_STATUS;
1034                 stat_word = inw(ESDI_STT_INT);
1035                 printk("%s: Blocks to do: %u", DEVICE_NAME, stat_word);
1036         }
1037         if (word_count -= 2) {
1038                 WAIT_FOR_STATUS;
1039                 rba = inw(ESDI_STT_INT);
1040                 WAIT_FOR_STATUS;
1041                 rba |= inw(ESDI_STT_INT) << 16;
1042                 printk(", Last Cyl: %u Head: %u Sector: %u\n",
1043                        (u_short) ((rba & 0x1ff80000) >> 11),
1044                  (u_short) ((rba & 0x7E0) >> 5), (u_short) (rba & 0x1f));
1045         } else
1046                 printk("\n");
1047
1048         if (word_count--) {
1049                 WAIT_FOR_STATUS;
1050                 stat_word = inw(ESDI_STT_INT);
1051                 printk("%s: Blocks required ECC: %u", DEVICE_NAME, stat_word);
1052         }
1053         printk("\n");
1054
1055 #undef WAIT_FOR_STATUS
1056
1057 }
1058
1059 static int ps2esdi_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1060 {
1061         struct ps2esdi_i_struct *p = bdev->bd_disk->private_data;
1062
1063         geo->heads = p->head;
1064         geo->sectors = p->sect;
1065         geo->cylinders = p->cyl;
1066         return 0;
1067 }
1068
1069 static void ps2esdi_reset_timer(unsigned long unused)
1070 {
1071
1072         int status;
1073
1074         status = inb(ESDI_INTRPT);
1075         if ((status & 0xf) == INT_RESET) {
1076                 outb((status & 0xe0) | ATT_EOI, ESDI_ATTN);
1077                 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
1078                 reset_status = 1;
1079         }
1080         wake_up(&ps2esdi_int);
1081 }