amiflop.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 *  linux/amiga/amiflop.c
   4 *
   5 *  Copyright (C) 1993  Greg Harp
   6 *  Portions of this driver are based on code contributed by Brad Pepers
   7 *  
   8 *  revised 28.5.95 by Joerg Dorchain
   9 *  - now no bugs(?) any more for both HD & DD
  10 *  - added support for 40 Track 5.25" drives, 80-track hopefully behaves
  11 *    like 3.5" dd (no way to test - are there any 5.25" drives out there
  12 *    that work on an A4000?)
  13 *  - wrote formatting routine (maybe dirty, but works)
  14 *
  15 *  june/july 1995 added ms-dos support by Joerg Dorchain
  16 *  (portions based on messydos.device and various contributors)
  17 *  - currently only 9 and 18 sector disks
  18 *
  19 *  - fixed a bug with the internal trackbuffer when using multiple 
  20 *    disks the same time
  21 *  - made formatting a bit safer
  22 *  - added command line and machine based default for "silent" df0
  23 *
  24 *  december 1995 adapted for 1.2.13pl4 by Joerg Dorchain
  25 *  - works but I think it's inefficient. (look in redo_fd_request)
  26 *    But the changes were very efficient. (only three and a half lines)
  27 *
  28 *  january 1996 added special ioctl for tracking down read/write problems
  29 *  - usage ioctl(d, RAW_TRACK, ptr); the raw track buffer (MFM-encoded data
  30 *    is copied to area. (area should be large enough since no checking is
  31 *    done - 30K is currently sufficient). return the actual size of the
  32 *    trackbuffer
  33 *  - replaced udelays() by a timer (CIAA timer B) for the waits 
  34 *    needed for the disk mechanic.
  35 *
  36 *  february 1996 fixed error recovery and multiple disk access
  37 *  - both got broken the first time I tampered with the driver :-(
  38 *  - still not safe, but better than before
  39 *
  40 *  revised Marts 3rd, 1996 by Jes Sorensen for use in the 1.3.28 kernel.
  41 *  - Minor changes to accept the kdev_t.
  42 *  - Replaced some more udelays with ms_delays. Udelay is just a loop,
  43 *    and so the delay will be different depending on the given
  44 *    processor :-(
  45 *  - The driver could use a major cleanup because of the new
  46 *    major/minor handling that came with kdev_t. It seems to work for
  47 *    the time being, but I can't guarantee that it will stay like
  48 *    that when we start using 16 (24?) bit minors.
  49 *
  50 * restructured jan 1997 by Joerg Dorchain
  51 * - Fixed Bug accessing multiple disks
  52 * - some code cleanup
  53 * - added trackbuffer for each drive to speed things up
  54 * - fixed some race conditions (who finds the next may send it to me ;-)
  55 */
  56
  57#include <linux/module.h>
  58#include <linux/slab.h>
  59
  60#include <linux/fd.h>
  61#include <linux/hdreg.h>
  62#include <linux/delay.h>
  63#include <linux/init.h>
  64#include <linux/major.h>
  65#include <linux/mutex.h>
  66#include <linux/fs.h>
  67#include <linux/blk-mq.h>
  68#include <linux/interrupt.h>
  69#include <linux/platform_device.h>
  70
  71#include <asm/setup.h>
  72#include <linux/uaccess.h>
  73#include <asm/amigahw.h>
  74#include <asm/amigaints.h>
  75#include <asm/irq.h>
  76
  77#undef DEBUG /* print _LOTS_ of infos */
  78
  79#define RAW_IOCTL
  80#ifdef RAW_IOCTL
  81#define IOCTL_RAW_TRACK 0x5254524B  /* 'RTRK' */
  82#endif
  83
  84/*
  85 *  Defines
  86 */
  87
  88/*
  89 * CIAAPRA bits (read only)
  90 */
  91
  92#define DSKRDY      (0x1<<5)        /* disk ready when low */
  93#define DSKTRACK0   (0x1<<4)        /* head at track zero when low */
  94#define DSKPROT     (0x1<<3)        /* disk protected when low */
  95#define DSKCHANGE   (0x1<<2)        /* low when disk removed */
  96
  97/*
  98 * CIAAPRB bits (read/write)
  99 */
 100
 101#define DSKMOTOR    (0x1<<7)        /* motor on when low */
 102#define DSKSEL3     (0x1<<6)        /* select drive 3 when low */
 103#define DSKSEL2     (0x1<<5)        /* select drive 2 when low */
 104#define DSKSEL1     (0x1<<4)        /* select drive 1 when low */
 105#define DSKSEL0     (0x1<<3)        /* select drive 0 when low */
 106#define DSKSIDE     (0x1<<2)        /* side selection: 0 = upper, 1 = lower */
 107#define DSKDIREC    (0x1<<1)        /* step direction: 0=in, 1=out (to trk 0) */
 108#define DSKSTEP     (0x1)           /* pulse low to step head 1 track */
 109
 110/*
 111 * DSKBYTR bits (read only)
 112 */
 113
 114#define DSKBYT      (1<<15)         /* register contains valid byte when set */
 115#define DMAON       (1<<14)         /* disk DMA enabled */
 116#define DISKWRITE   (1<<13)         /* disk write bit in DSKLEN enabled */
 117#define WORDEQUAL   (1<<12)         /* DSKSYNC register match when true */
 118/* bits 7-0 are data */
 119
 120/*
 121 * ADKCON/ADKCONR bits
 122 */
 123
 124#ifndef SETCLR
 125#define ADK_SETCLR      (1<<15)     /* control bit */
 126#endif
 127#define ADK_PRECOMP1    (1<<14)     /* precompensation selection */
 128#define ADK_PRECOMP0    (1<<13)     /* 00=none, 01=140ns, 10=280ns, 11=500ns */
 129#define ADK_MFMPREC     (1<<12)     /* 0=GCR precomp., 1=MFM precomp. */
 130#define ADK_WORDSYNC    (1<<10)     /* enable DSKSYNC auto DMA */
 131#define ADK_MSBSYNC     (1<<9)      /* when 1, enable sync on MSbit (for GCR) */
 132#define ADK_FAST        (1<<8)      /* bit cell: 0=2us (GCR), 1=1us (MFM) */
 133
 134/*
 135 * DSKLEN bits
 136 */
 137
 138#define DSKLEN_DMAEN    (1<<15)
 139#define DSKLEN_WRITE    (1<<14)
 140
 141/*
 142 * INTENA/INTREQ bits
 143 */
 144
 145#define DSKINDEX    (0x1<<4)        /* DSKINDEX bit */
 146
 147/*
 148 * Misc
 149 */
 150
 151#define MFM_SYNC    0x4489          /* standard MFM sync value */
 152
 153/* Values for FD_COMMAND */
 154#define FD_RECALIBRATE		0x07	/* move to track 0 */
 155#define FD_SEEK			0x0F	/* seek track */
 156#define FD_READ			0xE6	/* read with MT, MFM, SKip deleted */
 157#define FD_WRITE		0xC5	/* write with MT, MFM */
 158#define FD_SENSEI		0x08	/* Sense Interrupt Status */
 159#define FD_SPECIFY		0x03	/* specify HUT etc */
 160#define FD_FORMAT		0x4D	/* format one track */
 161#define FD_VERSION		0x10	/* get version code */
 162#define FD_CONFIGURE		0x13	/* configure FIFO operation */
 163#define FD_PERPENDICULAR	0x12	/* perpendicular r/w mode */
 164
 165#define FD_MAX_UNITS    4	/* Max. Number of drives */
 166#define FLOPPY_MAX_SECTORS	22	/* Max. Number of sectors per track */
 167
 168struct fd_data_type {
 169	char *name;		/* description of data type */
 170	int sects;		/* sectors per track */
 171	int (*read_fkt)(int);	/* read whole track */
 172	void (*write_fkt)(int);	/* write whole track */
 173};
 174
 175struct fd_drive_type {
 176	unsigned long code;		/* code returned from drive */
 177	char *name;			/* description of drive */
 178	unsigned int tracks;	/* number of tracks */
 179	unsigned int heads;		/* number of heads */
 180	unsigned int read_size;	/* raw read size for one track */
 181	unsigned int write_size;	/* raw write size for one track */
 182	unsigned int sect_mult;	/* sectors and gap multiplier (HD = 2) */
 183	unsigned int precomp1;	/* start track for precomp 1 */
 184	unsigned int precomp2;	/* start track for precomp 2 */
 185	unsigned int step_delay;	/* time (in ms) for delay after step */
 186	unsigned int settle_time;	/* time to settle after dir change */
 187	unsigned int side_time;	/* time needed to change sides */
 188};
 189
 190struct amiga_floppy_struct {
 191	struct fd_drive_type *type;	/* type of floppy for this unit */
 192	struct fd_data_type *dtype;	/* type of floppy for this unit */
 193	int track;			/* current track (-1 == unknown) */
 194	unsigned char *trackbuf;	/* current track (kmaloc()'d */
 195
 196	int blocks;			/* total # blocks on disk */
 197
 198	int changed;			/* true when not known */
 199	int disk;			/* disk in drive (-1 == unknown) */
 200	int motor;			/* true when motor is at speed */
 201	int busy;			/* true when drive is active */
 202	int dirty;			/* true when trackbuf is not on disk */
 203	int status;			/* current error code for unit */
 204	struct gendisk *gendisk[2];
 205	struct blk_mq_tag_set tag_set;
 206};
 207
 208/*
 209 *  Error codes
 210 */
 211#define FD_OK		0	/* operation succeeded */
 212#define FD_ERROR	-1	/* general error (seek, read, write, etc) */
 213#define FD_NOUNIT	1	/* unit does not exist */
 214#define FD_UNITBUSY	2	/* unit already active */
 215#define FD_NOTACTIVE	3	/* unit is not active */
 216#define FD_NOTREADY	4	/* unit is not ready (motor not on/no disk) */
 217
 218#define MFM_NOSYNC	1
 219#define MFM_HEADER	2
 220#define MFM_DATA	3
 221#define MFM_TRACK	4
 222
 223/*
 224 *  Floppy ID values
 225 */
 226#define FD_NODRIVE	0x00000000  /* response when no unit is present */
 227#define FD_DD_3 	0xffffffff  /* double-density 3.5" (880K) drive */
 228#define FD_HD_3 	0x55555555  /* high-density 3.5" (1760K) drive */
 229#define FD_DD_5 	0xaaaaaaaa  /* double-density 5.25" (440K) drive */
 230
 231static DEFINE_MUTEX(amiflop_mutex);
 232static unsigned long int fd_def_df0 = FD_DD_3;     /* default for df0 if it doesn't identify */
 233
 234module_param(fd_def_df0, ulong, 0);
 235MODULE_DESCRIPTION("Amiga floppy driver");
 236MODULE_LICENSE("GPL");
 237
 238/*
 239 *  Macros
 240 */
 241#define MOTOR_ON	(ciab.prb &= ~DSKMOTOR)
 242#define MOTOR_OFF	(ciab.prb |= DSKMOTOR)
 243#define SELECT(mask)    (ciab.prb &= ~mask)
 244#define DESELECT(mask)  (ciab.prb |= mask)
 245#define SELMASK(drive)  (1 << (3 + (drive & 3)))
 246
 247static struct fd_drive_type drive_types[] = {
 248/*  code	name	   tr he   rdsz   wrsz sm pc1 pc2 sd  st st*/
 249/*  warning: times are now in milliseconds (ms)                    */
 250{ FD_DD_3,	"DD 3.5",  80, 2, 14716, 13630, 1, 80,161, 3, 18, 1},
 251{ FD_HD_3,	"HD 3.5",  80, 2, 28344, 27258, 2, 80,161, 3, 18, 1},
 252{ FD_DD_5,	"DD 5.25", 40, 2, 14716, 13630, 1, 40, 81, 6, 30, 2},
 253{ FD_NODRIVE, "No Drive", 0, 0,     0,     0, 0,  0,  0,  0,  0, 0}
 254};
 255static int num_dr_types = ARRAY_SIZE(drive_types);
 256
 257static int amiga_read(int), dos_read(int);
 258static void amiga_write(int), dos_write(int);
 259static struct fd_data_type data_types[] = {
 260	{ "Amiga", 11 , amiga_read, amiga_write},
 261	{ "MS-Dos", 9, dos_read, dos_write}
 262};
 263
 264/* current info on each unit */
 265static struct amiga_floppy_struct unit[FD_MAX_UNITS];
 266
 267static struct timer_list flush_track_timer[FD_MAX_UNITS];
 268static struct timer_list post_write_timer;
 269static unsigned long post_write_timer_drive;
 270static struct timer_list motor_on_timer;
 271static struct timer_list motor_off_timer[FD_MAX_UNITS];
 272static int on_attempts;
 273
 274/* Synchronization of FDC access */
 275/* request loop (trackbuffer) */
 276static volatile int fdc_busy = -1;
 277static volatile int fdc_nested;
 278static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
 279 
 280static DECLARE_COMPLETION(motor_on_completion);
 281
 282static volatile int selected = -1;	/* currently selected drive */
 283
 284static int writepending;
 285static int writefromint;
 286static char *raw_buf;
 287
 288static DEFINE_SPINLOCK(amiflop_lock);
 289
 290#define RAW_BUF_SIZE 30000  /* size of raw disk data */
 291
 292/*
 293 * These are global variables, as that's the easiest way to give
 294 * information to interrupts. They are the data used for the current
 295 * request.
 296 */
 297static volatile char block_flag;
 298static DECLARE_WAIT_QUEUE_HEAD(wait_fd_block);
 299
 300/* MS-Dos MFM Coding tables (should go quick and easy) */
 301static unsigned char mfmencode[16]={
 302	0x2a, 0x29, 0x24, 0x25, 0x12, 0x11, 0x14, 0x15,
 303	0x4a, 0x49, 0x44, 0x45, 0x52, 0x51, 0x54, 0x55
 304};
 305static unsigned char mfmdecode[128];
 306
 307/* floppy internal millisecond timer stuff */
 308static DECLARE_COMPLETION(ms_wait_completion);
 309#define MS_TICKS ((amiga_eclock+50)/1000)
 310
 311/*
 312 * Note that MAX_ERRORS=X doesn't imply that we retry every bad read
 313 * max X times - some types of errors increase the errorcount by 2 or
 314 * even 3, so we might actually retry only X/2 times before giving up.
 315 */
 316#define MAX_ERRORS 12
 317
 318#define custom amiga_custom
 319
 320/* Prevent "aliased" accesses. */
 321static int fd_ref[4] = { 0,0,0,0 };
 322static int fd_device[4] = { 0, 0, 0, 0 };
 323
 324/*
 325 * Here come the actual hardware access and helper functions.
 326 * They are not reentrant and single threaded because all drives
 327 * share the same hardware and the same trackbuffer.
 328 */
 329
 330/* Milliseconds timer */
 331
 332static irqreturn_t ms_isr(int irq, void *dummy)
 333{
 334	complete(&ms_wait_completion);
 335	return IRQ_HANDLED;
 336}
 337
 338/* all waits are queued up 
 339   A more generic routine would do a schedule a la timer.device */
 340static void ms_delay(int ms)
 341{
 342	int ticks;
 343	static DEFINE_MUTEX(mutex);
 344
 345	if (ms > 0) {
 346		mutex_lock(&mutex);
 347		ticks = MS_TICKS*ms-1;
 348		ciaa.tblo=ticks%256;
 349		ciaa.tbhi=ticks/256;
 350		ciaa.crb=0x19; /*count eclock, force load, one-shoot, start */
 351		wait_for_completion(&ms_wait_completion);
 352		mutex_unlock(&mutex);
 353	}
 354}
 355
 356/* Hardware semaphore */
 357
 358/* returns true when we would get the semaphore */
 359static inline int try_fdc(int drive)
 360{
 361	drive &= 3;
 362	return ((fdc_busy < 0) || (fdc_busy == drive));
 363}
 364
 365static void get_fdc(int drive)
 366{
 367	unsigned long flags;
 368
 369	drive &= 3;
 370#ifdef DEBUG
 371	printk("get_fdc: drive %d  fdc_busy %d  fdc_nested %d\n",drive,fdc_busy,fdc_nested);
 372#endif
 373	local_irq_save(flags);
 374	wait_event(fdc_wait, try_fdc(drive));
 375	fdc_busy = drive;
 376	fdc_nested++;
 377	local_irq_restore(flags);
 378}
 379
 380static inline void rel_fdc(void)
 381{
 382#ifdef DEBUG
 383	if (fdc_nested == 0)
 384		printk("fd: unmatched rel_fdc\n");
 385	printk("rel_fdc: fdc_busy %d fdc_nested %d\n",fdc_busy,fdc_nested);
 386#endif
 387	fdc_nested--;
 388	if (fdc_nested == 0) {
 389		fdc_busy = -1;
 390		wake_up(&fdc_wait);
 391	}
 392}
 393
 394static void fd_select (int drive)
 395{
 396	unsigned char prb = ~0;
 397
 398	drive&=3;
 399#ifdef DEBUG
 400	printk("selecting %d\n",drive);
 401#endif
 402	if (drive == selected)
 403		return;
 404	get_fdc(drive);
 405	selected = drive;
 406
 407	if (unit[drive].track % 2 != 0)
 408		prb &= ~DSKSIDE;
 409	if (unit[drive].motor == 1)
 410		prb &= ~DSKMOTOR;
 411	ciab.prb |= (SELMASK(0)|SELMASK(1)|SELMASK(2)|SELMASK(3));
 412	ciab.prb = prb;
 413	prb &= ~SELMASK(drive);
 414	ciab.prb = prb;
 415	rel_fdc();
 416}
 417
 418static void fd_deselect (int drive)
 419{
 420	unsigned char prb;
 421	unsigned long flags;
 422
 423	drive&=3;
 424#ifdef DEBUG
 425	printk("deselecting %d\n",drive);
 426#endif
 427	if (drive != selected) {
 428		printk(KERN_WARNING "Deselecting drive %d while %d was selected!\n",drive,selected);
 429		return;
 430	}
 431
 432	get_fdc(drive);
 433	local_irq_save(flags);
 434
 435	selected = -1;
 436
 437	prb = ciab.prb;
 438	prb |= (SELMASK(0)|SELMASK(1)|SELMASK(2)|SELMASK(3));
 439	ciab.prb = prb;
 440
 441	local_irq_restore (flags);
 442	rel_fdc();
 443
 444}
 445
 446static void motor_on_callback(struct timer_list *unused)
 447{
 448	if (!(ciaa.pra & DSKRDY) || --on_attempts == 0) {
 449		complete_all(&motor_on_completion);
 450	} else {
 451		motor_on_timer.expires = jiffies + HZ/10;
 452		add_timer(&motor_on_timer);
 453	}
 454}
 455
 456static int fd_motor_on(int nr)
 457{
 458	nr &= 3;
 459
 460	timer_delete(motor_off_timer + nr);
 461
 462	if (!unit[nr].motor) {
 463		unit[nr].motor = 1;
 464		fd_select(nr);
 465
 466		reinit_completion(&motor_on_completion);
 467		mod_timer(&motor_on_timer, jiffies + HZ/2);
 468
 469		on_attempts = 10;
 470		wait_for_completion(&motor_on_completion);
 471		fd_deselect(nr);
 472	}
 473
 474	if (on_attempts == 0) {
 475		on_attempts = -1;
 476#if 0
 477		printk (KERN_ERR "motor_on failed, turning motor off\n");
 478		fd_motor_off (motor_off_timer + nr);
 479		return 0;
 480#else
 481		printk (KERN_WARNING "DSKRDY not set after 1.5 seconds - assuming drive is spinning notwithstanding\n");
 482#endif
 483	}
 484
 485	return 1;
 486}
 487
 488static void fd_motor_off(struct timer_list *timer)
 489{
 490	unsigned long drive = ((unsigned long)timer -
 491			       (unsigned long)&motor_off_timer[0]) /
 492					sizeof(motor_off_timer[0]);
 493
 494	drive&=3;
 495	if (!try_fdc(drive)) {
 496		/* We would be blocked in an interrupt, so try again later */
 497		timer->expires = jiffies + 1;
 498		add_timer(timer);
 499		return;
 500	}
 501	unit[drive].motor = 0;
 502	fd_select(drive);
 503	udelay (1);
 504	fd_deselect(drive);
 505}
 506
 507static void floppy_off (unsigned int nr)
 508{
 509	int drive;
 510
 511	drive = nr & 3;
 512	mod_timer(motor_off_timer + drive, jiffies + 3*HZ);
 513}
 514
 515static int fd_calibrate(int drive)
 516{
 517	unsigned char prb;
 518	int n;
 519
 520	drive &= 3;
 521	get_fdc(drive);
 522	if (!fd_motor_on (drive))
 523		return 0;
 524	fd_select (drive);
 525	prb = ciab.prb;
 526	prb |= DSKSIDE;
 527	prb &= ~DSKDIREC;
 528	ciab.prb = prb;
 529	for (n = unit[drive].type->tracks/2; n != 0; --n) {
 530		if (ciaa.pra & DSKTRACK0)
 531			break;
 532		prb &= ~DSKSTEP;
 533		ciab.prb = prb;
 534		prb |= DSKSTEP;
 535		udelay (2);
 536		ciab.prb = prb;
 537		ms_delay(unit[drive].type->step_delay);
 538	}
 539	ms_delay (unit[drive].type->settle_time);
 540	prb |= DSKDIREC;
 541	n = unit[drive].type->tracks + 20;
 542	for (;;) {
 543		prb &= ~DSKSTEP;
 544		ciab.prb = prb;
 545		prb |= DSKSTEP;
 546		udelay (2);
 547		ciab.prb = prb;
 548		ms_delay(unit[drive].type->step_delay + 1);
 549		if ((ciaa.pra & DSKTRACK0) == 0)
 550			break;
 551		if (--n == 0) {
 552			printk (KERN_ERR "fd%d: calibrate failed, turning motor off\n", drive);
 553			fd_motor_off (motor_off_timer + drive);
 554			unit[drive].track = -1;
 555			rel_fdc();
 556			return 0;
 557		}
 558	}
 559	unit[drive].track = 0;
 560	ms_delay(unit[drive].type->settle_time);
 561
 562	rel_fdc();
 563	fd_deselect(drive);
 564	return 1;
 565}
 566
 567static int fd_seek(int drive, int track)
 568{
 569	unsigned char prb;
 570	int cnt;
 571
 572#ifdef DEBUG
 573	printk("seeking drive %d to track %d\n",drive,track);
 574#endif
 575	drive &= 3;
 576	get_fdc(drive);
 577	if (unit[drive].track == track) {
 578		rel_fdc();
 579		return 1;
 580	}
 581	if (!fd_motor_on(drive)) {
 582		rel_fdc();
 583		return 0;
 584	}
 585	if (unit[drive].track < 0 && !fd_calibrate(drive)) {
 586		rel_fdc();
 587		return 0;
 588	}
 589
 590	fd_select (drive);
 591	cnt = unit[drive].track/2 - track/2;
 592	prb = ciab.prb;
 593	prb |= DSKSIDE | DSKDIREC;
 594	if (track % 2 != 0)
 595		prb &= ~DSKSIDE;
 596	if (cnt < 0) {
 597		cnt = - cnt;
 598		prb &= ~DSKDIREC;
 599	}
 600	ciab.prb = prb;
 601	if (track % 2 != unit[drive].track % 2)
 602		ms_delay (unit[drive].type->side_time);
 603	unit[drive].track = track;
 604	if (cnt == 0) {
 605		rel_fdc();
 606		fd_deselect(drive);
 607		return 1;
 608	}
 609	do {
 610		prb &= ~DSKSTEP;
 611		ciab.prb = prb;
 612		prb |= DSKSTEP;
 613		udelay (1);
 614		ciab.prb = prb;
 615		ms_delay (unit[drive].type->step_delay);
 616	} while (--cnt != 0);
 617	ms_delay (unit[drive].type->settle_time);
 618
 619	rel_fdc();
 620	fd_deselect(drive);
 621	return 1;
 622}
 623
 624static unsigned long fd_get_drive_id(int drive)
 625{
 626	int i;
 627	ulong id = 0;
 628
 629  	drive&=3;
 630  	get_fdc(drive);
 631	/* set up for ID */
 632	MOTOR_ON;
 633	udelay(2);
 634	SELECT(SELMASK(drive));
 635	udelay(2);
 636	DESELECT(SELMASK(drive));
 637	udelay(2);
 638	MOTOR_OFF;
 639	udelay(2);
 640	SELECT(SELMASK(drive));
 641	udelay(2);
 642	DESELECT(SELMASK(drive));
 643	udelay(2);
 644
 645	/* loop and read disk ID */
 646	for (i=0; i<32; i++) {
 647		SELECT(SELMASK(drive));
 648		udelay(2);
 649
 650		/* read and store value of DSKRDY */
 651		id <<= 1;
 652		id |= (ciaa.pra & DSKRDY) ? 0 : 1;	/* cia regs are low-active! */
 653
 654		DESELECT(SELMASK(drive));
 655	}
 656
 657	rel_fdc();
 658
 659        /*
 660         * RB: At least A500/A2000's df0: don't identify themselves.
 661         * As every (real) Amiga has at least a 3.5" DD drive as df0:
 662         * we default to that if df0: doesn't identify as a certain
 663         * type.
 664         */
 665        if(drive == 0 && id == FD_NODRIVE)
 666	{
 667                id = fd_def_df0;
 668                printk(KERN_NOTICE "fd: drive 0 didn't identify, setting default %08lx\n", (ulong)fd_def_df0);
 669	}
 670	/* return the ID value */
 671	return (id);
 672}
 673
 674static irqreturn_t fd_block_done(int irq, void *dummy)
 675{
 676	if (block_flag)
 677		custom.dsklen = 0x4000;
 678
 679	if (block_flag == 2) { /* writing */
 680		writepending = 2;
 681		post_write_timer.expires = jiffies + 1; /* at least 2 ms */
 682		post_write_timer_drive = selected;
 683		add_timer(&post_write_timer);
 684	}
 685	else {                /* reading */
 686		block_flag = 0;
 687		wake_up (&wait_fd_block);
 688	}
 689	return IRQ_HANDLED;
 690}
 691
 692static void raw_read(int drive)
 693{
 694	drive&=3;
 695	get_fdc(drive);
 696	wait_event(wait_fd_block, !block_flag);
 697	fd_select(drive);
 698	/* setup adkcon bits correctly */
 699	custom.adkcon = ADK_MSBSYNC;
 700	custom.adkcon = ADK_SETCLR|ADK_WORDSYNC|ADK_FAST;
 701
 702	custom.dsksync = MFM_SYNC;
 703
 704	custom.dsklen = 0;
 705	custom.dskptr = (u_char *)ZTWO_PADDR((u_char *)raw_buf);
 706	custom.dsklen = unit[drive].type->read_size/sizeof(short) | DSKLEN_DMAEN;
 707	custom.dsklen = unit[drive].type->read_size/sizeof(short) | DSKLEN_DMAEN;
 708
 709	block_flag = 1;
 710
 711	wait_event(wait_fd_block, !block_flag);
 712
 713	custom.dsklen = 0;
 714	fd_deselect(drive);
 715	rel_fdc();
 716}
 717
 718static int raw_write(int drive)
 719{
 720	ushort adk;
 721
 722	drive&=3;
 723	get_fdc(drive); /* corresponds to rel_fdc() in post_write() */
 724	if ((ciaa.pra & DSKPROT) == 0) {
 725		rel_fdc();
 726		return 0;
 727	}
 728	wait_event(wait_fd_block, !block_flag);
 729	fd_select(drive);
 730	/* clear adkcon bits */
 731	custom.adkcon = ADK_PRECOMP1|ADK_PRECOMP0|ADK_WORDSYNC|ADK_MSBSYNC;
 732	/* set appropriate adkcon bits */
 733	adk = ADK_SETCLR|ADK_FAST;
 734	if ((ulong)unit[drive].track >= unit[drive].type->precomp2)
 735		adk |= ADK_PRECOMP1;
 736	else if ((ulong)unit[drive].track >= unit[drive].type->precomp1)
 737		adk |= ADK_PRECOMP0;
 738	custom.adkcon = adk;
 739
 740	custom.dsklen = DSKLEN_WRITE;
 741	custom.dskptr = (u_char *)ZTWO_PADDR((u_char *)raw_buf);
 742	custom.dsklen = unit[drive].type->write_size/sizeof(short) | DSKLEN_DMAEN|DSKLEN_WRITE;
 743	custom.dsklen = unit[drive].type->write_size/sizeof(short) | DSKLEN_DMAEN|DSKLEN_WRITE;
 744
 745	block_flag = 2;
 746	return 1;
 747}
 748
 749/*
 750 * to be called at least 2ms after the write has finished but before any
 751 * other access to the hardware.
 752 */
 753static void post_write (unsigned long drive)
 754{
 755#ifdef DEBUG
 756	printk("post_write for drive %ld\n",drive);
 757#endif
 758	drive &= 3;
 759	custom.dsklen = 0;
 760	block_flag = 0;
 761	writepending = 0;
 762	writefromint = 0;
 763	unit[drive].dirty = 0;
 764	wake_up(&wait_fd_block);
 765	fd_deselect(drive);
 766	rel_fdc(); /* corresponds to get_fdc() in raw_write */
 767}
 768
 769static void post_write_callback(struct timer_list *timer)
 770{
 771	post_write(post_write_timer_drive);
 772}
 773
 774/*
 775 * The following functions are to convert the block contents into raw data
 776 * written to disk and vice versa.
 777 * (Add other formats here ;-))
 778 */
 779
 780static unsigned long scan_sync(unsigned long raw, unsigned long end)
 781{
 782	ushort *ptr = (ushort *)raw, *endp = (ushort *)end;
 783
 784	while (ptr < endp && *ptr++ != 0x4489)
 785		;
 786	if (ptr < endp) {
 787		while (*ptr == 0x4489 && ptr < endp)
 788			ptr++;
 789		return (ulong)ptr;
 790	}
 791	return 0;
 792}
 793
 794static inline unsigned long checksum(unsigned long *addr, int len)
 795{
 796	unsigned long csum = 0;
 797
 798	len /= sizeof(*addr);
 799	while (len-- > 0)
 800		csum ^= *addr++;
 801	csum = ((csum>>1) & 0x55555555)  ^  (csum & 0x55555555);
 802
 803	return csum;
 804}
 805
 806static unsigned long decode (unsigned long *data, unsigned long *raw,
 807			     int len)
 808{
 809	ulong *odd, *even;
 810
 811	/* convert length from bytes to longwords */
 812	len >>= 2;
 813	odd = raw;
 814	even = odd + len;
 815
 816	/* prepare return pointer */
 817	raw += len * 2;
 818
 819	do {
 820		*data++ = ((*odd++ & 0x55555555) << 1) | (*even++ & 0x55555555);
 821	} while (--len != 0);
 822
 823	return (ulong)raw;
 824}
 825
 826struct header {
 827	unsigned char magic;
 828	unsigned char track;
 829	unsigned char sect;
 830	unsigned char ord;
 831	unsigned char labels[16];
 832	unsigned long hdrchk;
 833	unsigned long datachk;
 834};
 835
 836static int amiga_read(int drive)
 837{
 838	unsigned long raw;
 839	unsigned long end;
 840	int scnt;
 841	unsigned long csum;
 842	struct header hdr;
 843
 844	drive&=3;
 845	raw = (long) raw_buf;
 846	end = raw + unit[drive].type->read_size;
 847
 848	for (scnt = 0;scnt < unit[drive].dtype->sects * unit[drive].type->sect_mult; scnt++) {
 849		if (!(raw = scan_sync(raw, end))) {
 850			printk (KERN_INFO "can't find sync for sector %d\n", scnt);
 851			return MFM_NOSYNC;
 852		}
 853
 854		raw = decode ((ulong *)&hdr.magic, (ulong *)raw, 4);
 855		raw = decode ((ulong *)&hdr.labels, (ulong *)raw, 16);
 856		raw = decode ((ulong *)&hdr.hdrchk, (ulong *)raw, 4);
 857		raw = decode ((ulong *)&hdr.datachk, (ulong *)raw, 4);
 858		csum = checksum((ulong *)&hdr,
 859				(char *)&hdr.hdrchk-(char *)&hdr);
 860
 861#ifdef DEBUG
 862		printk ("(%x,%d,%d,%d) (%lx,%lx,%lx,%lx) %lx %lx\n",
 863			hdr.magic, hdr.track, hdr.sect, hdr.ord,
 864			*(ulong *)&hdr.labels[0], *(ulong *)&hdr.labels[4],
 865			*(ulong *)&hdr.labels[8], *(ulong *)&hdr.labels[12],
 866			hdr.hdrchk, hdr.datachk);
 867#endif
 868
 869		if (hdr.hdrchk != csum) {
 870			printk(KERN_INFO "MFM_HEADER: %08lx,%08lx\n", hdr.hdrchk, csum);
 871			return MFM_HEADER;
 872		}
 873
 874		/* verify track */
 875		if (hdr.track != unit[drive].track) {
 876			printk(KERN_INFO "MFM_TRACK: %d, %d\n", hdr.track, unit[drive].track);
 877			return MFM_TRACK;
 878		}
 879
 880		raw = decode ((ulong *)(unit[drive].trackbuf + hdr.sect*512),
 881			      (ulong *)raw, 512);
 882		csum = checksum((ulong *)(unit[drive].trackbuf + hdr.sect*512), 512);
 883
 884		if (hdr.datachk != csum) {
 885			printk(KERN_INFO "MFM_DATA: (%x:%d:%d:%d) sc=%d %lx, %lx\n",
 886			       hdr.magic, hdr.track, hdr.sect, hdr.ord, scnt,
 887			       hdr.datachk, csum);
 888			printk (KERN_INFO "data=(%lx,%lx,%lx,%lx)\n",
 889				((ulong *)(unit[drive].trackbuf+hdr.sect*512))[0],
 890				((ulong *)(unit[drive].trackbuf+hdr.sect*512))[1],
 891				((ulong *)(unit[drive].trackbuf+hdr.sect*512))[2],
 892				((ulong *)(unit[drive].trackbuf+hdr.sect*512))[3]);
 893			return MFM_DATA;
 894		}
 895	}
 896
 897	return 0;
 898}
 899
 900static void encode(unsigned long data, unsigned long *dest)
 901{
 902	unsigned long data2;
 903
 904	data &= 0x55555555;
 905	data2 = data ^ 0x55555555;
 906	data |= ((data2 >> 1) | 0x80000000) & (data2 << 1);
 907
 908	if (*(dest - 1) & 0x00000001)
 909		data &= 0x7FFFFFFF;
 910
 911	*dest = data;
 912}
 913
 914static void encode_block(unsigned long *dest, unsigned long *src, int len)
 915{
 916	int cnt, to_cnt = 0;
 917	unsigned long data;
 918
 919	/* odd bits */
 920	for (cnt = 0; cnt < len / 4; cnt++) {
 921		data = src[cnt] >> 1;
 922		encode(data, dest + to_cnt++);
 923	}
 924
 925	/* even bits */
 926	for (cnt = 0; cnt < len / 4; cnt++) {
 927		data = src[cnt];
 928		encode(data, dest + to_cnt++);
 929	}
 930}
 931
 932static unsigned long *putsec(int disk, unsigned long *raw, int cnt)
 933{
 934	struct header hdr;
 935	int i;
 936
 937	disk&=3;
 938	*raw = (raw[-1]&1) ? 0x2AAAAAAA : 0xAAAAAAAA;
 939	raw++;
 940	*raw++ = 0x44894489;
 941
 942	hdr.magic = 0xFF;
 943	hdr.track = unit[disk].track;
 944	hdr.sect = cnt;
 945	hdr.ord = unit[disk].dtype->sects * unit[disk].type->sect_mult - cnt;
 946	for (i = 0; i < 16; i++)
 947		hdr.labels[i] = 0;
 948	hdr.hdrchk = checksum((ulong *)&hdr,
 949			      (char *)&hdr.hdrchk-(char *)&hdr);
 950	hdr.datachk = checksum((ulong *)(unit[disk].trackbuf+cnt*512), 512);
 951
 952	encode_block(raw, (ulong *)&hdr.magic, 4);
 953	raw += 2;
 954	encode_block(raw, (ulong *)&hdr.labels, 16);
 955	raw += 8;
 956	encode_block(raw, (ulong *)&hdr.hdrchk, 4);
 957	raw += 2;
 958	encode_block(raw, (ulong *)&hdr.datachk, 4);
 959	raw += 2;
 960	encode_block(raw, (ulong *)(unit[disk].trackbuf+cnt*512), 512);
 961	raw += 256;
 962
 963	return raw;
 964}
 965
 966static void amiga_write(int disk)
 967{
 968	unsigned int cnt;
 969	unsigned long *ptr = (unsigned long *)raw_buf;
 970
 971	disk&=3;
 972	/* gap space */
 973	for (cnt = 0; cnt < 415 * unit[disk].type->sect_mult; cnt++)
 974		*ptr++ = 0xaaaaaaaa;
 975
 976	/* sectors */
 977	for (cnt = 0; cnt < unit[disk].dtype->sects * unit[disk].type->sect_mult; cnt++)
 978		ptr = putsec (disk, ptr, cnt);
 979	*(ushort *)ptr = (ptr[-1]&1) ? 0x2AA8 : 0xAAA8;
 980}
 981
 982
 983struct dos_header {
 984	unsigned char track,   /* 0-80 */
 985		side,    /* 0-1 */
 986		sec,     /* 0-...*/
 987		len_desc;/* 2 */
 988	unsigned short crc;     /* on 68000 we got an alignment problem, 
 989				   but this compiler solves it  by adding silently 
 990				   adding a pad byte so data won't fit
 991				   and this took about 3h to discover.... */
 992	unsigned char gap1[22];     /* for longword-alignedness (0x4e) */
 993};
 994
 995/* crc routines are borrowed from the messydos-handler  */
 996
 997/* excerpt from the messydos-device           
 998; The CRC is computed not only over the actual data, but including
 999; the SYNC mark (3 * $a1) and the 'ID/DATA - Address Mark' ($fe/$fb).
1000; As we don't read or encode these fields into our buffers, we have to
1001; preload the registers containing the CRC with the values they would have
1002; after stepping over these fields.
1003;
1004; How CRCs "really" work:
1005;
1006; First, you should regard a bitstring as a series of coefficients of
1007; polynomials. We calculate with these polynomials in modulo-2
1008; arithmetic, in which both add and subtract are done the same as
1009; exclusive-or. Now, we modify our data (a very long polynomial) in
1010; such a way that it becomes divisible by the CCITT-standard 16-bit
1011;		 16   12   5
1012; polynomial:	x  + x	+ x + 1, represented by $11021. The easiest
1013; way to do this would be to multiply (using proper arithmetic) our
1014; datablock with $11021. So we have:
1015;   data * $11021		 =
1016;   data * ($10000 + $1021)      =
1017;   data * $10000 + data * $1021
1018; The left part of this is simple: Just add two 0 bytes. But then
1019; the right part (data $1021) remains difficult and even could have
1020; a carry into the left part. The solution is to use a modified
1021; multiplication, which has a result that is not correct, but with
1022; a difference of any multiple of $11021. We then only need to keep
1023; the 16 least significant bits of the result.
1024;
1025; The following algorithm does this for us:
1026;
1027;   unsigned char *data, c, crclo, crchi;
1028;   while (not done) {
1029;	c = *data++ + crchi;
1030;	crchi = (@ c) >> 8 + crclo;
1031;	crclo = @ c;
1032;   }
1033;
1034; Remember, + is done with EOR, the @ operator is in two tables (high
1035; and low byte separately), which is calculated as
1036;
1037;      $1021 * (c & $F0)
1038;  xor $1021 * (c & $0F)
1039;  xor $1021 * (c >> 4)         (* is regular multiplication)
1040;
1041;
1042; Anyway, the end result is the same as the remainder of the division of
1043; the data by $11021. I am afraid I need to study theory a bit more...
1044
1045
1046my only works was to code this from manx to C....
1047
1048*/
1049
1050static ushort dos_crc(void * data_a3, int data_d0, int data_d1, int data_d3)
1051{
1052	static unsigned char CRCTable1[] = {
1053		0x00,0x10,0x20,0x30,0x40,0x50,0x60,0x70,0x81,0x91,0xa1,0xb1,0xc1,0xd1,0xe1,0xf1,
1054		0x12,0x02,0x32,0x22,0x52,0x42,0x72,0x62,0x93,0x83,0xb3,0xa3,0xd3,0xc3,0xf3,0xe3,
1055		0x24,0x34,0x04,0x14,0x64,0x74,0x44,0x54,0xa5,0xb5,0x85,0x95,0xe5,0xf5,0xc5,0xd5,
1056		0x36,0x26,0x16,0x06,0x76,0x66,0x56,0x46,0xb7,0xa7,0x97,0x87,0xf7,0xe7,0xd7,0xc7,
1057		0x48,0x58,0x68,0x78,0x08,0x18,0x28,0x38,0xc9,0xd9,0xe9,0xf9,0x89,0x99,0xa9,0xb9,
1058		0x5a,0x4a,0x7a,0x6a,0x1a,0x0a,0x3a,0x2a,0xdb,0xcb,0xfb,0xeb,0x9b,0x8b,0xbb,0xab,
1059		0x6c,0x7c,0x4c,0x5c,0x2c,0x3c,0x0c,0x1c,0xed,0xfd,0xcd,0xdd,0xad,0xbd,0x8d,0x9d,
1060		0x7e,0x6e,0x5e,0x4e,0x3e,0x2e,0x1e,0x0e,0xff,0xef,0xdf,0xcf,0xbf,0xaf,0x9f,0x8f,
1061		0x91,0x81,0xb1,0xa1,0xd1,0xc1,0xf1,0xe1,0x10,0x00,0x30,0x20,0x50,0x40,0x70,0x60,
1062		0x83,0x93,0xa3,0xb3,0xc3,0xd3,0xe3,0xf3,0x02,0x12,0x22,0x32,0x42,0x52,0x62,0x72,
1063		0xb5,0xa5,0x95,0x85,0xf5,0xe5,0xd5,0xc5,0x34,0x24,0x14,0x04,0x74,0x64,0x54,0x44,
1064		0xa7,0xb7,0x87,0x97,0xe7,0xf7,0xc7,0xd7,0x26,0x36,0x06,0x16,0x66,0x76,0x46,0x56,
1065		0xd9,0xc9,0xf9,0xe9,0x99,0x89,0xb9,0xa9,0x58,0x48,0x78,0x68,0x18,0x08,0x38,0x28,
1066		0xcb,0xdb,0xeb,0xfb,0x8b,0x9b,0xab,0xbb,0x4a,0x5a,0x6a,0x7a,0x0a,0x1a,0x2a,0x3a,
1067		0xfd,0xed,0xdd,0xcd,0xbd,0xad,0x9d,0x8d,0x7c,0x6c,0x5c,0x4c,0x3c,0x2c,0x1c,0x0c,
1068		0xef,0xff,0xcf,0xdf,0xaf,0xbf,0x8f,0x9f,0x6e,0x7e,0x4e,0x5e,0x2e,0x3e,0x0e,0x1e
1069	};
1070
1071	static unsigned char CRCTable2[] = {
1072		0x00,0x21,0x42,0x63,0x84,0xa5,0xc6,0xe7,0x08,0x29,0x4a,0x6b,0x8c,0xad,0xce,0xef,
1073		0x31,0x10,0x73,0x52,0xb5,0x94,0xf7,0xd6,0x39,0x18,0x7b,0x5a,0xbd,0x9c,0xff,0xde,
1074		0x62,0x43,0x20,0x01,0xe6,0xc7,0xa4,0x85,0x6a,0x4b,0x28,0x09,0xee,0xcf,0xac,0x8d,
1075		0x53,0x72,0x11,0x30,0xd7,0xf6,0x95,0xb4,0x5b,0x7a,0x19,0x38,0xdf,0xfe,0x9d,0xbc,
1076		0xc4,0xe5,0x86,0xa7,0x40,0x61,0x02,0x23,0xcc,0xed,0x8e,0xaf,0x48,0x69,0x0a,0x2b,
1077		0xf5,0xd4,0xb7,0x96,0x71,0x50,0x33,0x12,0xfd,0xdc,0xbf,0x9e,0x79,0x58,0x3b,0x1a,
1078		0xa6,0x87,0xe4,0xc5,0x22,0x03,0x60,0x41,0xae,0x8f,0xec,0xcd,0x2a,0x0b,0x68,0x49,
1079		0x97,0xb6,0xd5,0xf4,0x13,0x32,0x51,0x70,0x9f,0xbe,0xdd,0xfc,0x1b,0x3a,0x59,0x78,
1080		0x88,0xa9,0xca,0xeb,0x0c,0x2d,0x4e,0x6f,0x80,0xa1,0xc2,0xe3,0x04,0x25,0x46,0x67,
1081		0xb9,0x98,0xfb,0xda,0x3d,0x1c,0x7f,0x5e,0xb1,0x90,0xf3,0xd2,0x35,0x14,0x77,0x56,
1082		0xea,0xcb,0xa8,0x89,0x6e,0x4f,0x2c,0x0d,0xe2,0xc3,0xa0,0x81,0x66,0x47,0x24,0x05,
1083		0xdb,0xfa,0x99,0xb8,0x5f,0x7e,0x1d,0x3c,0xd3,0xf2,0x91,0xb0,0x57,0x76,0x15,0x34,
1084		0x4c,0x6d,0x0e,0x2f,0xc8,0xe9,0x8a,0xab,0x44,0x65,0x06,0x27,0xc0,0xe1,0x82,0xa3,
1085		0x7d,0x5c,0x3f,0x1e,0xf9,0xd8,0xbb,0x9a,0x75,0x54,0x37,0x16,0xf1,0xd0,0xb3,0x92,
1086		0x2e,0x0f,0x6c,0x4d,0xaa,0x8b,0xe8,0xc9,0x26,0x07,0x64,0x45,0xa2,0x83,0xe0,0xc1,
1087		0x1f,0x3e,0x5d,0x7c,0x9b,0xba,0xd9,0xf8,0x17,0x36,0x55,0x74,0x93,0xb2,0xd1,0xf0
1088	};
1089
1090/* look at the asm-code - what looks in C a bit strange is almost as good as handmade */
1091	register int i;
1092	register unsigned char *CRCT1, *CRCT2, *data, c, crch, crcl;
1093
1094	CRCT1=CRCTable1;
1095	CRCT2=CRCTable2;
1096	data=data_a3;
1097	crcl=data_d1;
1098	crch=data_d0;
1099	for (i=data_d3; i>=0; i--) {
1100		c = (*data++) ^ crch;
1101		crch = CRCT1[c] ^ crcl;
1102		crcl = CRCT2[c];
1103	}
1104	return (crch<<8)|crcl;
1105}
1106
1107static inline ushort dos_hdr_crc (struct dos_header *hdr)
1108{
1109	return dos_crc(&(hdr->track), 0xb2, 0x30, 3); /* precomputed magic */
1110}
1111
1112static inline ushort dos_data_crc(unsigned char *data)
1113{
1114	return dos_crc(data, 0xe2, 0x95 ,511); /* precomputed magic */
1115}
1116
1117static inline unsigned char dos_decode_byte(ushort word)
1118{
1119	register ushort w2;
1120	register unsigned char byte;
1121	register unsigned char *dec = mfmdecode;
1122
1123	w2=word;
1124	w2>>=8;
1125	w2&=127;
1126	byte = dec[w2];
1127	byte <<= 4;
1128	w2 = word & 127;
1129	byte |= dec[w2];
1130	return byte;
1131}
1132
1133static unsigned long dos_decode(unsigned char *data, unsigned short *raw, int len)
1134{
1135	int i;
1136
1137	for (i = 0; i < len; i++)
1138		*data++=dos_decode_byte(*raw++);
1139	return ((ulong)raw);
1140}
1141
1142#ifdef DEBUG
1143static void dbg(unsigned long ptr)
1144{
1145	printk("raw data @%08lx: %08lx, %08lx ,%08lx, %08lx\n", ptr,
1146	       ((ulong *)ptr)[0], ((ulong *)ptr)[1],
1147	       ((ulong *)ptr)[2], ((ulong *)ptr)[3]);
1148}
1149#endif
1150
1151static int dos_read(int drive)
1152{
1153	unsigned long end;
1154	unsigned long raw;
1155	int scnt;
1156	unsigned short crc,data_crc[2];
1157	struct dos_header hdr;
1158
1159	drive&=3;
1160	raw = (long) raw_buf;
1161	end = raw + unit[drive].type->read_size;
1162
1163	for (scnt=0; scnt < unit[drive].dtype->sects * unit[drive].type->sect_mult; scnt++) {
1164		do { /* search for the right sync of each sec-hdr */
1165			if (!(raw = scan_sync (raw, end))) {
1166				printk(KERN_INFO "dos_read: no hdr sync on "
1167				       "track %d, unit %d for sector %d\n",
1168				       unit[drive].track,drive,scnt);
1169				return MFM_NOSYNC;
1170			}
1171#ifdef DEBUG
1172			dbg(raw);
1173#endif
1174		} while (*((ushort *)raw)!=0x5554); /* loop usually only once done */
1175		raw+=2; /* skip over headermark */
1176		raw = dos_decode((unsigned char *)&hdr,(ushort *) raw,8);
1177		crc = dos_hdr_crc(&hdr);
1178
1179#ifdef DEBUG
1180		printk("(%3d,%d,%2d,%d) %x\n", hdr.track, hdr.side,
1181		       hdr.sec, hdr.len_desc, hdr.crc);
1182#endif
1183
1184		if (crc != hdr.crc) {
1185			printk(KERN_INFO "dos_read: MFM_HEADER %04x,%04x\n",
1186			       hdr.crc, crc);
1187			return MFM_HEADER;
1188		}
1189		if (hdr.track != unit[drive].track/unit[drive].type->heads) {
1190			printk(KERN_INFO "dos_read: MFM_TRACK %d, %d\n",
1191			       hdr.track,
1192			       unit[drive].track/unit[drive].type->heads);
1193			return MFM_TRACK;
1194		}
1195
1196		if (hdr.side != unit[drive].track%unit[drive].type->heads) {
1197			printk(KERN_INFO "dos_read: MFM_SIDE %d, %d\n",
1198			       hdr.side,
1199			       unit[drive].track%unit[drive].type->heads);
1200			return MFM_TRACK;
1201		}
1202
1203		if (hdr.len_desc != 2) {
1204			printk(KERN_INFO "dos_read: unknown sector len "
1205			       "descriptor %d\n", hdr.len_desc);
1206			return MFM_DATA;
1207		}
1208#ifdef DEBUG
1209		printk("hdr accepted\n");
1210#endif
1211		if (!(raw = scan_sync (raw, end))) {
1212			printk(KERN_INFO "dos_read: no data sync on track "
1213			       "%d, unit %d for sector%d, disk sector %d\n",
1214			       unit[drive].track, drive, scnt, hdr.sec);
1215			return MFM_NOSYNC;
1216		}
1217#ifdef DEBUG
1218		dbg(raw);
1219#endif
1220
1221		if (*((ushort *)raw)!=0x5545) {
1222			printk(KERN_INFO "dos_read: no data mark after "
1223			       "sync (%d,%d,%d,%d) sc=%d\n",
1224			       hdr.track,hdr.side,hdr.sec,hdr.len_desc,scnt);
1225			return MFM_NOSYNC;
1226		}
1227
1228		raw+=2;  /* skip data mark (included in checksum) */
1229		raw = dos_decode((unsigned char *)(unit[drive].trackbuf + (hdr.sec - 1) * 512), (ushort *) raw, 512);
1230		raw = dos_decode((unsigned char  *)data_crc,(ushort *) raw,4);
1231		crc = dos_data_crc(unit[drive].trackbuf + (hdr.sec - 1) * 512);
1232
1233		if (crc != data_crc[0]) {
1234			printk(KERN_INFO "dos_read: MFM_DATA (%d,%d,%d,%d) "
1235			       "sc=%d, %x %x\n", hdr.track, hdr.side,
1236			       hdr.sec, hdr.len_desc, scnt,data_crc[0], crc);
1237			printk(KERN_INFO "data=(%lx,%lx,%lx,%lx,...)\n",
1238			       ((ulong *)(unit[drive].trackbuf+(hdr.sec-1)*512))[0],
1239			       ((ulong *)(unit[drive].trackbuf+(hdr.sec-1)*512))[1],
1240			       ((ulong *)(unit[drive].trackbuf+(hdr.sec-1)*512))[2],
1241			       ((ulong *)(unit[drive].trackbuf+(hdr.sec-1)*512))[3]);
1242			return MFM_DATA;
1243		}
1244	}
1245	return 0;
1246}
1247
1248static inline ushort dos_encode_byte(unsigned char byte)
1249{
1250	register unsigned char *enc, b2, b1;
1251	register ushort word;
1252
1253	enc=mfmencode;
1254	b1=byte;
1255	b2=b1>>4;
1256	b1&=15;
1257	word=enc[b2] <<8 | enc [b1];
1258	return (word|((word&(256|64)) ? 0: 128));
1259}
1260
1261static void dos_encode_block(ushort *dest, unsigned char *src, int len)
1262{
1263	int i;
1264
1265	for (i = 0; i < len; i++) {
1266		*dest=dos_encode_byte(*src++);
1267		*dest|=((dest[-1]&1)||(*dest&0x4000))? 0: 0x8000;
1268		dest++;
1269	}
1270}
1271
1272static unsigned long *ms_putsec(int drive, unsigned long *raw, int cnt)
1273{
1274	static struct dos_header hdr={0,0,0,2,0,
1275	  {78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78}};
1276	int i;
1277	static ushort crc[2]={0,0x4e4e};
1278
1279	drive&=3;
1280/* id gap 1 */
1281/* the MFM word before is always 9254 */
1282	for(i=0;i<6;i++)
1283		*raw++=0xaaaaaaaa;
1284/* 3 sync + 1 headermark */
1285	*raw++=0x44894489;
1286	*raw++=0x44895554;
1287
1288/* fill in the variable parts of the header */
1289	hdr.track=unit[drive].track/unit[drive].type->heads;
1290	hdr.side=unit[drive].track%unit[drive].type->heads;
1291	hdr.sec=cnt+1;
1292	hdr.crc=dos_hdr_crc(&hdr);
1293
1294/* header (without "magic") and id gap 2*/
1295	dos_encode_block((ushort *)raw,(unsigned char *) &hdr.track,28);
1296	raw+=14;
1297
1298/*id gap 3 */
1299	for(i=0;i<6;i++)
1300		*raw++=0xaaaaaaaa;
1301
1302/* 3 syncs and 1 datamark */
1303	*raw++=0x44894489;
1304	*raw++=0x44895545;
1305
1306/* data */
1307	dos_encode_block((ushort *)raw,
1308			 (unsigned char *)unit[drive].trackbuf+cnt*512,512);
1309	raw+=256;
1310
1311/*data crc + jd's special gap (long words :-/) */
1312	crc[0]=dos_data_crc(unit[drive].trackbuf+cnt*512);
1313	dos_encode_block((ushort *) raw,(unsigned char *)crc,4);
1314	raw+=2;
1315
1316/* data gap */
1317	for(i=0;i<38;i++)
1318		*raw++=0x92549254;
1319
1320	return raw; /* wrote 652 MFM words */
1321}
1322
1323static void dos_write(int disk)
1324{
1325	int cnt;
1326	unsigned long raw = (unsigned long) raw_buf;
1327	unsigned long *ptr=(unsigned long *)raw;
1328
1329	disk&=3;
1330/* really gap4 + indexgap , but we write it first and round it up */
1331	for (cnt=0;cnt<425;cnt++)
1332		*ptr++=0x92549254;
1333
1334/* the following is just guessed */
1335	if (unit[disk].type->sect_mult==2)  /* check for HD-Disks */
1336		for(cnt=0;cnt<473;cnt++)
1337			*ptr++=0x92549254;
1338
1339/* now the index marks...*/
1340	for (cnt=0;cnt<20;cnt++)
1341		*ptr++=0x92549254;
1342	for (cnt=0;cnt<6;cnt++)
1343		*ptr++=0xaaaaaaaa;
1344	*ptr++=0x52245224;
1345	*ptr++=0x52245552;
1346	for (cnt=0;cnt<20;cnt++)
1347		*ptr++=0x92549254;
1348
1349/* sectors */
1350	for(cnt = 0; cnt < unit[disk].dtype->sects * unit[disk].type->sect_mult; cnt++)
1351		ptr=ms_putsec(disk,ptr,cnt);
1352
1353	*(ushort *)ptr = 0xaaa8; /* MFM word before is always 0x9254 */
1354}
1355
1356/*
1357 * Here comes the high level stuff (i.e. the filesystem interface)
1358 * and helper functions.
1359 * Normally this should be the only part that has to be adapted to
1360 * different kernel versions.
1361 */
1362
1363/* FIXME: this assumes the drive is still spinning -
1364 * which is only true if we complete writing a track within three seconds
1365 */
1366static void flush_track_callback(struct timer_list *timer)
1367{
1368	unsigned long nr = ((unsigned long)timer -
1369			       (unsigned long)&flush_track_timer[0]) /
1370					sizeof(flush_track_timer[0]);
1371
1372	nr&=3;
1373	writefromint = 1;
1374	if (!try_fdc(nr)) {
1375		/* we might block in an interrupt, so try again later */
1376		flush_track_timer[nr].expires = jiffies + 1;
1377		add_timer(flush_track_timer + nr);
1378		return;
1379	}
1380	get_fdc(nr);
1381	(*unit[nr].dtype->write_fkt)(nr);
1382	if (!raw_write(nr)) {
1383		printk (KERN_NOTICE "floppy disk write protected\n");
1384		writefromint = 0;
1385		writepending = 0;
1386	}
1387	rel_fdc();
1388}
1389
1390static int non_int_flush_track (unsigned long nr)
1391{
1392	unsigned long flags;
1393
1394	nr&=3;
1395	writefromint = 0;
1396	timer_delete(&post_write_timer);
1397	get_fdc(nr);
1398	if (!fd_motor_on(nr)) {
1399		writepending = 0;
1400		rel_fdc();
1401		return 0;
1402	}
1403	local_irq_save(flags);
1404	if (writepending != 2) {
1405		local_irq_restore(flags);
1406		(*unit[nr].dtype->write_fkt)(nr);
1407		if (!raw_write(nr)) {
1408			printk (KERN_NOTICE "floppy disk write protected "
1409				"in write!\n");
1410			writepending = 0;
1411			return 0;
1412		}
1413		wait_event(wait_fd_block, block_flag != 2);
1414	}
1415	else {
1416		local_irq_restore(flags);
1417		ms_delay(2); /* 2 ms post_write delay */
1418		post_write(nr);
1419	}
1420	rel_fdc();
1421	return 1;
1422}
1423
1424static int get_track(int drive, int track)
1425{
1426	int error, errcnt;
1427
1428	drive&=3;
1429	if (unit[drive].track == track)
1430		return 0;
1431	get_fdc(drive);
1432	if (!fd_motor_on(drive)) {
1433		rel_fdc();
1434		return -1;
1435	}
1436
1437	if (unit[drive].dirty == 1) {
1438		timer_delete(flush_track_timer + drive);
1439		non_int_flush_track (drive);
1440	}
1441	errcnt = 0;
1442	while (errcnt < MAX_ERRORS) {
1443		if (!fd_seek(drive, track))
1444			return -1;
1445		raw_read(drive);
1446		error = (*unit[drive].dtype->read_fkt)(drive);
1447		if (error == 0) {
1448			rel_fdc();
1449			return 0;
1450		}
1451		/* Read Error Handling: recalibrate and try again */
1452		unit[drive].track = -1;
1453		errcnt++;
1454	}
1455	rel_fdc();
1456	return -1;
1457}
1458
1459static blk_status_t amiflop_rw_cur_segment(struct amiga_floppy_struct *floppy,
1460					   struct request *rq)
1461{
1462	int drive = floppy - unit;
1463	unsigned int cnt, block, track, sector;
1464	char *data;
1465
1466	for (cnt = 0; cnt < blk_rq_cur_sectors(rq); cnt++) {
1467#ifdef DEBUG
1468		printk("fd: sector %ld + %d requested for %s\n",
1469		       blk_rq_pos(rq), cnt,
1470		       (rq_data_dir(rq) == READ) ? "read" : "write");
1471#endif
1472		block = blk_rq_pos(rq) + cnt;
1473		track = block / (floppy->dtype->sects * floppy->type->sect_mult);
1474		sector = block % (floppy->dtype->sects * floppy->type->sect_mult);
1475		data = bio_data(rq->bio) + 512 * cnt;
1476#ifdef DEBUG
1477		printk("access to track %d, sector %d, with buffer at "
1478		       "0x%08lx\n", track, sector, data);
1479#endif
1480
1481		if (get_track(drive, track) == -1)
1482			return BLK_STS_IOERR;
1483
1484		if (rq_data_dir(rq) == READ) {
1485			memcpy(data, floppy->trackbuf + sector * 512, 512);
1486		} else {
1487			memcpy(floppy->trackbuf + sector * 512, data, 512);
1488
1489			/* keep the drive spinning while writes are scheduled */
1490			if (!fd_motor_on(drive))
1491				return BLK_STS_IOERR;
1492			/*
1493			 * setup a callback to write the track buffer
1494			 * after a short (1 tick) delay.
1495			 */
1496			floppy->dirty = 1;
1497		        /* reset the timer */
1498			mod_timer (flush_track_timer + drive, jiffies + 1);
1499		}
1500	}
1501
1502	return BLK_STS_OK;
1503}
1504
1505static blk_status_t amiflop_queue_rq(struct blk_mq_hw_ctx *hctx,
1506				     const struct blk_mq_queue_data *bd)
1507{
1508	struct request *rq = bd->rq;
1509	struct amiga_floppy_struct *floppy = rq->q->disk->private_data;
1510	blk_status_t err;
1511
1512	if (!spin_trylock_irq(&amiflop_lock))
1513		return BLK_STS_DEV_RESOURCE;
1514
1515	blk_mq_start_request(rq);
1516
1517	do {
1518		err = amiflop_rw_cur_segment(floppy, rq);
1519	} while (blk_update_request(rq, err, blk_rq_cur_bytes(rq)));
1520	blk_mq_end_request(rq, err);
1521
1522	spin_unlock_irq(&amiflop_lock);
1523	return BLK_STS_OK;
1524}
1525
1526static int fd_getgeo(struct gendisk *disk, struct hd_geometry *geo)
1527{
1528	struct amiga_floppy_struct *p = disk->private_data;
1529
1530	geo->heads = p->type->heads;
1531	geo->sectors = p->dtype->sects * p->type->sect_mult;
1532	geo->cylinders = p->type->tracks;
1533	return 0;
1534}
1535
1536static int fd_locked_ioctl(struct block_device *bdev, blk_mode_t mode,
1537		    unsigned int cmd, unsigned long param)
1538{
1539	struct amiga_floppy_struct *p = bdev->bd_disk->private_data;
1540	int drive = p - unit;
1541	static struct floppy_struct getprm;
1542	void __user *argp = (void __user *)param;
1543
1544	switch(cmd){
1545	case FDFMTBEG:
1546		get_fdc(drive);
1547		if (fd_ref[drive] > 1) {
1548			rel_fdc();
1549			return -EBUSY;
1550		}
1551		if (fd_motor_on(drive) == 0) {
1552			rel_fdc();
1553			return -ENODEV;
1554		}
1555		if (fd_calibrate(drive) == 0) {
1556			rel_fdc();
1557			return -ENXIO;
1558		}
1559		floppy_off(drive);
1560		rel_fdc();
1561		break;
1562	case FDFMTTRK:
1563		if (param < p->type->tracks * p->type->heads)
1564		{
1565			get_fdc(drive);
1566			if (fd_seek(drive,param) != 0){
1567				memset(p->trackbuf, FD_FILL_BYTE,
1568				       p->dtype->sects * p->type->sect_mult * 512);
1569				non_int_flush_track(drive);
1570			}
1571			floppy_off(drive);
1572			rel_fdc();
1573		}
1574		else
1575			return -EINVAL;
1576		break;
1577	case FDFMTEND:
1578		floppy_off(drive);
1579		invalidate_bdev(bdev);
1580		break;
1581	case FDGETPRM:
1582		memset((void *)&getprm, 0, sizeof (getprm));
1583		getprm.track=p->type->tracks;
1584		getprm.head=p->type->heads;
1585		getprm.sect=p->dtype->sects * p->type->sect_mult;
1586		getprm.size=p->blocks;
1587		if (copy_to_user(argp, &getprm, sizeof(struct floppy_struct)))
1588			return -EFAULT;
1589		break;
1590	case FDSETPRM:
1591	case FDDEFPRM:
1592		return -EINVAL;
1593	case FDFLUSH: /* unconditionally, even if not needed */
1594		timer_delete(flush_track_timer + drive);
1595		non_int_flush_track(drive);
1596		break;
1597#ifdef RAW_IOCTL
1598	case IOCTL_RAW_TRACK:
1599		if (copy_to_user(argp, raw_buf, p->type->read_size))
1600			return -EFAULT;
1601		else
1602			return p->type->read_size;
1603#endif
1604	default:
1605		return -ENOSYS;
1606	}
1607	return 0;
1608}
1609
1610static int fd_ioctl(struct block_device *bdev, blk_mode_t mode,
1611			     unsigned int cmd, unsigned long param)
1612{
1613	int ret;
1614
1615	mutex_lock(&amiflop_mutex);
1616	ret = fd_locked_ioctl(bdev, mode, cmd, param);
1617	mutex_unlock(&amiflop_mutex);
1618
1619	return ret;
1620}
1621
1622static void fd_probe(int dev)
1623{
1624	unsigned long code;
1625	int type;
1626	int drive;
1627
1628	drive = dev & 3;
1629	code = fd_get_drive_id(drive);
1630
1631	/* get drive type */
1632	for (type = 0; type < num_dr_types; type++)
1633		if (drive_types[type].code == code)
1634			break;
1635
1636	if (type >= num_dr_types) {
1637		printk(KERN_WARNING "fd_probe: unsupported drive type "
1638		       "%08lx found\n", code);
1639		unit[drive].type = &drive_types[num_dr_types-1]; /* FD_NODRIVE */
1640		return;
1641	}
1642
1643	unit[drive].type = drive_types + type;
1644	unit[drive].track = -1;
1645
1646	unit[drive].disk = -1;
1647	unit[drive].motor = 0;
1648	unit[drive].busy = 0;
1649	unit[drive].status = -1;
1650}
1651
1652/*
1653 * floppy_open check for aliasing (/dev/fd0 can be the same as
1654 * /dev/PS0 etc), and disallows simultaneous access to the same
1655 * drive with different device numbers.
1656 */
1657static int floppy_open(struct gendisk *disk, blk_mode_t mode)
1658{
1659	int drive = disk->first_minor & 3;
1660	int system = (disk->first_minor & 4) >> 2;
1661	int old_dev;
1662	unsigned long flags;
1663
1664	mutex_lock(&amiflop_mutex);
1665	old_dev = fd_device[drive];
1666
1667	if (fd_ref[drive] && old_dev != system) {
1668		mutex_unlock(&amiflop_mutex);
1669		return -EBUSY;
1670	}
1671
1672	if (unit[drive].type->code == FD_NODRIVE) {
1673		mutex_unlock(&amiflop_mutex);
1674		return -ENXIO;
1675	}
1676	if (mode & (BLK_OPEN_READ | BLK_OPEN_WRITE)) {
1677		disk_check_media_change(disk);
1678		if (mode & BLK_OPEN_WRITE) {
1679			int wrprot;
1680
1681			get_fdc(drive);
1682			fd_select (drive);
1683			wrprot = !(ciaa.pra & DSKPROT);
1684			fd_deselect (drive);
1685			rel_fdc();
1686
1687			if (wrprot) {
1688				mutex_unlock(&amiflop_mutex);
1689				return -EROFS;
1690			}
1691		}
1692	}
1693	local_irq_save(flags);
1694	fd_ref[drive]++;
1695	fd_device[drive] = system;
1696	local_irq_restore(flags);
1697
1698	unit[drive].dtype=&data_types[system];
1699	unit[drive].blocks=unit[drive].type->heads*unit[drive].type->tracks*
1700		data_types[system].sects*unit[drive].type->sect_mult;
1701	set_capacity(unit[drive].gendisk[system], unit[drive].blocks);
1702
1703	printk(KERN_INFO "fd%d: accessing %s-disk with %s-layout\n",drive,
1704	       unit[drive].type->name, data_types[system].name);
1705
1706	mutex_unlock(&amiflop_mutex);
1707	return 0;
1708}
1709
1710static void floppy_release(struct gendisk *disk)
1711{
1712	struct amiga_floppy_struct *p = disk->private_data;
1713	int drive = p - unit;
1714
1715	mutex_lock(&amiflop_mutex);
1716	if (unit[drive].dirty == 1) {
1717		timer_delete(flush_track_timer + drive);
1718		non_int_flush_track (drive);
1719	}
1720  
1721	if (!fd_ref[drive]--) {
1722		printk(KERN_CRIT "floppy_release with fd_ref == 0");
1723		fd_ref[drive] = 0;
1724	}
1725#ifdef MODULE
1726	floppy_off (drive);
1727#endif
1728	mutex_unlock(&amiflop_mutex);
1729}
1730
1731/*
1732 * check_events is never called from an interrupt, so we can relax a bit
1733 * here, sleep etc. Note that floppy-on tries to set current_DOR to point
1734 * to the desired drive, but it will probably not survive the sleep if
1735 * several floppies are used at the same time: thus the loop.
1736 */
1737static unsigned amiga_check_events(struct gendisk *disk, unsigned int clearing)
1738{
1739	struct amiga_floppy_struct *p = disk->private_data;
1740	int drive = p - unit;
1741	int changed;
1742	static int first_time = 1;
1743
1744	if (first_time)
1745		changed = first_time--;
1746	else {
1747		get_fdc(drive);
1748		fd_select (drive);
1749		changed = !(ciaa.pra & DSKCHANGE);
1750		fd_deselect (drive);
1751		rel_fdc();
1752	}
1753
1754	if (changed) {
1755		fd_probe(drive);
1756		p->track = -1;
1757		p->dirty = 0;
1758		writepending = 0; /* if this was true before, too bad! */
1759		writefromint = 0;
1760		return DISK_EVENT_MEDIA_CHANGE;
1761	}
1762	return 0;
1763}
1764
1765static const struct block_device_operations floppy_fops = {
1766	.owner		= THIS_MODULE,
1767	.open		= floppy_open,
1768	.release	= floppy_release,
1769	.ioctl		= fd_ioctl,
1770	.getgeo		= fd_getgeo,
1771	.check_events	= amiga_check_events,
1772};
1773
1774static const struct blk_mq_ops amiflop_mq_ops = {
1775	.queue_rq = amiflop_queue_rq,
1776};
1777
1778static int fd_alloc_disk(int drive, int system)
1779{
1780	struct queue_limits lim = {
1781		.features		= BLK_FEAT_ROTATIONAL,
1782	};
1783	struct gendisk *disk;
1784	int err;
1785
1786	disk = blk_mq_alloc_disk(&unit[drive].tag_set, &lim, NULL);
1787	if (IS_ERR(disk))
1788		return PTR_ERR(disk);
1789
1790	disk->major = FLOPPY_MAJOR;
1791	disk->first_minor = drive + system;
1792	disk->minors = 1;
1793	disk->fops = &floppy_fops;
1794	disk->flags |= GENHD_FL_NO_PART;
1795	disk->events = DISK_EVENT_MEDIA_CHANGE;
1796	if (system)
1797		sprintf(disk->disk_name, "fd%d_msdos", drive);
1798	else
1799		sprintf(disk->disk_name, "fd%d", drive);
1800	disk->private_data = &unit[drive];
1801	set_capacity(disk, 880 * 2);
1802
1803	unit[drive].gendisk[system] = disk;
1804	err = add_disk(disk);
1805	if (err)
1806		put_disk(disk);
1807	return err;
1808}
1809
1810static int fd_alloc_drive(int drive)
1811{
1812	unit[drive].trackbuf = kmalloc(FLOPPY_MAX_SECTORS * 512, GFP_KERNEL);
1813	if (!unit[drive].trackbuf)
1814		goto out;
1815
1816	memset(&unit[drive].tag_set, 0, sizeof(unit[drive].tag_set));
1817	unit[drive].tag_set.ops = &amiflop_mq_ops;
1818	unit[drive].tag_set.nr_hw_queues = 1;
1819	unit[drive].tag_set.nr_maps = 1;
1820	unit[drive].tag_set.queue_depth = 2;
1821	unit[drive].tag_set.numa_node = NUMA_NO_NODE;
1822	if (blk_mq_alloc_tag_set(&unit[drive].tag_set))
1823		goto out_cleanup_trackbuf;
1824
1825	pr_cont(" fd%d", drive);
1826
1827	if (fd_alloc_disk(drive, 0) || fd_alloc_disk(drive, 1))
1828		goto out_cleanup_tagset;
1829	return 0;
1830
1831out_cleanup_tagset:
1832	blk_mq_free_tag_set(&unit[drive].tag_set);
1833out_cleanup_trackbuf:
1834	kfree(unit[drive].trackbuf);
1835out:
1836	unit[drive].type->code = FD_NODRIVE;
1837	return -ENOMEM;
1838}
1839
1840static int __init fd_probe_drives(void)
1841{
1842	int drive,drives,nomem;
1843
1844	pr_info("FD: probing units\nfound");
1845	drives=0;
1846	nomem=0;
1847	for(drive=0;drive<FD_MAX_UNITS;drive++) {
1848		fd_probe(drive);
1849		if (unit[drive].type->code == FD_NODRIVE)
1850			continue;
1851
1852		if (fd_alloc_drive(drive) < 0) {
1853			pr_cont(" no mem for fd%d", drive);
1854			nomem = 1;
1855			continue;
1856		}
1857		drives++;
1858	}
1859	if ((drives > 0) || (nomem == 0)) {
1860		if (drives == 0)
1861			pr_cont(" no drives");
1862		pr_cont("\n");
1863		return drives;
1864	}
1865	pr_cont("\n");
1866	return -ENOMEM;
1867}
1868 
1869static int __init amiga_floppy_probe(struct platform_device *pdev)
1870{
1871	int i, ret;
1872
1873	if (register_blkdev(FLOPPY_MAJOR,"fd"))
1874		return -EBUSY;
1875
1876	ret = -ENOMEM;
1877	raw_buf = amiga_chip_alloc(RAW_BUF_SIZE, "Floppy");
1878	if (!raw_buf) {
1879		printk("fd: cannot get chip mem buffer\n");
1880		goto out_blkdev;
1881	}
1882
1883	ret = -EBUSY;
1884	if (request_irq(IRQ_AMIGA_DSKBLK, fd_block_done, 0, "floppy_dma", NULL)) {
1885		printk("fd: cannot get irq for dma\n");
1886		goto out_irq;
1887	}
1888
1889	if (request_irq(IRQ_AMIGA_CIAA_TB, ms_isr, 0, "floppy_timer", NULL)) {
1890		printk("fd: cannot get irq for timer\n");
1891		goto out_irq2;
1892	}
1893
1894	ret = -ENODEV;
1895	if (fd_probe_drives() < 1) /* No usable drives */
1896		goto out_probe;
1897
1898	/* initialize variables */
1899	timer_setup(&motor_on_timer, motor_on_callback, 0);
1900	motor_on_timer.expires = 0;
1901	for (i = 0; i < FD_MAX_UNITS; i++) {
1902		timer_setup(&motor_off_timer[i], fd_motor_off, 0);
1903		motor_off_timer[i].expires = 0;
1904		timer_setup(&flush_track_timer[i], flush_track_callback, 0);
1905		flush_track_timer[i].expires = 0;
1906
1907		unit[i].track = -1;
1908	}
1909
1910	timer_setup(&post_write_timer, post_write_callback, 0);
1911	post_write_timer.expires = 0;
1912  
1913	for (i = 0; i < 128; i++)
1914		mfmdecode[i]=255;
1915	for (i = 0; i < 16; i++)
1916		mfmdecode[mfmencode[i]]=i;
1917
1918	/* make sure that disk DMA is enabled */
1919	custom.dmacon = DMAF_SETCLR | DMAF_DISK;
1920
1921	/* init ms timer */
1922	ciaa.crb = 8; /* one-shot, stop */
1923	return 0;
1924
1925out_probe:
1926	free_irq(IRQ_AMIGA_CIAA_TB, NULL);
1927out_irq2:
1928	free_irq(IRQ_AMIGA_DSKBLK, NULL);
1929out_irq:
1930	amiga_chip_free(raw_buf);
1931out_blkdev:
1932	unregister_blkdev(FLOPPY_MAJOR,"fd");
1933	return ret;
1934}
1935
1936static struct platform_driver amiga_floppy_driver = {
1937	.driver   = {
1938		.name	= "amiga-floppy",
1939	},
1940};
1941
1942static int __init amiga_floppy_init(void)
1943{
1944	return platform_driver_probe(&amiga_floppy_driver, amiga_floppy_probe);
1945}
1946
1947module_init(amiga_floppy_init);
1948
1949#ifndef MODULE
1950static int __init amiga_floppy_setup (char *str)
1951{
1952	int n;
1953	if (!MACH_IS_AMIGA)
1954		return 0;
1955	if (!get_option(&str, &n))
1956		return 0;
1957	printk (KERN_INFO "amiflop: Setting default df0 to %x\n", n);
1958	fd_def_df0 = n;
1959	return 1;
1960}
1961
1962__setup("floppy=", amiga_floppy_setup);
1963#endif
1964
1965MODULE_ALIAS("platform:amiga-floppy");