1/* asm-sparc/floppy.h: Sparc specific parts of the Floppy driver. 2 * 3 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) 4 */ 5 6#ifndef __ASM_SPARC_FLOPPY_H 7#define __ASM_SPARC_FLOPPY_H 8 9#include <asm/page.h> 10#include <asm/pgtable.h> 11#include <asm/system.h> 12#include <asm/idprom.h> 13#include <asm/machines.h> 14#include <asm/oplib.h> 15#include <asm/auxio.h> 16#include <asm/irq.h> 17 18/* We don't need no stinkin' I/O port allocation crap. */ 19#undef release_region 20#undef request_region 21#define release_region(X, Y) do { } while(0) 22#define request_region(X, Y, Z) (1) 23 24/* References: 25 * 1) Netbsd Sun floppy driver. 26 * 2) NCR 82077 controller manual 27 * 3) Intel 82077 controller manual 28 */ 29struct sun_flpy_controller { 30 volatile unsigned char status_82072; /* Main Status reg. */ 31#define dcr_82072 status_82072 /* Digital Control reg. */ 32#define status1_82077 status_82072 /* Auxiliary Status reg. 1 */ 33 34 volatile unsigned char data_82072; /* Data fifo. */ 35#define status2_82077 data_82072 /* Auxiliary Status reg. 2 */ 36 37 volatile unsigned char dor_82077; /* Digital Output reg. */ 38 volatile unsigned char tapectl_82077; /* What the? Tape control reg? */ 39 40 volatile unsigned char status_82077; /* Main Status Register. */ 41#define drs_82077 status_82077 /* Digital Rate Select reg. */ 42 43 volatile unsigned char data_82077; /* Data fifo. */ 44 volatile unsigned char ___unused; 45 volatile unsigned char dir_82077; /* Digital Input reg. */ 46#define dcr_82077 dir_82077 /* Config Control reg. */ 47}; 48 49/* You'll only ever find one controller on a SparcStation anyways. */ 50static struct sun_flpy_controller *sun_fdc = NULL; 51volatile unsigned char *fdc_status; 52 53struct sun_floppy_ops { 54 unsigned char (*fd_inb)(int port); 55 void (*fd_outb)(unsigned char value, int port); 56}; 57 58static struct sun_floppy_ops sun_fdops; 59 60#define fd_inb(port) sun_fdops.fd_inb(port) 61#define fd_outb(value,port) sun_fdops.fd_outb(value,port) 62#define fd_enable_dma() sun_fd_enable_dma() 63#define fd_disable_dma() sun_fd_disable_dma() 64#define fd_request_dma() (0) /* nothing... */ 65#define fd_free_dma() /* nothing... */ 66#define fd_clear_dma_ff() /* nothing... */ 67#define fd_set_dma_mode(mode) sun_fd_set_dma_mode(mode) 68#define fd_set_dma_addr(addr) sun_fd_set_dma_addr(addr) 69#define fd_set_dma_count(count) sun_fd_set_dma_count(count) 70#define fd_enable_irq() /* nothing... */ 71#define fd_disable_irq() /* nothing... */ 72#define fd_cacheflush(addr, size) /* nothing... */ 73#define fd_request_irq() sun_fd_request_irq() 74#define fd_free_irq() /* nothing... */ 75 76#define FLOPPY_MOTOR_MASK 0x10 77 78#define get_dma_residue(x) (0) 79 80#define FLOPPY0_TYPE 4 81#define FLOPPY1_TYPE 0 82 83/* Super paranoid... */ 84#undef HAVE_DISABLE_HLT 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 FDC1 sun_floppy_init() 91 92#define N_FDC 1 93#define N_DRIVE 8 94 95/* No 64k boundary crossing problems on the Sparc. */ 96#define CROSS_64KB(a,s) (0) 97 98/* Routines unique to each controller type on a Sun. */ 99static unsigned char sun_82072_fd_inb(int port) 100{ 101 udelay(5); 102 switch(port & 7) { 103 default: 104 printk("floppy: Asked to read unknown port %d\n", port); 105 panic("floppy: Port bolixed."); 106 case 4: /* FD_STATUS */ 107 return sun_fdc->status_82072 & ~STATUS_DMA; 108 case 5: /* FD_DATA */ 109 return sun_fdc->data_82072; 110 case 7: /* FD_DIR */ 111 return (get_auxio() & AUXIO_FLPY_DCHG)? 0x80: 0; 112 }; 113 panic("sun_82072_fd_inb: How did I get here?"); 114} 115 116static void sun_82072_fd_outb(unsigned char value, int port) 117{ 118 udelay(5); 119 switch(port & 7) { 120 default: 121 printk("floppy: Asked to write to unknown port %d\n", port); 122 panic("floppy: Port bolixed."); 123 case 2: /* FD_DOR */ 124 /* Oh geese, 82072 on the Sun has no DOR register, 125 * the functionality is implemented via the AUXIO 126 * I/O register. So we must emulate the behavior. 127 * 128 * ASSUMPTIONS: There will only ever be one floppy 129 * drive attached to a Sun controller 130 * and it will be at drive zero. 131 */ 132 { 133 unsigned bits = 0; 134 if (value & 0x10) bits |= AUXIO_FLPY_DSEL; 135 if ((value & 0x80) == 0) bits |= AUXIO_FLPY_EJCT; 136 set_auxio(bits, (~bits) & (AUXIO_FLPY_DSEL|AUXIO_FLPY_EJCT)); 137 } 138 break; 139 case 5: /* FD_DATA */ 140 sun_fdc->data_82072 = value; 141 break; 142 case 7: /* FD_DCR */ 143 sun_fdc->dcr_82072 = value; 144 break; 145 case 4: /* FD_STATUS */ 146 sun_fdc->status_82072 = value; 147 break; 148 }; 149 return; 150} 151 152static unsigned char sun_82077_fd_inb(int port) 153{ 154 udelay(5); 155 switch(port & 7) { 156 default: 157 printk("floppy: Asked to read unknown port %d\n", port); 158 panic("floppy: Port bolixed."); 159 case 4: /* FD_STATUS */ 160 return sun_fdc->status_82077 & ~STATUS_DMA; 161 case 5: /* FD_DATA */ 162 return sun_fdc->data_82077; 163 case 7: /* FD_DIR */ 164 return sun_fdc->dir_82077; 165 }; 166 panic("sun_82072_fd_inb: How did I get here?"); 167} 168 169static void sun_82077_fd_outb(unsigned char value, int port) 170{ 171 udelay(5); 172 switch(port & 7) { 173 default: 174 printk("floppy: Asked to write to unknown port %d\n", port); 175 panic("floppy: Port bolixed."); 176 case 2: /* FD_DOR */ 177 /* Happily, the 82077 has a real DOR register. */ 178 sun_fdc->dor_82077 = value; 179 break; 180 case 5: /* FD_DATA */ 181 sun_fdc->data_82077 = value; 182 break; 183 case 7: /* FD_DCR */ 184 sun_fdc->dcr_82077 = value; 185 break; 186 case 4: /* FD_STATUS */ 187 sun_fdc->status_82077 = value; 188 break; 189 }; 190 return; 191} 192 193/* For pseudo-dma (Sun floppy drives have no real DMA available to 194 * them so we must eat the data fifo bytes directly ourselves) we have 195 * three state variables. doing_pdma tells our inline low-level 196 * assembly floppy interrupt entry point whether it should sit and eat 197 * bytes from the fifo or just transfer control up to the higher level 198 * floppy interrupt c-code. I tried very hard but I could not get the 199 * pseudo-dma to work in c-code without getting many overruns and 200 * underruns. If non-zero, doing_pdma encodes the direction of 201 * the transfer for debugging. 1=read 2=write 202 */ 203char *pdma_vaddr; 204unsigned long pdma_size; 205volatile int doing_pdma = 0; 206 207/* This is software state */ 208char *pdma_base = NULL; 209unsigned long pdma_areasize; 210 211/* Common routines to all controller types on the Sparc. */ 212static __inline__ void virtual_dma_init(void) 213{ 214 /* nothing... */ 215} 216 217static __inline__ void sun_fd_disable_dma(void) 218{ 219 doing_pdma = 0; 220 if (pdma_base) { 221 mmu_unlockarea(pdma_base, pdma_areasize); 222 pdma_base = NULL; 223 } 224} 225 226static __inline__ void sun_fd_set_dma_mode(int mode) 227{ 228 switch(mode) { 229 case DMA_MODE_READ: 230 doing_pdma = 1; 231 break; 232 case DMA_MODE_WRITE: 233 doing_pdma = 2; 234 break; 235 default: 236 printk("Unknown dma mode %d\n", mode); 237 panic("floppy: Giving up..."); 238 } 239} 240 241static __inline__ void sun_fd_set_dma_addr(char *buffer) 242{ 243 pdma_vaddr = buffer; 244} 245 246static __inline__ void sun_fd_set_dma_count(int length) 247{ 248 pdma_size = length; 249} 250 251static __inline__ void sun_fd_enable_dma(void) 252{ 253 pdma_vaddr = mmu_lockarea(pdma_vaddr, pdma_size); 254 pdma_base = pdma_vaddr; 255 pdma_areasize = pdma_size; 256} 257 258/* Our low-level entry point in arch/sparc/kernel/entry.S */ 259irqreturn_t floppy_hardint(int irq, void *unused); 260 261static int sun_fd_request_irq(void) 262{ 263 static int once = 0; 264 int error; 265 266 if(!once) { 267 once = 1; 268 error = request_fast_irq(FLOPPY_IRQ, floppy_hardint, 269 IRQF_DISABLED, "floppy"); 270 return ((error == 0) ? 0 : -1); 271 } else return 0; 272} 273 274static struct linux_prom_registers fd_regs[2]; 275 276static int sun_floppy_init(void) 277{ 278 char state[128]; 279 int tnode, fd_node, num_regs; 280 struct resource r; 281 282 use_virtual_dma = 1; 283 284 FLOPPY_IRQ = 11; 285 /* Forget it if we aren't on a machine that could possibly 286 * ever have a floppy drive. 287 */ 288 if((sparc_cpu_model != sun4c && sparc_cpu_model != sun4m) || 289 ((idprom->id_machtype == (SM_SUN4C | SM_4C_SLC)) || 290 (idprom->id_machtype == (SM_SUN4C | SM_4C_ELC)))) { 291 /* We certainly don't have a floppy controller. */ 292 goto no_sun_fdc; 293 } 294 /* Well, try to find one. */ 295 tnode = prom_getchild(prom_root_node); 296 fd_node = prom_searchsiblings(tnode, "obio"); 297 if(fd_node != 0) { 298 tnode = prom_getchild(fd_node); 299 fd_node = prom_searchsiblings(tnode, "SUNW,fdtwo"); 300 } else { 301 fd_node = prom_searchsiblings(tnode, "fd"); 302 } 303 if(fd_node == 0) { 304 goto no_sun_fdc; 305 } 306 307 /* The sun4m lets us know if the controller is actually usable. */ 308 if(sparc_cpu_model == sun4m && 309 prom_getproperty(fd_node, "status", state, sizeof(state)) != -1) { 310 if(!strcmp(state, "disabled")) { 311 goto no_sun_fdc; 312 } 313 } 314 num_regs = prom_getproperty(fd_node, "reg", (char *) fd_regs, sizeof(fd_regs)); 315 num_regs = (num_regs / sizeof(fd_regs[0])); 316 prom_apply_obio_ranges(fd_regs, num_regs); 317 memset(&r, 0, sizeof(r)); 318 r.flags = fd_regs[0].which_io; 319 r.start = fd_regs[0].phys_addr; 320 sun_fdc = (struct sun_flpy_controller *) 321 sbus_ioremap(&r, 0, fd_regs[0].reg_size, "floppy"); 322 323 /* Last minute sanity check... */ 324 if(sun_fdc->status_82072 == 0xff) { 325 sun_fdc = NULL; 326 goto no_sun_fdc; 327 } 328 329 if(sparc_cpu_model == sun4c) { 330 sun_fdops.fd_inb = sun_82072_fd_inb; 331 sun_fdops.fd_outb = sun_82072_fd_outb; 332 fdc_status = &sun_fdc->status_82072; 333 /* printk("AUXIO @0x%lx\n", auxio_register); */ /* P3 */ 334 } else { 335 sun_fdops.fd_inb = sun_82077_fd_inb; 336 sun_fdops.fd_outb = sun_82077_fd_outb; 337 fdc_status = &sun_fdc->status_82077; 338 /* printk("DOR @0x%p\n", &sun_fdc->dor_82077); */ /* P3 */ 339 } 340 341 /* Success... */ 342 allowed_drive_mask = 0x01; 343 return (int) sun_fdc; 344 345no_sun_fdc: 346 return -1; 347} 348 349static int sparc_eject(void) 350{ 351 set_dor(0x00, 0xff, 0x90); 352 udelay(500); 353 set_dor(0x00, 0x6f, 0x00); 354 udelay(500); 355 return 0; 356} 357 358#define fd_eject(drive) sparc_eject() 359 360#define EXTRA_FLOPPY_PARAMS 361 362#endif /* !(__ASM_SPARC_FLOPPY_H) */ 363