1 /* asm/floppy.h: Sparc specific parts of the Floppy driver. 2 * 3 * Copyright (C) 1995 David S. Miller (davem@davemloft.net) 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 */ 29 struct 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. */ 50 static struct sun_flpy_controller *sun_fdc = NULL; 51 extern volatile unsigned char *fdc_status; 52 53 struct sun_floppy_ops { 54 unsigned char (*fd_inb)(int port); 55 void (*fd_outb)(unsigned char value, int port); 56 }; 57 58 static 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 #if 0 /* P3: added by Alain, these cause a MMU corruption. 19960524 XXX */ 76 #define fd_dma_mem_alloc(size) ((unsigned long) vmalloc(size)) 77 #define fd_dma_mem_free(addr,size) (vfree((void *)(addr))) 78 #endif 79 80 /* XXX This isn't really correct. XXX */ 81 #define get_dma_residue(x) (0) 82 83 #define FLOPPY0_TYPE 4 84 #define FLOPPY1_TYPE 0 85 86 /* Super paranoid... */ 87 #undef HAVE_DISABLE_HLT 88 89 /* Here is where we catch the floppy driver trying to initialize, 90 * therefore this is where we call the PROM device tree probing 91 * routine etc. on the Sparc. 92 */ 93 #define FDC1 sun_floppy_init() 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 /* Routines unique to each controller type on a Sun. */ 102 static void sun_set_dor(unsigned char value, int fdc_82077) 103 { 104 if (sparc_cpu_model == sun4c) { 105 unsigned int bits = 0; 106 if (value & 0x10) 107 bits |= AUXIO_FLPY_DSEL; 108 if ((value & 0x80) == 0) 109 bits |= AUXIO_FLPY_EJCT; 110 set_auxio(bits, (~bits) & (AUXIO_FLPY_DSEL|AUXIO_FLPY_EJCT)); 111 } 112 if (fdc_82077) { 113 sun_fdc->dor_82077 = value; 114 } 115 } 116 117 static unsigned char sun_read_dir(void) 118 { 119 if (sparc_cpu_model == sun4c) 120 return (get_auxio() & AUXIO_FLPY_DCHG) ? 0x80 : 0; 121 else 122 return sun_fdc->dir_82077; 123 } 124 125 static unsigned char sun_82072_fd_inb(int port) 126 { 127 udelay(5); 128 switch(port & 7) { 129 default: 130 printk("floppy: Asked to read unknown port %d\n", port); 131 panic("floppy: Port bolixed."); 132 case 4: /* FD_STATUS */ 133 return sun_fdc->status_82072 & ~STATUS_DMA; 134 case 5: /* FD_DATA */ 135 return sun_fdc->data_82072; 136 case 7: /* FD_DIR */ 137 return sun_read_dir(); 138 }; 139 panic("sun_82072_fd_inb: How did I get here?"); 140 } 141 142 static void sun_82072_fd_outb(unsigned char value, int port) 143 { 144 udelay(5); 145 switch(port & 7) { 146 default: 147 printk("floppy: Asked to write to unknown port %d\n", port); 148 panic("floppy: Port bolixed."); 149 case 2: /* FD_DOR */ 150 sun_set_dor(value, 0); 151 break; 152 case 5: /* FD_DATA */ 153 sun_fdc->data_82072 = value; 154 break; 155 case 7: /* FD_DCR */ 156 sun_fdc->dcr_82072 = value; 157 break; 158 case 4: /* FD_STATUS */ 159 sun_fdc->status_82072 = value; 160 break; 161 }; 162 return; 163 } 164 165 static unsigned char sun_82077_fd_inb(int port) 166 { 167 udelay(5); 168 switch(port & 7) { 169 default: 170 printk("floppy: Asked to read unknown port %d\n", port); 171 panic("floppy: Port bolixed."); 172 case 0: /* FD_STATUS_0 */ 173 return sun_fdc->status1_82077; 174 case 1: /* FD_STATUS_1 */ 175 return sun_fdc->status2_82077; 176 case 2: /* FD_DOR */ 177 return sun_fdc->dor_82077; 178 case 3: /* FD_TDR */ 179 return sun_fdc->tapectl_82077; 180 case 4: /* FD_STATUS */ 181 return sun_fdc->status_82077 & ~STATUS_DMA; 182 case 5: /* FD_DATA */ 183 return sun_fdc->data_82077; 184 case 7: /* FD_DIR */ 185 return sun_read_dir(); 186 }; 187 panic("sun_82077_fd_inb: How did I get here?"); 188 } 189 190 static void sun_82077_fd_outb(unsigned char value, int port) 191 { 192 udelay(5); 193 switch(port & 7) { 194 default: 195 printk("floppy: Asked to write to unknown port %d\n", port); 196 panic("floppy: Port bolixed."); 197 case 2: /* FD_DOR */ 198 sun_set_dor(value, 1); 199 break; 200 case 5: /* FD_DATA */ 201 sun_fdc->data_82077 = value; 202 break; 203 case 7: /* FD_DCR */ 204 sun_fdc->dcr_82077 = value; 205 break; 206 case 4: /* FD_STATUS */ 207 sun_fdc->status_82077 = value; 208 break; 209 case 3: /* FD_TDR */ 210 sun_fdc->tapectl_82077 = value; 211 break; 212 }; 213 return; 214 } 215 216 /* For pseudo-dma (Sun floppy drives have no real DMA available to 217 * them so we must eat the data fifo bytes directly ourselves) we have 218 * three state variables. doing_pdma tells our inline low-level 219 * assembly floppy interrupt entry point whether it should sit and eat 220 * bytes from the fifo or just transfer control up to the higher level 221 * floppy interrupt c-code. I tried very hard but I could not get the 222 * pseudo-dma to work in c-code without getting many overruns and 223 * underruns. If non-zero, doing_pdma encodes the direction of 224 * the transfer for debugging. 1=read 2=write 225 */ 226 extern char *pdma_vaddr; 227 extern unsigned long pdma_size; 228 extern volatile int doing_pdma; 229 230 /* This is software state */ 231 extern char *pdma_base; 232 extern unsigned long pdma_areasize; 233 234 /* Common routines to all controller types on the Sparc. */ 235 static inline void virtual_dma_init(void) 236 { 237 /* nothing... */ 238 } 239 240 static inline void sun_fd_disable_dma(void) 241 { 242 doing_pdma = 0; 243 if (pdma_base) { 244 mmu_unlockarea(pdma_base, pdma_areasize); 245 pdma_base = NULL; 246 } 247 } 248 249 static inline void sun_fd_set_dma_mode(int mode) 250 { 251 switch(mode) { 252 case DMA_MODE_READ: 253 doing_pdma = 1; 254 break; 255 case DMA_MODE_WRITE: 256 doing_pdma = 2; 257 break; 258 default: 259 printk("Unknown dma mode %d\n", mode); 260 panic("floppy: Giving up..."); 261 } 262 } 263 264 static inline void sun_fd_set_dma_addr(char *buffer) 265 { 266 pdma_vaddr = buffer; 267 } 268 269 static inline void sun_fd_set_dma_count(int length) 270 { 271 pdma_size = length; 272 } 273 274 static inline void sun_fd_enable_dma(void) 275 { 276 pdma_vaddr = mmu_lockarea(pdma_vaddr, pdma_size); 277 pdma_base = pdma_vaddr; 278 pdma_areasize = pdma_size; 279 } 280 281 /* Our low-level entry point in arch/sparc/kernel/entry.S */ 282 extern int sparc_floppy_request_irq(int irq, unsigned long flags, 283 irq_handler_t irq_handler); 284 285 static int sun_fd_request_irq(void) 286 { 287 static int once = 0; 288 int error; 289 290 if(!once) { 291 once = 1; 292 error = sparc_floppy_request_irq(FLOPPY_IRQ, 293 IRQF_DISABLED, 294 floppy_interrupt); 295 return ((error == 0) ? 0 : -1); 296 } else return 0; 297 } 298 299 static struct linux_prom_registers fd_regs[2]; 300 301 static int sun_floppy_init(void) 302 { 303 char state[128]; 304 int tnode, fd_node, num_regs; 305 struct resource r; 306 307 use_virtual_dma = 1; 308 309 FLOPPY_IRQ = 11; 310 /* Forget it if we aren't on a machine that could possibly 311 * ever have a floppy drive. 312 */ 313 if((sparc_cpu_model != sun4c && sparc_cpu_model != sun4m) || 314 ((idprom->id_machtype == (SM_SUN4C | SM_4C_SLC)) || 315 (idprom->id_machtype == (SM_SUN4C | SM_4C_ELC)))) { 316 /* We certainly don't have a floppy controller. */ 317 goto no_sun_fdc; 318 } 319 /* Well, try to find one. */ 320 tnode = prom_getchild(prom_root_node); 321 fd_node = prom_searchsiblings(tnode, "obio"); 322 if(fd_node != 0) { 323 tnode = prom_getchild(fd_node); 324 fd_node = prom_searchsiblings(tnode, "SUNW,fdtwo"); 325 } else { 326 fd_node = prom_searchsiblings(tnode, "fd"); 327 } 328 if(fd_node == 0) { 329 goto no_sun_fdc; 330 } 331 332 /* The sun4m lets us know if the controller is actually usable. */ 333 if(sparc_cpu_model == sun4m && 334 prom_getproperty(fd_node, "status", state, sizeof(state)) != -1) { 335 if(!strcmp(state, "disabled")) { 336 goto no_sun_fdc; 337 } 338 } 339 num_regs = prom_getproperty(fd_node, "reg", (char *) fd_regs, sizeof(fd_regs)); 340 num_regs = (num_regs / sizeof(fd_regs[0])); 341 prom_apply_obio_ranges(fd_regs, num_regs); 342 memset(&r, 0, sizeof(r)); 343 r.flags = fd_regs[0].which_io; 344 r.start = fd_regs[0].phys_addr; 345 sun_fdc = (struct sun_flpy_controller *) 346 sbus_ioremap(&r, 0, fd_regs[0].reg_size, "floppy"); 347 348 /* Last minute sanity check... */ 349 if(sun_fdc->status_82072 == 0xff) { 350 sun_fdc = NULL; 351 goto no_sun_fdc; 352 } 353 354 sun_fdops.fd_inb = sun_82077_fd_inb; 355 sun_fdops.fd_outb = sun_82077_fd_outb; 356 fdc_status = &sun_fdc->status_82077; 357 358 if (sun_fdc->dor_82077 == 0x80) { 359 sun_fdc->dor_82077 = 0x02; 360 if (sun_fdc->dor_82077 == 0x80) { 361 sun_fdops.fd_inb = sun_82072_fd_inb; 362 sun_fdops.fd_outb = sun_82072_fd_outb; 363 fdc_status = &sun_fdc->status_82072; 364 } 365 } 366 367 /* Success... */ 368 allowed_drive_mask = 0x01; 369 return (int) sun_fdc; 370 371 no_sun_fdc: 372 return -1; 373 } 374 375 static int sparc_eject(void) 376 { 377 set_dor(0x00, 0xff, 0x90); 378 udelay(500); 379 set_dor(0x00, 0x6f, 0x00); 380 udelay(500); 381 return 0; 382 } 383 384 #define fd_eject(drive) sparc_eject() 385 386 #define EXTRA_FLOPPY_PARAMS 387 388 #endif /* !(__ASM_SPARC_FLOPPY_H) */ 389