~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/sparc/include/asm/floppy_64.h

Version: ~ [ linux-5.2-rc6 ] ~ [ linux-5.1.15 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.56 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.130 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.183 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.183 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.69 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp