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