1 /* This file contains the device dependent part of the driver for the Floppy 2 * Disk Controller (FDC) using the NEC PD765 chip. 3 * 4 * The file contains two entry points: 5 * 6 * floppy_task: main entry when system is brought up 7 * 8 * Changes: 9 * Sep 11, 2005 code cleanup (Andy Tanenbaum) 10 * Dec 01, 2004 floppy driver moved to user-space (Jorrit N. Herder) 11 * Sep 15, 2004 sync alarms/ local timer management (Jorrit N. Herder) 12 * Aug 12, 2003 null seek no interrupt fix (Mike Haertel) 13 * May 14, 2000 d-d/i rewrite (Kees J. Bot) 14 * Apr 04, 1992 device dependent/independent split (Kees J. Bot) 15 * Mar 27, 1992 last details on density checking (Kees J. Bot) 16 * Feb 14, 1992 check drive density on opens only (Andy Tanenbaum) 17 * 1991 len[] / motors / reset / step rate / ... (Bruce Evans) 18 * May 13, 1991 renovated the errors loop (Don Chapman) 19 * 1989 I/O vector to keep up with 1-1 interleave (Bruce Evans) 20 * Jan 06, 1988 allow 1.44 MB diskettes (Al Crew) 21 * Nov 28, 1986 better resetting for 386 (Peter Kay) 22 * Oct 27, 1986 fdc_results fixed for 8 MHz (Jakob Schripsema) 23 */ 24 25 #include "floppy.h" 26 #include <minix/timers.h> 27 #include <machine/diskparm.h> 28 #include <minix/sysutil.h> 29 #include <minix/syslib.h> 30 #include <minix/endpoint.h> 31 #include <stdio.h> 32 33 /* I/O Ports used by floppy disk task. */ 34 #define DOR 0x3F2 /* motor drive control bits */ 35 #define FDC_STATUS 0x3F4 /* floppy disk controller status register */ 36 #define FDC_DATA 0x3F5 /* floppy disk controller data register */ 37 #define FDC_RATE 0x3F7 /* transfer rate register */ 38 #define DMA_ADDR 0x004 /* port for low 16 bits of DMA address */ 39 #define DMA_TOP 0x081 /* port for top 8 bits of 24-bit DMA addr */ 40 #define DMA_COUNT 0x005 /* port for DMA count (count = bytes - 1) */ 41 #define DMA_FLIPFLOP 0x00C /* DMA byte pointer flip-flop */ 42 #define DMA_MODE 0x00B /* DMA mode port */ 43 #define DMA_INIT 0x00A /* DMA init port */ 44 #define DMA_RESET_VAL 0x006 45 46 #define DMA_ADDR_MASK 0xFFFFFF /* mask to verify DMA address is 24-bit */ 47 48 /* Status registers returned as result of operation. */ 49 #define ST0 0x00 /* status register 0 */ 50 #define ST1 0x01 /* status register 1 */ 51 #define ST2 0x02 /* status register 2 */ 52 #define ST3 0x00 /* status register 3 (return by DRIVE_SENSE) */ 53 #define ST_CYL 0x03 /* slot where controller reports cylinder */ 54 #define ST_HEAD 0x04 /* slot where controller reports head */ 55 #define ST_SEC 0x05 /* slot where controller reports sector */ 56 #define ST_PCN 0x01 /* slot where controller reports present cyl */ 57 58 /* Fields within the I/O ports. */ 59 /* Main status register. */ 60 #define CTL_BUSY 0x10 /* bit is set when read or write in progress */ 61 #define DIRECTION 0x40 /* bit is set when reading data reg is valid */ 62 #define MASTER 0x80 /* bit is set when data reg can be accessed */ 63 64 /* Digital output port (DOR). */ 65 #define MOTOR_SHIFT 4 /* high 4 bits control the motors in DOR */ 66 #define ENABLE_INT 0x0C /* used for setting DOR port */ 67 68 /* ST0. */ 69 #define ST0_BITS_TRANS 0xD8 /* check 4 bits of status */ 70 #define TRANS_ST0 0x00 /* 4 bits of ST0 for READ/WRITE */ 71 #define ST0_BITS_SEEK 0xF8 /* check top 5 bits of seek status */ 72 #define SEEK_ST0 0x20 /* top 5 bits of ST0 for SEEK */ 73 74 /* ST1. */ 75 #define BAD_SECTOR 0x05 /* if these bits are set in ST1, recalibrate */ 76 #define WRITE_PROTECT 0x02 /* bit is set if diskette is write protected */ 77 78 /* ST2. */ 79 #define BAD_CYL 0x1F /* if any of these bits are set, recalibrate */ 80 81 /* ST3 (not used). */ 82 #define ST3_FAULT 0x80 /* if this bit is set, drive is sick */ 83 #define ST3_WR_PROTECT 0x40 /* set when diskette is write protected */ 84 #define ST3_READY 0x20 /* set when drive is ready */ 85 86 /* Floppy disk controller command bytes. */ 87 #define FDC_SEEK 0x0F /* command the drive to seek */ 88 #define FDC_READ 0xE6 /* command the drive to read */ 89 #define FDC_WRITE 0xC5 /* command the drive to write */ 90 #define FDC_SENSE 0x08 /* command the controller to tell its status */ 91 #define FDC_RECALIBRATE 0x07 /* command the drive to go to cyl 0 */ 92 #define FDC_SPECIFY 0x03 /* command the drive to accept params */ 93 #define FDC_READ_ID 0x4A /* command the drive to read sector identity */ 94 #define FDC_FORMAT 0x4D /* command the drive to format a track */ 95 96 /* DMA channel commands. */ 97 #define DMA_READ 0x46 /* DMA read opcode */ 98 #define DMA_WRITE 0x4A /* DMA write opcode */ 99 100 /* Parameters for the disk drive. */ 101 #define HC_SIZE 2880 /* # sectors on largest legal disk (1.44MB) */ 102 #define NR_HEADS 0x02 /* two heads (i.e., two tracks/cylinder) */ 103 #define MAX_SECTORS 18 /* largest # sectors per track */ 104 #define DTL 0xFF /* determines data length (sector size) */ 105 #define SPEC2 0x02 /* second parameter to SPECIFY */ 106 #define MOTOR_OFF (3*system_hz) /* how long to wait before stopping motor */ 107 #define WAKEUP (2*system_hz) /* timeout on I/O, FDC won't quit. */ 108 109 /* Error codes */ 110 #define ERR_SEEK (-1) /* bad seek */ 111 #define ERR_TRANSFER (-2) /* bad transfer */ 112 #define ERR_STATUS (-3) /* something wrong when getting status */ 113 #define ERR_READ_ID (-4) /* bad read id */ 114 #define ERR_RECALIBRATE (-5) /* recalibrate didn't work properly */ 115 #define ERR_DRIVE (-6) /* something wrong with a drive */ 116 #define ERR_WR_PROTECT (-7) /* diskette is write protected */ 117 #define ERR_TIMEOUT (-8) /* interrupt timeout */ 118 119 /* No retries on some errors. */ 120 #define err_no_retry(err) ((err) <= ERR_WR_PROTECT) 121 122 /* Encoding of drive type in minor device number. */ 123 #define DEV_TYPE_BITS 0x7C /* drive type + 1, if nonzero */ 124 #define DEV_TYPE_SHIFT 2 /* right shift to normalize type bits */ 125 #define FORMAT_DEV_BIT 0x80 /* bit in minor to turn write into format */ 126 127 /* Miscellaneous. */ 128 #define MAX_ERRORS 6 /* how often to try rd/wt before quitting */ 129 #define MAX_RESULTS 7 /* max number of bytes controller returns */ 130 #define NR_DRIVES 2 /* maximum number of drives */ 131 #define DIVISOR 128 /* used for sector size encoding */ 132 #define SECTOR_SIZE_CODE 2 /* code to say "512" to the controller */ 133 #define TIMEOUT_MICROS 5000000L /* microseconds waiting for FDC */ 134 #define NT 7 /* number of diskette/drive combinations */ 135 #define UNCALIBRATED 0 /* drive needs to be calibrated at next use */ 136 #define CALIBRATED 1 /* no calibration needed */ 137 #define BASE_SECTOR 1 /* sectors are numbered starting at 1 */ 138 #define NO_SECTOR ((unsigned) -1) /* current sector unknown */ 139 #define NO_CYL (-1) /* current cylinder unknown, must seek */ 140 #define NO_DENS 100 /* current media unknown */ 141 #define BSY_IDLE 0 /* busy doing nothing */ 142 #define BSY_IO 1 /* busy doing I/O */ 143 #define BSY_WAKEN 2 /* got a wakeup call */ 144 145 /* Seven combinations of diskette/drive are supported. 146 * 147 * # Diskette Drive Sectors Tracks Rotation Data-rate Comment 148 * 0 360K 360K 9 40 300 RPM 250 kbps Standard PC DSDD 149 * 1 1.2M 1.2M 15 80 360 RPM 500 kbps AT disk in AT drive 150 * 2 360K 720K 9 40 300 RPM 250 kbps Quad density PC 151 * 3 720K 720K 9 80 300 RPM 250 kbps Toshiba, et al. 152 * 4 360K 1.2M 9 40 360 RPM 300 kbps PC disk in AT drive 153 * 5 720K 1.2M 9 80 360 RPM 300 kbps Toshiba in AT drive 154 * 6 1.44M 1.44M 18 80 300 RPM 500 kbps PS/2, et al. 155 * 156 * In addition, 720K diskettes can be read in 1.44MB drives, but that does 157 * not need a different set of parameters. This combination uses 158 * 159 * 3 720K 1.44M 9 80 300 RPM 250 kbps PS/2, et al. 160 */ 161 static struct density { 162 u8_t secpt; /* sectors per track */ 163 u8_t cyls; /* tracks per side */ 164 u8_t steps; /* steps per cylinder (2 = double step) */ 165 u8_t test; /* sector to try for density test */ 166 u8_t rate; /* data rate (2=250, 1=300, 0=500 kbps) */ 167 clock_t start_ms; /* motor start (milliseconds) */ 168 u8_t gap; /* gap size */ 169 u8_t spec1; /* first specify byte (SRT/HUT) */ 170 } fdensity[NT] = { 171 { 9, 40, 1, 4*9, 2, 500, 0x2A, 0xDF }, /* 360K / 360K */ 172 { 15, 80, 1, 14, 0, 500, 0x1B, 0xDF }, /* 1.2M / 1.2M */ 173 { 9, 40, 2, 2*9, 2, 500, 0x2A, 0xDF }, /* 360K / 720K */ 174 { 9, 80, 1, 4*9, 2, 750, 0x2A, 0xDF }, /* 720K / 720K */ 175 { 9, 40, 2, 2*9, 1, 500, 0x23, 0xDF }, /* 360K / 1.2M */ 176 { 9, 80, 1, 4*9, 1, 500, 0x23, 0xDF }, /* 720K / 1.2M */ 177 { 18, 80, 1, 17, 0, 750, 0x1B, 0xCF }, /* 1.44M / 1.44M */ 178 }; 179 180 /* The following table is used with the test_sector array to recognize a 181 * drive/floppy combination. The sector to test has been determined by 182 * looking at the differences in gap size, sectors/track, and double stepping. 183 * This means that types 0 and 3 can't be told apart, only the motor start 184 * time differs. If a read test succeeds then the drive is limited to the 185 * set of densities it can support to avoid unnecessary tests in the future. 186 */ 187 188 #define b(d) (1 << (d)) /* bit for density d. */ 189 190 static struct test_order { 191 u8_t t_density; /* floppy/drive type */ 192 u8_t t_class; /* limit drive to this class of densities */ 193 } test_order[NT-1] = { 194 { 6, b(3) | b(6) }, /* 1.44M {720K, 1.44M} */ 195 { 1, b(1) | b(4) | b(5) }, /* 1.2M {1.2M, 360K, 720K} */ 196 { 3, b(2) | b(3) | b(6) }, /* 720K {360K, 720K, 1.44M} */ 197 { 4, b(1) | b(4) | b(5) }, /* 360K {1.2M, 360K, 720K} */ 198 { 5, b(1) | b(4) | b(5) }, /* 720K {1.2M, 360K, 720K} */ 199 { 2, b(2) | b(3) }, /* 360K {360K, 720K} */ 200 /* Note that type 0 is missing, type 3 can read/write it too, which is 201 * why the type 3 parameters have been pessimized to be like type 0. 202 */ 203 }; 204 205 /* Variables. */ 206 static struct floppy { /* main drive struct, one entry per drive */ 207 unsigned fl_curcyl; /* current cylinder */ 208 unsigned fl_hardcyl; /* hardware cylinder, as opposed to: */ 209 unsigned fl_cylinder; /* cylinder number addressed */ 210 unsigned fl_sector; /* sector addressed */ 211 unsigned fl_head; /* head number addressed */ 212 char fl_calibration; /* CALIBRATED or UNCALIBRATED */ 213 u8_t fl_density; /* NO_DENS = ?, 0 = 360K; 1 = 360K/1.2M; etc.*/ 214 u8_t fl_class; /* bitmap for possible densities */ 215 minix_timer_t fl_tmr_stop; /* timer to stop motor */ 216 struct device fl_geom; /* Geometry of the drive */ 217 struct device fl_part[NR_PARTITIONS]; /* partition's base & size */ 218 } floppy[NR_DRIVES]; 219 220 static int irq_hook_id; /* id of irq hook at the kernel */ 221 int motor_status; /* bitmap of current motor status */ 222 static int need_reset; /* set to 1 when controller must be reset */ 223 unsigned f_drive; /* selected drive */ 224 static unsigned f_device; /* selected minor device */ 225 static struct floppy *f_fp; /* current drive */ 226 static struct density *f_dp; /* current density parameters */ 227 static struct density *prev_dp;/* previous density parameters */ 228 static unsigned f_sectors; /* equal to f_dp->secpt (needed a lot) */ 229 u16_t f_busy; /* BSY_IDLE, BSY_IO, BSY_WAKEN */ 230 static struct device *f_dv; /* device's base and size */ 231 static struct disk_parameter_s fmt_param; /* parameters for format */ 232 static u8_t f_results[MAX_RESULTS];/* the controller can give lots of output */ 233 234 /* The floppy uses various timers. These are managed by the floppy driver 235 * itself, because only a single synchronous alarm is available per process. 236 * Besides the 'f_tmr_timeout' timer below, the floppy structure for each 237 * floppy disk drive contains a 'fl_tmr_stop' timer. 238 */ 239 static minix_timer_t f_tmr_timeout; /* timer for various timeouts */ 240 static u32_t system_hz; /* system clock frequency */ 241 static void f_expire_tmrs(clock_t stamp); 242 static void stop_motor(int arg); 243 static void f_timeout(int arg); 244 245 static struct device *f_prepare(devminor_t device); 246 static struct device *f_part(devminor_t minor); 247 static void f_cleanup(void); 248 static ssize_t f_transfer(devminor_t minor, int do_write, u64_t position, 249 endpoint_t proc_nr, iovec_t *iov, unsigned int nr_req, int flags); 250 static int dma_setup(int do_write); 251 static void start_motor(void); 252 static int seek(void); 253 static int fdc_transfer(int do_write); 254 static int fdc_results(void); 255 static int fdc_command(const u8_t *cmd, int len); 256 static void fdc_out(int val); 257 static int recalibrate(void); 258 static void f_reset(void); 259 static int f_intr_wait(void); 260 static int read_id(void); 261 static int f_do_open(devminor_t minor, int access); 262 static int f_do_close(devminor_t minor); 263 static int test_read(int density); 264 static void f_geometry(devminor_t minor, struct part_geom *entry); 265 266 /* Entry points to this driver. */ 267 static struct blockdriver f_dtab = { 268 .bdr_type = BLOCKDRIVER_TYPE_DISK, /* handle partition requests */ 269 .bdr_open = f_do_open, /* open request, sense type of diskette */ 270 .bdr_close = f_do_close, /* nothing on a close */ 271 .bdr_transfer = f_transfer, /* do the I/O */ 272 .bdr_cleanup = f_cleanup, /* cleanup before sending reply to caller */ 273 .bdr_part = f_part, /* return partition information structure */ 274 .bdr_geometry = f_geometry, /* tell the geometry of the diskette */ 275 .bdr_alarm = f_expire_tmrs /* expire all alarm timers */ 276 }; 277 278 static char *floppy_buf; 279 static phys_bytes floppy_buf_phys; 280 281 /* SEF functions and variables. */ 282 static void sef_local_startup(void); 283 static int sef_cb_init_fresh(int type, sef_init_info_t *info); 284 static void sef_cb_signal_handler(int signo); 285 EXTERN int sef_cb_lu_prepare(int state); 286 EXTERN int sef_cb_lu_state_isvalid(int state, int flags); 287 EXTERN void sef_cb_lu_state_dump(int state); 288 int last_was_write; 289 290 /*===========================================================================* 291 * floppy_task * 292 *===========================================================================*/ 293 int main(void) 294 { 295 /* SEF local startup. */ 296 sef_local_startup(); 297 298 /* Call the generic receive loop. */ 299 blockdriver_task(&f_dtab); 300 301 return(OK); 302 } 303 304 /*===========================================================================* 305 * sef_local_startup * 306 *===========================================================================*/ 307 static void sef_local_startup(void) 308 { 309 /* Register init callbacks. */ 310 sef_setcb_init_fresh(sef_cb_init_fresh); 311 312 /* Register live update callbacks. */ 313 sef_setcb_lu_prepare(sef_cb_lu_prepare); 314 sef_setcb_lu_state_isvalid(sef_cb_lu_state_isvalid); 315 sef_setcb_lu_state_dump(sef_cb_lu_state_dump); 316 317 /* Register signal callbacks. */ 318 sef_setcb_signal_handler(sef_cb_signal_handler); 319 320 /* Let SEF perform startup. */ 321 sef_startup(); 322 } 323 324 /*===========================================================================* 325 * sef_cb_init_fresh * 326 *===========================================================================*/ 327 static int sef_cb_init_fresh(int type, sef_init_info_t *UNUSED(info)) 328 { 329 /* Initialize the floppy driver. */ 330 struct floppy *fp; 331 int s; 332 333 /* Initialize the floppy structure and the timers. */ 334 system_hz = sys_hz(); 335 336 if(!(floppy_buf = alloc_contig(2*DMA_BUF_SIZE, 337 AC_LOWER16M | AC_ALIGN4K, &floppy_buf_phys))) 338 panic("couldn't allocate dma buffer"); 339 340 init_timer(&f_tmr_timeout); 341 342 for (fp = &floppy[0]; fp < &floppy[NR_DRIVES]; fp++) { 343 fp->fl_curcyl = NO_CYL; 344 fp->fl_density = NO_DENS; 345 fp->fl_class = ~0; 346 init_timer(&fp->fl_tmr_stop); 347 } 348 349 /* Set IRQ policy, only request notifications, do not automatically 350 * reenable interrupts. ID return on interrupt is the IRQ line number. 351 */ 352 irq_hook_id = FLOPPY_IRQ; 353 if ((s=sys_irqsetpolicy(FLOPPY_IRQ, 0, &irq_hook_id )) != OK) 354 panic("Couldn't set IRQ policy: %d", s); 355 if ((s=sys_irqenable(&irq_hook_id)) != OK) 356 panic("Couldn't enable IRQs: %d", s); 357 358 /* Announce we are up! */ 359 blockdriver_announce(type); 360 361 return(OK); 362 } 363 364 /*===========================================================================* 365 * sef_cb_signal_handler * 366 *===========================================================================*/ 367 static void sef_cb_signal_handler(int signo) 368 { 369 int s; 370 371 /* Only check for termination signal, ignore anything else. */ 372 if (signo != SIGTERM) return; 373 374 /* Stop all activity and cleanly exit with the system. */ 375 if ((s=sys_outb(DOR, ENABLE_INT)) != OK) 376 panic("Sys_outb failed: %d", s); 377 exit(0); 378 } 379 380 /*===========================================================================* 381 * f_expire_tmrs * 382 *===========================================================================*/ 383 static void f_expire_tmrs(clock_t stamp) 384 { 385 /* A synchronous alarm message was received. Call the watchdog function for 386 * each expired timer, if any. 387 */ 388 389 expire_timers(stamp); 390 } 391 392 /*===========================================================================* 393 * f_prepare * 394 *===========================================================================*/ 395 static struct device *f_prepare(devminor_t device) 396 { 397 /* Prepare for I/O on a device. */ 398 399 f_device = device; 400 f_drive = device & ~(DEV_TYPE_BITS | FORMAT_DEV_BIT); 401 if (device < 0 || f_drive >= NR_DRIVES) return(NULL); 402 403 f_fp = &floppy[f_drive]; 404 f_dv = &f_fp->fl_geom; 405 if (f_fp->fl_density < NT) { 406 f_dp = &fdensity[f_fp->fl_density]; 407 f_sectors = f_dp->secpt; 408 f_fp->fl_geom.dv_size = (u64_t)(NR_HEADS * f_sectors * f_dp->cyls) * 409 SECTOR_SIZE; 410 } 411 412 /* A partition? */ 413 if ((device &= DEV_TYPE_BITS) >= MINOR_fd0p0) 414 f_dv = &f_fp->fl_part[(device - MINOR_fd0p0) >> DEV_TYPE_SHIFT]; 415 416 return f_dv; 417 } 418 419 /*===========================================================================* 420 * f_part * 421 *===========================================================================*/ 422 static struct device *f_part(devminor_t minor) 423 { 424 /* Return a pointer to the partition information of the given minor device. */ 425 426 return f_prepare(minor); 427 } 428 429 /*===========================================================================* 430 * f_cleanup * 431 *===========================================================================*/ 432 static void f_cleanup(void) 433 { 434 /* Start a timer to turn the motor off in a few seconds. */ 435 set_timer(&f_fp->fl_tmr_stop, MOTOR_OFF, stop_motor, f_drive); 436 437 /* Exiting the floppy driver, so forget where we are. */ 438 f_fp->fl_sector = NO_SECTOR; 439 } 440 441 /*===========================================================================* 442 * f_transfer * 443 *===========================================================================*/ 444 static ssize_t f_transfer( 445 devminor_t minor, /* minor device number */ 446 int do_write, /* read or write? */ 447 u64_t pos64, /* offset on device to read or write */ 448 endpoint_t proc_nr, /* process doing the request */ 449 iovec_t *iov, /* pointer to read or write request vector */ 450 unsigned int nr_req, /* length of request vector */ 451 int UNUSED(flags) /* transfer flags */ 452 ) 453 { 454 #define NO_OFFSET -1 455 struct floppy *fp; 456 iovec_t *iop, *iov_end = iov + nr_req; 457 int s, r, errors, nr; 458 unsigned block, nbytes, count, chunk, sector; 459 u64_t dv_size; 460 vir_bytes user_offset, iov_offset = 0, iop_offset; 461 unsigned long position; 462 signed long uoffsets[MAX_SECTORS], *up; 463 cp_grant_id_t ugrants[MAX_SECTORS], *ug = NULL; 464 u8_t cmd[3]; 465 ssize_t total; 466 467 if (f_prepare(minor) == NULL) return(ENXIO); 468 469 fp = f_fp; 470 dv_size = f_dv->dv_size; 471 472 if (ex64hi(pos64) != 0) 473 return OK; /* Way beyond EOF */ 474 position= pos64; 475 total = 0; 476 477 /* Record the direction of the last transfer performed. */ 478 last_was_write = do_write; 479 480 /* Check disk address. */ 481 if ((position & SECTOR_MASK) != 0) return(EINVAL); 482 483 #if 0 /* XXX hack to create a disk driver that crashes */ 484 { static int count= 0; if (++count > 10) { 485 printf("floppy: time to die\n"); *(int *)-1= 42; 486 }} 487 #endif 488 489 errors = 0; 490 while (nr_req > 0) { 491 /* How many bytes to transfer? */ 492 nbytes = 0; 493 for (iop = iov; iop < iov_end; iop++) nbytes += iop->iov_size; 494 495 /* Which block on disk and how close to EOF? */ 496 if (position >= dv_size) return(total); /* At EOF */ 497 if (position + nbytes > dv_size) nbytes = dv_size - position; 498 block = (unsigned long)((f_dv->dv_base + position) / SECTOR_SIZE); 499 500 if ((nbytes & SECTOR_MASK) != 0) return(EINVAL); 501 502 /* Using a formatting device? */ 503 if (f_device & FORMAT_DEV_BIT) { 504 if (!do_write) return(EIO); 505 if (iov->iov_size < SECTOR_SIZE + sizeof(fmt_param)) 506 return(EINVAL); 507 508 if(proc_nr != SELF) { 509 s=sys_safecopyfrom(proc_nr, iov->iov_addr, 510 SECTOR_SIZE + iov_offset, (vir_bytes) &fmt_param, 511 (phys_bytes) sizeof(fmt_param)); 512 if(s != OK) 513 panic("sys_safecopyfrom failed: %d", s); 514 } else { 515 memcpy(&fmt_param, (void *) (iov->iov_addr + 516 SECTOR_SIZE + iov_offset), 517 (phys_bytes) sizeof(fmt_param)); 518 } 519 520 /* Check that the number of sectors in the data is reasonable, 521 * to avoid division by 0. Leave checking of other data to 522 * the FDC. 523 */ 524 if (fmt_param.sectors_per_cylinder == 0) return(EIO); 525 526 /* Only the first sector of the parameters now needed. */ 527 iov->iov_size = nbytes = SECTOR_SIZE; 528 } 529 530 /* Only try one sector if there were errors. */ 531 if (errors > 0) nbytes = SECTOR_SIZE; 532 533 /* Compute cylinder and head of the track to access. */ 534 fp->fl_cylinder = block / (NR_HEADS * f_sectors); 535 fp->fl_hardcyl = fp->fl_cylinder * f_dp->steps; 536 fp->fl_head = (block % (NR_HEADS * f_sectors)) / f_sectors; 537 538 /* For each sector on this track compute the user address it is to 539 * go or to come from. 540 */ 541 for (up = uoffsets; up < uoffsets + MAX_SECTORS; up++) *up = NO_OFFSET; 542 count = 0; 543 iop = iov; 544 sector = block % f_sectors; 545 nr = 0; 546 iop_offset = iov_offset; 547 for (;;) { 548 nr++; 549 user_offset = iop_offset; 550 chunk = iop->iov_size; 551 if ((chunk & SECTOR_MASK) != 0) return(EINVAL); 552 553 while (chunk > 0) { 554 ugrants[sector] = iop->iov_addr; 555 uoffsets[sector++] = user_offset; 556 chunk -= SECTOR_SIZE; 557 user_offset += SECTOR_SIZE; 558 count += SECTOR_SIZE; 559 if (sector == f_sectors || count == nbytes) 560 goto track_set_up; 561 } 562 iop_offset = 0; 563 iop++; 564 } 565 track_set_up: 566 567 /* First check to see if a reset is needed. */ 568 if (need_reset) f_reset(); 569 570 /* See if motor is running; if not, turn it on and wait. */ 571 start_motor(); 572 573 /* Set the stepping rate and data rate */ 574 if (f_dp != prev_dp) { 575 cmd[0] = FDC_SPECIFY; 576 cmd[1] = f_dp->spec1; 577 cmd[2] = SPEC2; 578 (void) fdc_command(cmd, 3); 579 if ((s=sys_outb(FDC_RATE, f_dp->rate)) != OK) 580 panic("Sys_outb failed: %d", s); 581 prev_dp = f_dp; 582 } 583 584 /* If we are going to a new cylinder, perform a seek. */ 585 r = seek(); 586 587 /* Avoid read_id() if we don't plan to read much. */ 588 if (fp->fl_sector == NO_SECTOR && count < (6 * SECTOR_SIZE)) 589 fp->fl_sector = 0; 590 591 for (nbytes = 0; nbytes < count; nbytes += SECTOR_SIZE) { 592 if (fp->fl_sector == NO_SECTOR) { 593 /* Find out what the current sector is. This often 594 * fails right after a seek, so try it twice. 595 */ 596 if (r == OK && read_id() != OK) r = read_id(); 597 } 598 599 /* Look for the next job in uoffsets[] */ 600 if (r == OK) { 601 for (;;) { 602 if (fp->fl_sector >= f_sectors) 603 fp->fl_sector = 0; 604 605 up = &uoffsets[fp->fl_sector]; 606 ug = &ugrants[fp->fl_sector]; 607 if (*up != NO_OFFSET) break; 608 fp->fl_sector++; 609 } 610 611 if (do_write) { 612 /* Copy the user bytes to the DMA buffer. */ 613 if(proc_nr != SELF) { 614 s=sys_safecopyfrom(proc_nr, *ug, *up, 615 (vir_bytes) floppy_buf, 616 (phys_bytes) SECTOR_SIZE); 617 if(s != OK) 618 panic("sys_safecopyfrom failed: %d", s); 619 } else { 620 memcpy(floppy_buf, (void *) (*ug + *up), SECTOR_SIZE); 621 } 622 } 623 } 624 625 /* Set up the DMA chip and perform the transfer. */ 626 if (r == OK) { 627 if (dma_setup(do_write) != OK) { 628 /* This can only fail for addresses above 16MB 629 * that cannot be handled by the controller, 630 * because it uses 24-bit addressing. 631 */ 632 return(EIO); 633 } 634 r = fdc_transfer(do_write); 635 } 636 637 if (r == OK && !do_write) { 638 /* Copy the DMA buffer to user space. */ 639 if(proc_nr != SELF) { 640 s=sys_safecopyto(proc_nr, *ug, *up, 641 (vir_bytes) floppy_buf, 642 (phys_bytes) SECTOR_SIZE); 643 if(s != OK) 644 panic("sys_safecopyto failed: %d", s); 645 } else { 646 memcpy((void *) (*ug + *up), floppy_buf, SECTOR_SIZE); 647 } 648 } 649 650 if (r != OK) { 651 /* Don't retry if write protected or too many errors. */ 652 if (err_no_retry(r) || ++errors == MAX_ERRORS) { 653 return(EIO); 654 } 655 656 /* Recalibrate if halfway. */ 657 if (errors == MAX_ERRORS / 2) 658 fp->fl_calibration = UNCALIBRATED; 659 660 nbytes = 0; 661 break; /* retry */ 662 } 663 } 664 665 /* Book the bytes successfully transferred. */ 666 position += nbytes; 667 total += nbytes; 668 while (nbytes > 0) { 669 if (nbytes < iov->iov_size) { 670 /* Not done with this one yet. */ 671 iov_offset += nbytes; 672 iov->iov_size -= nbytes; 673 break; 674 } 675 iov_offset = 0; 676 nbytes -= iov->iov_size; 677 iov->iov_size = 0; 678 iov++; 679 nr_req--; 680 } 681 } 682 return(total); 683 } 684 685 /*===========================================================================* 686 * dma_setup * 687 *===========================================================================*/ 688 static int dma_setup(int do_write) 689 { 690 /* The IBM PC can perform DMA operations by using the DMA chip. To use it, 691 * the DMA (Direct Memory Access) chip is loaded with the 20-bit memory address 692 * to be read from or written to, the byte count minus 1, and a read or write 693 * opcode. This routine sets up the DMA chip. Note that the chip is not 694 * capable of doing a DMA across a 64K boundary (e.g., you can't read a 695 * 512-byte block starting at physical address 65520). 696 * 697 * Warning! Also note that it's not possible to do DMA above 16 MB because 698 * the ISA bus uses 24-bit addresses. Addresses above 16 MB therefore will 699 * be interpreted modulo 16 MB, dangerously overwriting arbitrary memory. 700 * A check here denies the I/O if the address is out of range. 701 */ 702 pvb_pair_t byte_out[9]; 703 int s; 704 705 /* First check the DMA memory address not to exceed maximum. */ 706 if (floppy_buf_phys != (floppy_buf_phys & DMA_ADDR_MASK)) { 707 printf("floppy: DMA denied because address out of range\n"); 708 return(EIO); 709 } 710 711 /* Set up the DMA registers. (The comment on the reset is a bit strong, 712 * it probably only resets the floppy channel.) 713 */ 714 pv_set(byte_out[0], DMA_INIT, DMA_RESET_VAL); /* reset the dma controller */ 715 pv_set(byte_out[1], DMA_FLIPFLOP, 0); /* write anything to reset it */ 716 pv_set(byte_out[2], DMA_MODE, do_write ? DMA_WRITE : DMA_READ); 717 pv_set(byte_out[3], DMA_ADDR, (unsigned) (floppy_buf_phys >> 0) & 0xff); 718 pv_set(byte_out[4], DMA_ADDR, (unsigned) (floppy_buf_phys >> 8) & 0xff); 719 pv_set(byte_out[5], DMA_TOP, (unsigned) (floppy_buf_phys >> 16) & 0xff); 720 pv_set(byte_out[6], DMA_COUNT, (((SECTOR_SIZE - 1) >> 0)) & 0xff); 721 pv_set(byte_out[7], DMA_COUNT, (SECTOR_SIZE - 1) >> 8); 722 pv_set(byte_out[8], DMA_INIT, 2); /* some sort of enable */ 723 724 if ((s=sys_voutb(byte_out, 9)) != OK) 725 panic("Sys_voutb in dma_setup() failed: %d", s); 726 return(OK); 727 } 728 729 /*===========================================================================* 730 * start_motor * 731 *===========================================================================*/ 732 static void start_motor(void) 733 { 734 /* Control of the floppy disk motors is a big pain. If a motor is off, you 735 * have to turn it on first, which takes 1/2 second. You can't leave it on 736 * all the time, since that would wear out the diskette. However, if you turn 737 * the motor off after each operation, the system performance will be awful. 738 * The compromise used here is to leave it on for a few seconds after each 739 * operation. If a new operation is started in that interval, it need not be 740 * turned on again. If no new operation is started, a timer goes off and the 741 * motor is turned off. I/O port DOR has bits to control each of 4 drives. 742 */ 743 744 int s, motor_bit, running; 745 message mess; 746 int ipc_status; 747 748 motor_bit = 1 << f_drive; /* bit mask for this drive */ 749 running = motor_status & motor_bit; /* nonzero if this motor is running */ 750 motor_status |= motor_bit; /* want this drive running too */ 751 752 if ((s=sys_outb(DOR, 753 (motor_status << MOTOR_SHIFT) | ENABLE_INT | f_drive)) != OK) 754 panic("Sys_outb in start_motor() failed: %d", s); 755 756 /* If the motor was already running, we don't have to wait for it. */ 757 if (running) return; /* motor was already running */ 758 759 /* Set an alarm timer to force a timeout if the hardware does not interrupt 760 * in time. Expect an interrupt, but check for a timeout. 761 */ 762 set_timer(&f_tmr_timeout, f_dp->start_ms * system_hz / 1000, f_timeout, 0); 763 f_busy = BSY_IO; 764 do { 765 if ((s = driver_receive(ANY, &mess, &ipc_status)) != OK) 766 panic("Couldn't receive message: %d", s); 767 768 if (is_ipc_notify(ipc_status)) { 769 switch (_ENDPOINT_P(mess.m_source)) { 770 case CLOCK: 771 f_expire_tmrs(mess.m_notify.timestamp); 772 break; 773 default : 774 f_busy = BSY_IDLE; 775 break; 776 } 777 } else { 778 f_busy = BSY_IDLE; 779 } 780 } while (f_busy == BSY_IO); 781 f_fp->fl_sector = NO_SECTOR; 782 } 783 784 /*===========================================================================* 785 * stop_motor * 786 *===========================================================================*/ 787 static void stop_motor(int arg) 788 { 789 /* This routine is called from an alarm timer after several seconds have 790 * elapsed with no floppy disk activity. It turns the drive motor off. 791 */ 792 int s; 793 motor_status &= ~(1 << arg); 794 if ((s=sys_outb(DOR, (motor_status << MOTOR_SHIFT) | ENABLE_INT)) != OK) 795 panic("Sys_outb in stop_motor() failed: %d", s); 796 } 797 798 /*===========================================================================* 799 * seek * 800 *===========================================================================*/ 801 static int seek(void) 802 { 803 /* Issue a SEEK command on the indicated drive unless the arm is already 804 * positioned on the correct cylinder. 805 */ 806 807 struct floppy *fp = f_fp; 808 int r; 809 message mess; 810 int ipc_status; 811 u8_t cmd[3]; 812 813 /* Are we already on the correct cylinder? */ 814 if (fp->fl_calibration == UNCALIBRATED) 815 if (recalibrate() != OK) return(ERR_SEEK); 816 if (fp->fl_curcyl == fp->fl_hardcyl) return(OK); 817 818 /* No. Wrong cylinder. Issue a SEEK and wait for interrupt. */ 819 cmd[0] = FDC_SEEK; 820 cmd[1] = (fp->fl_head << 2) | f_drive; 821 cmd[2] = fp->fl_hardcyl; 822 if (fdc_command(cmd, 3) != OK) return(ERR_SEEK); 823 if (f_intr_wait() != OK) return(ERR_TIMEOUT); 824 825 /* Interrupt has been received. Check drive status. */ 826 fdc_out(FDC_SENSE); /* probe FDC to make it return status */ 827 r = fdc_results(); /* get controller status bytes */ 828 if (r != OK || (f_results[ST0] & ST0_BITS_SEEK) != SEEK_ST0 829 || f_results[ST1] != fp->fl_hardcyl) { 830 /* seek failed, may need a recalibrate */ 831 return(ERR_SEEK); 832 } 833 /* Give head time to settle on a format, no retrying here! */ 834 if (f_device & FORMAT_DEV_BIT) { 835 /* Set a synchronous alarm to force a timeout if the hardware does 836 * not interrupt. 837 */ 838 set_timer(&f_tmr_timeout, system_hz/30, f_timeout, 0); 839 f_busy = BSY_IO; 840 do { 841 if ((r = driver_receive(ANY, &mess, &ipc_status)) != OK) 842 panic("Couldn't receive message: %d", r); 843 844 if (is_ipc_notify(ipc_status)) { 845 switch (_ENDPOINT_P(mess.m_source)) { 846 case CLOCK: 847 f_expire_tmrs(mess.m_notify.timestamp); 848 break; 849 default : 850 f_busy = BSY_IDLE; 851 break; 852 } 853 } else { 854 f_busy = BSY_IDLE; 855 } 856 } while (f_busy == BSY_IO); 857 } 858 fp->fl_curcyl = fp->fl_hardcyl; 859 fp->fl_sector = NO_SECTOR; 860 return(OK); 861 } 862 863 /*===========================================================================* 864 * fdc_transfer * 865 *===========================================================================*/ 866 static int fdc_transfer(int do_write) 867 { 868 /* The drive is now on the proper cylinder. Read, write or format 1 block. */ 869 870 struct floppy *fp = f_fp; 871 int r, s; 872 u8_t cmd[9]; 873 874 /* Never attempt a transfer if the drive is uncalibrated or motor is off. */ 875 if (fp->fl_calibration == UNCALIBRATED) return(ERR_TRANSFER); 876 if ((motor_status & (1 << f_drive)) == 0) return(ERR_TRANSFER); 877 878 /* The command is issued by outputting several bytes to the controller chip. 879 */ 880 if (f_device & FORMAT_DEV_BIT) { 881 cmd[0] = FDC_FORMAT; 882 cmd[1] = (fp->fl_head << 2) | f_drive; 883 cmd[2] = fmt_param.sector_size_code; 884 cmd[3] = fmt_param.sectors_per_cylinder; 885 cmd[4] = fmt_param.gap_length_for_format; 886 cmd[5] = fmt_param.fill_byte_for_format; 887 if (fdc_command(cmd, 6) != OK) return(ERR_TRANSFER); 888 } else { 889 cmd[0] = do_write ? FDC_WRITE : FDC_READ; 890 cmd[1] = (fp->fl_head << 2) | f_drive; 891 cmd[2] = fp->fl_cylinder; 892 cmd[3] = fp->fl_head; 893 cmd[4] = BASE_SECTOR + fp->fl_sector; 894 cmd[5] = SECTOR_SIZE_CODE; 895 cmd[6] = f_sectors; 896 cmd[7] = f_dp->gap; /* sector gap */ 897 cmd[8] = DTL; /* data length */ 898 if (fdc_command(cmd, 9) != OK) return(ERR_TRANSFER); 899 } 900 901 /* Block, waiting for disk interrupt. */ 902 if (f_intr_wait() != OK) { 903 printf("fd%u: disk interrupt timed out.\n", f_drive); 904 return(ERR_TIMEOUT); 905 } 906 907 /* Get controller status and check for errors. */ 908 r = fdc_results(); 909 if (r != OK) return(r); 910 911 if (f_results[ST1] & WRITE_PROTECT) { 912 printf("fd%u: diskette is write protected.\n", f_drive); 913 return(ERR_WR_PROTECT); 914 } 915 916 if ((f_results[ST0] & ST0_BITS_TRANS) != TRANS_ST0) return(ERR_TRANSFER); 917 if (f_results[ST1] | f_results[ST2]) return(ERR_TRANSFER); 918 919 if (f_device & FORMAT_DEV_BIT) return(OK); 920 921 /* Compare actual numbers of sectors transferred with expected number. */ 922 s = (f_results[ST_CYL] - fp->fl_cylinder) * NR_HEADS * f_sectors; 923 s += (f_results[ST_HEAD] - fp->fl_head) * f_sectors; 924 s += (f_results[ST_SEC] - BASE_SECTOR - fp->fl_sector); 925 if (s != 1) return(ERR_TRANSFER); 926 927 /* This sector is next for I/O: */ 928 fp->fl_sector = f_results[ST_SEC] - BASE_SECTOR; 929 #if 0 930 if (processor < 386) fp->fl_sector++; /* Old CPU can't keep up. */ 931 #endif 932 return(OK); 933 } 934 935 /*===========================================================================* 936 * fdc_results * 937 *===========================================================================*/ 938 static int fdc_results(void) 939 { 940 /* Extract results from the controller after an operation, then allow floppy 941 * interrupts again. 942 */ 943 944 int s, result_nr; 945 u32_t status; 946 spin_t spin; 947 948 /* Extract bytes from FDC until it says it has no more. The loop is 949 * really an outer loop on result_nr and an inner loop on status. 950 * A timeout flag alarm is set. 951 */ 952 result_nr = 0; 953 SPIN_FOR(&spin, TIMEOUT_MICROS) { 954 /* Reading one byte is almost a mirror of fdc_out() - the DIRECTION 955 * bit must be set instead of clear, but the CTL_BUSY bit destroys 956 * the perfection of the mirror. 957 */ 958 if ((s=sys_inb(FDC_STATUS, &status)) != OK) 959 panic("Sys_inb in fdc_results() failed: %d", s); 960 status &= (MASTER | DIRECTION | CTL_BUSY); 961 if (status == (MASTER | DIRECTION | CTL_BUSY)) { 962 u32_t tmp_r; 963 if (result_nr >= MAX_RESULTS) break; /* too many results */ 964 if ((s=sys_inb(FDC_DATA, &tmp_r)) != OK) 965 panic("Sys_inb in fdc_results() failed: %d", s); 966 f_results[result_nr] = tmp_r; 967 result_nr ++; 968 continue; 969 } 970 if (status == MASTER) { /* all read */ 971 if ((s=sys_irqenable(&irq_hook_id)) != OK) 972 panic("Couldn't enable IRQs: %d", s); 973 974 return(OK); /* only good exit */ 975 } 976 } 977 need_reset = TRUE; /* controller chip must be reset */ 978 979 if ((s=sys_irqenable(&irq_hook_id)) != OK) 980 panic("Couldn't enable IRQs: %d", s); 981 return(ERR_STATUS); 982 } 983 984 /*===========================================================================* 985 * fdc_command * 986 *===========================================================================*/ 987 static int fdc_command( 988 const u8_t *cmd, /* command bytes */ 989 int len /* command length */ 990 ) 991 { 992 /* Output a command to the controller. */ 993 994 /* Set a synchronous alarm to force a timeout if the hardware does 995 * not interrupt. 996 * Note that the actual check is done by the code that issued the 997 * fdc_command() call. 998 */ 999 set_timer(&f_tmr_timeout, WAKEUP, f_timeout, 0); 1000 1001 f_busy = BSY_IO; 1002 while (len > 0) { 1003 fdc_out(*cmd++); 1004 len--; 1005 } 1006 return(need_reset ? ERR_DRIVE : OK); 1007 } 1008 1009 /*===========================================================================* 1010 * fdc_out * 1011 *===========================================================================*/ 1012 static void fdc_out( 1013 int val /* write this byte to floppy disk controller */ 1014 ) 1015 { 1016 /* Output a byte to the controller. This is not entirely trivial, since you 1017 * can only write to it when it is listening, and it decides when to listen. 1018 * If the controller refuses to listen, the FDC chip is given a hard reset. 1019 */ 1020 spin_t spin; 1021 int s; 1022 u32_t status; 1023 1024 if (need_reset) return; /* if controller is not listening, return */ 1025 1026 /* It may take several tries to get the FDC to accept a command. */ 1027 SPIN_FOR(&spin, TIMEOUT_MICROS) { 1028 if ((s=sys_inb(FDC_STATUS, &status)) != OK) 1029 panic("Sys_inb in fdc_out() failed: %d", s); 1030 1031 if ((status & (MASTER | DIRECTION)) == (MASTER | 0)) { 1032 if ((s=sys_outb(FDC_DATA, val)) != OK) 1033 panic("Sys_outb in fdc_out() failed: %d", s); 1034 1035 return; 1036 } 1037 } 1038 1039 need_reset = TRUE; /* hit it over the head */ 1040 } 1041 1042 /*===========================================================================* 1043 * recalibrate * 1044 *===========================================================================*/ 1045 static int recalibrate(void) 1046 { 1047 /* The floppy disk controller has no way of determining its absolute arm 1048 * position (cylinder). Instead, it steps the arm a cylinder at a time and 1049 * keeps track of where it thinks it is (in software). However, after a 1050 * SEEK, the hardware reads information from the diskette telling where the 1051 * arm actually is. If the arm is in the wrong place, a recalibration is done, 1052 * which forces the arm to cylinder 0. This way the controller can get back 1053 * into sync with reality. 1054 */ 1055 1056 struct floppy *fp = f_fp; 1057 int r; 1058 u8_t cmd[2]; 1059 1060 /* Issue the RECALIBRATE command and wait for the interrupt. */ 1061 cmd[0] = FDC_RECALIBRATE; /* tell drive to recalibrate itself */ 1062 cmd[1] = f_drive; /* specify drive */ 1063 if (fdc_command(cmd, 2) != OK) return(ERR_SEEK); 1064 if (f_intr_wait() != OK) return(ERR_TIMEOUT); 1065 1066 /* Determine if the recalibration succeeded. */ 1067 fdc_out(FDC_SENSE); /* issue SENSE command to request results */ 1068 r = fdc_results(); /* get results of the FDC_RECALIBRATE command*/ 1069 fp->fl_curcyl = NO_CYL; /* force a SEEK next time */ 1070 fp->fl_sector = NO_SECTOR; 1071 if (r != OK || /* controller would not respond */ 1072 (f_results[ST0] & ST0_BITS_SEEK) != SEEK_ST0 || f_results[ST_PCN] != 0) { 1073 /* Recalibration failed. FDC must be reset. */ 1074 need_reset = TRUE; 1075 return(ERR_RECALIBRATE); 1076 } else { 1077 /* Recalibration succeeded. */ 1078 fp->fl_calibration = CALIBRATED; 1079 fp->fl_curcyl = f_results[ST_PCN]; 1080 return(OK); 1081 } 1082 } 1083 1084 /*===========================================================================* 1085 * f_reset * 1086 *===========================================================================*/ 1087 static void f_reset(void) 1088 { 1089 /* Issue a reset to the controller. This is done after any catastrophe, 1090 * like the controller refusing to respond. 1091 */ 1092 pvb_pair_t byte_out[2]; 1093 int s,i; 1094 message mess; 1095 int ipc_status; 1096 1097 /* Disable interrupts and strobe reset bit low. */ 1098 need_reset = FALSE; 1099 1100 /* It is not clear why the next lock is needed. Writing 0 to DOR causes 1101 * interrupt, while the PC documentation says turning bit 8 off disables 1102 * interrupts. Without the lock: 1103 * 1) the interrupt handler sets the floppy mask bit in the 8259. 1104 * 2) writing ENABLE_INT to DOR causes the FDC to assert the interrupt 1105 * line again, but the mask stops the cpu being interrupted. 1106 * 3) the sense interrupt clears the interrupt (not clear which one). 1107 * and for some reason the reset does not work. 1108 */ 1109 (void) fdc_command((u8_t *) 0, 0); /* need only the timer */ 1110 motor_status = 0; 1111 pv_set(byte_out[0], DOR, 0); /* strobe reset bit low */ 1112 pv_set(byte_out[1], DOR, ENABLE_INT); /* strobe it high again */ 1113 if ((s=sys_voutb(byte_out, 2)) != OK) 1114 panic("Sys_voutb in f_reset() failed: %d", s); 1115 1116 /* A synchronous alarm timer was set in fdc_command. Expect an interrupt, 1117 * but be prepared to handle a timeout. 1118 */ 1119 do { 1120 if ((s = driver_receive(ANY, &mess, &ipc_status)) != OK) 1121 panic("Couldn't receive message: %d", s); 1122 if (is_ipc_notify(ipc_status)) { 1123 switch (_ENDPOINT_P(mess.m_source)) { 1124 case CLOCK: 1125 f_expire_tmrs(mess.m_notify.timestamp); 1126 break; 1127 default : 1128 f_busy = BSY_IDLE; 1129 break; 1130 } 1131 } else { /* expect hw interrupt */ 1132 f_busy = BSY_IDLE; 1133 } 1134 } while (f_busy == BSY_IO); 1135 1136 /* The controller supports 4 drives and returns a result for each of them. 1137 * Collect all the results now. The old version only collected the first 1138 * result. This happens to work for 2 drives, but it doesn't work for 3 1139 * or more drives, at least with only drives 0 and 2 actually connected 1140 * (the controller generates an extra interrupt for the middle drive when 1141 * drive 2 is accessed and the driver panics). 1142 * 1143 * It would be better to keep collecting results until there are no more. 1144 * For this, fdc_results needs to return the number of results (instead 1145 * of OK) when it succeeds. 1146 */ 1147 for (i = 0; i < 4; i++) { 1148 fdc_out(FDC_SENSE); /* probe FDC to make it return status */ 1149 (void) fdc_results(); /* flush controller */ 1150 } 1151 for (i = 0; i < NR_DRIVES; i++) /* clear each drive */ 1152 floppy[i].fl_calibration = UNCALIBRATED; 1153 1154 /* The current timing parameters must be specified again. */ 1155 prev_dp = NULL; 1156 } 1157 1158 /*===========================================================================* 1159 * f_intr_wait * 1160 *===========================================================================*/ 1161 static int f_intr_wait(void) 1162 { 1163 /* Wait for an interrupt, but not forever. The FDC may have all the time of 1164 * the world, but we humans do not. 1165 */ 1166 message mess; 1167 int r, ipc_status; 1168 1169 /* We expect an interrupt, but if a timeout, occurs, report an error. */ 1170 do { 1171 if ((r = driver_receive(ANY, &mess, &ipc_status)) != OK) 1172 panic("Couldn't receive message: %d", r); 1173 if (is_ipc_notify(ipc_status)) { 1174 switch (_ENDPOINT_P(mess.m_source)) { 1175 case CLOCK: 1176 f_expire_tmrs(mess.m_notify.timestamp); 1177 break; 1178 default : 1179 f_busy = BSY_IDLE; 1180 break; 1181 } 1182 } else { 1183 f_busy = BSY_IDLE; 1184 } 1185 } while (f_busy == BSY_IO); 1186 1187 if (f_busy == BSY_WAKEN) { 1188 1189 /* No interrupt from the FDC, this means that there is probably no 1190 * floppy in the drive. Get the FDC down to earth and return error. 1191 */ 1192 need_reset = TRUE; 1193 return(ERR_TIMEOUT); 1194 } 1195 return(OK); 1196 } 1197 1198 /*===========================================================================* 1199 * f_timeout * 1200 *===========================================================================*/ 1201 static void f_timeout(int arg __unused) 1202 { 1203 /* This routine is called when a timer expires. Usually to tell that a 1204 * motor has spun up, but also to forge an interrupt when it takes too long 1205 * for the FDC to interrupt (no floppy in the drive). It sets a flag to tell 1206 * what has happened. 1207 */ 1208 if (f_busy == BSY_IO) { 1209 f_busy = BSY_WAKEN; 1210 } 1211 } 1212 1213 /*===========================================================================* 1214 * read_id * 1215 *===========================================================================*/ 1216 static int read_id(void) 1217 { 1218 /* Determine current cylinder and sector. */ 1219 1220 struct floppy *fp = f_fp; 1221 int result; 1222 u8_t cmd[2]; 1223 1224 /* Never attempt a read id if the drive is uncalibrated or motor is off. */ 1225 if (fp->fl_calibration == UNCALIBRATED) return(ERR_READ_ID); 1226 if ((motor_status & (1 << f_drive)) == 0) return(ERR_READ_ID); 1227 1228 /* The command is issued by outputting 2 bytes to the controller chip. */ 1229 cmd[0] = FDC_READ_ID; /* issue the read id command */ 1230 cmd[1] = (fp->fl_head << 2) | f_drive; 1231 if (fdc_command(cmd, 2) != OK) return(ERR_READ_ID); 1232 if (f_intr_wait() != OK) return(ERR_TIMEOUT); 1233 1234 /* Get controller status and check for errors. */ 1235 result = fdc_results(); 1236 if (result != OK) return(result); 1237 1238 if ((f_results[ST0] & ST0_BITS_TRANS) != TRANS_ST0) return(ERR_READ_ID); 1239 if (f_results[ST1] | f_results[ST2]) return(ERR_READ_ID); 1240 1241 /* The next sector is next for I/O: */ 1242 fp->fl_sector = f_results[ST_SEC] - BASE_SECTOR + 1; 1243 return(OK); 1244 } 1245 1246 /*===========================================================================* 1247 * f_do_open * 1248 *===========================================================================*/ 1249 static int f_do_open(devminor_t minor, int UNUSED(access)) 1250 { 1251 /* Handle an open on a floppy. Determine diskette type if need be. */ 1252 1253 int dtype; 1254 struct test_order *top; 1255 1256 /* Decode the message parameters. */ 1257 if (f_prepare(minor) == NULL) return(ENXIO); 1258 1259 dtype = f_device & DEV_TYPE_BITS; /* get density from minor dev */ 1260 if (dtype >= MINOR_fd0p0) dtype = 0; 1261 1262 if (dtype != 0) { 1263 /* All types except 0 indicate a specific drive/medium combination.*/ 1264 dtype = (dtype >> DEV_TYPE_SHIFT) - 1; 1265 if (dtype >= NT) return(ENXIO); 1266 f_fp->fl_density = dtype; 1267 (void) f_prepare(f_device); /* Recompute parameters. */ 1268 return(OK); 1269 } 1270 if (f_device & FORMAT_DEV_BIT) return(EIO); /* Can't format /dev/fdN */ 1271 1272 /* The device opened is /dev/fdN. Experimentally determine drive/medium. 1273 * First check fl_density. If it is not NO_DENS, the drive has been used 1274 * before and the value of fl_density tells what was found last time. Try 1275 * that first. If the motor is still running then assume nothing changed. 1276 */ 1277 if (f_fp->fl_density != NO_DENS) { 1278 if (motor_status & (1 << f_drive)) return(OK); 1279 if (test_read(f_fp->fl_density) == OK) return(OK); 1280 } 1281 1282 /* Either drive type is unknown or a different diskette is now present. 1283 * Use test_order to try them one by one. 1284 */ 1285 for (top = &test_order[0]; top < &test_order[NT-1]; top++) { 1286 dtype = top->t_density; 1287 1288 /* Skip densities that have been proven to be impossible */ 1289 if (!(f_fp->fl_class & (1 << dtype))) continue; 1290 1291 if (test_read(dtype) == OK) { 1292 /* The test succeeded, use this knowledge to limit the 1293 * drive class to match the density just read. 1294 */ 1295 f_fp->fl_class &= top->t_class; 1296 return(OK); 1297 } 1298 /* Test failed, wrong density or did it time out? */ 1299 if (f_busy == BSY_WAKEN) break; 1300 } 1301 f_fp->fl_density = NO_DENS; 1302 return(EIO); /* nothing worked */ 1303 } 1304 1305 /*===========================================================================* 1306 * f_do_close * 1307 *===========================================================================*/ 1308 static int f_do_close(devminor_t UNUSED(minor)) 1309 { 1310 /* Handle a close on a floppy. Nothing to do here. */ 1311 1312 return(OK); 1313 } 1314 1315 /*===========================================================================* 1316 * test_read * 1317 *===========================================================================*/ 1318 static int test_read(int density) 1319 { 1320 /* Try to read the highest numbered sector on cylinder 2. Not all floppy 1321 * types have as many sectors per track, and trying cylinder 2 finds the 1322 * ones that need double stepping. 1323 */ 1324 int device; 1325 off_t position; 1326 iovec_t iovec1; 1327 ssize_t result; 1328 1329 f_fp->fl_density = density; 1330 device = ((density + 1) << DEV_TYPE_SHIFT) + f_drive; 1331 1332 (void) f_prepare(device); 1333 position = (off_t) f_dp->test << SECTOR_SHIFT; 1334 iovec1.iov_addr = (vir_bytes) floppy_buf; 1335 iovec1.iov_size = SECTOR_SIZE; 1336 result = f_transfer(device, FALSE /*do_write*/, position, SELF, 1337 &iovec1, 1, BDEV_NOFLAGS); 1338 1339 if (result != SECTOR_SIZE) return(EIO); 1340 1341 partition(&f_dtab, f_drive, P_FLOPPY, 0); 1342 return(OK); 1343 } 1344 1345 /*===========================================================================* 1346 * f_geometry * 1347 *===========================================================================*/ 1348 static void f_geometry(devminor_t minor, struct part_geom *entry) 1349 { 1350 if (f_prepare(minor) == NULL) return; 1351 1352 entry->cylinders = f_dp->cyls; 1353 entry->heads = NR_HEADS; 1354 entry->sectors = f_sectors; 1355 } 1356