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