arch/sparc/include/asm/floppy

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

INCLUDED FROM

DEFINITIONS
