arch/sparc/include/asm/floppy_64.h

   1 /* floppy.h: Sparc specific parts of the Floppy driver.
   2  *
   3  * Copyright (C) 1996, 2007, 2008 David S. Miller (davem@davemloft.net)
   4  * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
   5  *
   6  * Ultra/PCI support added: Sep 1997  Eddie C. Dost  (ecd@skynet.be)
   7  */
   8
   9 #ifndef __ASM_SPARC64_FLOPPY_H
  10 #define __ASM_SPARC64_FLOPPY_H
  11
  12 #include <linux/of.h>
  13 #include <linux/of_device.h>
  14 #include <linux/dma-mapping.h>
  15
  16 #include <asm/auxio.h>
  17
  18 /*
  19  * Define this to enable exchanging drive 0 and 1 if only drive 1 is
  20  * probed on PCI machines.
  21  */
  22 #undef PCI_FDC_SWAP_DRIVES
  23
  24
  25 /* References:
  26  * 1) Netbsd Sun floppy driver.
  27  * 2) NCR 82077 controller manual
  28  * 3) Intel 82077 controller manual
  29  */
  30 struct sun_flpy_controller {
  31         volatile unsigned char status1_82077; /* Auxiliary Status reg. 1 */
  32         volatile unsigned char status2_82077; /* Auxiliary Status reg. 2 */
  33         volatile unsigned char dor_82077;     /* Digital Output reg. */
  34         volatile unsigned char tapectl_82077; /* Tape Control reg */
  35         volatile unsigned char status_82077;  /* Main Status Register. */
  36 #define drs_82077              status_82077   /* Digital Rate Select reg. */
  37         volatile unsigned char data_82077;    /* Data fifo. */
  38         volatile unsigned char ___unused;
  39         volatile unsigned char dir_82077;     /* Digital Input reg. */
  40 #define dcr_82077              dir_82077      /* Config Control reg. */
  41 };
  42
  43 /* You'll only ever find one controller on an Ultra anyways. */
  44 static struct sun_flpy_controller *sun_fdc = (struct sun_flpy_controller *)-1;
  45 unsigned long fdc_status;
  46 static struct platform_device *floppy_op = NULL;
  47
  48 struct sun_floppy_ops {
  49         unsigned char   (*fd_inb) (unsigned long port);
  50         void            (*fd_outb) (unsigned char value, unsigned long port);
  51         void            (*fd_enable_dma) (void);
  52         void            (*fd_disable_dma) (void);
  53         void            (*fd_set_dma_mode) (int);
  54         void            (*fd_set_dma_addr) (char *);
  55         void            (*fd_set_dma_count) (int);
  56         unsigned int    (*get_dma_residue) (void);
  57         int             (*fd_request_irq) (void);
  58         void            (*fd_free_irq) (void);
  59         int             (*fd_eject) (int);
  60 };
  61
  62 static struct sun_floppy_ops sun_fdops;
  63
  64 #define fd_inb(port)              sun_fdops.fd_inb(port)
  65 #define fd_outb(value,port)       sun_fdops.fd_outb(value,port)
  66 #define fd_enable_dma()           sun_fdops.fd_enable_dma()
  67 #define fd_disable_dma()          sun_fdops.fd_disable_dma()
  68 #define fd_request_dma()          (0) /* nothing... */
  69 #define fd_free_dma()             /* nothing... */
  70 #define fd_clear_dma_ff()         /* nothing... */
  71 #define fd_set_dma_mode(mode)     sun_fdops.fd_set_dma_mode(mode)
  72 #define fd_set_dma_addr(addr)     sun_fdops.fd_set_dma_addr(addr)
  73 #define fd_set_dma_count(count)   sun_fdops.fd_set_dma_count(count)
  74 #define get_dma_residue(x)        sun_fdops.get_dma_residue()
  75 #define fd_cacheflush(addr, size) /* nothing... */
  76 #define fd_request_irq()          sun_fdops.fd_request_irq()
  77 #define fd_free_irq()             sun_fdops.fd_free_irq()
  78 #define fd_eject(drive)           sun_fdops.fd_eject(drive)
  79
  80 /* Super paranoid... */
  81 #undef HAVE_DISABLE_HLT
  82
  83 static int sun_floppy_types[2] = { 0, 0 };
  84
  85 /* Here is where we catch the floppy driver trying to initialize,
  86  * therefore this is where we call the PROM device tree probing
  87  * routine etc. on the Sparc.
  88  */
  89 #define FLOPPY0_TYPE            sun_floppy_init()
  90 #define FLOPPY1_TYPE            sun_floppy_types[1]
  91
  92 #define FDC1                    ((unsigned long)sun_fdc)
  93
  94 #define N_FDC    1
  95 #define N_DRIVE  8
  96
  97 /* No 64k boundary crossing problems on the Sparc. */
  98 #define CROSS_64KB(a,s) (0)
  99
 100 static unsigned char sun_82077_fd_inb(unsigned long port)
 101 {
 102         udelay(5);
 103         switch(port & 7) {
 104         default:
 105                 printk("floppy: Asked to read unknown port %lx\n", port);
 106                 panic("floppy: Port bolixed.");
 107         case 4: /* FD_STATUS */
 108                 return sbus_readb(&sun_fdc->status_82077) & ~STATUS_DMA;
 109         case 5: /* FD_DATA */
 110                 return sbus_readb(&sun_fdc->data_82077);
 111         case 7: /* FD_DIR */
 112                 /* XXX: Is DCL on 0x80 in sun4m? */
 113                 return sbus_readb(&sun_fdc->dir_82077);
 114         }
 115         panic("sun_82072_fd_inb: How did I get here?");
 116 }
 117
 118 static void sun_82077_fd_outb(unsigned char value, unsigned long port)
 119 {
 120         udelay(5);
 121         switch(port & 7) {
 122         default:
 123                 printk("floppy: Asked to write to unknown port %lx\n", port);
 124                 panic("floppy: Port bolixed.");
 125         case 2: /* FD_DOR */
 126                 /* Happily, the 82077 has a real DOR register. */
 127                 sbus_writeb(value, &sun_fdc->dor_82077);
 128                 break;
 129         case 5: /* FD_DATA */
 130                 sbus_writeb(value, &sun_fdc->data_82077);
 131                 break;
 132         case 7: /* FD_DCR */
 133                 sbus_writeb(value, &sun_fdc->dcr_82077);
 134                 break;
 135         case 4: /* FD_STATUS */
 136                 sbus_writeb(value, &sun_fdc->status_82077);
 137                 break;
 138         }
 139         return;
 140 }
 141
 142 /* For pseudo-dma (Sun floppy drives have no real DMA available to
 143  * them so we must eat the data fifo bytes directly ourselves) we have
 144  * three state variables.  doing_pdma tells our inline low-level
 145  * assembly floppy interrupt entry point whether it should sit and eat
 146  * bytes from the fifo or just transfer control up to the higher level
 147  * floppy interrupt c-code.  I tried very hard but I could not get the
 148  * pseudo-dma to work in c-code without getting many overruns and
 149  * underruns.  If non-zero, doing_pdma encodes the direction of
 150  * the transfer for debugging.  1=read 2=write
 151  */
 152 unsigned char *pdma_vaddr;
 153 unsigned long pdma_size;
 154 volatile int doing_pdma = 0;
 155
 156 /* This is software state */
 157 char *pdma_base = NULL;
 158 unsigned long pdma_areasize;
 159
 160 /* Common routines to all controller types on the Sparc. */
 161 static void sun_fd_disable_dma(void)
 162 {
 163         doing_pdma = 0;
 164         if (pdma_base) {
 165                 mmu_unlockarea(pdma_base, pdma_areasize);
 166                 pdma_base = NULL;
 167         }
 168 }
 169
 170 static void sun_fd_set_dma_mode(int mode)
 171 {
 172         switch(mode) {
 173         case DMA_MODE_READ:
 174                 doing_pdma = 1;
 175                 break;
 176         case DMA_MODE_WRITE:
 177                 doing_pdma = 2;
 178                 break;
 179         default:
 180                 printk("Unknown dma mode %d\n", mode);
 181                 panic("floppy: Giving up...");
 182         }
 183 }
 184
 185 static void sun_fd_set_dma_addr(char *buffer)
 186 {
 187         pdma_vaddr = buffer;
 188 }
 189
 190 static void sun_fd_set_dma_count(int length)
 191 {
 192         pdma_size = length;
 193 }
 194
 195 static void sun_fd_enable_dma(void)
 196 {
 197         pdma_vaddr = mmu_lockarea(pdma_vaddr, pdma_size);
 198         pdma_base = pdma_vaddr;
 199         pdma_areasize = pdma_size;
 200 }
 201
 202 irqreturn_t sparc_floppy_irq(int irq, void *dev_cookie)
 203 {
 204         if (likely(doing_pdma)) {
 205                 void __iomem *stat = (void __iomem *) fdc_status;
 206                 unsigned char *vaddr = pdma_vaddr;
 207                 unsigned long size = pdma_size;
 208                 u8 val;
 209
 210                 while (size) {
 211                         val = readb(stat);
 212                         if (unlikely(!(val & 0x80))) {
 213                                 pdma_vaddr = vaddr;
 214                                 pdma_size = size;
 215                                 return IRQ_HANDLED;
 216                         }
 217                         if (unlikely(!(val & 0x20))) {
 218                                 pdma_vaddr = vaddr;
 219                                 pdma_size = size;
 220                                 doing_pdma = 0;
 221                                 goto main_interrupt;
 222                         }
 223                         if (val & 0x40) {
 224                                 /* read */
 225                                 *vaddr++ = readb(stat + 1);
 226                         } else {
 227                                 unsigned char data = *vaddr++;
 228
 229                                 /* write */
 230                                 writeb(data, stat + 1);
 231                         }
 232                         size--;
 233                 }
 234
 235                 pdma_vaddr = vaddr;
 236                 pdma_size = size;
 237
 238                 /* Send Terminal Count pulse to floppy controller. */
 239                 val = readb(auxio_register);
 240                 val |= AUXIO_AUX1_FTCNT;
 241                 writeb(val, auxio_register);
 242                 val &= ~AUXIO_AUX1_FTCNT;
 243                 writeb(val, auxio_register);
 244
 245                 doing_pdma = 0;
 246         }
 247
 248 main_interrupt:
 249         return floppy_interrupt(irq, dev_cookie);
 250 }
 251
 252 static int sun_fd_request_irq(void)
 253 {
 254         static int once = 0;
 255         int error;
 256
 257         if(!once) {
 258                 once = 1;
 259
 260                 error = request_irq(FLOPPY_IRQ, sparc_floppy_irq,
 261                                     IRQF_DISABLED, "floppy", NULL);
 262
 263                 return ((error == 0) ? 0 : -1);
 264         }
 265         return 0;
 266 }
 267
 268 static void sun_fd_free_irq(void)
 269 {
 270 }
 271
 272 static unsigned int sun_get_dma_residue(void)
 273 {
 274         /* XXX This isn't really correct. XXX */
 275         return 0;
 276 }
 277
 278 static int sun_fd_eject(int drive)
 279 {
 280         set_dor(0x00, 0xff, 0x90);
 281         udelay(500);
 282         set_dor(0x00, 0x6f, 0x00);
 283         udelay(500);
 284         return 0;
 285 }
 286
 287 #include <asm/ebus_dma.h>
 288 #include <asm/ns87303.h>
 289
 290 static struct ebus_dma_info sun_pci_fd_ebus_dma;
 291 static struct device *sun_floppy_dev;
 292 static int sun_pci_broken_drive = -1;
 293
 294 struct sun_pci_dma_op {
 295         unsigned int    addr;
 296         int             len;
 297         int             direction;
 298         char            *buf;
 299 };
 300 static struct sun_pci_dma_op sun_pci_dma_current = { -1U, 0, 0, NULL};
 301 static struct sun_pci_dma_op sun_pci_dma_pending = { -1U, 0, 0, NULL};
 302
 303 extern irqreturn_t floppy_interrupt(int irq, void *dev_id);
 304
 305 static unsigned char sun_pci_fd_inb(unsigned long port)
 306 {
 307         udelay(5);
 308         return inb(port);
 309 }
 310
 311 static void sun_pci_fd_outb(unsigned char val, unsigned long port)
 312 {
 313         udelay(5);
 314         outb(val, port);
 315 }
 316
 317 static void sun_pci_fd_broken_outb(unsigned char val, unsigned long port)
 318 {
 319         udelay(5);
 320         /*
 321          * XXX: Due to SUN's broken floppy connector on AX and AXi
 322          *      we need to turn on MOTOR_0 also, if the floppy is
 323          *      jumpered to DS1 (like most PC floppies are). I hope
 324          *      this does not hurt correct hardware like the AXmp.
 325          *      (Eddie, Sep 12 1998).
 326          */
 327         if (port == ((unsigned long)sun_fdc) + 2) {
 328                 if (((val & 0x03) == sun_pci_broken_drive) && (val & 0x20)) {
 329                         val |= 0x10;
 330                 }
 331         }
 332         outb(val, port);
 333 }
 334
 335 #ifdef PCI_FDC_SWAP_DRIVES
 336 static void sun_pci_fd_lde_broken_outb(unsigned char val, unsigned long port)
 337 {
 338         udelay(5);
 339         /*
 340          * XXX: Due to SUN's broken floppy connector on AX and AXi
 341          *      we need to turn on MOTOR_0 also, if the floppy is
 342          *      jumpered to DS1 (like most PC floppies are). I hope
 343          *      this does not hurt correct hardware like the AXmp.
 344          *      (Eddie, Sep 12 1998).
 345          */
 346         if (port == ((unsigned long)sun_fdc) + 2) {
 347                 if (((val & 0x03) == sun_pci_broken_drive) && (val & 0x10)) {
 348                         val &= ~(0x03);
 349                         val |= 0x21;
 350                 }
 351         }
 352         outb(val, port);
 353 }
 354 #endif /* PCI_FDC_SWAP_DRIVES */
 355
 356 static void sun_pci_fd_enable_dma(void)
 357 {
 358         BUG_ON((NULL == sun_pci_dma_pending.buf)        ||
 359             (0    == sun_pci_dma_pending.len)   ||
 360             (0    == sun_pci_dma_pending.direction));
 361
 362         sun_pci_dma_current.buf = sun_pci_dma_pending.buf;
 363         sun_pci_dma_current.len = sun_pci_dma_pending.len;
 364         sun_pci_dma_current.direction = sun_pci_dma_pending.direction;
 365
 366         sun_pci_dma_pending.buf  = NULL;
 367         sun_pci_dma_pending.len  = 0;
 368         sun_pci_dma_pending.direction = 0;
 369         sun_pci_dma_pending.addr = -1U;
 370
 371         sun_pci_dma_current.addr =
 372                 dma_map_single(sun_floppy_dev,
 373                                sun_pci_dma_current.buf,
 374                                sun_pci_dma_current.len,
 375                                sun_pci_dma_current.direction);
 376
 377         ebus_dma_enable(&sun_pci_fd_ebus_dma, 1);
 378
 379         if (ebus_dma_request(&sun_pci_fd_ebus_dma,
 380                              sun_pci_dma_current.addr,
 381                              sun_pci_dma_current.len))
 382                 BUG();
 383 }
 384
 385 static void sun_pci_fd_disable_dma(void)
 386 {
 387         ebus_dma_enable(&sun_pci_fd_ebus_dma, 0);
 388         if (sun_pci_dma_current.addr != -1U)
 389                 dma_unmap_single(sun_floppy_dev,
 390                                  sun_pci_dma_current.addr,
 391                                  sun_pci_dma_current.len,
 392                                  sun_pci_dma_current.direction);
 393         sun_pci_dma_current.addr = -1U;
 394 }
 395
 396 static void sun_pci_fd_set_dma_mode(int mode)
 397 {
 398         if (mode == DMA_MODE_WRITE)
 399                 sun_pci_dma_pending.direction = DMA_TO_DEVICE;
 400         else
 401                 sun_pci_dma_pending.direction = DMA_FROM_DEVICE;
 402
 403         ebus_dma_prepare(&sun_pci_fd_ebus_dma, mode != DMA_MODE_WRITE);
 404 }
 405
 406 static void sun_pci_fd_set_dma_count(int length)
 407 {
 408         sun_pci_dma_pending.len = length;
 409 }
 410
 411 static void sun_pci_fd_set_dma_addr(char *buffer)
 412 {
 413         sun_pci_dma_pending.buf = buffer;
 414 }
 415
 416 static unsigned int sun_pci_get_dma_residue(void)
 417 {
 418         return ebus_dma_residue(&sun_pci_fd_ebus_dma);
 419 }
 420
 421 static int sun_pci_fd_request_irq(void)
 422 {
 423         return ebus_dma_irq_enable(&sun_pci_fd_ebus_dma, 1);
 424 }
 425
 426 static void sun_pci_fd_free_irq(void)
 427 {
 428         ebus_dma_irq_enable(&sun_pci_fd_ebus_dma, 0);
 429 }
 430
 431 static int sun_pci_fd_eject(int drive)
 432 {
 433         return -EINVAL;
 434 }
 435
 436 void sun_pci_fd_dma_callback(struct ebus_dma_info *p, int event, void *cookie)
 437 {
 438         floppy_interrupt(0, NULL);
 439 }
 440
 441 /*
 442  * Floppy probing, we'd like to use /dev/fd0 for a single Floppy on PCI,
 443  * even if this is configured using DS1, thus looks like /dev/fd1 with
 444  * the cabling used in Ultras.
 445  */
 446 #define DOR     (port + 2)
 447 #define MSR     (port + 4)
 448 #define FIFO    (port + 5)
 449
 450 static void sun_pci_fd_out_byte(unsigned long port, unsigned char val,
 451                                 unsigned long reg)
 452 {
 453         unsigned char status;
 454         int timeout = 1000;
 455
 456         while (!((status = inb(MSR)) & 0x80) && --timeout)
 457                 udelay(100);
 458         outb(val, reg);
 459 }
 460
 461 static unsigned char sun_pci_fd_sensei(unsigned long port)
 462 {
 463         unsigned char result[2] = { 0x70, 0x00 };
 464         unsigned char status;
 465         int i = 0;
 466
 467         sun_pci_fd_out_byte(port, 0x08, FIFO);
 468         do {
 469                 int timeout = 1000;
 470
 471                 while (!((status = inb(MSR)) & 0x80) && --timeout)
 472                         udelay(100);
 473
 474                 if (!timeout)
 475                         break;
 476
 477                 if ((status & 0xf0) == 0xd0)
 478                         result[i++] = inb(FIFO);
 479                 else
 480                         break;
 481         } while (i < 2);
 482
 483         return result[0];
 484 }
 485
 486 static void sun_pci_fd_reset(unsigned long port)
 487 {
 488         unsigned char mask = 0x00;
 489         unsigned char status;
 490         int timeout = 10000;
 491
 492         outb(0x80, MSR);
 493         do {
 494                 status = sun_pci_fd_sensei(port);
 495                 if ((status & 0xc0) == 0xc0)
 496                         mask |= 1 << (status & 0x03);
 497                 else
 498                         udelay(100);
 499         } while ((mask != 0x0f) && --timeout);
 500 }
 501
 502 static int sun_pci_fd_test_drive(unsigned long port, int drive)
 503 {
 504         unsigned char status, data;
 505         int timeout = 1000;
 506         int ready;
 507
 508         sun_pci_fd_reset(port);
 509
 510         data = (0x10 << drive) | 0x0c | drive;
 511         sun_pci_fd_out_byte(port, data, DOR);
 512
 513         sun_pci_fd_out_byte(port, 0x07, FIFO);
 514         sun_pci_fd_out_byte(port, drive & 0x03, FIFO);
 515
 516         do {
 517                 udelay(100);
 518                 status = sun_pci_fd_sensei(port);
 519         } while (((status & 0xc0) == 0x80) && --timeout);
 520
 521         if (!timeout)
 522                 ready = 0;
 523         else
 524                 ready = (status & 0x10) ? 0 : 1;
 525
 526         sun_pci_fd_reset(port);
 527         return ready;
 528 }
 529 #undef FIFO
 530 #undef MSR
 531 #undef DOR
 532
 533 static int __init ebus_fdthree_p(struct device_node *dp)
 534 {
 535         if (!strcmp(dp->name, "fdthree"))
 536                 return 1;
 537         if (!strcmp(dp->name, "floppy")) {
 538                 const char *compat;
 539
 540                 compat = of_get_property(dp, "compatible", NULL);
 541                 if (compat && !strcmp(compat, "fdthree"))
 542                         return 1;
 543         }
 544         return 0;
 545 }
 546
 547 static unsigned long __init sun_floppy_init(void)
 548 {
 549         static int initialized = 0;
 550         struct device_node *dp;
 551         struct platform_device *op;
 552         const char *prop;
 553         char state[128];
 554
 555         if (initialized)
 556                 return sun_floppy_types[0];
 557         initialized = 1;
 558
 559         op = NULL;
 560
 561         for_each_node_by_name(dp, "SUNW,fdtwo") {
 562                 if (strcmp(dp->parent->name, "sbus"))
 563                         continue;
 564                 op = of_find_device_by_node(dp);
 565                 if (op)
 566                         break;
 567         }
 568         if (op) {
 569                 floppy_op = op;
 570                 FLOPPY_IRQ = op->archdata.irqs[0];
 571         } else {
 572                 struct device_node *ebus_dp;
 573                 void __iomem *auxio_reg;
 574                 const char *state_prop;
 575                 unsigned long config;
 576
 577                 dp = NULL;
 578                 for_each_node_by_name(ebus_dp, "ebus") {
 579                         for (dp = ebus_dp->child; dp; dp = dp->sibling) {
 580                                 if (ebus_fdthree_p(dp))
 581                                         goto found_fdthree;
 582                         }
 583                 }
 584         found_fdthree:
 585                 if (!dp)
 586                         return 0;
 587
 588                 op = of_find_device_by_node(dp);
 589                 if (!op)
 590                         return 0;
 591
 592                 state_prop = of_get_property(op->dev.of_node, "status", NULL);
 593                 if (state_prop && !strncmp(state_prop, "disabled", 8))
 594                         return 0;
 595
 596                 FLOPPY_IRQ = op->archdata.irqs[0];
 597
 598                 /* Make sure the high density bit is set, some systems
 599                  * (most notably Ultra5/Ultra10) come up with it clear.
 600                  */
 601                 auxio_reg = (void __iomem *) op->resource[2].start;
 602                 writel(readl(auxio_reg)|0x2, auxio_reg);
 603
 604                 sun_floppy_dev = &op->dev;
 605
 606                 spin_lock_init(&sun_pci_fd_ebus_dma.lock);
 607
 608                 /* XXX ioremap */
 609                 sun_pci_fd_ebus_dma.regs = (void __iomem *)
 610                         op->resource[1].start;
 611                 if (!sun_pci_fd_ebus_dma.regs)
 612                         return 0;
 613
 614                 sun_pci_fd_ebus_dma.flags = (EBUS_DMA_FLAG_USE_EBDMA_HANDLER |
 615                                              EBUS_DMA_FLAG_TCI_DISABLE);
 616                 sun_pci_fd_ebus_dma.callback = sun_pci_fd_dma_callback;
 617                 sun_pci_fd_ebus_dma.client_cookie = NULL;
 618                 sun_pci_fd_ebus_dma.irq = FLOPPY_IRQ;
 619                 strcpy(sun_pci_fd_ebus_dma.name, "floppy");
 620                 if (ebus_dma_register(&sun_pci_fd_ebus_dma))
 621                         return 0;
 622
 623                 /* XXX ioremap */
 624                 sun_fdc = (struct sun_flpy_controller *) op->resource[0].start;
 625
 626                 sun_fdops.fd_inb = sun_pci_fd_inb;
 627                 sun_fdops.fd_outb = sun_pci_fd_outb;
 628
 629                 can_use_virtual_dma = use_virtual_dma = 0;
 630                 sun_fdops.fd_enable_dma = sun_pci_fd_enable_dma;
 631                 sun_fdops.fd_disable_dma = sun_pci_fd_disable_dma;
 632                 sun_fdops.fd_set_dma_mode = sun_pci_fd_set_dma_mode;
 633                 sun_fdops.fd_set_dma_addr = sun_pci_fd_set_dma_addr;
 634                 sun_fdops.fd_set_dma_count = sun_pci_fd_set_dma_count;
 635                 sun_fdops.get_dma_residue = sun_pci_get_dma_residue;
 636
 637                 sun_fdops.fd_request_irq = sun_pci_fd_request_irq;
 638                 sun_fdops.fd_free_irq = sun_pci_fd_free_irq;
 639
 640                 sun_fdops.fd_eject = sun_pci_fd_eject;
 641
 642                 fdc_status = (unsigned long) &sun_fdc->status_82077;
 643
 644                 /*
 645                  * XXX: Find out on which machines this is really needed.
 646                  */
 647                 if (1) {
 648                         sun_pci_broken_drive = 1;
 649                         sun_fdops.fd_outb = sun_pci_fd_broken_outb;
 650                 }
 651
 652                 allowed_drive_mask = 0;
 653                 if (sun_pci_fd_test_drive((unsigned long)sun_fdc, 0))
 654                         sun_floppy_types[0] = 4;
 655                 if (sun_pci_fd_test_drive((unsigned long)sun_fdc, 1))
 656                         sun_floppy_types[1] = 4;
 657
 658                 /*
 659                  * Find NS87303 SuperIO config registers (through ecpp).
 660                  */
 661                 config = 0;
 662                 for (dp = ebus_dp->child; dp; dp = dp->sibling) {
 663                         if (!strcmp(dp->name, "ecpp")) {
 664                                 struct platform_device *ecpp_op;
 665
 666                                 ecpp_op = of_find_device_by_node(dp);
 667                                 if (ecpp_op)
 668                                         config = ecpp_op->resource[1].start;
 669                                 goto config_done;
 670                         }
 671                 }
 672         config_done:
 673
 674                 /*
 675                  * Sanity check, is this really the NS87303?
 676                  */
 677                 switch (config & 0x3ff) {
 678                 case 0x02e:
 679                 case 0x15c:
 680                 case 0x26e:
 681                 case 0x398:
 682                         break;
 683                 default:
 684                         config = 0;
 685                 }
 686
 687                 if (!config)
 688                         return sun_floppy_types[0];
 689
 690                 /* Enable PC-AT mode. */
 691                 ns87303_modify(config, ASC, 0, 0xc0);
 692
 693 #ifdef PCI_FDC_SWAP_DRIVES
 694                 /*
 695                  * If only Floppy 1 is present, swap drives.
 696                  */
 697                 if (!sun_floppy_types[0] && sun_floppy_types[1]) {
 698                         /*
 699                          * Set the drive exchange bit in FCR on NS87303,
 700                          * make sure other bits are sane before doing so.
 701                          */
 702                         ns87303_modify(config, FER, FER_EDM, 0);
 703                         ns87303_modify(config, ASC, ASC_DRV2_SEL, 0);
 704                         ns87303_modify(config, FCR, 0, FCR_LDE);
 705
 706                         config = sun_floppy_types[0];
 707                         sun_floppy_types[0] = sun_floppy_types[1];
 708                         sun_floppy_types[1] = config;
 709
 710                         if (sun_pci_broken_drive != -1) {
 711                                 sun_pci_broken_drive = 1 - sun_pci_broken_drive;
 712                                 sun_fdops.fd_outb = sun_pci_fd_lde_broken_outb;
 713                         }
 714                 }
 715 #endif /* PCI_FDC_SWAP_DRIVES */
 716
 717                 return sun_floppy_types[0];
 718         }
 719         prop = of_get_property(op->dev.of_node, "status", NULL);
 720         if (prop && !strncmp(state, "disabled", 8))
 721                 return 0;
 722
 723         /*
 724          * We cannot do of_ioremap here: it does request_region,
 725          * which the generic floppy driver tries to do once again.
 726          * But we must use the sdev resource values as they have
 727          * had parent ranges applied.
 728          */
 729         sun_fdc = (struct sun_flpy_controller *)
 730                 (op->resource[0].start +
 731                  ((op->resource[0].flags & 0x1ffUL) << 32UL));
 732
 733         /* Last minute sanity check... */
 734         if (sbus_readb(&sun_fdc->status1_82077) == 0xff) {
 735                 sun_fdc = (struct sun_flpy_controller *)-1;
 736                 return 0;
 737         }
 738
 739         sun_fdops.fd_inb = sun_82077_fd_inb;
 740         sun_fdops.fd_outb = sun_82077_fd_outb;
 741
 742         can_use_virtual_dma = use_virtual_dma = 1;
 743         sun_fdops.fd_enable_dma = sun_fd_enable_dma;
 744         sun_fdops.fd_disable_dma = sun_fd_disable_dma;
 745         sun_fdops.fd_set_dma_mode = sun_fd_set_dma_mode;
 746         sun_fdops.fd_set_dma_addr = sun_fd_set_dma_addr;
 747         sun_fdops.fd_set_dma_count = sun_fd_set_dma_count;
 748         sun_fdops.get_dma_residue = sun_get_dma_residue;
 749
 750         sun_fdops.fd_request_irq = sun_fd_request_irq;
 751         sun_fdops.fd_free_irq = sun_fd_free_irq;
 752
 753         sun_fdops.fd_eject = sun_fd_eject;
 754
 755         fdc_status = (unsigned long) &sun_fdc->status_82077;
 756
 757         /* Success... */
 758         allowed_drive_mask = 0x01;
 759         sun_floppy_types[0] = 4;
 760         sun_floppy_types[1] = 0;
 761
 762         return sun_floppy_types[0];
 763 }
 764
 765 #define EXTRA_FLOPPY_PARAMS
 766
 767 static DEFINE_SPINLOCK(dma_spin_lock);
 768
 769 #define claim_dma_lock() \
 770 ({      unsigned long flags; \
 771         spin_lock_irqsave(&dma_spin_lock, flags); \
 772         flags; \
 773 })
 774
 775 #define release_dma_lock(__flags) \
 776         spin_unlock_irqrestore(&dma_spin_lock, __flags);
 777
 778 #endif /* !(__ASM_SPARC64_FLOPPY_H) */