![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to floppy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / drivers|
Return to floppy.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / drivers |
1.1 ! root 1: #include "config.h" ! 2: #include "libopenbios/bindings.h" ! 3: #include "kernel/kernel.h" ! 4: #include "libc/byteorder.h" ! 5: #include "libc/vsprintf.h" ! 6: ! 7: #include "drivers/drivers.h" ! 8: ! 9: #include "timer.h" ! 10: ! 11: /* DECLARE data structures for the nodes. */ ! 12: DECLARE_UNNAMED_NODE( ob_floppy, INSTALL_OPEN, 2*sizeof(int) ); ! 13: ! 14: #ifdef CONFIG_DEBUG_FLOPPY ! 15: #define printk_info printk ! 16: #define printk_debug printk ! 17: #else ! 18: #define printk_info(x ...) ! 19: #define printk_debug(x ...) ! 20: #endif ! 21: #define printk_err printk ! 22: ! 23: #define FD_DRIVE 0 ! 24: ! 25: ! 26: #define FD_STATUS_A (0) /* Status register A */ ! 27: #define FD_STATUS_B (1) /* Status register B */ ! 28: #define FD_DOR (2) /* Digital Output Register */ ! 29: #define FD_TDR (3) /* Tape Drive Register */ ! 30: #define FD_STATUS (4) /* Main Status Register */ ! 31: #define FD_DSR (4) /* Data Rate Select Register (old) */ ! 32: #define FD_DATA (5) /* Data Transfer (FIFO) register */ ! 33: #define FD_DIR (7) /* Digital Input Register (read) */ ! 34: #define FD_DCR (7) /* Diskette Control Register (write)*/ ! 35: ! 36: /* Bit of FD_STATUS_A */ ! 37: #define STA_INT_PENDING 0x80 /* Interrupt Pending */ ! 38: ! 39: /* DOR */ ! 40: #define DOR_DRIVE0 0x00 ! 41: #define DOR_DRIVE1 0x01 ! 42: #define DOR_DRIVE2 0x02 ! 43: #define DOR_DRIVE3 0x03 ! 44: #define DOR_DRIVE_MASK 0x03 ! 45: #define DOR_NO_RESET 0x04 ! 46: #define DOR_DMA_EN 0x08 ! 47: #define DOR_MOT_EN0 0x10 ! 48: #define DOR_MOT_EN1 0x20 ! 49: #define DOR_MOT_EN2 0x40 ! 50: #define DOR_MOT_EN3 0x80 ! 51: ! 52: /* Bits of main status register */ ! 53: #define STATUS_BUSYMASK 0x0F /* drive busy mask */ ! 54: #define STATUS_BUSY 0x10 /* FDC busy */ ! 55: #define STATUS_NON_DMA 0x20 /* 0- DMA mode */ ! 56: #define STATUS_DIR 0x40 /* 0- cpu->fdc */ ! 57: #define STATUS_READY 0x80 /* Data reg ready */ ! 58: ! 59: /* Bits of FD_ST0 */ ! 60: #define ST0_DS 0x03 /* drive select mask */ ! 61: #define ST0_HA 0x04 /* Head (Address) */ ! 62: #define ST0_NR 0x08 /* Not Ready */ ! 63: #define ST0_ECE 0x10 /* Equipment check error */ ! 64: #define ST0_SE 0x20 /* Seek end */ ! 65: #define ST0_INTR 0xC0 /* Interrupt code mask */ ! 66: #define ST0_INTR_OK (0 << 6) ! 67: #define ST0_INTR_ERROR (1 << 6) ! 68: #define ST0_INTR_INVALID (2 << 6) ! 69: #define ST0_INTR_POLL_ERROR (3 << 6) ! 70: ! 71: /* Bits of FD_ST1 */ ! 72: #define ST1_MAM 0x01 /* Missing Address Mark */ ! 73: #define ST1_WP 0x02 /* Write Protect */ ! 74: #define ST1_ND 0x04 /* No Data - unreadable */ ! 75: #define ST1_OR 0x10 /* OverRun */ ! 76: #define ST1_CRC 0x20 /* CRC error in data or addr */ ! 77: #define ST1_EOC 0x80 /* End Of Cylinder */ ! 78: ! 79: /* Bits of FD_ST2 */ ! 80: #define ST2_MAM 0x01 /* Missing Address Mark (again) */ ! 81: #define ST2_BC 0x02 /* Bad Cylinder */ ! 82: #define ST2_SNS 0x04 /* Scan Not Satisfied */ ! 83: #define ST2_SEH 0x08 /* Scan Equal Hit */ ! 84: #define ST2_WC 0x10 /* Wrong Cylinder */ ! 85: #define ST2_CRC 0x20 /* CRC error in data field */ ! 86: #define ST2_CM 0x40 /* Control Mark = deleted */ ! 87: ! 88: /* Bits of FD_ST3 */ ! 89: #define ST3_HA 0x04 /* Head (Address) */ ! 90: #define ST3_DS 0x08 /* drive is double-sided */ ! 91: #define ST3_TZ 0x10 /* Track Zero signal (1=track 0) */ ! 92: #define ST3_RY 0x20 /* drive is ready */ ! 93: #define ST3_WP 0x40 /* Write Protect */ ! 94: #define ST3_FT 0x80 /* Drive Fault */ ! 95: ! 96: /* Values for FD_COMMAND */ ! 97: #define FD_RECALIBRATE 0x07 /* move to track 0 */ ! 98: #define FD_SEEK 0x0F /* seek track */ ! 99: #define FD_READ 0xA6 /* read with MT, SKip deleted */ ! 100: #define FD_WRITE 0xC5 /* write with MT, MFM */ ! 101: #define FD_SENSEI 0x08 /* Sense Interrupt Status */ ! 102: #define FD_SPECIFY 0x03 /* specify HUT etc */ ! 103: #define FD_FORMAT 0x4D /* format one track */ ! 104: #define FD_VERSION 0x10 /* get version code */ ! 105: #define FD_CONFIGURE 0x13 /* configure FIFO operation */ ! 106: #define FD_PERPENDICULAR 0x12 /* perpendicular r/w mode */ ! 107: #define FD_GETSTATUS 0x04 /* read ST3 */ ! 108: #define FD_DUMPREGS 0x0E /* dump the contents of the fdc regs */ ! 109: #define FD_READID 0xEA /* prints the header of a sector */ ! 110: #define FD_UNLOCK 0x14 /* Fifo config unlock */ ! 111: #define FD_LOCK 0x94 /* Fifo config lock */ ! 112: #define FD_RSEEK_OUT 0x8f /* seek out (i.e. to lower tracks) */ ! 113: #define FD_RSEEK_IN 0xcf /* seek in (i.e. to higher tracks) */ ! 114: ! 115: ! 116: /* the following commands are new in the 82078. They are not used in the ! 117: * floppy driver, except the first three. These commands may be useful for apps ! 118: * which use the FDRAWCMD interface. For doc, get the 82078 spec sheets at ! 119: * http://www-techdoc.intel.com/docs/periph/fd_contr/datasheets/ */ ! 120: ! 121: #define FD_PARTID 0x18 /* part id ("extended" version cmd) */ ! 122: #define FD_SAVE 0x2e /* save fdc regs for later restore */ ! 123: #define FD_DRIVESPEC 0x8e /* drive specification: Access to the ! 124: * 2 Mbps data transfer rate for tape ! 125: * drives */ ! 126: ! 127: #define FD_RESTORE 0x4e /* later restore */ ! 128: #define FD_POWERDOWN 0x27 /* configure FDC's powersave features */ ! 129: #define FD_FORMAT_N_WRITE 0xef /* format and write in one go. */ ! 130: #define FD_OPTION 0x33 /* ISO format (which is a clean way to ! 131: * pack more sectors on a track) */ ! 132: ! 133: /* FDC version return types */ ! 134: #define FDC_NONE 0x00 ! 135: #define FDC_UNKNOWN 0x10 /* DO NOT USE THIS TYPE EXCEPT IF IDENTIFICATION ! 136: FAILS EARLY */ ! 137: #define FDC_8272A 0x20 /* Intel 8272a, NEC 765 */ ! 138: #define FDC_765ED 0x30 /* Non-Intel 1MB-compatible FDC, can't detect */ ! 139: #define FDC_82072 0x40 /* Intel 82072; 8272a + FIFO + DUMPREGS */ ! 140: #define FDC_82072A 0x45 /* 82072A (on Sparcs) */ ! 141: #define FDC_82077_ORIG 0x51 /* Original version of 82077AA, sans LOCK */ ! 142: #define FDC_82077 0x52 /* 82077AA-1 */ ! 143: #define FDC_82078_UNKN 0x5f /* Unknown 82078 variant */ ! 144: #define FDC_82078 0x60 /* 44pin 82078 or 64pin 82078SL */ ! 145: #define FDC_82078_1 0x61 /* 82078-1 (2Mbps fdc) */ ! 146: #define FDC_S82078B 0x62 /* S82078B (first seen on Adaptec AVA-2825 VLB ! 147: * SCSI/EIDE/Floppy controller) */ ! 148: #define FDC_87306 0x63 /* National Semiconductor PC 87306 */ ! 149: ! 150: /* ! 151: * Beware: the fdc type list is roughly sorted by increasing features. ! 152: * Presence of features is tested by comparing the FDC version id with the ! 153: * "oldest" version that has the needed feature. ! 154: * If during FDC detection, an obscure test fails late in the sequence, don't ! 155: * assign FDC_UNKNOWN. Else the FDC will be treated as a dumb 8272a, or worse. ! 156: * This is especially true if the tests are unneeded. ! 157: */ ! 158: ! 159: /* Parameters for a 1.44 3.5" disk */ ! 160: #define DISK_H1440_SIZE 2880 ! 161: #define DISK_H1440_SECT 18 ! 162: #define DISK_H1440_HEAD 2 ! 163: #define DISK_H1440_TRACK 80 ! 164: #define DISK_H1440_STRETCH 0 ! 165: #define DISK_H1440_GAP 0x1B ! 166: #define DISK_H1440_RATE 0x00 ! 167: #define DISK_H1440_SPEC1 0xCF ! 168: #define DISK_H1440_FMT_GAP 0x6C ! 169: ! 170: /* Parameters for a 1.44 3.5" drive */ ! 171: #define DRIVE_H1440_MAX_DTR 500 ! 172: #define DRIVE_H1440_HLT 16 /* ms */ ! 173: #define DRIVE_H1440_HUT 16 /* ms */ ! 174: #define DRIVE_H1440_SRT 4000 /* us */ ! 175: #define DRIVE_H1440_SPINUP 400 /* ms */ ! 176: #define DRIVE_H1440_SPINDOWN 3000 /* ms */ ! 177: #define DRIVE_H1440_SPINDOWN_OFFSET 10 ! 178: #define DRIVE_H1440_SELECT_DELAY 20 /* ms */ ! 179: #define DRIVE_H1440_RPS 5 ! 180: #define DRIVE_H1440_TRACKS 83 ! 181: #define DRIVE_H1440_TIMEOUT 3000 /* ms */ ! 182: #define DRIVE_H1440_INTERLEAVE_SECT 20 ! 183: ! 184: /* Floppy drive configuration */ ! 185: #define FIFO_DEPTH 10 ! 186: #define USE_IMPLIED_SEEK 0 ! 187: #define USE_FIFO 1 ! 188: #define FIFO_THRESHOLD 10 ! 189: #define TRACK_PRECOMPENSATION 0 ! 190: ! 191: #define SLOW_FLOPPY 0 ! 192: ! 193: #define FD_RESET_DELAY 20 /* microseconds */ ! 194: ! 195: /* ! 196: * FDC state ! 197: */ ! 198: static struct drive_state { ! 199: unsigned track; ! 200: } drive_state[1]; ! 201: ! 202: static struct floppy_fdc_state { ! 203: int in_sync; ! 204: int spec1; /* spec1 value last used */ ! 205: int spec2; /* spec2 value last used */ ! 206: int dtr; ! 207: unsigned char dor; ! 208: unsigned char version; /* FDC version code */ ! 209: void (*fdc_outb)(unsigned char data, unsigned long port); ! 210: unsigned char (*fdc_inb)(unsigned long port); ! 211: unsigned long io_base; ! 212: unsigned long mmio_base; ! 213: } fdc_state; ! 214: ! 215: /* Synchronization of FDC access. */ ! 216: #define FD_COMMAND_NONE -1 ! 217: #define FD_COMMAND_ERROR 2 ! 218: #define FD_COMMAND_OKAY 3 ! 219: ! 220: /* ! 221: * globals used by 'result()' ! 222: */ ! 223: #define MAX_REPLIES 16 ! 224: ! 225: static void show_floppy(void); ! 226: static void floppy_reset(void); ! 227: ! 228: /* ! 229: * IO port operations ! 230: */ ! 231: static unsigned char ! 232: ob_fdc_inb(unsigned long port) ! 233: { ! 234: return inb(fdc_state.io_base + port); ! 235: } ! 236: ! 237: static void ! 238: ob_fdc_outb(unsigned char data, unsigned long port) ! 239: { ! 240: outb(data, fdc_state.io_base + port); ! 241: } ! 242: ! 243: /* ! 244: * MMIO operations ! 245: */ ! 246: static unsigned char ! 247: ob_fdc_mmio_readb(unsigned long port) ! 248: { ! 249: return *(unsigned char *)(fdc_state.mmio_base + port); ! 250: } ! 251: ! 252: static void ! 253: ob_fdc_mmio_writeb(unsigned char data, unsigned long port) ! 254: { ! 255: *(unsigned char *)(fdc_state.mmio_base + port) = data; ! 256: } ! 257: ! 258: static int set_dor(char mask, char data) ! 259: { ! 260: unsigned char newdor,olddor; ! 261: ! 262: olddor = fdc_state.dor; ! 263: newdor = (olddor & mask) | data; ! 264: if (newdor != olddor){ ! 265: fdc_state.dor = newdor; ! 266: fdc_state.fdc_outb(newdor, FD_DOR); ! 267: } ! 268: return olddor; ! 269: } ! 270: ! 271: /* waits until the fdc becomes ready */ ! 272: static int wait_til_ready(void) ! 273: { ! 274: int counter, status; ! 275: for (counter = 0; counter < 10000; counter++) { ! 276: status = fdc_state.fdc_inb(FD_STATUS); ! 277: if (status & STATUS_READY) { ! 278: return status; ! 279: } ! 280: } ! 281: printk_debug("Getstatus times out (%x)\n", status); ! 282: show_floppy(); ! 283: return -3; ! 284: } ! 285: ! 286: ! 287: /* sends a command byte to the fdc */ ! 288: static int output_byte(unsigned char byte) ! 289: { ! 290: int status; ! 291: ! 292: if ((status = wait_til_ready()) < 0) ! 293: return status; ! 294: if ((status & (STATUS_READY|STATUS_DIR|STATUS_NON_DMA)) == STATUS_READY){ ! 295: fdc_state.fdc_outb(byte,FD_DATA); ! 296: return 0; ! 297: } ! 298: printk_debug("Unable to send byte %x to FDC_STATE. Status=%x\n", ! 299: byte, status); ! 300: ! 301: show_floppy(); ! 302: return -2; ! 303: } ! 304: ! 305: /* gets the response from the fdc */ ! 306: static int result(unsigned char *reply_buffer, int max_replies) ! 307: { ! 308: int i, status=0; ! 309: ! 310: for(i=0; i < max_replies; i++) { ! 311: if ((status = wait_til_ready()) < 0) ! 312: break; ! 313: status &= STATUS_DIR|STATUS_READY|STATUS_BUSY|STATUS_NON_DMA; ! 314: if ((status & ~STATUS_BUSY) == STATUS_READY){ ! 315: return i; ! 316: } ! 317: if (status == (STATUS_DIR|STATUS_READY|STATUS_BUSY)) ! 318: reply_buffer[i] = fdc_state.fdc_inb(FD_DATA); ! 319: else ! 320: break; ! 321: } ! 322: if (i == max_replies) ! 323: return i; ! 324: printk_debug("get result error. Last status=%x Read bytes=%d\n", ! 325: status, i); ! 326: show_floppy(); ! 327: return -1; ! 328: } ! 329: #define MORE_OUTPUT -2 ! 330: /* does the fdc need more output? */ ! 331: static int need_more_output(void) ! 332: { ! 333: unsigned char reply_buffer[MAX_REPLIES]; ! 334: int status; ! 335: if ((status = wait_til_ready()) < 0) ! 336: return -1; ! 337: if ((status & (STATUS_READY|STATUS_DIR|STATUS_NON_DMA)) == STATUS_READY) ! 338: return MORE_OUTPUT; ! 339: return result(reply_buffer, MAX_REPLIES); ! 340: } ! 341: ! 342: static int output_command(unsigned char *cmd, int count) ! 343: { ! 344: int i, status; ! 345: for(i = 0; i < count; i++) { ! 346: if ((status = output_byte(cmd[i])) < 0) { ! 347: printk_err("full command not acceppted, status =%x\n", ! 348: status); ! 349: return -1; ! 350: } ! 351: } ! 352: return 0; ! 353: } ! 354: ! 355: static int output_new_command(unsigned char *cmd, int count) ! 356: { ! 357: int i, status; ! 358: if ((status = output_byte(cmd[0])) < 0) ! 359: return -1; ! 360: if (need_more_output() != MORE_OUTPUT) ! 361: return -1; ! 362: for(i = 1; i < count; i++) { ! 363: if ((status = output_byte(cmd[i])) < 0) { ! 364: printk_err("full new command not acceppted, status =%d\n", ! 365: status); ! 366: return -1; ! 367: } ! 368: } ! 369: return 0; ! 370: } ! 371: ! 372: ! 373: /* Collect pending interrupt status */ ! 374: static unsigned char collect_interrupt(void) ! 375: { ! 376: unsigned char pcn = 0xff; ! 377: unsigned char reply_buffer[MAX_REPLIES]; ! 378: int nr; ! 379: #ifdef CONFIG_DEBUG_FLOPPY ! 380: int i, status; ! 381: #endif ! 382: nr = result(reply_buffer, MAX_REPLIES); ! 383: if (nr != 0) { ! 384: printk_debug("SENSEI\n"); ! 385: } ! 386: else { ! 387: int max_sensei = 4; ! 388: do { ! 389: if (output_byte(FD_SENSEI) < 0) ! 390: break; ! 391: nr = result(reply_buffer, MAX_REPLIES); ! 392: if (nr == 2) { ! 393: pcn = reply_buffer[1]; ! 394: printk_debug("SENSEI %02x %02x\n", ! 395: reply_buffer[0], reply_buffer[1]); ! 396: } ! 397: max_sensei--; ! 398: }while(((reply_buffer[0] & 0x83) != FD_DRIVE) && (nr == 2) && max_sensei); ! 399: #ifdef CONFIG_DEBUG_FLOPPY ! 400: status = fdc_state.fdc_inb(FD_STATUS); ! 401: printk_debug("status = %x, reply_buffer=", status); ! 402: for(i = 0; i < nr; i++) { ! 403: printk_debug(" %x", ! 404: reply_buffer[i]); ! 405: } ! 406: printk_debug("\n"); ! 407: #else ! 408: fdc_state.fdc_inb(FD_STATUS); ! 409: #endif ! 410: } ! 411: ! 412: return pcn; ! 413: } ! 414: ! 415: ! 416: /* selects the fdc and drive, and enables the fdc's input/dma, and it's motor. */ ! 417: static void set_drive(int drive) ! 418: { ! 419: int fdc = (drive >> 2) & 1; ! 420: int status; ! 421: unsigned new_dor; ! 422: if (drive > 3) { ! 423: printk_err("bad drive value\n"); ! 424: return; ! 425: } ! 426: if (fdc != 0) { ! 427: printk_err("bad fdc value\n"); ! 428: return; ! 429: } ! 430: drive &= 3; ! 431: #if 0 ! 432: new_dor = 8; /* Enable the controller */ ! 433: #else ! 434: new_dor = 0; /* Don't enable DMA on the controller */ ! 435: #endif ! 436: new_dor |= (1 << (drive + 4)); /* Spinup the selected drive */ ! 437: new_dor |= drive; /* Select the drive for commands as well */ ! 438: set_dor(0xc, new_dor); ! 439: ! 440: mdelay(DRIVE_H1440_SPINUP); ! 441: ! 442: status = fdc_state.fdc_inb(FD_STATUS); ! 443: printk_debug("set_drive status = %02x, new_dor = %02x\n", ! 444: status, new_dor); ! 445: if (status != STATUS_READY) { ! 446: printk_err("set_drive bad status\n"); ! 447: } ! 448: } ! 449: ! 450: ! 451: /* Disable the motor for a given floppy drive */ ! 452: static void floppy_motor_off(int drive) ! 453: { ! 454: unsigned mask; ! 455: printk_debug("floppy_motor_off\n"); ! 456: /* fix the number of drives */ ! 457: drive &= 3; ! 458: /* Clear the bit for the drive we care about */ ! 459: mask = 0xff; ! 460: mask &= ~(1 << (drive +4)); ! 461: /* Now clear the bit in the Digital Output Register */ ! 462: set_dor(mask, 0); ! 463: } ! 464: ! 465: /* Set the FDC's data transfer rate on behalf of the specified drive. ! 466: * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue ! 467: * of the specify command (i.e. using the fdc_specify function). ! 468: */ ! 469: static void fdc_dtr(unsigned rate) ! 470: { ! 471: rate &= 3; ! 472: /* If data rate not already set to desired value, set it. */ ! 473: if (fdc_state.in_sync && (rate == fdc_state.dtr)) ! 474: return; ! 475: ! 476: /* Set dtr */ ! 477: fdc_state.fdc_outb(rate, FD_DCR); ! 478: ! 479: /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB) ! 480: * need a stabilization period of several milliseconds to be ! 481: * enforced after data rate changes before R/W operations. ! 482: * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies) ! 483: */ ! 484: fdc_state.dtr = rate & 3; ! 485: mdelay(5); ! 486: } /* fdc_dtr */ ! 487: ! 488: static int fdc_configure(int use_implied_seek, int use_fifo, ! 489: unsigned fifo_threshold, unsigned precompensation) ! 490: { ! 491: unsigned config_bits; ! 492: unsigned char cmd[4]; ! 493: /* 0 EIS EFIFO POLL FIFOOTHR[4] */ ! 494: ! 495: /* santize parameters */ ! 496: config_bits = fifo_threshold & 0xf; ! 497: config_bits |= (1 << 4); /* Always disable background floppy poll */ ! 498: config_bits |= (!use_fifo) << 5; ! 499: config_bits |= (!!use_implied_seek) << 6; ! 500: ! 501: precompensation &= 0xff; /* pre-compensation from track 0 upwards */ ! 502: ! 503: cmd[0] = FD_CONFIGURE; ! 504: cmd[1] = 0; ! 505: cmd[2] = config_bits; ! 506: cmd[3] = precompensation; ! 507: ! 508: /* Turn on FIFO */ ! 509: if (output_new_command(cmd, 4) < 0) ! 510: return 0; ! 511: return 1; ! 512: } ! 513: ! 514: #define NOMINAL_DTR 500 ! 515: /* Issue a "SPECIFY" command to set the step rate time, head unload time, ! 516: * head load time, and DMA disable flag to values needed by floppy. ! 517: * ! 518: * The value "dtr" is the data transfer rate in Kbps. It is needed ! 519: * to account for the data rate-based scaling done by the 82072 and 82077 ! 520: * FDC types. This parameter is ignored for other types of FDCs (i.e. ! 521: * 8272a). ! 522: * ! 523: * Note that changing the data transfer rate has a (probably deleterious) ! 524: * effect on the parameters subject to scaling for 82072/82077 FDCs, so ! 525: * fdc_specify is called again after each data transfer rate ! 526: * change. ! 527: * ! 528: * srt: 1000 to 16000 in microseconds ! 529: * hut: 16 to 240 milliseconds ! 530: * hlt: 2 to 254 milliseconds ! 531: * ! 532: * These values are rounded up to the next highest available delay time. ! 533: */ ! 534: static void fdc_specify( ! 535: unsigned head_load_time, unsigned head_unload_time, unsigned step_rate) ! 536: { ! 537: unsigned char cmd[3]; ! 538: unsigned long srt, hlt, hut; ! 539: unsigned long dtr = NOMINAL_DTR; ! 540: unsigned long scale_dtr = NOMINAL_DTR; ! 541: int hlt_max_code = 0x7f; ! 542: int hut_max_code = 0xf; ! 543: ! 544: printk_debug("fdc_specify\n"); ! 545: ! 546: switch (DISK_H1440_RATE & 0x03) { ! 547: case 3: ! 548: dtr = 1000; ! 549: break; ! 550: case 1: ! 551: dtr = 300; ! 552: if (fdc_state.version >= FDC_82078) { ! 553: /* chose the default rate table, not the one ! 554: * where 1 = 2 Mbps */ ! 555: cmd[0] = FD_DRIVESPEC; ! 556: cmd[1] = FD_DRIVE & 3; ! 557: cmd[2] = 0xc0; ! 558: output_new_command(cmd,3); ! 559: /* FIXME how do I handle errors here? */ ! 560: } ! 561: break; ! 562: case 2: ! 563: dtr = 250; ! 564: break; ! 565: } ! 566: ! 567: ! 568: if (fdc_state.version >= FDC_82072) { ! 569: scale_dtr = dtr; ! 570: hlt_max_code = 0x00; /* 0==256msec*dtr0/dtr (not linear!) */ ! 571: hut_max_code = 0x0; /* 0==256msec*dtr0/dtr (not linear!) */ ! 572: } ! 573: ! 574: /* Convert step rate from microseconds to milliseconds and 4 bits */ ! 575: srt = 16 - (step_rate*scale_dtr/1000 + NOMINAL_DTR - 1)/NOMINAL_DTR; ! 576: if (SLOW_FLOPPY) { ! 577: srt = srt / 4; ! 578: } ! 579: if (srt > 0xf) { ! 580: srt = 0xf; ! 581: } ! 582: ! 583: hlt = (head_load_time*scale_dtr/2 + NOMINAL_DTR - 1)/NOMINAL_DTR; ! 584: if (hlt < 0x01) ! 585: hlt = 0x01; ! 586: else if (hlt > 0x7f) ! 587: hlt = hlt_max_code; ! 588: ! 589: hut = (head_unload_time*scale_dtr/16 + NOMINAL_DTR - 1)/NOMINAL_DTR; ! 590: if (hut < 0x1) ! 591: hut = 0x1; ! 592: else if (hut > 0xf) ! 593: hut = hut_max_code; ! 594: ! 595: cmd[0] = FD_SPECIFY; ! 596: cmd[1] = (srt << 4) | hut; ! 597: cmd[2] = (hlt << 1) | 1; /* Always disable DMA */ ! 598: ! 599: /* If these parameters did not change, just return with success */ ! 600: if (!fdc_state.in_sync || fdc_state.spec1 != cmd[1] || fdc_state.spec2 != cmd[2]) { ! 601: /* Go ahead and set spec1 and spec2 */ ! 602: output_command(cmd, 3); ! 603: /* FIXME how do I handle errors here... */ ! 604: printk_info("FD_SPECIFY(%02x, %02x)\n", cmd[1], cmd[2]); ! 605: } ! 606: } /* fdc_specify */ ! 607: ! 608: ! 609: /* ! 610: * reset is done by pulling bit 2 of DOR low for a while (old FDCs), ! 611: * or by setting the self clearing bit 7 of STATUS (newer FDCs) ! 612: */ ! 613: static void reset_fdc(void) ! 614: { ! 615: unsigned char reply[MAX_REPLIES]; ! 616: ! 617: fdc_state.in_sync = 0; ! 618: ! 619: /* Pseudo-DMA may intercept 'reset finished' interrupt. */ ! 620: /* Irrelevant for systems with true DMA (i386). */ ! 621: ! 622: if (fdc_state.version >= FDC_82072A) ! 623: fdc_state.fdc_outb(0x80 | (fdc_state.dtr &3), FD_DSR); ! 624: else { ! 625: fdc_state.fdc_outb(fdc_state.dor & ~DOR_NO_RESET, FD_DOR); ! 626: udelay(FD_RESET_DELAY); ! 627: fdc_state.fdc_outb(fdc_state.dor, FD_DOR); ! 628: } ! 629: result(reply, MAX_REPLIES); ! 630: } ! 631: ! 632: ! 633: ! 634: static void show_floppy(void) ! 635: { ! 636: ! 637: printk_debug("\n"); ! 638: printk_debug("floppy driver state\n"); ! 639: printk_debug("-------------------\n"); ! 640: ! 641: printk_debug("fdc_bytes: %02x %02x xx %02x %02x %02x xx %02x\n", ! 642: fdc_state.fdc_inb(FD_STATUS_A), ! 643: fdc_state.fdc_inb(FD_STATUS_B), ! 644: fdc_state.fdc_inb(FD_TDR), ! 645: fdc_state.fdc_inb(FD_STATUS), ! 646: fdc_state.fdc_inb(FD_DATA), ! 647: fdc_state.fdc_inb(FD_DIR)); ! 648: ! 649: printk_debug("status=%x\n", fdc_state.fdc_inb(FD_STATUS)); ! 650: printk_debug("\n"); ! 651: } ! 652: ! 653: static void floppy_recalibrate(void) ! 654: { ! 655: unsigned char cmd[2]; ! 656: unsigned char reply[MAX_REPLIES]; ! 657: int nr, success; ! 658: success = 0; ! 659: do { ! 660: printk_debug("floppy_recalibrate\n"); ! 661: /* Send the recalibrate command to the controller. ! 662: * We don't have interrupts or anything we can poll ! 663: * so we have to guess when it is done. ! 664: */ ! 665: cmd[0] = FD_RECALIBRATE; ! 666: cmd[1] = 0; ! 667: if (output_command(cmd, 2) < 0) ! 668: continue; ! 669: ! 670: /* Sleep for the maximum time the recalibrate command ! 671: * can run. ! 672: */ ! 673: mdelay(80*DRIVE_H1440_SRT/1000); ! 674: ! 675: /* Now call FD_SENSEI to end the command ! 676: * and collect up the reply. ! 677: */ ! 678: if (output_byte(FD_SENSEI) < 0) ! 679: continue; ! 680: nr = result(reply, MAX_REPLIES); ! 681: ! 682: /* Now see if we have succeeded in our seek */ ! 683: success = ! 684: /* We have the right size result */ ! 685: (nr == 2) && ! 686: /* The command didn't terminate in error */ ! 687: ((reply[0] & ST0_INTR) == ST0_INTR_OK) && ! 688: /* We finished a seek */ ! 689: (reply[0] & ST0_SE) && ! 690: /* We are at cylinder 0 */ ! 691: (reply[1] == 0); ! 692: } while(!success); ! 693: /* Remember we are at track 0 */ ! 694: drive_state[FD_DRIVE].track = 0; ! 695: } ! 696: ! 697: ! 698: static int floppy_seek(unsigned track) ! 699: { ! 700: unsigned char cmd[3]; ! 701: unsigned char reply[MAX_REPLIES]; ! 702: int nr, success; ! 703: unsigned distance, old_track; ! 704: ! 705: /* Look up the old track and see if we need to ! 706: * do anything. ! 707: */ ! 708: old_track = drive_state[FD_DRIVE].track; ! 709: if (old_track == track) { ! 710: return 1; ! 711: } ! 712: ! 713: /* Compute the distance we are about to move, ! 714: * We need to know this so we know how long to sleep... ! 715: */ ! 716: distance = (old_track > track)?(old_track - track):(track - old_track); ! 717: distance += 1; ! 718: ! 719: ! 720: /* Send the seek command to the controller. ! 721: * We don't have interrupts or anything we can poll ! 722: * so we have to guess when it is done. ! 723: */ ! 724: cmd[0] = FD_SEEK; ! 725: cmd[1] = FD_DRIVE; ! 726: cmd[2] = track; ! 727: if (output_command(cmd, 3) < 0) ! 728: return 0; ! 729: ! 730: /* Sleep for the time it takes to step throuhg distance tracks. ! 731: */ ! 732: mdelay(distance*DRIVE_H1440_SRT/1000); ! 733: ! 734: /* Now call FD_SENSEI to end the command ! 735: * and collect up the reply. ! 736: */ ! 737: cmd[0] = FD_SENSEI; ! 738: if (output_command(cmd, 1) < 0) ! 739: return 0; ! 740: nr = result(reply, MAX_REPLIES); ! 741: ! 742: /* Now see if we have succeeded in our seek */ ! 743: success = ! 744: /* We have the right size result */ ! 745: (nr == 2) && ! 746: /* The command didn't terminate in error */ ! 747: ((reply[0] & ST0_INTR) == ST0_INTR_OK) && ! 748: /* We finished a seek */ ! 749: (reply[0] & ST0_SE) && ! 750: /* We are at cylinder 0 */ ! 751: (reply[1] == track); ! 752: if (success) ! 753: drive_state[FD_DRIVE].track = track; ! 754: else { ! 755: printk_debug("seek failed\n"); ! 756: printk_debug("nr = %d\n", nr); ! 757: printk_debug("ST0 = %02x\n", reply[0]); ! 758: printk_debug("PCN = %02x\n", reply[1]); ! 759: printk_debug("status = %d\n", fdc_state.fdc_inb(FD_STATUS)); ! 760: } ! 761: return success; ! 762: } ! 763: ! 764: static int read_ok(unsigned head) ! 765: { ! 766: unsigned char results[7]; ! 767: int result_ok; ! 768: int nr; ! 769: ! 770: /* read back the read results */ ! 771: nr = result(results, 7); ! 772: ! 773: /* Now see if they say we are o.k. */ ! 774: result_ok = 0; ! 775: /* Are my result bytes o.k.? */ ! 776: if (nr == 7) { ! 777: /* Are we o.k. */ ! 778: if ((results[0] & ST0_INTR) == ST0_INTR_OK) { ! 779: result_ok = 1; ! 780: } ! 781: /* Or did we get just an overflow error */ ! 782: else if (((results[0] & ST0_INTR) == ST0_INTR_ERROR) && ! 783: (results[1]== ST1_OR) && ! 784: (results[2] == 0)) { ! 785: result_ok = 1; ! 786: } ! 787: /* Verify the reply had the correct head */ ! 788: if (((results[0] & ST0_HA) >> 2) != head) { ! 789: result_ok = 0; ! 790: } ! 791: /* Verify the reply had the correct drive */ ! 792: if (((results[0] & ST0_DS) != FD_DRIVE)) { ! 793: result_ok = 0; ! 794: } ! 795: } ! 796: if (!result_ok) { ! 797: printk_debug("result_bytes = %d\n", nr); ! 798: printk_debug("ST0 = %02x\n", results[0]); ! 799: printk_debug("ST1 = %02x\n", results[1]); ! 800: printk_debug("ST2 = %02x\n", results[2]); ! 801: printk_debug(" C = %02x\n", results[3]); ! 802: printk_debug(" H = %02x\n", results[4]); ! 803: printk_debug(" R = %02x\n", results[5]); ! 804: printk_debug(" N = %02x\n", results[6]); ! 805: } ! 806: return result_ok; ! 807: } ! 808: ! 809: static int floppy_read_sectors( ! 810: char *dest, unsigned byte_offset, unsigned length, ! 811: unsigned sector, unsigned head, unsigned track) ! 812: { ! 813: /* MT == Multitrack */ ! 814: /* MFM == MFM or FM Mode */ ! 815: /* SK == Skip deleted data addres Mark */ ! 816: /* HDS == Head number select */ ! 817: /* DS0 == Disk Drive Select 0 */ ! 818: /* DS1 == Disk Drive Select 1 */ ! 819: /* C == Cylinder number 0 - 255 */ ! 820: /* H == Head number */ ! 821: /* R == Record */ ! 822: /* N == The number of data bytes written in a sector */ ! 823: /* EOT == End of Track */ ! 824: /* GPL == Gap Length */ ! 825: /* DTL == Data Length */ ! 826: /* MT MFM SK 0 1 1 0 0 */ ! 827: /* 0 0 0 0 0 HDS DS1 DS0 */ ! 828: /* C, H, R, N, EOT, GPL, DTL */ ! 829: ! 830: int i, status, result_ok; ! 831: int max_bytes, bytes_read; ! 832: int ret; ! 833: unsigned char cmd[9]; ! 834: unsigned end_offset; ! 835: ! 836: end_offset = byte_offset + length; ! 837: max_bytes = 512*(DISK_H1440_SECT - sector + 1); ! 838: ! 839: if (byte_offset >= max_bytes) { ! 840: return 0; ! 841: } ! 842: cmd[0] = FD_READ | (((DISK_H1440_HEAD ==2)?1:0) << 6); ! 843: cmd[1] = (head << 2) | FD_DRIVE; ! 844: cmd[2] = track; ! 845: cmd[3] = head; ! 846: cmd[4] = sector; ! 847: cmd[5] = 2; /* 2^N *128 == Sector size. Hard coded to 512 bytes */ ! 848: cmd[6] = DISK_H1440_SECT; ! 849: cmd[7] = DISK_H1440_GAP; ! 850: cmd[8] = 0xff; ! 851: ! 852: /* Output the command bytes */ ! 853: if (output_command(cmd, 9) < 0) ! 854: return -1; ! 855: ! 856: /* The execution stage begins when STATUS_READY&STATUS_NON_DMA is set */ ! 857: do { ! 858: status = fdc_state.fdc_inb(FD_STATUS); ! 859: status &= STATUS_READY | STATUS_NON_DMA; ! 860: } while(status != (STATUS_READY|STATUS_NON_DMA)); ! 861: ! 862: for(i = 0; i < max_bytes; i++) { ! 863: unsigned char byte; ! 864: if ((status = wait_til_ready()) < 0) { ! 865: break; ! 866: } ! 867: status &= STATUS_READY|STATUS_DIR|STATUS_NON_DMA; ! 868: if (status != (STATUS_READY|STATUS_DIR|STATUS_NON_DMA)) { ! 869: break; ! 870: } ! 871: byte = fdc_state.fdc_inb(FD_DATA); ! 872: if ((i >= byte_offset) && (i < end_offset)) { ! 873: dest[i - byte_offset] = byte; ! 874: } ! 875: } ! 876: bytes_read = i; ! 877: ! 878: /* The result stage begins when STATUS_NON_DMA is cleared */ ! 879: while((status = fdc_state.fdc_inb(FD_STATUS)) & STATUS_NON_DMA) { ! 880: /* We get extra bytes in the fifo past ! 881: * the end of the sector and drop them on the floor. ! 882: * Otherwise the fifo is polluted. ! 883: */ ! 884: fdc_state.fdc_inb(FD_DATA); ! 885: } ! 886: /* Did I get an error? */ ! 887: result_ok = read_ok(head); ! 888: /* Did I read enough bytes? */ ! 889: ret = -1; ! 890: if (result_ok && (bytes_read == max_bytes)) { ! 891: ret = bytes_read - byte_offset; ! 892: if (ret > length) { ! 893: ret = length; ! 894: } ! 895: } ! 896: ! 897: if (ret < 0) { ! 898: printk_debug("ret = %d\n", ret); ! 899: printk_debug("bytes_read = %d\n", bytes_read); ! 900: printk_debug("status = %x\n", status); ! 901: } ! 902: return ret; ! 903: } ! 904: ! 905: ! 906: static int __floppy_read(char *dest, unsigned long offset, unsigned long length) ! 907: { ! 908: unsigned head, track, sector, byte_offset, sector_offset; ! 909: int ret; ! 910: ! 911: /* break the offset up into sectors and bytes */ ! 912: byte_offset = offset % 512; ! 913: sector_offset = offset / 512; ! 914: ! 915: /* Find the disk block we are starting with... */ ! 916: sector = (sector_offset % DISK_H1440_SECT) + 1; ! 917: head = (sector_offset / DISK_H1440_SECT) % DISK_H1440_HEAD; ! 918: track = (sector_offset / (DISK_H1440_SECT *DISK_H1440_HEAD))% DISK_H1440_TRACK; ! 919: ! 920: /* First seek to our start track */ ! 921: if (!floppy_seek(track)) { ! 922: return -1; ! 923: } ! 924: /* Then read the data */ ! 925: ret = floppy_read_sectors(dest, byte_offset, length, sector, head, track); ! 926: if (ret >= 0) { ! 927: return ret; ! 928: } ! 929: /* If we failed reset the fdc... */ ! 930: floppy_reset(); ! 931: return -1; ! 932: } ! 933: ! 934: static int floppy_read(char *dest, unsigned long offset, unsigned long length) ! 935: { ! 936: int fr_result, bytes_read;; ! 937: ! 938: printk_debug("floppy_read\n"); ! 939: bytes_read = 0; ! 940: do { ! 941: int max_errors = 3; ! 942: do { ! 943: fr_result = __floppy_read(dest + bytes_read, offset, ! 944: length - bytes_read); ! 945: if (max_errors-- == 0) { ! 946: return (bytes_read)?bytes_read: -1; ! 947: } ! 948: } while (fr_result <= 0); ! 949: offset += fr_result; ! 950: bytes_read += fr_result; ! 951: } while(bytes_read < length); ! 952: return bytes_read; ! 953: } ! 954: ! 955: /* Determine the floppy disk controller type */ ! 956: /* This routine was written by David C. Niemi */ ! 957: static char get_fdc_version(void) ! 958: { ! 959: int bytes, ret; ! 960: unsigned char reply_buffer[MAX_REPLIES]; ! 961: ! 962: ret = output_byte(FD_DUMPREGS); /* 82072 and better know DUMPREGS */ ! 963: if (ret < 0) ! 964: return FDC_NONE; ! 965: if ((bytes = result(reply_buffer, MAX_REPLIES)) <= 0x00) ! 966: return FDC_NONE; /* No FDC present ??? */ ! 967: if ((bytes==1) && (reply_buffer[0] == 0x80)){ ! 968: printk_info("FDC is an 8272A\n"); ! 969: return FDC_8272A; /* 8272a/765 don't know DUMPREGS */ ! 970: } ! 971: if (bytes != 10) { ! 972: printk_debug("init: DUMPREGS: unexpected return of %d bytes.\n", ! 973: bytes); ! 974: return FDC_UNKNOWN; ! 975: } ! 976: if (!fdc_configure(USE_IMPLIED_SEEK, USE_FIFO, FIFO_THRESHOLD, ! 977: TRACK_PRECOMPENSATION)) { ! 978: printk_info("FDC is an 82072\n"); ! 979: return FDC_82072; /* 82072 doesn't know CONFIGURE */ ! 980: } ! 981: ! 982: output_byte(FD_PERPENDICULAR); ! 983: if (need_more_output() == MORE_OUTPUT) { ! 984: output_byte(0); ! 985: } else { ! 986: printk_info("FDC is an 82072A\n"); ! 987: return FDC_82072A; /* 82072A as found on Sparcs. */ ! 988: } ! 989: ! 990: output_byte(FD_UNLOCK); ! 991: bytes = result(reply_buffer, MAX_REPLIES); ! 992: if ((bytes == 1) && (reply_buffer[0] == 0x80)){ ! 993: printk_info("FDC is a pre-1991 82077\n"); ! 994: return FDC_82077_ORIG; /* Pre-1991 82077, doesn't know ! 995: * LOCK/UNLOCK */ ! 996: } ! 997: if ((bytes != 1) || (reply_buffer[0] != 0x00)) { ! 998: printk_debug("FDC init: UNLOCK: unexpected return of %d bytes.\n", ! 999: bytes); ! 1000: return FDC_UNKNOWN; ! 1001: } ! 1002: output_byte(FD_PARTID); ! 1003: bytes = result(reply_buffer, MAX_REPLIES); ! 1004: if (bytes != 1) { ! 1005: printk_debug("FDC init: PARTID: unexpected return of %d bytes.\n", ! 1006: bytes); ! 1007: return FDC_UNKNOWN; ! 1008: } ! 1009: if (reply_buffer[0] == 0x80) { ! 1010: printk_info("FDC is a post-1991 82077\n"); ! 1011: return FDC_82077; /* Revised 82077AA passes all the tests */ ! 1012: } ! 1013: switch (reply_buffer[0] >> 5) { ! 1014: case 0x0: ! 1015: /* Either a 82078-1 or a 82078SL running at 5Volt */ ! 1016: printk_info("FDC is an 82078.\n"); ! 1017: return FDC_82078; ! 1018: case 0x1: ! 1019: printk_info("FDC is a 44pin 82078\n"); ! 1020: return FDC_82078; ! 1021: case 0x2: ! 1022: printk_info("FDC is a S82078B\n"); ! 1023: return FDC_S82078B; ! 1024: case 0x3: ! 1025: printk_info("FDC is a National Semiconductor PC87306\n"); ! 1026: return FDC_87306; ! 1027: default: ! 1028: printk_info("FDC init: 82078 variant with unknown PARTID=%d.\n", ! 1029: reply_buffer[0] >> 5); ! 1030: return FDC_82078_UNKN; ! 1031: } ! 1032: } /* get_fdc_version */ ! 1033: ! 1034: ! 1035: static int floppy_init(unsigned long io_base, unsigned long mmio_base) ! 1036: { ! 1037: printk_debug("floppy_init\n"); ! 1038: fdc_state.in_sync = 0; ! 1039: fdc_state.spec1 = -1; ! 1040: fdc_state.spec2 = -1; ! 1041: fdc_state.dtr = -1; ! 1042: fdc_state.dor = DOR_NO_RESET; ! 1043: fdc_state.version = FDC_UNKNOWN; ! 1044: if (mmio_base) { ! 1045: fdc_state.fdc_inb = ob_fdc_mmio_readb; ! 1046: fdc_state.fdc_outb = ob_fdc_mmio_writeb; ! 1047: } else { ! 1048: fdc_state.fdc_inb = ob_fdc_inb; ! 1049: fdc_state.fdc_outb = ob_fdc_outb; ! 1050: } ! 1051: fdc_state.io_base = io_base; ! 1052: fdc_state.mmio_base = mmio_base; ! 1053: reset_fdc(); ! 1054: /* Try to determine the floppy controller type */ ! 1055: fdc_state.version = get_fdc_version(); ! 1056: if (fdc_state.version == FDC_NONE) { ! 1057: return -1; ! 1058: } ! 1059: floppy_reset(); ! 1060: printk_info("fdc_state.version = %04x\n", fdc_state.version); ! 1061: return 0; ! 1062: } ! 1063: ! 1064: static void floppy_reset(void) ! 1065: { ! 1066: printk_debug("floppy_reset\n"); ! 1067: floppy_motor_off(FD_DRIVE); ! 1068: reset_fdc(); ! 1069: fdc_dtr(DISK_H1440_RATE); ! 1070: /* program data rate via ccr */ ! 1071: collect_interrupt(); ! 1072: fdc_configure(USE_IMPLIED_SEEK, USE_FIFO, FIFO_THRESHOLD, ! 1073: TRACK_PRECOMPENSATION); ! 1074: fdc_specify(DRIVE_H1440_HLT, DRIVE_H1440_HUT, DRIVE_H1440_SRT); ! 1075: set_drive(FD_DRIVE); ! 1076: floppy_recalibrate(); ! 1077: fdc_state.in_sync = 1; ! 1078: } ! 1079: ! 1080: static void ! 1081: ob_floppy_initialize(const char *path) ! 1082: { ! 1083: int props[3]; ! 1084: phandle_t ph = find_dev(path); ! 1085: ! 1086: set_property(ph, "device_type", "block", sizeof("block")); ! 1087: ! 1088: // Set dummy reg properties ! 1089: props[0] = __cpu_to_be32(0); props[1] = __cpu_to_be32(0); props[2] = __cpu_to_be32(0); ! 1090: set_property(ph, "reg", (char *)&props, 3*sizeof(int)); ! 1091: ! 1092: fword("is-deblocker"); ! 1093: } ! 1094: ! 1095: ! 1096: static void ! 1097: ob_floppy_open(int *idx) ! 1098: { ! 1099: int ret = 1; ! 1100: phandle_t ph; ! 1101: ! 1102: fword("my-unit"); ! 1103: idx[0]=POP(); ! 1104: ! 1105: fword("my-parent"); ! 1106: fword("ihandle>phandle"); ! 1107: ph=(phandle_t)POP(); ! 1108: ! 1109: selfword("open-deblocker"); ! 1110: ! 1111: /* interpose disk-label */ ! 1112: ph = find_dev("/packages/disk-label"); ! 1113: fword("my-args"); ! 1114: PUSH_ph( ph ); ! 1115: fword("interpose"); ! 1116: ! 1117: RET ( -ret ); ! 1118: } ! 1119: ! 1120: static void ! 1121: ob_floppy_close(int *idx) ! 1122: { ! 1123: selfword("close-deblocker"); ! 1124: } ! 1125: ! 1126: static void ! 1127: ob_floppy_read_blocks(int *idx) ! 1128: { ! 1129: cell cnt = POP(); ! 1130: ucell blk = POP(); ! 1131: char *dest = (char*)POP(); ! 1132: floppy_read(dest, blk*512, cnt*512); ! 1133: PUSH(cnt); ! 1134: } ! 1135: ! 1136: ! 1137: static void ! 1138: ob_floppy_block_size(int *idx) ! 1139: { ! 1140: PUSH(512); ! 1141: } ! 1142: ! 1143: static void ! 1144: ob_floppy_max_transfer(int *idx) ! 1145: { ! 1146: // Fixme ! 1147: PUSH(18 * 512); ! 1148: } ! 1149: ! 1150: NODE_METHODS(ob_floppy) = { ! 1151: { "open", ob_floppy_open }, ! 1152: { "close", ob_floppy_close }, ! 1153: { "read-blocks", ob_floppy_read_blocks }, ! 1154: { "block-size", ob_floppy_block_size }, ! 1155: { "max-transfer", ob_floppy_max_transfer }, ! 1156: }; ! 1157: ! 1158: ! 1159: int ob_floppy_init(const char *path, const char *dev_name, ! 1160: unsigned long io_base, unsigned long mmio_base) ! 1161: { ! 1162: char nodebuff[128]; ! 1163: phandle_t aliases; ! 1164: ! 1165: snprintf(nodebuff, sizeof(nodebuff), "%s/%s", path, dev_name); ! 1166: if (!mmio_base) { ! 1167: REGISTER_NAMED_NODE(ob_floppy, nodebuff); ! 1168: ob_floppy_initialize(nodebuff); ! 1169: } else { ! 1170: // Already in tree and mapped ! 1171: REGISTER_NODE_METHODS(ob_floppy, nodebuff); ! 1172: } ! 1173: floppy_init(io_base, mmio_base); ! 1174: ! 1175: aliases = find_dev("/aliases"); ! 1176: set_property(aliases, "floppy", nodebuff, strlen(nodebuff) + 1); ! 1177: ! 1178: return 0; ! 1179: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.