#include "config.h" #include "libopenbios/bindings.h" #include "kernel/kernel.h" #include "libc/byteorder.h" #include "libc/vsprintf.h" #include "drivers/drivers.h" #include "timer.h" /* DECLARE data structures for the nodes. */ DECLARE_UNNAMED_NODE( ob_floppy, INSTALL_OPEN, 2*sizeof(int) ); #ifdef CONFIG_DEBUG_FLOPPY #define printk_info printk #define printk_debug printk #else #define printk_info(x ...) #define printk_debug(x ...) #endif #define printk_err printk #define FD_DRIVE 0 #define FD_STATUS_A (0) /* Status register A */ #define FD_STATUS_B (1) /* Status register B */ #define FD_DOR (2) /* Digital Output Register */ #define FD_TDR (3) /* Tape Drive Register */ #define FD_STATUS (4) /* Main Status Register */ #define FD_DSR (4) /* Data Rate Select Register (old) */ #define FD_DATA (5) /* Data Transfer (FIFO) register */ #define FD_DIR (7) /* Digital Input Register (read) */ #define FD_DCR (7) /* Diskette Control Register (write)*/ /* Bit of FD_STATUS_A */ #define STA_INT_PENDING 0x80 /* Interrupt Pending */ /* DOR */ #define DOR_DRIVE0 0x00 #define DOR_DRIVE1 0x01 #define DOR_DRIVE2 0x02 #define DOR_DRIVE3 0x03 #define DOR_DRIVE_MASK 0x03 #define DOR_NO_RESET 0x04 #define DOR_DMA_EN 0x08 #define DOR_MOT_EN0 0x10 #define DOR_MOT_EN1 0x20 #define DOR_MOT_EN2 0x40 #define DOR_MOT_EN3 0x80 /* Bits of main status register */ #define STATUS_BUSYMASK 0x0F /* drive busy mask */ #define STATUS_BUSY 0x10 /* FDC busy */ #define STATUS_NON_DMA 0x20 /* 0- DMA mode */ #define STATUS_DIR 0x40 /* 0- cpu->fdc */ #define STATUS_READY 0x80 /* Data reg ready */ /* Bits of FD_ST0 */ #define ST0_DS 0x03 /* drive select mask */ #define ST0_HA 0x04 /* Head (Address) */ #define ST0_NR 0x08 /* Not Ready */ #define ST0_ECE 0x10 /* Equipment check error */ #define ST0_SE 0x20 /* Seek end */ #define ST0_INTR 0xC0 /* Interrupt code mask */ #define ST0_INTR_OK (0 << 6) #define ST0_INTR_ERROR (1 << 6) #define ST0_INTR_INVALID (2 << 6) #define ST0_INTR_POLL_ERROR (3 << 6) /* Bits of FD_ST1 */ #define ST1_MAM 0x01 /* Missing Address Mark */ #define ST1_WP 0x02 /* Write Protect */ #define ST1_ND 0x04 /* No Data - unreadable */ #define ST1_OR 0x10 /* OverRun */ #define ST1_CRC 0x20 /* CRC error in data or addr */ #define ST1_EOC 0x80 /* End Of Cylinder */ /* Bits of FD_ST2 */ #define ST2_MAM 0x01 /* Missing Address Mark (again) */ #define ST2_BC 0x02 /* Bad Cylinder */ #define ST2_SNS 0x04 /* Scan Not Satisfied */ #define ST2_SEH 0x08 /* Scan Equal Hit */ #define ST2_WC 0x10 /* Wrong Cylinder */ #define ST2_CRC 0x20 /* CRC error in data field */ #define ST2_CM 0x40 /* Control Mark = deleted */ /* Bits of FD_ST3 */ #define ST3_HA 0x04 /* Head (Address) */ #define ST3_DS 0x08 /* drive is double-sided */ #define ST3_TZ 0x10 /* Track Zero signal (1=track 0) */ #define ST3_RY 0x20 /* drive is ready */ #define ST3_WP 0x40 /* Write Protect */ #define ST3_FT 0x80 /* Drive Fault */ /* Values for FD_COMMAND */ #define FD_RECALIBRATE 0x07 /* move to track 0 */ #define FD_SEEK 0x0F /* seek track */ #define FD_READ 0xA6 /* read with MT, SKip deleted */ #define FD_WRITE 0xC5 /* write with MT, MFM */ #define FD_SENSEI 0x08 /* Sense Interrupt Status */ #define FD_SPECIFY 0x03 /* specify HUT etc */ #define FD_FORMAT 0x4D /* format one track */ #define FD_VERSION 0x10 /* get version code */ #define FD_CONFIGURE 0x13 /* configure FIFO operation */ #define FD_PERPENDICULAR 0x12 /* perpendicular r/w mode */ #define FD_GETSTATUS 0x04 /* read ST3 */ #define FD_DUMPREGS 0x0E /* dump the contents of the fdc regs */ #define FD_READID 0xEA /* prints the header of a sector */ #define FD_UNLOCK 0x14 /* Fifo config unlock */ #define FD_LOCK 0x94 /* Fifo config lock */ #define FD_RSEEK_OUT 0x8f /* seek out (i.e. to lower tracks) */ #define FD_RSEEK_IN 0xcf /* seek in (i.e. to higher tracks) */ /* the following commands are new in the 82078. They are not used in the * floppy driver, except the first three. These commands may be useful for apps * which use the FDRAWCMD interface. For doc, get the 82078 spec sheets at * http://www-techdoc.intel.com/docs/periph/fd_contr/datasheets/ */ #define FD_PARTID 0x18 /* part id ("extended" version cmd) */ #define FD_SAVE 0x2e /* save fdc regs for later restore */ #define FD_DRIVESPEC 0x8e /* drive specification: Access to the * 2 Mbps data transfer rate for tape * drives */ #define FD_RESTORE 0x4e /* later restore */ #define FD_POWERDOWN 0x27 /* configure FDC's powersave features */ #define FD_FORMAT_N_WRITE 0xef /* format and write in one go. */ #define FD_OPTION 0x33 /* ISO format (which is a clean way to * pack more sectors on a track) */ /* FDC version return types */ #define FDC_NONE 0x00 #define FDC_UNKNOWN 0x10 /* DO NOT USE THIS TYPE EXCEPT IF IDENTIFICATION FAILS EARLY */ #define FDC_8272A 0x20 /* Intel 8272a, NEC 765 */ #define FDC_765ED 0x30 /* Non-Intel 1MB-compatible FDC, can't detect */ #define FDC_82072 0x40 /* Intel 82072; 8272a + FIFO + DUMPREGS */ #define FDC_82072A 0x45 /* 82072A (on Sparcs) */ #define FDC_82077_ORIG 0x51 /* Original version of 82077AA, sans LOCK */ #define FDC_82077 0x52 /* 82077AA-1 */ #define FDC_82078_UNKN 0x5f /* Unknown 82078 variant */ #define FDC_82078 0x60 /* 44pin 82078 or 64pin 82078SL */ #define FDC_82078_1 0x61 /* 82078-1 (2Mbps fdc) */ #define FDC_S82078B 0x62 /* S82078B (first seen on Adaptec AVA-2825 VLB * SCSI/EIDE/Floppy controller) */ #define FDC_87306 0x63 /* National Semiconductor PC 87306 */ /* * Beware: the fdc type list is roughly sorted by increasing features. * Presence of features is tested by comparing the FDC version id with the * "oldest" version that has the needed feature. * If during FDC detection, an obscure test fails late in the sequence, don't * assign FDC_UNKNOWN. Else the FDC will be treated as a dumb 8272a, or worse. * This is especially true if the tests are unneeded. */ /* Parameters for a 1.44 3.5" disk */ #define DISK_H1440_SIZE 2880 #define DISK_H1440_SECT 18 #define DISK_H1440_HEAD 2 #define DISK_H1440_TRACK 80 #define DISK_H1440_STRETCH 0 #define DISK_H1440_GAP 0x1B #define DISK_H1440_RATE 0x00 #define DISK_H1440_SPEC1 0xCF #define DISK_H1440_FMT_GAP 0x6C /* Parameters for a 1.44 3.5" drive */ #define DRIVE_H1440_MAX_DTR 500 #define DRIVE_H1440_HLT 16 /* ms */ #define DRIVE_H1440_HUT 16 /* ms */ #define DRIVE_H1440_SRT 4000 /* us */ #define DRIVE_H1440_SPINUP 400 /* ms */ #define DRIVE_H1440_SPINDOWN 3000 /* ms */ #define DRIVE_H1440_SPINDOWN_OFFSET 10 #define DRIVE_H1440_SELECT_DELAY 20 /* ms */ #define DRIVE_H1440_RPS 5 #define DRIVE_H1440_TRACKS 83 #define DRIVE_H1440_TIMEOUT 3000 /* ms */ #define DRIVE_H1440_INTERLEAVE_SECT 20 /* Floppy drive configuration */ #define FIFO_DEPTH 10 #define USE_IMPLIED_SEEK 0 #define USE_FIFO 1 #define FIFO_THRESHOLD 10 #define TRACK_PRECOMPENSATION 0 #define SLOW_FLOPPY 0 #define FD_RESET_DELAY 20 /* microseconds */ /* * FDC state */ static struct drive_state { unsigned track; } drive_state[1]; static struct floppy_fdc_state { int in_sync; int spec1; /* spec1 value last used */ int spec2; /* spec2 value last used */ int dtr; unsigned char dor; unsigned char version; /* FDC version code */ void (*fdc_outb)(unsigned char data, unsigned long port); unsigned char (*fdc_inb)(unsigned long port); unsigned long io_base; unsigned long mmio_base; } fdc_state; /* Synchronization of FDC access. */ #define FD_COMMAND_NONE -1 #define FD_COMMAND_ERROR 2 #define FD_COMMAND_OKAY 3 /* * globals used by 'result()' */ #define MAX_REPLIES 16 static void show_floppy(void); static void floppy_reset(void); /* * IO port operations */ static unsigned char ob_fdc_inb(unsigned long port) { return inb(fdc_state.io_base + port); } static void ob_fdc_outb(unsigned char data, unsigned long port) { outb(data, fdc_state.io_base + port); } /* * MMIO operations */ static unsigned char ob_fdc_mmio_readb(unsigned long port) { return *(unsigned char *)(fdc_state.mmio_base + port); } static void ob_fdc_mmio_writeb(unsigned char data, unsigned long port) { *(unsigned char *)(fdc_state.mmio_base + port) = data; } static int set_dor(char mask, char data) { unsigned char newdor,olddor; olddor = fdc_state.dor; newdor = (olddor & mask) | data; if (newdor != olddor){ fdc_state.dor = newdor; fdc_state.fdc_outb(newdor, FD_DOR); } return olddor; } /* waits until the fdc becomes ready */ static int wait_til_ready(void) { int counter, status; for (counter = 0; counter < 10000; counter++) { status = fdc_state.fdc_inb(FD_STATUS); if (status & STATUS_READY) { return status; } } printk_debug("Getstatus times out (%x)\n", status); show_floppy(); return -3; } /* sends a command byte to the fdc */ static int output_byte(unsigned char byte) { int status; if ((status = wait_til_ready()) < 0) return status; if ((status & (STATUS_READY|STATUS_DIR|STATUS_NON_DMA)) == STATUS_READY){ fdc_state.fdc_outb(byte,FD_DATA); return 0; } printk_debug("Unable to send byte %x to FDC_STATE. Status=%x\n", byte, status); show_floppy(); return -2; } /* gets the response from the fdc */ static int result(unsigned char *reply_buffer, int max_replies) { int i, status=0; for(i=0; i < max_replies; i++) { if ((status = wait_til_ready()) < 0) break; status &= STATUS_DIR|STATUS_READY|STATUS_BUSY|STATUS_NON_DMA; if ((status & ~STATUS_BUSY) == STATUS_READY){ return i; } if (status == (STATUS_DIR|STATUS_READY|STATUS_BUSY)) reply_buffer[i] = fdc_state.fdc_inb(FD_DATA); else break; } if (i == max_replies) return i; printk_debug("get result error. Last status=%x Read bytes=%d\n", status, i); show_floppy(); return -1; } #define MORE_OUTPUT -2 /* does the fdc need more output? */ static int need_more_output(void) { unsigned char reply_buffer[MAX_REPLIES]; int status; if ((status = wait_til_ready()) < 0) return -1; if ((status & (STATUS_READY|STATUS_DIR|STATUS_NON_DMA)) == STATUS_READY) return MORE_OUTPUT; return result(reply_buffer, MAX_REPLIES); } static int output_command(unsigned char *cmd, int count) { int i, status; for(i = 0; i < count; i++) { if ((status = output_byte(cmd[i])) < 0) { printk_err("full command not acceppted, status =%x\n", status); return -1; } } return 0; } static int output_new_command(unsigned char *cmd, int count) { int i, status; if ((status = output_byte(cmd[0])) < 0) return -1; if (need_more_output() != MORE_OUTPUT) return -1; for(i = 1; i < count; i++) { if ((status = output_byte(cmd[i])) < 0) { printk_err("full new command not acceppted, status =%d\n", status); return -1; } } return 0; } /* Collect pending interrupt status */ static unsigned char collect_interrupt(void) { unsigned char pcn = 0xff; unsigned char reply_buffer[MAX_REPLIES]; int nr; #ifdef CONFIG_DEBUG_FLOPPY int i, status; #endif nr = result(reply_buffer, MAX_REPLIES); if (nr != 0) { printk_debug("SENSEI\n"); } else { int max_sensei = 4; do { if (output_byte(FD_SENSEI) < 0) break; nr = result(reply_buffer, MAX_REPLIES); if (nr == 2) { pcn = reply_buffer[1]; printk_debug("SENSEI %02x %02x\n", reply_buffer[0], reply_buffer[1]); } max_sensei--; }while(((reply_buffer[0] & 0x83) != FD_DRIVE) && (nr == 2) && max_sensei); #ifdef CONFIG_DEBUG_FLOPPY status = fdc_state.fdc_inb(FD_STATUS); printk_debug("status = %x, reply_buffer=", status); for(i = 0; i < nr; i++) { printk_debug(" %x", reply_buffer[i]); } printk_debug("\n"); #else fdc_state.fdc_inb(FD_STATUS); #endif } return pcn; } /* selects the fdc and drive, and enables the fdc's input/dma, and it's motor. */ static void set_drive(int drive) { int fdc = (drive >> 2) & 1; int status; unsigned new_dor; if (drive > 3) { printk_err("bad drive value\n"); return; } if (fdc != 0) { printk_err("bad fdc value\n"); return; } drive &= 3; #if 0 new_dor = 8; /* Enable the controller */ #else new_dor = 0; /* Don't enable DMA on the controller */ #endif new_dor |= (1 << (drive + 4)); /* Spinup the selected drive */ new_dor |= drive; /* Select the drive for commands as well */ set_dor(0xc, new_dor); mdelay(DRIVE_H1440_SPINUP); status = fdc_state.fdc_inb(FD_STATUS); printk_debug("set_drive status = %02x, new_dor = %02x\n", status, new_dor); if (status != STATUS_READY) { printk_err("set_drive bad status\n"); } } /* Disable the motor for a given floppy drive */ static void floppy_motor_off(int drive) { unsigned mask; printk_debug("floppy_motor_off\n"); /* fix the number of drives */ drive &= 3; /* Clear the bit for the drive we care about */ mask = 0xff; mask &= ~(1 << (drive +4)); /* Now clear the bit in the Digital Output Register */ set_dor(mask, 0); } /* Set the FDC's data transfer rate on behalf of the specified drive. * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue * of the specify command (i.e. using the fdc_specify function). */ static void fdc_dtr(unsigned rate) { rate &= 3; /* If data rate not already set to desired value, set it. */ if (fdc_state.in_sync && (rate == fdc_state.dtr)) return; /* Set dtr */ fdc_state.fdc_outb(rate, FD_DCR); /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB) * need a stabilization period of several milliseconds to be * enforced after data rate changes before R/W operations. * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies) */ fdc_state.dtr = rate & 3; mdelay(5); } /* fdc_dtr */ static int fdc_configure(int use_implied_seek, int use_fifo, unsigned fifo_threshold, unsigned precompensation) { unsigned config_bits; unsigned char cmd[4]; /* 0 EIS EFIFO POLL FIFOOTHR[4] */ /* santize parameters */ config_bits = fifo_threshold & 0xf; config_bits |= (1 << 4); /* Always disable background floppy poll */ config_bits |= (!use_fifo) << 5; config_bits |= (!!use_implied_seek) << 6; precompensation &= 0xff; /* pre-compensation from track 0 upwards */ cmd[0] = FD_CONFIGURE; cmd[1] = 0; cmd[2] = config_bits; cmd[3] = precompensation; /* Turn on FIFO */ if (output_new_command(cmd, 4) < 0) return 0; return 1; } #define NOMINAL_DTR 500 /* Issue a "SPECIFY" command to set the step rate time, head unload time, * head load time, and DMA disable flag to values needed by floppy. * * The value "dtr" is the data transfer rate in Kbps. It is needed * to account for the data rate-based scaling done by the 82072 and 82077 * FDC types. This parameter is ignored for other types of FDCs (i.e. * 8272a). * * Note that changing the data transfer rate has a (probably deleterious) * effect on the parameters subject to scaling for 82072/82077 FDCs, so * fdc_specify is called again after each data transfer rate * change. * * srt: 1000 to 16000 in microseconds * hut: 16 to 240 milliseconds * hlt: 2 to 254 milliseconds * * These values are rounded up to the next highest available delay time. */ static void fdc_specify( unsigned head_load_time, unsigned head_unload_time, unsigned step_rate) { unsigned char cmd[3]; unsigned long srt, hlt, hut; unsigned long dtr = NOMINAL_DTR; unsigned long scale_dtr = NOMINAL_DTR; int hlt_max_code = 0x7f; int hut_max_code = 0xf; printk_debug("fdc_specify\n"); switch (DISK_H1440_RATE & 0x03) { case 3: dtr = 1000; break; case 1: dtr = 300; if (fdc_state.version >= FDC_82078) { /* chose the default rate table, not the one * where 1 = 2 Mbps */ cmd[0] = FD_DRIVESPEC; cmd[1] = FD_DRIVE & 3; cmd[2] = 0xc0; output_new_command(cmd,3); /* FIXME how do I handle errors here? */ } break; case 2: dtr = 250; break; } if (fdc_state.version >= FDC_82072) { scale_dtr = dtr; hlt_max_code = 0x00; /* 0==256msec*dtr0/dtr (not linear!) */ hut_max_code = 0x0; /* 0==256msec*dtr0/dtr (not linear!) */ } /* Convert step rate from microseconds to milliseconds and 4 bits */ srt = 16 - (step_rate*scale_dtr/1000 + NOMINAL_DTR - 1)/NOMINAL_DTR; if (SLOW_FLOPPY) { srt = srt / 4; } if (srt > 0xf) { srt = 0xf; } hlt = (head_load_time*scale_dtr/2 + NOMINAL_DTR - 1)/NOMINAL_DTR; if (hlt < 0x01) hlt = 0x01; else if (hlt > 0x7f) hlt = hlt_max_code; hut = (head_unload_time*scale_dtr/16 + NOMINAL_DTR - 1)/NOMINAL_DTR; if (hut < 0x1) hut = 0x1; else if (hut > 0xf) hut = hut_max_code; cmd[0] = FD_SPECIFY; cmd[1] = (srt << 4) | hut; cmd[2] = (hlt << 1) | 1; /* Always disable DMA */ /* If these parameters did not change, just return with success */ if (!fdc_state.in_sync || fdc_state.spec1 != cmd[1] || fdc_state.spec2 != cmd[2]) { /* Go ahead and set spec1 and spec2 */ output_command(cmd, 3); /* FIXME how do I handle errors here... */ printk_info("FD_SPECIFY(%02x, %02x)\n", cmd[1], cmd[2]); } } /* fdc_specify */ /* * reset is done by pulling bit 2 of DOR low for a while (old FDCs), * or by setting the self clearing bit 7 of STATUS (newer FDCs) */ static void reset_fdc(void) { unsigned char reply[MAX_REPLIES]; fdc_state.in_sync = 0; /* Pseudo-DMA may intercept 'reset finished' interrupt. */ /* Irrelevant for systems with true DMA (i386). */ if (fdc_state.version >= FDC_82072A) fdc_state.fdc_outb(0x80 | (fdc_state.dtr &3), FD_DSR); else { fdc_state.fdc_outb(fdc_state.dor & ~DOR_NO_RESET, FD_DOR); udelay(FD_RESET_DELAY); fdc_state.fdc_outb(fdc_state.dor, FD_DOR); } result(reply, MAX_REPLIES); } static void show_floppy(void) { printk_debug("\n"); printk_debug("floppy driver state\n"); printk_debug("-------------------\n"); printk_debug("fdc_bytes: %02x %02x xx %02x %02x %02x xx %02x\n", fdc_state.fdc_inb(FD_STATUS_A), fdc_state.fdc_inb(FD_STATUS_B), fdc_state.fdc_inb(FD_TDR), fdc_state.fdc_inb(FD_STATUS), fdc_state.fdc_inb(FD_DATA), fdc_state.fdc_inb(FD_DIR)); printk_debug("status=%x\n", fdc_state.fdc_inb(FD_STATUS)); printk_debug("\n"); } static void floppy_recalibrate(void) { unsigned char cmd[2]; unsigned char reply[MAX_REPLIES]; int nr, success; success = 0; do { printk_debug("floppy_recalibrate\n"); /* Send the recalibrate command to the controller. * We don't have interrupts or anything we can poll * so we have to guess when it is done. */ cmd[0] = FD_RECALIBRATE; cmd[1] = 0; if (output_command(cmd, 2) < 0) continue; /* Sleep for the maximum time the recalibrate command * can run. */ mdelay(80*DRIVE_H1440_SRT/1000); /* Now call FD_SENSEI to end the command * and collect up the reply. */ if (output_byte(FD_SENSEI) < 0) continue; nr = result(reply, MAX_REPLIES); /* Now see if we have succeeded in our seek */ success = /* We have the right size result */ (nr == 2) && /* The command didn't terminate in error */ ((reply[0] & ST0_INTR) == ST0_INTR_OK) && /* We finished a seek */ (reply[0] & ST0_SE) && /* We are at cylinder 0 */ (reply[1] == 0); } while(!success); /* Remember we are at track 0 */ drive_state[FD_DRIVE].track = 0; } static int floppy_seek(unsigned track) { unsigned char cmd[3]; unsigned char reply[MAX_REPLIES]; int nr, success; unsigned distance, old_track; /* Look up the old track and see if we need to * do anything. */ old_track = drive_state[FD_DRIVE].track; if (old_track == track) { return 1; } /* Compute the distance we are about to move, * We need to know this so we know how long to sleep... */ distance = (old_track > track)?(old_track - track):(track - old_track); distance += 1; /* Send the seek command to the controller. * We don't have interrupts or anything we can poll * so we have to guess when it is done. */ cmd[0] = FD_SEEK; cmd[1] = FD_DRIVE; cmd[2] = track; if (output_command(cmd, 3) < 0) return 0; /* Sleep for the time it takes to step throuhg distance tracks. */ mdelay(distance*DRIVE_H1440_SRT/1000); /* Now call FD_SENSEI to end the command * and collect up the reply. */ cmd[0] = FD_SENSEI; if (output_command(cmd, 1) < 0) return 0; nr = result(reply, MAX_REPLIES); /* Now see if we have succeeded in our seek */ success = /* We have the right size result */ (nr == 2) && /* The command didn't terminate in error */ ((reply[0] & ST0_INTR) == ST0_INTR_OK) && /* We finished a seek */ (reply[0] & ST0_SE) && /* We are at cylinder 0 */ (reply[1] == track); if (success) drive_state[FD_DRIVE].track = track; else { printk_debug("seek failed\n"); printk_debug("nr = %d\n", nr); printk_debug("ST0 = %02x\n", reply[0]); printk_debug("PCN = %02x\n", reply[1]); printk_debug("status = %d\n", fdc_state.fdc_inb(FD_STATUS)); } return success; } static int read_ok(unsigned head) { unsigned char results[7]; int result_ok; int nr; /* read back the read results */ nr = result(results, 7); /* Now see if they say we are o.k. */ result_ok = 0; /* Are my result bytes o.k.? */ if (nr == 7) { /* Are we o.k. */ if ((results[0] & ST0_INTR) == ST0_INTR_OK) { result_ok = 1; } /* Or did we get just an overflow error */ else if (((results[0] & ST0_INTR) == ST0_INTR_ERROR) && (results[1]== ST1_OR) && (results[2] == 0)) { result_ok = 1; } /* Verify the reply had the correct head */ if (((results[0] & ST0_HA) >> 2) != head) { result_ok = 0; } /* Verify the reply had the correct drive */ if (((results[0] & ST0_DS) != FD_DRIVE)) { result_ok = 0; } } if (!result_ok) { printk_debug("result_bytes = %d\n", nr); printk_debug("ST0 = %02x\n", results[0]); printk_debug("ST1 = %02x\n", results[1]); printk_debug("ST2 = %02x\n", results[2]); printk_debug(" C = %02x\n", results[3]); printk_debug(" H = %02x\n", results[4]); printk_debug(" R = %02x\n", results[5]); printk_debug(" N = %02x\n", results[6]); } return result_ok; } static int floppy_read_sectors( char *dest, unsigned byte_offset, unsigned length, unsigned sector, unsigned head, unsigned track) { /* MT == Multitrack */ /* MFM == MFM or FM Mode */ /* SK == Skip deleted data addres Mark */ /* HDS == Head number select */ /* DS0 == Disk Drive Select 0 */ /* DS1 == Disk Drive Select 1 */ /* C == Cylinder number 0 - 255 */ /* H == Head number */ /* R == Record */ /* N == The number of data bytes written in a sector */ /* EOT == End of Track */ /* GPL == Gap Length */ /* DTL == Data Length */ /* MT MFM SK 0 1 1 0 0 */ /* 0 0 0 0 0 HDS DS1 DS0 */ /* C, H, R, N, EOT, GPL, DTL */ int i, status, result_ok; int max_bytes, bytes_read; int ret; unsigned char cmd[9]; unsigned end_offset; end_offset = byte_offset + length; max_bytes = 512*(DISK_H1440_SECT - sector + 1); if (byte_offset >= max_bytes) { return 0; } cmd[0] = FD_READ | (((DISK_H1440_HEAD ==2)?1:0) << 6); cmd[1] = (head << 2) | FD_DRIVE; cmd[2] = track; cmd[3] = head; cmd[4] = sector; cmd[5] = 2; /* 2^N *128 == Sector size. Hard coded to 512 bytes */ cmd[6] = DISK_H1440_SECT; cmd[7] = DISK_H1440_GAP; cmd[8] = 0xff; /* Output the command bytes */ if (output_command(cmd, 9) < 0) return -1; /* The execution stage begins when STATUS_READY&STATUS_NON_DMA is set */ do { status = fdc_state.fdc_inb(FD_STATUS); status &= STATUS_READY | STATUS_NON_DMA; } while(status != (STATUS_READY|STATUS_NON_DMA)); for(i = 0; i < max_bytes; i++) { unsigned char byte; if ((status = wait_til_ready()) < 0) { break; } status &= STATUS_READY|STATUS_DIR|STATUS_NON_DMA; if (status != (STATUS_READY|STATUS_DIR|STATUS_NON_DMA)) { break; } byte = fdc_state.fdc_inb(FD_DATA); if ((i >= byte_offset) && (i < end_offset)) { dest[i - byte_offset] = byte; } } bytes_read = i; /* The result stage begins when STATUS_NON_DMA is cleared */ while((status = fdc_state.fdc_inb(FD_STATUS)) & STATUS_NON_DMA) { /* We get extra bytes in the fifo past * the end of the sector and drop them on the floor. * Otherwise the fifo is polluted. */ fdc_state.fdc_inb(FD_DATA); } /* Did I get an error? */ result_ok = read_ok(head); /* Did I read enough bytes? */ ret = -1; if (result_ok && (bytes_read == max_bytes)) { ret = bytes_read - byte_offset; if (ret > length) { ret = length; } } if (ret < 0) { printk_debug("ret = %d\n", ret); printk_debug("bytes_read = %d\n", bytes_read); printk_debug("status = %x\n", status); } return ret; } static int __floppy_read(char *dest, unsigned long offset, unsigned long length) { unsigned head, track, sector, byte_offset, sector_offset; int ret; /* break the offset up into sectors and bytes */ byte_offset = offset % 512; sector_offset = offset / 512; /* Find the disk block we are starting with... */ sector = (sector_offset % DISK_H1440_SECT) + 1; head = (sector_offset / DISK_H1440_SECT) % DISK_H1440_HEAD; track = (sector_offset / (DISK_H1440_SECT *DISK_H1440_HEAD))% DISK_H1440_TRACK; /* First seek to our start track */ if (!floppy_seek(track)) { return -1; } /* Then read the data */ ret = floppy_read_sectors(dest, byte_offset, length, sector, head, track); if (ret >= 0) { return ret; } /* If we failed reset the fdc... */ floppy_reset(); return -1; } static int floppy_read(char *dest, unsigned long offset, unsigned long length) { int fr_result, bytes_read;; printk_debug("floppy_read\n"); bytes_read = 0; do { int max_errors = 3; do { fr_result = __floppy_read(dest + bytes_read, offset, length - bytes_read); if (max_errors-- == 0) { return (bytes_read)?bytes_read: -1; } } while (fr_result <= 0); offset += fr_result; bytes_read += fr_result; } while(bytes_read < length); return bytes_read; } /* Determine the floppy disk controller type */ /* This routine was written by David C. Niemi */ static char get_fdc_version(void) { int bytes, ret; unsigned char reply_buffer[MAX_REPLIES]; ret = output_byte(FD_DUMPREGS); /* 82072 and better know DUMPREGS */ if (ret < 0) return FDC_NONE; if ((bytes = result(reply_buffer, MAX_REPLIES)) <= 0x00) return FDC_NONE; /* No FDC present ??? */ if ((bytes==1) && (reply_buffer[0] == 0x80)){ printk_info("FDC is an 8272A\n"); return FDC_8272A; /* 8272a/765 don't know DUMPREGS */ } if (bytes != 10) { printk_debug("init: DUMPREGS: unexpected return of %d bytes.\n", bytes); return FDC_UNKNOWN; } if (!fdc_configure(USE_IMPLIED_SEEK, USE_FIFO, FIFO_THRESHOLD, TRACK_PRECOMPENSATION)) { printk_info("FDC is an 82072\n"); return FDC_82072; /* 82072 doesn't know CONFIGURE */ } output_byte(FD_PERPENDICULAR); if (need_more_output() == MORE_OUTPUT) { output_byte(0); } else { printk_info("FDC is an 82072A\n"); return FDC_82072A; /* 82072A as found on Sparcs. */ } output_byte(FD_UNLOCK); bytes = result(reply_buffer, MAX_REPLIES); if ((bytes == 1) && (reply_buffer[0] == 0x80)){ printk_info("FDC is a pre-1991 82077\n"); return FDC_82077_ORIG; /* Pre-1991 82077, doesn't know * LOCK/UNLOCK */ } if ((bytes != 1) || (reply_buffer[0] != 0x00)) { printk_debug("FDC init: UNLOCK: unexpected return of %d bytes.\n", bytes); return FDC_UNKNOWN; } output_byte(FD_PARTID); bytes = result(reply_buffer, MAX_REPLIES); if (bytes != 1) { printk_debug("FDC init: PARTID: unexpected return of %d bytes.\n", bytes); return FDC_UNKNOWN; } if (reply_buffer[0] == 0x80) { printk_info("FDC is a post-1991 82077\n"); return FDC_82077; /* Revised 82077AA passes all the tests */ } switch (reply_buffer[0] >> 5) { case 0x0: /* Either a 82078-1 or a 82078SL running at 5Volt */ printk_info("FDC is an 82078.\n"); return FDC_82078; case 0x1: printk_info("FDC is a 44pin 82078\n"); return FDC_82078; case 0x2: printk_info("FDC is a S82078B\n"); return FDC_S82078B; case 0x3: printk_info("FDC is a National Semiconductor PC87306\n"); return FDC_87306; default: printk_info("FDC init: 82078 variant with unknown PARTID=%d.\n", reply_buffer[0] >> 5); return FDC_82078_UNKN; } } /* get_fdc_version */ static int floppy_init(unsigned long io_base, unsigned long mmio_base) { printk_debug("floppy_init\n"); fdc_state.in_sync = 0; fdc_state.spec1 = -1; fdc_state.spec2 = -1; fdc_state.dtr = -1; fdc_state.dor = DOR_NO_RESET; fdc_state.version = FDC_UNKNOWN; if (mmio_base) { fdc_state.fdc_inb = ob_fdc_mmio_readb; fdc_state.fdc_outb = ob_fdc_mmio_writeb; } else { fdc_state.fdc_inb = ob_fdc_inb; fdc_state.fdc_outb = ob_fdc_outb; } fdc_state.io_base = io_base; fdc_state.mmio_base = mmio_base; reset_fdc(); /* Try to determine the floppy controller type */ fdc_state.version = get_fdc_version(); if (fdc_state.version == FDC_NONE) { return -1; } floppy_reset(); printk_info("fdc_state.version = %04x\n", fdc_state.version); return 0; } static void floppy_reset(void) { printk_debug("floppy_reset\n"); floppy_motor_off(FD_DRIVE); reset_fdc(); fdc_dtr(DISK_H1440_RATE); /* program data rate via ccr */ collect_interrupt(); fdc_configure(USE_IMPLIED_SEEK, USE_FIFO, FIFO_THRESHOLD, TRACK_PRECOMPENSATION); fdc_specify(DRIVE_H1440_HLT, DRIVE_H1440_HUT, DRIVE_H1440_SRT); set_drive(FD_DRIVE); floppy_recalibrate(); fdc_state.in_sync = 1; } static void ob_floppy_initialize(const char *path) { int props[3]; phandle_t ph = find_dev(path); set_property(ph, "device_type", "block", sizeof("block")); // Set dummy reg properties props[0] = __cpu_to_be32(0); props[1] = __cpu_to_be32(0); props[2] = __cpu_to_be32(0); set_property(ph, "reg", (char *)&props, 3*sizeof(int)); fword("is-deblocker"); } static void ob_floppy_open(int *idx) { int ret = 1; phandle_t ph; fword("my-unit"); idx[0]=POP(); fword("my-parent"); fword("ihandle>phandle"); ph=(phandle_t)POP(); selfword("open-deblocker"); /* interpose disk-label */ ph = find_dev("/packages/disk-label"); fword("my-args"); PUSH_ph( ph ); fword("interpose"); RET ( -ret ); } static void ob_floppy_close(int *idx) { selfword("close-deblocker"); } static void ob_floppy_read_blocks(int *idx) { cell cnt = POP(); ucell blk = POP(); char *dest = (char*)POP(); floppy_read(dest, blk*512, cnt*512); PUSH(cnt); } static void ob_floppy_block_size(int *idx) { PUSH(512); } static void ob_floppy_max_transfer(int *idx) { // Fixme PUSH(18 * 512); } NODE_METHODS(ob_floppy) = { { "open", ob_floppy_open }, { "close", ob_floppy_close }, { "read-blocks", ob_floppy_read_blocks }, { "block-size", ob_floppy_block_size }, { "max-transfer", ob_floppy_max_transfer }, }; int ob_floppy_init(const char *path, const char *dev_name, unsigned long io_base, unsigned long mmio_base) { char nodebuff[128]; phandle_t aliases; snprintf(nodebuff, sizeof(nodebuff), "%s/%s", path, dev_name); if (!mmio_base) { REGISTER_NAMED_NODE(ob_floppy, nodebuff); ob_floppy_initialize(nodebuff); } else { // Already in tree and mapped REGISTER_NODE_METHODS(ob_floppy, nodebuff); } floppy_init(io_base, mmio_base); aliases = find_dev("/aliases"); set_property(aliases, "floppy", nodebuff, strlen(nodebuff) + 1); return 0; }