src/floppy.c

   1 // 16bit code to access floppy drives.
   2 //
   3 // Copyright (C) 2008,2009  Kevin O'Connor <kevin@koconnor.net>
   4 // Copyright (C) 2002  MandrakeSoft S.A.
   5 //
   6 // This file may be distributed under the terms of the GNU LGPLv3 license.
   7
   8 #include "types.h" // u8
   9 #include "disk.h" // DISK_RET_SUCCESS
  10 #include "config.h" // CONFIG_FLOPPY
  11 #include "biosvar.h" // SET_BDA
  12 #include "util.h" // irq_disable
  13 #include "cmos.h" // inb_cmos
  14 #include "pic.h" // eoi_pic1
  15 #include "bregs.h" // struct bregs
  16
  17 #define FLOPPY_SIZE_CODE 0x02 // 512 byte sectors
  18 #define FLOPPY_DATALEN 0xff   // Not used - because size code is 0x02
  19 #define FLOPPY_MOTOR_TICKS 37 // ~2 seconds
  20 #define FLOPPY_FILLBYTE 0xf6
  21 #define FLOPPY_GAPLEN 0x1B
  22 #define FLOPPY_FORMAT_GAPLEN 0x6c
  23
  24 // New diskette parameter table adding 3 parameters from IBM
  25 // Since no provisions are made for multiple drive types, most
  26 // values in this table are ignored.  I set parameters for 1.44M
  27 // floppy here
  28 struct floppy_ext_dbt_s diskette_param_table2 VAR16VISIBLE = {
  29     .dbt = {
  30         .specify1       = 0xAF, // step rate 12ms, head unload 240ms
  31         .specify2       = 0x02, // head load time 4ms, DMA used
  32         .shutoff_ticks  = FLOPPY_MOTOR_TICKS, // ~2 seconds
  33         .bps_code       = FLOPPY_SIZE_CODE,
  34         .sectors        = 18,
  35         .interblock_len = FLOPPY_GAPLEN,
  36         .data_len       = FLOPPY_DATALEN,
  37         .gap_len        = FLOPPY_FORMAT_GAPLEN,
  38         .fill_byte      = FLOPPY_FILLBYTE,
  39         .settle_time    = 0x0F, // 15ms
  40         .startup_time   = 0x08, // 1 second
  41     },
  42     .max_track      = 79,   // maximum track
  43     .data_rate      = 0,    // data transfer rate
  44     .drive_type     = 4,    // drive type in cmos
  45 };
  46
  47 // Since no provisions are made for multiple drive types, most
  48 // values in this table are ignored.  I set parameters for 1.44M
  49 // floppy here
  50 struct floppy_dbt_s diskette_param_table VAR16FIXED(0xefc7) = {
  51     .specify1       = 0xAF,
  52     .specify2       = 0x02,
  53     .shutoff_ticks  = FLOPPY_MOTOR_TICKS,
  54     .bps_code       = FLOPPY_SIZE_CODE,
  55     .sectors        = 18,
  56     .interblock_len = FLOPPY_GAPLEN,
  57     .data_len       = FLOPPY_DATALEN,
  58     .gap_len        = FLOPPY_FORMAT_GAPLEN,
  59     .fill_byte      = FLOPPY_FILLBYTE,
  60     .settle_time    = 0x0F,
  61     .startup_time   = 0x08,
  62 };
  63
  64 struct floppyinfo_s {
  65     struct chs_s chs;
  66     u8 config_data;
  67     u8 media_state;
  68 };
  69
  70 struct floppyinfo_s FloppyInfo[] VAR16VISIBLE = {
  71     // Unknown
  72     { {0, 0, 0}, 0x00, 0x00},
  73     // 1 - 360KB, 5.25" - 2 heads, 40 tracks, 9 sectors
  74     { {2, 40, 9}, 0x00, 0x25},
  75     // 2 - 1.2MB, 5.25" - 2 heads, 80 tracks, 15 sectors
  76     { {2, 80, 15}, 0x00, 0x25},
  77     // 3 - 720KB, 3.5"  - 2 heads, 80 tracks, 9 sectors
  78     { {2, 80, 9}, 0x00, 0x17},
  79     // 4 - 1.44MB, 3.5" - 2 heads, 80 tracks, 18 sectors
  80     { {2, 80, 18}, 0x00, 0x17},
  81     // 5 - 2.88MB, 3.5" - 2 heads, 80 tracks, 36 sectors
  82     { {2, 80, 36}, 0xCC, 0xD7},
  83     // 6 - 160k, 5.25"  - 1 heads, 40 tracks, 8 sectors
  84     { {1, 40, 8}, 0x00, 0x27},
  85     // 7 - 180k, 5.25"  - 1 heads, 40 tracks, 9 sectors
  86     { {1, 40, 9}, 0x00, 0x27},
  87     // 8 - 320k, 5.25"  - 2 heads, 40 tracks, 8 sectors
  88     { {2, 40, 8}, 0x00, 0x27},
  89 };
  90
  91 int
  92 addFloppy(int floppyid, int ftype, int driver)
  93 {
  94     if (ftype <= 0 || ftype >= ARRAY_SIZE(FloppyInfo)) {
  95         dprintf(1, "Bad floppy type %d\n", ftype);
  96         return -1;
  97     }
  98
  99     int driveid = Drives.drivecount;
 100     if (driveid >= ARRAY_SIZE(Drives.drives))
 101         return -1;
 102     Drives.drivecount++;
 103     memset(&Drives.drives[driveid], 0, sizeof(Drives.drives[0]));
 104     Drives.drives[driveid].cntl_id = floppyid;
 105     Drives.drives[driveid].type = driver;
 106     Drives.drives[driveid].blksize = DISK_SECTOR_SIZE;
 107     Drives.drives[driveid].floppy_type = ftype;
 108     Drives.drives[driveid].sectors = (u64)-1;
 109
 110     memcpy(&Drives.drives[driveid].lchs, &FloppyInfo[ftype].chs
 111            , sizeof(FloppyInfo[ftype].chs));
 112
 113     map_floppy_drive(driveid);
 114     return driveid;
 115 }
 116
 117 void
 118 describe_floppy(int driveid)
 119 {
 120     printf("drive %c", 'A' + Drives.drives[driveid].cntl_id);
 121 }
 122
 123 void
 124 floppy_setup()
 125 {
 126     if (! CONFIG_FLOPPY)
 127         return;
 128     dprintf(3, "init floppy drives\n");
 129
 130     if (CONFIG_COREBOOT) {
 131         // XXX - disable floppies on coreboot for now.
 132     } else {
 133         u8 type = inb_cmos(CMOS_FLOPPY_DRIVE_TYPE);
 134         if (type & 0xf0)
 135             addFloppy(0, type >> 4, DTYPE_FLOPPY);
 136         if (type & 0x0f)
 137             addFloppy(1, type & 0x0f, DTYPE_FLOPPY);
 138     }
 139
 140     outb(0x02, PORT_DMA1_MASK_REG);
 141
 142     enable_hwirq(6, entry_0e);
 143 }
 144
 145 // Find a floppy type that matches a given image size.
 146 int
 147 find_floppy_type(u32 size)
 148 {
 149     int i;
 150     for (i=1; i<ARRAY_SIZE(FloppyInfo); i++) {
 151         struct chs_s *c = &FloppyInfo[i].chs;
 152         if (c->cylinders * c->heads * c->spt * DISK_SECTOR_SIZE == size)
 153             return i;
 154     }
 155     return -1;
 156 }
 157
 158
 159 /****************************************************************
 160  * Low-level floppy IO
 161  ****************************************************************/
 162
 163 static void
 164 floppy_reset_controller()
 165 {
 166     // Reset controller
 167     u8 val8 = inb(PORT_FD_DOR);
 168     outb(val8 & ~0x04, PORT_FD_DOR);
 169     outb(val8 | 0x04, PORT_FD_DOR);
 170
 171     // Wait for controller to come out of reset
 172     while ((inb(PORT_FD_STATUS) & 0xc0) != 0x80)
 173         ;
 174 }
 175
 176 static int
 177 wait_floppy_irq()
 178 {
 179     u8 v;
 180     for (;;) {
 181         if (!GET_BDA(floppy_motor_counter)) {
 182             irq_disable();
 183             return -1;
 184         }
 185         v = GET_BDA(floppy_recalibration_status);
 186         if (v & FRS_TIMEOUT)
 187             break;
 188         wait_irq();
 189     }
 190
 191     v &= ~FRS_TIMEOUT;
 192     SET_BDA(floppy_recalibration_status, v);
 193     return 0;
 194 }
 195
 196 static void
 197 floppy_prepare_controller(u8 floppyid)
 198 {
 199     CLEARBITS_BDA(floppy_recalibration_status, FRS_TIMEOUT);
 200
 201     // turn on motor of selected drive, DMA & int enabled, normal operation
 202     u8 prev_reset = inb(PORT_FD_DOR) & 0x04;
 203     u8 dor = 0x10;
 204     if (floppyid)
 205         dor = 0x20;
 206     dor |= 0x0c;
 207     dor |= floppyid;
 208     outb(dor, PORT_FD_DOR);
 209
 210     // reset the disk motor timeout value of INT 08
 211     SET_BDA(floppy_motor_counter, FLOPPY_MOTOR_TICKS);
 212
 213     // wait for drive readiness
 214     while ((inb(PORT_FD_STATUS) & 0xc0) != 0x80)
 215         ;
 216
 217     if (!prev_reset)
 218         wait_floppy_irq();
 219 }
 220
 221 static int
 222 floppy_pio(u8 *cmd, u8 cmdlen)
 223 {
 224     floppy_prepare_controller(cmd[1] & 1);
 225
 226     // send command to controller
 227     u8 i;
 228     for (i=0; i<cmdlen; i++)
 229         outb(cmd[i], PORT_FD_DATA);
 230
 231     int ret = wait_floppy_irq();
 232     if (ret) {
 233         floppy_reset_controller();
 234         return -1;
 235     }
 236
 237     return 0;
 238 }
 239
 240 static int
 241 floppy_cmd(struct disk_op_s *op, u16 count, u8 *cmd, u8 cmdlen)
 242 {
 243     // es:bx = pointer to where to place information from diskette
 244     u32 addr = (u32)op->buf_fl;
 245
 246     // check for 64K boundary overrun
 247     u16 end = count - 1;
 248     u32 last_addr = addr + end;
 249     if ((addr >> 16) != (last_addr >> 16))
 250         return DISK_RET_EBOUNDARY;
 251
 252     u8 mode_register = 0x4a; // single mode, increment, autoinit disable,
 253     if (cmd[0] == 0xe6)
 254         // read
 255         mode_register = 0x46;
 256
 257     //DEBUGF("floppy dma c2\n");
 258     outb(0x06, PORT_DMA1_MASK_REG);
 259     outb(0x00, PORT_DMA1_CLEAR_FF_REG); // clear flip-flop
 260     outb(addr, PORT_DMA_ADDR_2);
 261     outb(addr>>8, PORT_DMA_ADDR_2);
 262     outb(0x00, PORT_DMA1_CLEAR_FF_REG); // clear flip-flop
 263     outb(end, PORT_DMA_CNT_2);
 264     outb(end>>8, PORT_DMA_CNT_2);
 265
 266     // port 0b: DMA-1 Mode Register
 267     // transfer type=write, channel 2
 268     outb(mode_register, PORT_DMA1_MODE_REG);
 269
 270     // port 81: DMA-1 Page Register, channel 2
 271     outb(addr>>16, PORT_DMA_PAGE_2);
 272
 273     outb(0x02, PORT_DMA1_MASK_REG); // unmask channel 2
 274
 275     int ret = floppy_pio(cmd, cmdlen);
 276     if (ret)
 277         return DISK_RET_ETIMEOUT;
 278
 279     // check port 3f4 for accessibility to status bytes
 280     if ((inb(PORT_FD_STATUS) & 0xc0) != 0xc0)
 281         return DISK_RET_ECONTROLLER;
 282
 283     // read 7 return status bytes from controller
 284     u8 i;
 285     for (i=0; i<7; i++) {
 286         u8 v = inb(PORT_FD_DATA);
 287         cmd[i] = v;
 288         SET_BDA(floppy_return_status[i], v);
 289     }
 290
 291     return DISK_RET_SUCCESS;
 292 }
 293
 294
 295 /****************************************************************
 296  * Floppy media sense
 297  ****************************************************************/
 298
 299 static inline void
 300 set_diskette_current_cyl(u8 floppyid, u8 cyl)
 301 {
 302     SET_BDA(floppy_track[floppyid], cyl);
 303 }
 304
 305 static void
 306 floppy_drive_recal(u8 floppyid)
 307 {
 308     // send Recalibrate command (2 bytes) to controller
 309     u8 data[12];
 310     data[0] = 0x07;  // 07: Recalibrate
 311     data[1] = floppyid; // 0=drive0, 1=drive1
 312     floppy_pio(data, 2);
 313
 314     SETBITS_BDA(floppy_recalibration_status, 1<<floppyid);
 315     set_diskette_current_cyl(floppyid, 0);
 316 }
 317
 318 static int
 319 floppy_media_sense(u8 driveid)
 320 {
 321     // for now cheat and get drive type from CMOS,
 322     // assume media is same as drive type
 323
 324     // ** config_data **
 325     // Bitfields for diskette media control:
 326     // Bit(s)  Description (Table M0028)
 327     //  7-6  last data rate set by controller
 328     //        00=500kbps, 01=300kbps, 10=250kbps, 11=1Mbps
 329     //  5-4  last diskette drive step rate selected
 330     //        00=0Ch, 01=0Dh, 10=0Eh, 11=0Ah
 331     //  3-2  {data rate at start of operation}
 332     //  1-0  reserved
 333
 334     // ** media_state **
 335     // Bitfields for diskette drive media state:
 336     // Bit(s)  Description (Table M0030)
 337     //  7-6  data rate
 338     //    00=500kbps, 01=300kbps, 10=250kbps, 11=1Mbps
 339     //  5  double stepping required (e.g. 360kB in 1.2MB)
 340     //  4  media type established
 341     //  3  drive capable of supporting 4MB media
 342     //  2-0  on exit from BIOS, contains
 343     //    000 trying 360kB in 360kB
 344     //    001 trying 360kB in 1.2MB
 345     //    010 trying 1.2MB in 1.2MB
 346     //    011 360kB in 360kB established
 347     //    100 360kB in 1.2MB established
 348     //    101 1.2MB in 1.2MB established
 349     //    110 reserved
 350     //    111 all other formats/drives
 351
 352     u8 ftype = GET_GLOBAL(Drives.drives[driveid].floppy_type);
 353     SET_BDA(floppy_last_data_rate, GET_GLOBAL(FloppyInfo[ftype].config_data));
 354     u8 floppyid = GET_GLOBAL(Drives.drives[driveid].cntl_id);
 355     SET_BDA(floppy_media_state[floppyid]
 356             , GET_GLOBAL(FloppyInfo[ftype].media_state));
 357     return DISK_RET_SUCCESS;
 358 }
 359
 360 static int
 361 check_recal_drive(u8 driveid)
 362 {
 363     u8 floppyid = GET_GLOBAL(Drives.drives[driveid].cntl_id);
 364     if ((GET_BDA(floppy_recalibration_status) & (1<<floppyid))
 365         && (GET_BDA(floppy_media_state[floppyid]) & FMS_MEDIA_DRIVE_ESTABLISHED))
 366         // Media is known.
 367         return DISK_RET_SUCCESS;
 368
 369     // Recalibrate drive.
 370     floppy_drive_recal(floppyid);
 371
 372     // Sense media.
 373     return floppy_media_sense(driveid);
 374 }
 375
 376
 377 /****************************************************************
 378  * Floppy handlers
 379  ****************************************************************/
 380
 381 static void
 382 lba2chs(struct disk_op_s *op, u8 *track, u8 *sector, u8 *head)
 383 {
 384     u32 lba = op->lba;
 385     u8 driveid = op->driveid;
 386
 387     u32 tmp = lba + 1;
 388     u16 nlspt = GET_GLOBAL(Drives.drives[driveid].lchs.spt);
 389     *sector = tmp % nlspt;
 390
 391     tmp /= nlspt;
 392     u16 nlh = GET_GLOBAL(Drives.drives[driveid].lchs.heads);
 393     *head = tmp % nlh;
 394
 395     tmp /= nlh;
 396     *track = tmp;
 397 }
 398
 399 // diskette controller reset
 400 static int
 401 floppy_reset(struct disk_op_s *op)
 402 {
 403     u8 floppyid = GET_GLOBAL(Drives.drives[op->driveid].cntl_id);
 404     set_diskette_current_cyl(floppyid, 0); // current cylinder
 405     return DISK_RET_SUCCESS;
 406 }
 407
 408 // Read Diskette Sectors
 409 static int
 410 floppy_read(struct disk_op_s *op)
 411 {
 412     int res = check_recal_drive(op->driveid);
 413     if (res)
 414         goto fail;
 415
 416     u8 track, sector, head;
 417     lba2chs(op, &track, &sector, &head);
 418
 419     // send read-normal-data command (9 bytes) to controller
 420     u8 floppyid = GET_GLOBAL(Drives.drives[op->driveid].cntl_id);
 421     u8 data[12];
 422     data[0] = 0xe6; // e6: read normal data
 423     data[1] = (head << 2) | floppyid; // HD DR1 DR2
 424     data[2] = track;
 425     data[3] = head;
 426     data[4] = sector;
 427     data[5] = FLOPPY_SIZE_CODE;
 428     data[6] = sector + op->count - 1; // last sector to read on track
 429     data[7] = FLOPPY_GAPLEN;
 430     data[8] = FLOPPY_DATALEN;
 431
 432     res = floppy_cmd(op, op->count * DISK_SECTOR_SIZE, data, 9);
 433     if (res)
 434         goto fail;
 435
 436     if (data[0] & 0xc0) {
 437         res = DISK_RET_ECONTROLLER;
 438         goto fail;
 439     }
 440
 441     // ??? should track be new val from return_status[3] ?
 442     set_diskette_current_cyl(floppyid, track);
 443     return DISK_RET_SUCCESS;
 444 fail:
 445     op->count = 0; // no sectors read
 446     return res;
 447 }
 448
 449 // Write Diskette Sectors
 450 static int
 451 floppy_write(struct disk_op_s *op)
 452 {
 453     int res = check_recal_drive(op->driveid);
 454     if (res)
 455         goto fail;
 456
 457     u8 track, sector, head;
 458     lba2chs(op, &track, &sector, &head);
 459
 460     // send write-normal-data command (9 bytes) to controller
 461     u8 floppyid = GET_GLOBAL(Drives.drives[op->driveid].cntl_id);
 462     u8 data[12];
 463     data[0] = 0xc5; // c5: write normal data
 464     data[1] = (head << 2) | floppyid; // HD DR1 DR2
 465     data[2] = track;
 466     data[3] = head;
 467     data[4] = sector;
 468     data[5] = FLOPPY_SIZE_CODE;
 469     data[6] = sector + op->count - 1; // last sector to write on track
 470     data[7] = FLOPPY_GAPLEN;
 471     data[8] = FLOPPY_DATALEN;
 472
 473     res = floppy_cmd(op, op->count * DISK_SECTOR_SIZE, data, 9);
 474     if (res)
 475         goto fail;
 476
 477     if (data[0] & 0xc0) {
 478         if (data[1] & 0x02)
 479             res = DISK_RET_EWRITEPROTECT;
 480         else
 481             res = DISK_RET_ECONTROLLER;
 482         goto fail;
 483     }
 484
 485     // ??? should track be new val from return_status[3] ?
 486     set_diskette_current_cyl(floppyid, track);
 487     return DISK_RET_SUCCESS;
 488 fail:
 489     op->count = 0; // no sectors read
 490     return res;
 491 }
 492
 493 // Verify Diskette Sectors
 494 static int
 495 floppy_verify(struct disk_op_s *op)
 496 {
 497     int res = check_recal_drive(op->driveid);
 498     if (res)
 499         goto fail;
 500
 501     u8 track, sector, head;
 502     lba2chs(op, &track, &sector, &head);
 503
 504     // ??? should track be new val from return_status[3] ?
 505     u8 floppyid = GET_GLOBAL(Drives.drives[op->driveid].cntl_id);
 506     set_diskette_current_cyl(floppyid, track);
 507     return DISK_RET_SUCCESS;
 508 fail:
 509     op->count = 0; // no sectors read
 510     return res;
 511 }
 512
 513 // format diskette track
 514 static int
 515 floppy_format(struct disk_op_s *op)
 516 {
 517     int ret = check_recal_drive(op->driveid);
 518     if (ret)
 519         return ret;
 520
 521     u8 head = op->lba;
 522
 523     // send format-track command (6 bytes) to controller
 524     u8 floppyid = GET_GLOBAL(Drives.drives[op->driveid].cntl_id);
 525     u8 data[12];
 526     data[0] = 0x4d; // 4d: format track
 527     data[1] = (head << 2) | floppyid; // HD DR1 DR2
 528     data[2] = FLOPPY_SIZE_CODE;
 529     data[3] = op->count; // number of sectors per track
 530     data[4] = FLOPPY_FORMAT_GAPLEN;
 531     data[5] = FLOPPY_FILLBYTE;
 532
 533     ret = floppy_cmd(op, op->count * 4, data, 6);
 534     if (ret)
 535         return ret;
 536
 537     if (data[0] & 0xc0) {
 538         if (data[1] & 0x02)
 539             return DISK_RET_EWRITEPROTECT;
 540         return DISK_RET_ECONTROLLER;
 541     }
 542
 543     set_diskette_current_cyl(floppyid, 0);
 544     return DISK_RET_SUCCESS;
 545 }
 546
 547 int
 548 process_floppy_op(struct disk_op_s *op)
 549 {
 550     if (!CONFIG_FLOPPY)
 551         return 0;
 552
 553     switch (op->command) {
 554     case CMD_RESET:
 555         return floppy_reset(op);
 556     case CMD_READ:
 557         return floppy_read(op);
 558     case CMD_WRITE:
 559         return floppy_write(op);
 560     case CMD_VERIFY:
 561         return floppy_verify(op);
 562     case CMD_FORMAT:
 563         return floppy_format(op);
 564     default:
 565         op->count = 0;
 566         return DISK_RET_EPARAM;
 567     }
 568 }
 569
 570
 571 /****************************************************************
 572  * HW irqs
 573  ****************************************************************/
 574
 575 // INT 0Eh Diskette Hardware ISR Entry Point
 576 void VISIBLE16
 577 handle_0e()
 578 {
 579     debug_isr(DEBUG_ISR_0e);
 580     if (! CONFIG_FLOPPY)
 581         goto done;
 582
 583     if ((inb(PORT_FD_STATUS) & 0xc0) != 0xc0) {
 584         outb(0x08, PORT_FD_DATA); // sense interrupt status
 585         while ((inb(PORT_FD_STATUS) & 0xc0) != 0xc0)
 586             ;
 587         do {
 588             inb(PORT_FD_DATA);
 589         } while ((inb(PORT_FD_STATUS) & 0xc0) == 0xc0);
 590     }
 591     // diskette interrupt has occurred
 592     SETBITS_BDA(floppy_recalibration_status, FRS_TIMEOUT);
 593
 594 done:
 595     eoi_pic1();
 596 }
 597
 598 // Called from int08 handler.
 599 void
 600 floppy_tick()
 601 {
 602     if (! CONFIG_FLOPPY)
 603         return;
 604
 605     // time to turn off drive(s)?
 606     u8 fcount = GET_BDA(floppy_motor_counter);
 607     if (fcount) {
 608         fcount--;
 609         SET_BDA(floppy_motor_counter, fcount);
 610         if (fcount == 0)
 611             // turn motor(s) off
 612             outb(inb(PORT_FD_DOR) & 0xcf, PORT_FD_DOR);
 613     }
 614 }