/* *  linux/kernel/floppy.c * *  Copyright (C) 1991, 1992  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. *//* * 28.02.92 - made track-buffering routines, based on the routines written * by entropy@wintermute.wpi.edu (Lawrence Foard). Linus. *//* * Automatic floppy-detection and formatting written by Werner Almesberger * (almesber@nessie.cs.id.ethz.ch), who also corrected some problems with * the floppy-change signal detection. *//* * 1992/7/22 -- Hennus Bergman: Added better error reporting, fixed  * FDC data overrun bug, added some preliminary stuff for vertical * recording support. * * 1992/9/17: Added DMA allocation & DMA functions. -- hhb. * * TODO: Errors are still not counted properly. *//* 1992/9/20 * Modifications for ``Sector Shifting'' by Rob Hooft (hooft@chem.ruu.nl) * modelled after the freeware MS/DOS program fdformat/88 V1.8 by  * Christoph H. Hochst\"atter. * I have fixed the shift values to the ones I always use. Maybe a new * ioctl() should be created to be able to modify them. * There is a bug in the driver that makes it impossible to format a * floppy as the first thing after bootup. *//* * 1993/4/29 -- Linus -- cleaned up the timer handling in the kernel, and * this helped the floppy driver as well. Much cleaner, and still seems to * work. */#define REALLY_SLOW_IO#define FLOPPY_IRQ 6#define FLOPPY_DMA 2#include <linux/sched.h>#include <linux/fs.h>#include <linux/kernel.h>#include <linux/timer.h>#include <linux/fdreg.h>#include <linux/fd.h>#include <linux/errno.h>#include <asm/dma.h>#include <asm/system.h>#include <asm/io.h>#include <asm/segment.h>#define MAJOR_NR FLOPPY_MAJOR#include "blk.h"static unsigned int changed_floppies = 0, fake_change = 0;static int initial_reset_flag = 0;static int need_configure = 1;		/* for 82077 */static int recalibrate = 0;static int reset = 0;static int recover = 0; /* recalibrate immediately after resetting */static int seek = 0;static unsigned char current_DOR = 0x0C;static unsigned char running = 0;#define TYPE(x) ((x)>>2)#define DRIVE(x) ((x)&0x03)/* * Note that MAX_ERRORS=X doesn't imply that we retry every bad read * max X times - some types of errors increase the errorcount by 2 or * even 3, so we might actually retry only X/2 times before giving up. */#define MAX_ERRORS 12/* * Maximum disk size (in kilobytes). This default is used whenever the * current disk size is unknown. */#define MAX_DISK_SIZE 1440/* * Maximum number of sectors in a track buffer. Track buffering is disabled * if tracks are bigger. */#define MAX_BUFFER_SECTORS 18/* * The DMA channel used by the floppy controller cannot access data at * addresses >= 16MB * * Went back to the 1MB limit, as some people had problems with the floppy * driver otherwise. It doesn't matter much for performance anyway, as most * floppy accesses go through the track buffer. */#define LAST_DMA_ADDR	(0x100000 - BLOCK_SIZE)/* * globals used by 'result()' */#define MAX_REPLIES 7static 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. * * The 'stretch' tells if the tracks need to be doubled for some * types (ie 360kB diskette in 1.2MB drive etc). Others should * be self-explanatory. */static struct floppy_struct floppy_type[] = {	{    0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL },	/* no testing */	{  720, 9,2,40,0,0x2A,0x02,0xDF,0x50,NULL },	/* 360kB PC diskettes */	{ 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,NULL },	/* 1.2 MB AT-diskettes */	{  720, 9,2,40,1,0x2A,0x02,0xDF,0x50,NULL },	/* 360kB in 720kB drive */	{ 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,NULL },	/* 3.5" 720kB diskette */	{  720, 9,2,40,1,0x23,0x01,0xDF,0x50,NULL },	/* 360kB in 1.2MB drive */	{ 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,NULL },	/* 720kB in 1.2MB drive */	{ 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,NULL },	/* 1.44MB diskette */};/* * Auto-detection. Each drive type has a pair of formats which are * used in succession to try to read the disk. If the FDC cannot lock onto * the disk, the next format is tried. This uses the variable 'probing'. */static struct floppy_struct floppy_types[] = {	{  720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"360k/PC" }, /* 360kB PC diskettes */	{  720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"360k/PC" }, /* 360kB PC diskettes */	{ 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"1.2M" },	  /* 1.2 MB AT-diskettes */	{  720, 9,2,40,1,0x23,0x01,0xDF,0x50,"360k/AT" }, /* 360kB in 1.2MB drive */	{ 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"720k" },	  /* 3.5" 720kB diskette */	{ 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"720k" },	  /* 3.5" 720kB diskette */	{ 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"1.44M" },	  /* 1.44MB diskette */	{ 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"720k/AT" }, /* 3.5" 720kB diskette */};/* Auto-detection: Disk type used until the next media change occurs. */struct floppy_struct *current_type[4] = { NULL, NULL, NULL, NULL };/* This type is tried first. */struct floppy_struct *base_type[4];/* * User-provided type information. current_type points to * the respective entry of this array. */struct floppy_struct user_params[4];static int floppy_sizes[] ={	MAX_DISK_SIZE, MAX_DISK_SIZE, MAX_DISK_SIZE, MAX_DISK_SIZE,	 360, 360 ,360, 360,	1200,1200,1200,1200,	 360, 360, 360, 360,	 720, 720, 720, 720,	 360, 360, 360, 360,	 720, 720, 720, 720,	1440,1440,1440,1440};/* * The driver is trying to determine the correct media format * while probing is set. rw_interrupt() clears it after a * successful access. */static int probing = 0;/* * (User-provided) media information is _not_ discarded after a media change * if the corresponding keep_data flag is non-zero. Positive values are * decremented after each probe. */static int keep_data[4] = { 0,0,0,0 };/* * Announce successful media type detection and media information loss after * disk changes. * Also used to enable/disable printing of overrun warnings. */static ftd_msg[4] = { 0,0,0,0 };/* Prevent "aliased" accesses. */static fd_ref[4] = { 0,0,0,0 };static fd_device[4] = { 0,0,0,0 };/* Synchronization of FDC access. */static volatile int format_status = FORMAT_NONE, fdc_busy = 0;static struct wait_queue *fdc_wait = NULL, *format_done = NULL;/* Errors during formatting are counted here. */static int format_errors;/* Format request descriptor. */static struct format_descr format_req;/* * Current device number. Taken either from the block header or from the * format request descriptor. */#define CURRENT_DEVICE (format_status == FORMAT_BUSY ? format_req.device : \   (CURRENT->dev))/* Current error count. */#define CURRENT_ERRORS (format_status == FORMAT_BUSY ? format_errors : \    (CURRENT->errors))/* * Threshold for reporting FDC errors to the console. * Setting this to zero may flood your screen when using * ultra cheap floppies ;-) */static unsigned short min_report_error_cnt[4] = {2, 2, 2, 2};/* * Rate is 0 for 500kb/s, 1 for 300kbps, 2 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). *//* * Track buffer and block buffer (in case track buffering doesn't work). * Because these are written to by the DMA controller, they must * not contain a 64k byte boundary crossing, or data will be * corrupted/lost. Alignment of these is enforced in boot/head.s. * Note that you must not change the sizes below without updating head.s. */extern char tmp_floppy_area[BLOCK_SIZE];extern char floppy_track_buffer[512*2*MAX_BUFFER_SECTORS];static void redo_fd_request(void);/* * These are global variables, as that's the easiest way to give * information to interrupts. They are the data used for the current * request. */#define NO_TRACK 255static int read_track = 0;	/* flag to indicate if we want to read entire track */static int buffer_track = -1;static int buffer_drive = -1;static int cur_spec1 = -1;static int cur_rate = -1;static struct floppy_struct * floppy = floppy_type;static unsigned char current_drive = 255;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 = NO_TRACK;static unsigned char command = 0;static unsigned char fdc_version = FDC_TYPE_STD;	/* FDC version code */static void floppy_ready(void);static void select_callback(unsigned long unused){	floppy_ready();}static void floppy_select(unsigned int nr){	static struct timer_list select = { NULL, NULL, 0, 0, select_callback };	if (current_drive == (current_DOR & 3)) {		floppy_ready();		return;	}	seek = 1;	current_track = NO_TRACK;	current_DOR &= 0xFC;	current_DOR |= current_drive;	outb(current_DOR,FD_DOR);	del_timer(&select);	select.expires = 2;	add_timer(&select);}static void motor_on_callback(unsigned long nr){	running |= 0x10 << nr;	floppy_select(nr);}static struct timer_list motor_on_timer[4] = {	{ NULL, NULL, 0, 0, motor_on_callback },	{ NULL, NULL, 0, 1, motor_on_callback },	{ NULL, NULL, 0, 2, motor_on_callback },	{ NULL, NULL, 0, 3, motor_on_callback }};static void motor_off_callback(unsigned long nr){	unsigned char mask = ~(0x10 << nr);	cli();	running &= mask;	current_DOR &= mask;	outb(current_DOR,FD_DOR);	sti();}static struct timer_list motor_off_timer[4] = {	{ NULL, NULL, 0, 0, motor_off_callback },	{ NULL, NULL, 0, 1, motor_off_callback },	{ NULL, NULL, 0, 2, motor_off_callback },	{ NULL, NULL, 0, 3, motor_off_callback }};static void floppy_on(unsigned int nr){	unsigned char mask = 0x10 << nr;	del_timer(motor_off_timer + nr);	if (mask & running)		floppy_select(nr);	if (!(mask & current_DOR)) {		del_timer(motor_on_timer + nr);		motor_on_timer[nr].expires = HZ;		add_timer(motor_on_timer + nr);	}	current_DOR &= 0xFC;	current_DOR |= mask;	current_DOR |= nr;	outb(current_DOR,FD_DOR);}static void floppy_off(unsigned int nr){	del_timer(motor_off_timer+nr);	motor_off_timer[nr].expires = 3*HZ;	add_timer(motor_off_timer+nr);}void request_done(int uptodate){	timer_active &= ~(1 << FLOPPY_TIMER);	if (format_status != FORMAT_BUSY)		end_request(uptodate);	else {		format_status = uptodate ? FORMAT_OKAY : FORMAT_ERROR;		wake_up(&format_done);	}}/* * 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(struct buffer_head * bh){	unsigned int mask = 1 << (bh->b_dev & 0x03);	if (MAJOR(bh->b_dev) != MAJOR_NR) {		printk("floppy_changed: not a floppy\n");		return 0;	}	if (fake_change & mask) {		buffer_track = -1;		fake_change &= ~mask;/* omitting the next line breaks formatting in a horrible way ... */		changed_floppies &= ~mask;		return 1;	}	if (changed_floppies & mask) {		buffer_track = -1;		changed_floppies &= ~mask;		recalibrate = 1;		return 1;	}	if (!bh)		return 0;	if (bh->b_dirt)		ll_rw_block(WRITE, 1, &bh);	else {		buffer_track = -1;		bh->b_uptodate = 0;		ll_rw_block(READ, 1, &bh);	}	wait_on_buffer(bh);	if (changed_floppies & mask) {		changed_floppies &= ~mask;		recalibrate = 1;		return 1;	}	return 0;}#define copy_buffer(from,to) \__asm__("cld ; rep ; movsl" \	: \	:"c" (BLOCK_SIZE/4),"S" ((long)(from)),"D" ((long)(to)) \	:"cx","di","si")static void setup_DMA(void){	unsigned long addr,count;	unsigned char dma_code;	dma_code = DMA_WRITE;	if (command == FD_READ)		dma_code = DMA_READ;	if (command == FD_FORMAT) {		addr = (long) tmp_floppy_area;		count = floppy->sect*4;	} else {		addr = (long) CURRENT->buffer;		count = 1024;	}	if (read_track) {/* mark buffer-track bad, in case all this fails.. */		buffer_drive = buffer_track = -1;		count = floppy->sect*floppy->head*512;		addr = (long) floppy_track_buffer;	} else if (addr >= LAST_DMA_ADDR) {		addr = (long) tmp_floppy_area;		if (command == FD_WRITE)			copy_buffer(CURRENT->buffer,tmp_floppy_area);	}	cli();	disable_dma(FLOPPY_DMA);