2 * Support for IDE interfaces on Celleb platform
4 * (C) Copyright 2006 TOSHIBA CORPORATION
6 * This code is based on drivers/ide/pci/siimage.c:
7 * Copyright (C) 2001-2002 Andre Hedrick <andre@linux-ide.org>
8 * Copyright (C) 2003 Red Hat <alan@redhat.com>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License along
21 * with this program; if not, write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 #include <linux/types.h>
26 #include <linux/module.h>
27 #include <linux/pci.h>
28 #include <linux/delay.h>
29 #include <linux/hdreg.h>
30 #include <linux/ide.h>
31 #include <linux/init.h>
33 #define PCI_DEVICE_ID_TOSHIBA_SCC_ATA 0x01b4
35 #define SCC_PATA_NAME "scc IDE"
37 #define TDVHSEL_MASTER 0x00000001
38 #define TDVHSEL_SLAVE 0x00000004
40 #define MODE_JCUSFEN 0x00000080
42 #define CCKCTRL_ATARESET 0x00040000
43 #define CCKCTRL_BUFCNT 0x00020000
44 #define CCKCTRL_CRST 0x00010000
45 #define CCKCTRL_OCLKEN 0x00000100
46 #define CCKCTRL_ATACLKOEN 0x00000002
47 #define CCKCTRL_LCLKEN 0x00000001
49 #define QCHCD_IOS_SS 0x00000001
51 #define QCHSD_STPDIAG 0x00020000
53 #define INTMASK_MSK 0xD1000012
54 #define INTSTS_SERROR 0x80000000
55 #define INTSTS_PRERR 0x40000000
56 #define INTSTS_RERR 0x10000000
57 #define INTSTS_ICERR 0x01000000
58 #define INTSTS_BMSINT 0x00000010
59 #define INTSTS_BMHE 0x00000008
60 #define INTSTS_IOIRQS 0x00000004
61 #define INTSTS_INTRQ 0x00000002
62 #define INTSTS_ACTEINT 0x00000001
64 #define ECMODE_VALUE 0x01
66 static struct scc_ports
{
67 unsigned long ctl
, dma
;
68 unsigned char hwif_id
; /* for removing hwif from system */
69 } scc_ports
[MAX_HWIFS
];
71 /* PIO transfer mode table */
73 static unsigned long JCHSTtbl
[2][7] = {
74 {0x0E, 0x05, 0x02, 0x03, 0x02, 0x00, 0x00}, /* 100MHz */
75 {0x13, 0x07, 0x04, 0x04, 0x03, 0x00, 0x00} /* 133MHz */
79 static unsigned long JCHHTtbl
[2][7] = {
80 {0x0E, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00}, /* 100MHz */
81 {0x13, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00} /* 133MHz */
85 static unsigned long JCHCTtbl
[2][7] = {
86 {0x1D, 0x1D, 0x1C, 0x0B, 0x06, 0x00, 0x00}, /* 100MHz */
87 {0x27, 0x26, 0x26, 0x0E, 0x09, 0x00, 0x00} /* 133MHz */
91 /* DMA transfer mode table */
93 static unsigned long JCHDCTxtbl
[2][7] = {
94 {0x0A, 0x06, 0x04, 0x03, 0x01, 0x00, 0x00}, /* 100MHz */
95 {0x0E, 0x09, 0x06, 0x04, 0x02, 0x01, 0x00} /* 133MHz */
99 static unsigned long JCSTWTxtbl
[2][7] = {
100 {0x06, 0x04, 0x03, 0x02, 0x02, 0x02, 0x00}, /* 100MHz */
101 {0x09, 0x06, 0x04, 0x02, 0x02, 0x02, 0x02} /* 133MHz */
105 static unsigned long JCTSStbl
[2][7] = {
106 {0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x00}, /* 100MHz */
107 {0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05} /* 133MHz */
111 static unsigned long JCENVTtbl
[2][7] = {
112 {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00}, /* 100MHz */
113 {0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02} /* 133MHz */
116 /* JCACTSELS/JCACTSELM */
117 static unsigned long JCACTSELtbl
[2][7] = {
118 {0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00}, /* 100MHz */
119 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01} /* 133MHz */
123 static u8
scc_ide_inb(unsigned long port
)
125 u32 data
= in_be32((void*)port
);
129 static u16
scc_ide_inw(unsigned long port
)
131 u32 data
= in_be32((void*)port
);
135 static void scc_ide_insw(unsigned long port
, void *addr
, u32 count
)
137 u16
*ptr
= (u16
*)addr
;
139 *ptr
++ = le16_to_cpu(in_be32((void*)port
));
143 static void scc_ide_insl(unsigned long port
, void *addr
, u32 count
)
145 u16
*ptr
= (u16
*)addr
;
147 *ptr
++ = le16_to_cpu(in_be32((void*)port
));
148 *ptr
++ = le16_to_cpu(in_be32((void*)port
));
152 static void scc_ide_outb(u8 addr
, unsigned long port
)
154 out_be32((void*)port
, addr
);
157 static void scc_ide_outw(u16 addr
, unsigned long port
)
159 out_be32((void*)port
, addr
);
163 scc_ide_outbsync(ide_drive_t
* drive
, u8 addr
, unsigned long port
)
165 ide_hwif_t
*hwif
= HWIF(drive
);
167 out_be32((void*)port
, addr
);
169 in_be32((void*)(hwif
->dma_base
+ 0x01c));
174 scc_ide_outsw(unsigned long port
, void *addr
, u32 count
)
176 u16
*ptr
= (u16
*)addr
;
178 out_be32((void*)port
, cpu_to_le16(*ptr
++));
183 scc_ide_outsl(unsigned long port
, void *addr
, u32 count
)
185 u16
*ptr
= (u16
*)addr
;
187 out_be32((void*)port
, cpu_to_le16(*ptr
++));
188 out_be32((void*)port
, cpu_to_le16(*ptr
++));
193 * scc_set_pio_mode - set host controller for PIO mode
195 * @pio: PIO mode number
197 * Load the timing settings for this device mode into the
201 static void scc_set_pio_mode(ide_drive_t
*drive
, const u8 pio
)
203 ide_hwif_t
*hwif
= HWIF(drive
);
204 struct scc_ports
*ports
= ide_get_hwifdata(hwif
);
205 unsigned long ctl_base
= ports
->ctl
;
206 unsigned long cckctrl_port
= ctl_base
+ 0xff0;
207 unsigned long piosht_port
= ctl_base
+ 0x000;
208 unsigned long pioct_port
= ctl_base
+ 0x004;
212 reg
= in_be32((void __iomem
*)cckctrl_port
);
213 if (reg
& CCKCTRL_ATACLKOEN
) {
214 offset
= 1; /* 133MHz */
216 offset
= 0; /* 100MHz */
218 reg
= JCHSTtbl
[offset
][pio
] << 16 | JCHHTtbl
[offset
][pio
];
219 out_be32((void __iomem
*)piosht_port
, reg
);
220 reg
= JCHCTtbl
[offset
][pio
];
221 out_be32((void __iomem
*)pioct_port
, reg
);
225 * scc_set_dma_mode - set host controller for DMA mode
229 * Load the timing settings for this device mode into the
233 static void scc_set_dma_mode(ide_drive_t
*drive
, const u8 speed
)
235 ide_hwif_t
*hwif
= HWIF(drive
);
236 struct scc_ports
*ports
= ide_get_hwifdata(hwif
);
237 unsigned long ctl_base
= ports
->ctl
;
238 unsigned long cckctrl_port
= ctl_base
+ 0xff0;
239 unsigned long mdmact_port
= ctl_base
+ 0x008;
240 unsigned long mcrcst_port
= ctl_base
+ 0x00c;
241 unsigned long sdmact_port
= ctl_base
+ 0x010;
242 unsigned long scrcst_port
= ctl_base
+ 0x014;
243 unsigned long udenvt_port
= ctl_base
+ 0x018;
244 unsigned long tdvhsel_port
= ctl_base
+ 0x020;
245 int is_slave
= (&hwif
->drives
[1] == drive
);
248 unsigned long jcactsel
;
250 reg
= in_be32((void __iomem
*)cckctrl_port
);
251 if (reg
& CCKCTRL_ATACLKOEN
) {
252 offset
= 1; /* 133MHz */
254 offset
= 0; /* 100MHz */
265 idx
= speed
- XFER_UDMA_0
;
271 jcactsel
= JCACTSELtbl
[offset
][idx
];
273 out_be32((void __iomem
*)sdmact_port
, JCHDCTxtbl
[offset
][idx
]);
274 out_be32((void __iomem
*)scrcst_port
, JCSTWTxtbl
[offset
][idx
]);
275 jcactsel
= jcactsel
<< 2;
276 out_be32((void __iomem
*)tdvhsel_port
, (in_be32((void __iomem
*)tdvhsel_port
) & ~TDVHSEL_SLAVE
) | jcactsel
);
278 out_be32((void __iomem
*)mdmact_port
, JCHDCTxtbl
[offset
][idx
]);
279 out_be32((void __iomem
*)mcrcst_port
, JCSTWTxtbl
[offset
][idx
]);
280 out_be32((void __iomem
*)tdvhsel_port
, (in_be32((void __iomem
*)tdvhsel_port
) & ~TDVHSEL_MASTER
) | jcactsel
);
282 reg
= JCTSStbl
[offset
][idx
] << 16 | JCENVTtbl
[offset
][idx
];
283 out_be32((void __iomem
*)udenvt_port
, reg
);
287 * scc_configure_drive_for_dma - set up for DMA transfers
288 * @drive: drive we are going to set up
290 * Set up the drive for DMA, tune the controller and drive as
292 * If the drive isn't suitable for DMA or we hit other problems
293 * then we will drop down to PIO and set up PIO appropriately.
297 static int scc_config_drive_for_dma(ide_drive_t
*drive
)
299 if (ide_tune_dma(drive
))
302 if (ide_use_fast_pio(drive
))
303 ide_set_max_pio(drive
);
309 * scc_ide_dma_setup - begin a DMA phase
310 * @drive: target device
312 * Build an IDE DMA PRD (IDE speak for scatter gather table)
313 * and then set up the DMA transfer registers.
315 * Returns 0 on success. If a PIO fallback is required then 1
319 static int scc_dma_setup(ide_drive_t
*drive
)
321 ide_hwif_t
*hwif
= drive
->hwif
;
322 struct request
*rq
= HWGROUP(drive
)->rq
;
323 unsigned int reading
;
331 /* fall back to pio! */
332 if (!ide_build_dmatable(drive
, rq
)) {
333 ide_map_sg(drive
, rq
);
338 out_be32((void __iomem
*)hwif
->dma_prdtable
, hwif
->dmatable_dma
);
341 out_be32((void __iomem
*)hwif
->dma_command
, reading
);
343 /* read dma_status for INTR & ERROR flags */
344 dma_stat
= in_be32((void __iomem
*)hwif
->dma_status
);
346 /* clear INTR & ERROR flags */
347 out_be32((void __iomem
*)hwif
->dma_status
, dma_stat
|6);
348 drive
->waiting_for_dma
= 1;
354 * scc_ide_dma_end - Stop DMA
357 * Check and clear INT Status register.
358 * Then call __ide_dma_end().
361 static int scc_ide_dma_end(ide_drive_t
* drive
)
363 ide_hwif_t
*hwif
= HWIF(drive
);
364 unsigned long intsts_port
= hwif
->dma_base
+ 0x014;
366 int dma_stat
, data_loss
= 0;
367 static int retry
= 0;
369 /* errata A308 workaround: Step5 (check data loss) */
370 /* We don't check non ide_disk because it is limited to UDMA4 */
371 if (!(in_be32((void __iomem
*)IDE_ALTSTATUS_REG
) & ERR_STAT
) &&
372 drive
->media
== ide_disk
&& drive
->current_speed
> XFER_UDMA_4
) {
373 reg
= in_be32((void __iomem
*)intsts_port
);
374 if (!(reg
& INTSTS_ACTEINT
)) {
375 printk(KERN_WARNING
"%s: operation failed (transfer data loss)\n",
379 struct request
*rq
= HWGROUP(drive
)->rq
;
381 /* ERROR_RESET and drive->crc_count are needed
382 * to reduce DMA transfer mode in retry process.
385 rq
->errors
|= ERROR_RESET
;
386 for (unit
= 0; unit
< MAX_DRIVES
; unit
++) {
387 ide_drive_t
*drive
= &hwif
->drives
[unit
];
395 reg
= in_be32((void __iomem
*)intsts_port
);
397 if (reg
& INTSTS_SERROR
) {
398 printk(KERN_WARNING
"%s: SERROR\n", SCC_PATA_NAME
);
399 out_be32((void __iomem
*)intsts_port
, INTSTS_SERROR
|INTSTS_BMSINT
);
401 out_be32((void __iomem
*)hwif
->dma_command
, in_be32((void __iomem
*)hwif
->dma_command
) & ~QCHCD_IOS_SS
);
405 if (reg
& INTSTS_PRERR
) {
407 unsigned long ctl_base
= hwif
->config_data
;
409 maea0
= in_be32((void __iomem
*)(ctl_base
+ 0xF50));
410 maec0
= in_be32((void __iomem
*)(ctl_base
+ 0xF54));
412 printk(KERN_WARNING
"%s: PRERR [addr:%x cmd:%x]\n", SCC_PATA_NAME
, maea0
, maec0
);
414 out_be32((void __iomem
*)intsts_port
, INTSTS_PRERR
|INTSTS_BMSINT
);
416 out_be32((void __iomem
*)hwif
->dma_command
, in_be32((void __iomem
*)hwif
->dma_command
) & ~QCHCD_IOS_SS
);
420 if (reg
& INTSTS_RERR
) {
421 printk(KERN_WARNING
"%s: Response Error\n", SCC_PATA_NAME
);
422 out_be32((void __iomem
*)intsts_port
, INTSTS_RERR
|INTSTS_BMSINT
);
424 out_be32((void __iomem
*)hwif
->dma_command
, in_be32((void __iomem
*)hwif
->dma_command
) & ~QCHCD_IOS_SS
);
428 if (reg
& INTSTS_ICERR
) {
429 out_be32((void __iomem
*)hwif
->dma_command
, in_be32((void __iomem
*)hwif
->dma_command
) & ~QCHCD_IOS_SS
);
431 printk(KERN_WARNING
"%s: Illegal Configuration\n", SCC_PATA_NAME
);
432 out_be32((void __iomem
*)intsts_port
, INTSTS_ICERR
|INTSTS_BMSINT
);
436 if (reg
& INTSTS_BMSINT
) {
437 printk(KERN_WARNING
"%s: Internal Bus Error\n", SCC_PATA_NAME
);
438 out_be32((void __iomem
*)intsts_port
, INTSTS_BMSINT
);
444 if (reg
& INTSTS_BMHE
) {
445 out_be32((void __iomem
*)intsts_port
, INTSTS_BMHE
);
449 if (reg
& INTSTS_ACTEINT
) {
450 out_be32((void __iomem
*)intsts_port
, INTSTS_ACTEINT
);
454 if (reg
& INTSTS_IOIRQS
) {
455 out_be32((void __iomem
*)intsts_port
, INTSTS_IOIRQS
);
461 dma_stat
= __ide_dma_end(drive
);
463 dma_stat
|= 2; /* emulate DMA error (to retry command) */
467 /* returns 1 if dma irq issued, 0 otherwise */
468 static int scc_dma_test_irq(ide_drive_t
*drive
)
470 ide_hwif_t
*hwif
= HWIF(drive
);
471 u32 int_stat
= in_be32((void __iomem
*)hwif
->dma_base
+ 0x014);
473 /* SCC errata A252,A308 workaround: Step4 */
474 if ((in_be32((void __iomem
*)IDE_ALTSTATUS_REG
) & ERR_STAT
) &&
475 (int_stat
& INTSTS_INTRQ
))
478 /* SCC errata A308 workaround: Step5 (polling IOIRQS) */
479 if (int_stat
& INTSTS_IOIRQS
)
482 if (!drive
->waiting_for_dma
)
483 printk(KERN_WARNING
"%s: (%s) called while not waiting\n",
484 drive
->name
, __FUNCTION__
);
488 static u8
scc_udma_filter(ide_drive_t
*drive
)
490 ide_hwif_t
*hwif
= drive
->hwif
;
491 u8 mask
= hwif
->ultra_mask
;
493 /* errata A308 workaround: limit non ide_disk drive to UDMA4 */
494 if ((drive
->media
!= ide_disk
) && (mask
& 0xE0)) {
495 printk(KERN_INFO
"%s: limit %s to UDMA4\n",
496 SCC_PATA_NAME
, drive
->name
);
504 * setup_mmio_scc - map CTRL/BMID region
505 * @dev: PCI device we are configuring
510 static int setup_mmio_scc (struct pci_dev
*dev
, const char *name
)
512 unsigned long ctl_base
= pci_resource_start(dev
, 0);
513 unsigned long dma_base
= pci_resource_start(dev
, 1);
514 unsigned long ctl_size
= pci_resource_len(dev
, 0);
515 unsigned long dma_size
= pci_resource_len(dev
, 1);
516 void __iomem
*ctl_addr
;
517 void __iomem
*dma_addr
;
520 for (i
= 0; i
< MAX_HWIFS
; i
++) {
521 if (scc_ports
[i
].ctl
== 0)
527 if (!request_mem_region(ctl_base
, ctl_size
, name
)) {
528 printk(KERN_WARNING
"%s: IDE controller MMIO ports not available.\n", SCC_PATA_NAME
);
532 if (!request_mem_region(dma_base
, dma_size
, name
)) {
533 printk(KERN_WARNING
"%s: IDE controller MMIO ports not available.\n", SCC_PATA_NAME
);
537 if ((ctl_addr
= ioremap(ctl_base
, ctl_size
)) == NULL
)
540 if ((dma_addr
= ioremap(dma_base
, dma_size
)) == NULL
)
544 scc_ports
[i
].ctl
= (unsigned long)ctl_addr
;
545 scc_ports
[i
].dma
= (unsigned long)dma_addr
;
546 pci_set_drvdata(dev
, (void *) &scc_ports
[i
]);
553 release_mem_region(dma_base
, dma_size
);
555 release_mem_region(ctl_base
, ctl_size
);
561 * init_setup_scc - set up an SCC PATA Controller
565 * Perform the initial set up for this device.
568 static int __devinit
init_setup_scc(struct pci_dev
*dev
, ide_pci_device_t
*d
)
570 unsigned long ctl_base
;
571 unsigned long dma_base
;
572 unsigned long cckctrl_port
;
573 unsigned long intmask_port
;
574 unsigned long mode_port
;
575 unsigned long ecmode_port
;
576 unsigned long dma_status_port
;
578 struct scc_ports
*ports
;
581 rc
= setup_mmio_scc(dev
, d
->name
);
586 ports
= pci_get_drvdata(dev
);
587 ctl_base
= ports
->ctl
;
588 dma_base
= ports
->dma
;
589 cckctrl_port
= ctl_base
+ 0xff0;
590 intmask_port
= dma_base
+ 0x010;
591 mode_port
= ctl_base
+ 0x024;
592 ecmode_port
= ctl_base
+ 0xf00;
593 dma_status_port
= dma_base
+ 0x004;
595 /* controller initialization */
597 out_be32((void*)cckctrl_port
, reg
);
598 reg
|= CCKCTRL_ATACLKOEN
;
599 out_be32((void*)cckctrl_port
, reg
);
600 reg
|= CCKCTRL_LCLKEN
| CCKCTRL_OCLKEN
;
601 out_be32((void*)cckctrl_port
, reg
);
603 out_be32((void*)cckctrl_port
, reg
);
606 reg
= in_be32((void*)cckctrl_port
);
607 if (reg
& CCKCTRL_CRST
)
612 reg
|= CCKCTRL_ATARESET
;
613 out_be32((void*)cckctrl_port
, reg
);
615 out_be32((void*)ecmode_port
, ECMODE_VALUE
);
616 out_be32((void*)mode_port
, MODE_JCUSFEN
);
617 out_be32((void*)intmask_port
, INTMASK_MSK
);
619 return ide_setup_pci_device(dev
, d
);
623 * init_mmio_iops_scc - set up the iops for MMIO
624 * @hwif: interface to set up
628 static void __devinit
init_mmio_iops_scc(ide_hwif_t
*hwif
)
630 struct pci_dev
*dev
= hwif
->pci_dev
;
631 struct scc_ports
*ports
= pci_get_drvdata(dev
);
632 unsigned long dma_base
= ports
->dma
;
634 ide_set_hwifdata(hwif
, ports
);
636 hwif
->INB
= scc_ide_inb
;
637 hwif
->INW
= scc_ide_inw
;
638 hwif
->INSW
= scc_ide_insw
;
639 hwif
->INSL
= scc_ide_insl
;
640 hwif
->OUTB
= scc_ide_outb
;
641 hwif
->OUTBSYNC
= scc_ide_outbsync
;
642 hwif
->OUTW
= scc_ide_outw
;
643 hwif
->OUTSW
= scc_ide_outsw
;
644 hwif
->OUTSL
= scc_ide_outsl
;
646 hwif
->io_ports
[IDE_DATA_OFFSET
] = dma_base
+ 0x20;
647 hwif
->io_ports
[IDE_ERROR_OFFSET
] = dma_base
+ 0x24;
648 hwif
->io_ports
[IDE_NSECTOR_OFFSET
] = dma_base
+ 0x28;
649 hwif
->io_ports
[IDE_SECTOR_OFFSET
] = dma_base
+ 0x2c;
650 hwif
->io_ports
[IDE_LCYL_OFFSET
] = dma_base
+ 0x30;
651 hwif
->io_ports
[IDE_HCYL_OFFSET
] = dma_base
+ 0x34;
652 hwif
->io_ports
[IDE_SELECT_OFFSET
] = dma_base
+ 0x38;
653 hwif
->io_ports
[IDE_STATUS_OFFSET
] = dma_base
+ 0x3c;
654 hwif
->io_ports
[IDE_CONTROL_OFFSET
] = dma_base
+ 0x40;
656 hwif
->irq
= hwif
->pci_dev
->irq
;
657 hwif
->dma_base
= dma_base
;
658 hwif
->config_data
= ports
->ctl
;
663 * init_iops_scc - set up iops
664 * @hwif: interface to set up
666 * Do the basic setup for the SCC hardware interface
667 * and then do the MMIO setup.
670 static void __devinit
init_iops_scc(ide_hwif_t
*hwif
)
672 struct pci_dev
*dev
= hwif
->pci_dev
;
673 hwif
->hwif_data
= NULL
;
674 if (pci_get_drvdata(dev
) == NULL
)
676 init_mmio_iops_scc(hwif
);
680 * init_hwif_scc - set up hwif
681 * @hwif: interface to set up
683 * We do the basic set up of the interface structure. The SCC
684 * requires several custom handlers so we override the default
685 * ide DMA handlers appropriately.
688 static void __devinit
init_hwif_scc(ide_hwif_t
*hwif
)
690 struct scc_ports
*ports
= ide_get_hwifdata(hwif
);
692 ports
->hwif_id
= hwif
->index
;
694 hwif
->dma_command
= hwif
->dma_base
;
695 hwif
->dma_status
= hwif
->dma_base
+ 0x04;
696 hwif
->dma_prdtable
= hwif
->dma_base
+ 0x08;
699 out_be32((void __iomem
*)(hwif
->dma_base
+ 0x018), hwif
->dmatable_dma
);
701 hwif
->dma_setup
= scc_dma_setup
;
702 hwif
->ide_dma_end
= scc_ide_dma_end
;
703 hwif
->set_pio_mode
= scc_set_pio_mode
;
704 hwif
->set_dma_mode
= scc_set_dma_mode
;
705 hwif
->ide_dma_check
= scc_config_drive_for_dma
;
706 hwif
->ide_dma_test_irq
= scc_dma_test_irq
;
707 hwif
->udma_filter
= scc_udma_filter
;
709 hwif
->drives
[0].autotune
= IDE_TUNE_AUTO
;
710 hwif
->drives
[1].autotune
= IDE_TUNE_AUTO
;
712 if (in_be32((void __iomem
*)(hwif
->config_data
+ 0xff0)) & CCKCTRL_ATACLKOEN
) {
713 hwif
->ultra_mask
= 0x7f; /* 133MHz */
715 hwif
->ultra_mask
= 0x3f; /* 100MHz */
717 hwif
->mwdma_mask
= 0x00;
718 hwif
->swdma_mask
= 0x00;
721 /* we support 80c cable only. */
722 hwif
->cbl
= ATA_CBL_PATA80
;
727 hwif
->drives
[0].autodma
= hwif
->autodma
;
728 hwif
->drives
[1].autodma
= hwif
->autodma
;
731 #define DECLARE_SCC_DEV(name_str) \
734 .init_setup = init_setup_scc, \
735 .init_iops = init_iops_scc, \
736 .init_hwif = init_hwif_scc, \
737 .autodma = AUTODMA, \
738 .bootable = ON_BOARD, \
739 .host_flags = IDE_HFLAG_SINGLE, \
740 .pio_mask = ATA_PIO4, \
743 static ide_pci_device_t scc_chipsets
[] __devinitdata
= {
744 /* 0 */ DECLARE_SCC_DEV("sccIDE"),
748 * scc_init_one - pci layer discovery entry
750 * @id: ident table entry
752 * Called by the PCI code when it finds an SCC PATA controller.
753 * We then use the IDE PCI generic helper to do most of the work.
756 static int __devinit
scc_init_one(struct pci_dev
*dev
, const struct pci_device_id
*id
)
758 ide_pci_device_t
*d
= &scc_chipsets
[id
->driver_data
];
759 return d
->init_setup(dev
, d
);
763 * scc_remove - pci layer remove entry
766 * Called by the PCI code when it removes an SCC PATA controller.
769 static void __devexit
scc_remove(struct pci_dev
*dev
)
771 struct scc_ports
*ports
= pci_get_drvdata(dev
);
772 ide_hwif_t
*hwif
= &ide_hwifs
[ports
->hwif_id
];
773 unsigned long ctl_base
= pci_resource_start(dev
, 0);
774 unsigned long dma_base
= pci_resource_start(dev
, 1);
775 unsigned long ctl_size
= pci_resource_len(dev
, 0);
776 unsigned long dma_size
= pci_resource_len(dev
, 1);
778 if (hwif
->dmatable_cpu
) {
779 pci_free_consistent(hwif
->pci_dev
,
780 PRD_ENTRIES
* PRD_BYTES
,
783 hwif
->dmatable_cpu
= NULL
;
786 ide_unregister(hwif
->index
);
788 hwif
->chipset
= ide_unknown
;
789 iounmap((void*)ports
->dma
);
790 iounmap((void*)ports
->ctl
);
791 release_mem_region(dma_base
, dma_size
);
792 release_mem_region(ctl_base
, ctl_size
);
793 memset(ports
, 0, sizeof(*ports
));
796 static struct pci_device_id scc_pci_tbl
[] = {
797 { PCI_VENDOR_ID_TOSHIBA_2
, PCI_DEVICE_ID_TOSHIBA_SCC_ATA
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
800 MODULE_DEVICE_TABLE(pci
, scc_pci_tbl
);
802 static struct pci_driver driver
= {
804 .id_table
= scc_pci_tbl
,
805 .probe
= scc_init_one
,
806 .remove
= scc_remove
,
809 static int scc_ide_init(void)
811 return ide_pci_register_driver(&driver
);
814 module_init(scc_ide_init
);
816 static void scc_ide_exit(void)
818 ide_pci_unregister_driver(&driver);
820 module_exit(scc_ide_exit);
824 MODULE_DESCRIPTION("PCI driver module for Toshiba SCC IDE");
825 MODULE_LICENSE("GPL");