You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
464 lines
11 KiB
464 lines
11 KiB
/*
|
|
* linux/kernel/floppy.c
|
|
*
|
|
* (C) 1991 Linus Torvalds
|
|
*/
|
|
|
|
/*
|
|
* 02.12.91 - Changed to static variables to indicate need for reset
|
|
* and recalibrate. This makes some things easier (output_byte reset
|
|
* checking etc), and means less interrupt jumping in case of errors,
|
|
* so the code is hopefully easier to understand.
|
|
*/
|
|
|
|
/*
|
|
* This file is certainly a mess. I've tried my best to get it working,
|
|
* but I don't like programming floppies, and I have only one anyway.
|
|
* Urgel. I should check for more errors, and do more graceful error
|
|
* recovery. Seems there are problems with several drives. I've tried to
|
|
* correct them. No promises.
|
|
*/
|
|
|
|
/*
|
|
* As with hd.c, all routines within this file can (and will) be called
|
|
* by interrupts, so extreme caution is needed. A hardware interrupt
|
|
* handler may not sleep, or a kernel panic will happen. Thus I cannot
|
|
* call "floppy-on" directly, but have to set a special timer interrupt
|
|
* etc.
|
|
*
|
|
* Also, I'm not certain this works on more than 1 floppy. Bugs may
|
|
* abund.
|
|
*/
|
|
|
|
#include <linux/sched.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/fdreg.h>
|
|
#include <asm/system.h>
|
|
#include <asm/io.h>
|
|
#include <asm/segment.h>
|
|
|
|
#define MAJOR_NR 2
|
|
#include "blk.h"
|
|
|
|
static int recalibrate = 0;
|
|
static int reset = 0;
|
|
static int seek = 0;
|
|
|
|
extern unsigned char current_DOR;
|
|
|
|
#define immoutb_p(val,port) \
|
|
__asm__("outb %0,%1\n\tjmp 1f\n1:\tjmp 1f\n1:"::"a" ((char) (val)),"i" (port))
|
|
|
|
#define TYPE(x) ((x)>>2)
|
|
#define DRIVE(x) ((x)&0x03)
|
|
/*
|
|
* Note that MAX_ERRORS=8 doesn't imply that we retry every bad read
|
|
* max 8 times - some types of errors increase the errorcount by 2,
|
|
* so we might actually retry only 5-6 times before giving up.
|
|
*/
|
|
#define MAX_ERRORS 8
|
|
|
|
/*
|
|
* globals used by 'result()'
|
|
*/
|
|
#define MAX_REPLIES 7
|
|
static unsigned char reply_buffer[MAX_REPLIES];
|
|
#define ST0 (reply_buffer[0])
|
|
#define ST1 (reply_buffer[1])
|
|
#define ST2 (reply_buffer[2])
|
|
#define ST3 (reply_buffer[3])
|
|
|
|
/*
|
|
* This struct defines the different floppy types. Unlike minix
|
|
* linux doesn't have a "search for right type"-type, as the code
|
|
* for that is convoluted and weird. I've got enough problems with
|
|
* this driver as it is.
|
|
*
|
|
* The 'stretch' tells if the tracks need to be boubled for some
|
|
* types (ie 360kB diskette in 1.2MB drive etc). Others should
|
|
* be self-explanatory.
|
|
*/
|
|
static struct floppy_struct {
|
|
unsigned int size, sect, head, track, stretch;
|
|
unsigned char gap,rate,spec1;
|
|
} floppy_type[] = {
|
|
{ 0, 0,0, 0,0,0x00,0x00,0x00 }, /* no testing */
|
|
{ 720, 9,2,40,0,0x2A,0x02,0xDF }, /* 360kB PC diskettes */
|
|
{ 2400,15,2,80,0,0x1B,0x00,0xDF }, /* 1.2 MB AT-diskettes */
|
|
{ 720, 9,2,40,1,0x2A,0x02,0xDF }, /* 360kB in 720kB drive */
|
|
{ 1440, 9,2,80,0,0x2A,0x02,0xDF }, /* 3.5" 720kB diskette */
|
|
{ 720, 9,2,40,1,0x23,0x01,0xDF }, /* 360kB in 1.2MB drive */
|
|
{ 1440, 9,2,80,0,0x23,0x01,0xDF }, /* 720kB in 1.2MB drive */
|
|
{ 2880,18,2,80,0,0x1B,0x00,0xCF }, /* 1.44MB diskette */
|
|
};
|
|
/*
|
|
* Rate is 0 for 500kb/s, 2 for 300kbps, 1 for 250kbps
|
|
* Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
|
|
* H is head unload time (1=16ms, 2=32ms, etc)
|
|
*
|
|
* Spec2 is (HLD<<1 | ND), where HLD is head load time (1=2ms, 2=4 ms etc)
|
|
* and ND is set means no DMA. Hardcoded to 6 (HLD=6ms, use DMA).
|
|
*/
|
|
|
|
extern void floppy_interrupt(void);
|
|
extern char tmp_floppy_area[1024];
|
|
|
|
/*
|
|
* These are global variables, as that's the easiest way to give
|
|
* information to interrupts. They are the data used for the current
|
|
* request.
|
|
*/
|
|
static int cur_spec1 = -1;
|
|
static int cur_rate = -1;
|
|
static struct floppy_struct * floppy = floppy_type;
|
|
static unsigned char current_drive = 0;
|
|
static unsigned char sector = 0;
|
|
static unsigned char head = 0;
|
|
static unsigned char track = 0;
|
|
static unsigned char seek_track = 0;
|
|
static unsigned char current_track = 255;
|
|
static unsigned char command = 0;
|
|
unsigned char selected = 0;
|
|
struct task_struct * wait_on_floppy_select = NULL;
|
|
|
|
void floppy_deselect(unsigned int nr)
|
|
{
|
|
if (nr != (current_DOR & 3))
|
|
printk("floppy_deselect: drive not selected\n\r");
|
|
selected = 0;
|
|
wake_up(&wait_on_floppy_select);
|
|
}
|
|
|
|
/*
|
|
* floppy-change is never called from an interrupt, so we can relax a bit
|
|
* here, sleep etc. Note that floppy-on tries to set current_DOR to point
|
|
* to the desired drive, but it will probably not survive the sleep if
|
|
* several floppies are used at the same time: thus the loop.
|
|
*/
|
|
int floppy_change(unsigned int nr)
|
|
{
|
|
repeat:
|
|
floppy_on(nr);
|
|
while ((current_DOR & 3) != nr && selected)
|
|
interruptible_sleep_on(&wait_on_floppy_select);
|
|
if ((current_DOR & 3) != nr)
|
|
goto repeat;
|
|
if (inb(FD_DIR) & 0x80) {
|
|
floppy_off(nr);
|
|
return 1;
|
|
}
|
|
floppy_off(nr);
|
|
return 0;
|
|
}
|
|
|
|
#define copy_buffer(from,to) \
|
|
__asm__("cld ; rep ; movsl" \
|
|
::"c" (BLOCK_SIZE/4),"S" ((long)(from)),"D" ((long)(to)) \
|
|
)
|
|
|
|
static void setup_DMA(void)
|
|
{
|
|
long addr = (long) CURRENT->buffer;
|
|
|
|
cli();
|
|
if (addr >= 0x100000) {
|
|
addr = (long) tmp_floppy_area;
|
|
if (command == FD_WRITE)
|
|
copy_buffer(CURRENT->buffer,tmp_floppy_area);
|
|
}
|
|
/* mask DMA 2 */
|
|
immoutb_p(4|2,10);
|
|
/* output command byte. I don't know why, but everyone (minix, */
|
|
/* sanches & canton) output this twice, first to 12 then to 11 */
|
|
__asm__("outb %%al,$12\n\tjmp 1f\n1:\tjmp 1f\n1:\t"
|
|
"outb %%al,$11\n\tjmp 1f\n1:\tjmp 1f\n1:"::
|
|
"a" ((char) ((command == FD_READ)?DMA_READ:DMA_WRITE)));
|
|
/* 8 low bits of addr */
|
|
immoutb_p(addr,4);
|
|
addr >>= 8;
|
|
/* bits 8-15 of addr */
|
|
immoutb_p(addr,4);
|
|
addr >>= 8;
|
|
/* bits 16-19 of addr */
|
|
immoutb_p(addr,0x81);
|
|
/* low 8 bits of count-1 (1024-1=0x3ff) */
|
|
immoutb_p(0xff,5);
|
|
/* high 8 bits of count-1 */
|
|
immoutb_p(3,5);
|
|
/* activate DMA 2 */
|
|
immoutb_p(0|2,10);
|
|
sti();
|
|
}
|
|
|
|
static void output_byte(char byte)
|
|
{
|
|
int counter;
|
|
unsigned char status;
|
|
|
|
if (reset)
|
|
return;
|
|
for(counter = 0 ; counter < 10000 ; counter++) {
|
|
status = inb_p(FD_STATUS) & (STATUS_READY | STATUS_DIR);
|
|
if (status == STATUS_READY) {
|
|
outb(byte,FD_DATA);
|
|
return;
|
|
}
|
|
}
|
|
reset = 1;
|
|
printk("Unable to send byte to FDC\n\r");
|
|
}
|
|
|
|
static int result(void)
|
|
{
|
|
int i = 0, counter, status;
|
|
|
|
if (reset)
|
|
return -1;
|
|
for (counter = 0 ; counter < 10000 ; counter++) {
|
|
status = inb_p(FD_STATUS)&(STATUS_DIR|STATUS_READY|STATUS_BUSY);
|
|
if (status == STATUS_READY)
|
|
return i;
|
|
if (status == (STATUS_DIR|STATUS_READY|STATUS_BUSY)) {
|
|
if (i >= MAX_REPLIES)
|
|
break;
|
|
reply_buffer[i++] = inb_p(FD_DATA);
|
|
}
|
|
}
|
|
reset = 1;
|
|
printk("Getstatus times out\n\r");
|
|
return -1;
|
|
}
|
|
|
|
static void bad_flp_intr(void)
|
|
{
|
|
CURRENT->errors++;
|
|
if (CURRENT->errors > MAX_ERRORS) {
|
|
floppy_deselect(current_drive);
|
|
end_request(0);
|
|
}
|
|
if (CURRENT->errors > MAX_ERRORS/2)
|
|
reset = 1;
|
|
else
|
|
recalibrate = 1;
|
|
}
|
|
|
|
/*
|
|
* Ok, this interrupt is called after a DMA read/write has succeeded,
|
|
* so we check the results, and copy any buffers.
|
|
*/
|
|
static void rw_interrupt(void)
|
|
{
|
|
if (result() != 7 || (ST0 & 0xf8) || (ST1 & 0xbf) || (ST2 & 0x73)) {
|
|
if (ST1 & 0x02) {
|
|
printk("Drive %d is write protected\n\r",current_drive);
|
|
floppy_deselect(current_drive);
|
|
end_request(0);
|
|
} else
|
|
bad_flp_intr();
|
|
do_fd_request();
|
|
return;
|
|
}
|
|
if (command == FD_READ && (unsigned long)(CURRENT->buffer) >= 0x100000)
|
|
copy_buffer(tmp_floppy_area,CURRENT->buffer);
|
|
floppy_deselect(current_drive);
|
|
end_request(1);
|
|
do_fd_request();
|
|
}
|
|
|
|
inline void setup_rw_floppy(void)
|
|
{
|
|
setup_DMA();
|
|
do_floppy = rw_interrupt;
|
|
output_byte(command);
|
|
output_byte(head<<2 | current_drive);
|
|
output_byte(track);
|
|
output_byte(head);
|
|
output_byte(sector);
|
|
output_byte(2); /* sector size = 512 */
|
|
output_byte(floppy->sect);
|
|
output_byte(floppy->gap);
|
|
output_byte(0xFF); /* sector size (0xff when n!=0 ?) */
|
|
if (reset)
|
|
do_fd_request();
|
|
}
|
|
|
|
/*
|
|
* This is the routine called after every seek (or recalibrate) interrupt
|
|
* from the floppy controller. Note that the "unexpected interrupt" routine
|
|
* also does a recalibrate, but doesn't come here.
|
|
*/
|
|
static void seek_interrupt(void)
|
|
{
|
|
/* sense drive status */
|
|
output_byte(FD_SENSEI);
|
|
if (result() != 2 || (ST0 & 0xF8) != 0x20 || ST1 != seek_track) {
|
|
bad_flp_intr();
|
|
do_fd_request();
|
|
return;
|
|
}
|
|
current_track = ST1;
|
|
setup_rw_floppy();
|
|
}
|
|
|
|
/*
|
|
* This routine is called when everything should be correctly set up
|
|
* for the transfer (ie floppy motor is on and the correct floppy is
|
|
* selected).
|
|
*/
|
|
static void transfer(void)
|
|
{
|
|
if (cur_spec1 != floppy->spec1) {
|
|
cur_spec1 = floppy->spec1;
|
|
output_byte(FD_SPECIFY);
|
|
output_byte(cur_spec1); /* hut etc */
|
|
output_byte(6); /* Head load time =6ms, DMA */
|
|
}
|
|
if (cur_rate != floppy->rate)
|
|
outb_p(cur_rate = floppy->rate,FD_DCR);
|
|
if (reset) {
|
|
do_fd_request();
|
|
return;
|
|
}
|
|
if (!seek) {
|
|
setup_rw_floppy();
|
|
return;
|
|
}
|
|
do_floppy = seek_interrupt;
|
|
if (seek_track) {
|
|
output_byte(FD_SEEK);
|
|
output_byte(head<<2 | current_drive);
|
|
output_byte(seek_track);
|
|
} else {
|
|
output_byte(FD_RECALIBRATE);
|
|
output_byte(head<<2 | current_drive);
|
|
}
|
|
if (reset)
|
|
do_fd_request();
|
|
}
|
|
|
|
/*
|
|
* Special case - used after a unexpected interrupt (or reset)
|
|
*/
|
|
static void recal_interrupt(void)
|
|
{
|
|
output_byte(FD_SENSEI);
|
|
if (result()!=2 || (ST0 & 0xE0) == 0x60)
|
|
reset = 1;
|
|
else
|
|
recalibrate = 0;
|
|
do_fd_request();
|
|
}
|
|
|
|
void unexpected_floppy_interrupt(void)
|
|
{
|
|
output_byte(FD_SENSEI);
|
|
if (result()!=2 || (ST0 & 0xE0) == 0x60)
|
|
reset = 1;
|
|
else
|
|
recalibrate = 1;
|
|
}
|
|
|
|
static void recalibrate_floppy(void)
|
|
{
|
|
recalibrate = 0;
|
|
current_track = 0;
|
|
current_drive = 1; /* by wyj, ?? */
|
|
do_floppy = recal_interrupt;
|
|
output_byte(FD_RECALIBRATE);
|
|
output_byte(head<<2 | current_drive);
|
|
if (reset)
|
|
do_fd_request();
|
|
}
|
|
|
|
static void reset_interrupt(void)
|
|
{
|
|
output_byte(FD_SENSEI);
|
|
(void) result();
|
|
output_byte(FD_SPECIFY);
|
|
output_byte(cur_spec1); /* hut etc */
|
|
output_byte(6); /* Head load time =6ms, DMA */
|
|
do_fd_request();
|
|
}
|
|
|
|
/*
|
|
* reset is done by pulling bit 2 of DOR low for a while.
|
|
*/
|
|
static void reset_floppy(void)
|
|
{
|
|
int i;
|
|
|
|
reset = 0;
|
|
cur_spec1 = -1;
|
|
cur_rate = -1;
|
|
recalibrate = 1;
|
|
printk("Reset-floppy called\n\r");
|
|
cli();
|
|
do_floppy = reset_interrupt;
|
|
outb_p(current_DOR & ~0x04,FD_DOR);
|
|
for (i=0 ; i<100 ; i++)
|
|
__asm__("nop");
|
|
outb(current_DOR,FD_DOR);
|
|
sti();
|
|
}
|
|
|
|
static void floppy_on_interrupt(void)
|
|
{
|
|
/* We cannot do a floppy-select, as that might sleep. We just force it */
|
|
selected = 1;
|
|
if (current_drive != (current_DOR & 3)) {
|
|
current_DOR &= 0xFC;
|
|
current_DOR |= current_drive;
|
|
outb(current_DOR,FD_DOR);
|
|
add_timer(2,&transfer);
|
|
} else
|
|
transfer();
|
|
}
|
|
|
|
void do_fd_request(void)
|
|
{
|
|
unsigned int block;
|
|
|
|
seek = 0;
|
|
if (reset) {
|
|
reset_floppy();
|
|
return;
|
|
}
|
|
if (recalibrate) {
|
|
recalibrate_floppy();
|
|
return;
|
|
}
|
|
INIT_REQUEST;
|
|
floppy = (MINOR(CURRENT->dev)>>2) + floppy_type;
|
|
if (current_drive != CURRENT_DEV)
|
|
seek = 1;
|
|
current_drive = CURRENT_DEV;
|
|
block = CURRENT->sector;
|
|
if (block+2 > floppy->size) {
|
|
end_request(0);
|
|
goto repeat;
|
|
}
|
|
sector = block % floppy->sect;
|
|
block /= floppy->sect;
|
|
head = block % floppy->head;
|
|
track = block / floppy->head;
|
|
seek_track = track << floppy->stretch;
|
|
if (seek_track != current_track)
|
|
seek = 1;
|
|
sector++;
|
|
if (CURRENT->cmd == READ)
|
|
command = FD_READ;
|
|
else if (CURRENT->cmd == WRITE)
|
|
command = FD_WRITE;
|
|
else
|
|
panic("do_fd_request: unknown command");
|
|
add_timer(ticks_to_floppy_on(current_drive),&floppy_on_interrupt);
|
|
}
|
|
|
|
void floppy_init(void)
|
|
{
|
|
blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
|
|
set_trap_gate(0x26,&floppy_interrupt);
|
|
outb(inb_p(0x21)&~0x40,0x21);
|
|
}
|