Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Bartlomiej Zolnierkiewicz | 204f47c | 2008-02-26 21:50:36 +0100 | [diff] [blame] | 2 | * IDE DMA support (including IDE PCI BM-DMA). |
| 3 | * |
Bartlomiej Zolnierkiewicz | 59bca8c | 2008-02-01 23:09:33 +0100 | [diff] [blame] | 4 | * Copyright (C) 1995-1998 Mark Lord |
| 5 | * Copyright (C) 1999-2000 Andre Hedrick <andre@linux-ide.org> |
| 6 | * Copyright (C) 2004, 2007 Bartlomiej Zolnierkiewicz |
Bartlomiej Zolnierkiewicz | 58f189f | 2008-02-01 23:09:33 +0100 | [diff] [blame] | 7 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 8 | * May be copied or modified under the terms of the GNU General Public License |
Bartlomiej Zolnierkiewicz | 204f47c | 2008-02-26 21:50:36 +0100 | [diff] [blame] | 9 | * |
| 10 | * DMA is supported for all IDE devices (disk drives, cdroms, tapes, floppies). |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | */ |
| 12 | |
| 13 | /* |
| 14 | * Special Thanks to Mark for his Six years of work. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | */ |
| 16 | |
| 17 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | * Thanks to "Christopher J. Reimer" <reimer@doe.carleton.ca> for |
| 19 | * fixing the problem with the BIOS on some Acer motherboards. |
| 20 | * |
| 21 | * Thanks to "Benoit Poulot-Cazajous" <poulot@chorus.fr> for testing |
| 22 | * "TX" chipset compatibility and for providing patches for the "TX" chipset. |
| 23 | * |
| 24 | * Thanks to Christian Brunner <chb@muc.de> for taking a good first crack |
| 25 | * at generic DMA -- his patches were referred to when preparing this code. |
| 26 | * |
| 27 | * Most importantly, thanks to Robert Bringman <rob@mars.trion.com> |
| 28 | * for supplying a Promise UDMA board & WD UDMA drive for this work! |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | */ |
| 30 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | #include <linux/module.h> |
| 32 | #include <linux/types.h> |
| 33 | #include <linux/kernel.h> |
| 34 | #include <linux/timer.h> |
| 35 | #include <linux/mm.h> |
| 36 | #include <linux/interrupt.h> |
| 37 | #include <linux/pci.h> |
| 38 | #include <linux/init.h> |
| 39 | #include <linux/ide.h> |
| 40 | #include <linux/delay.h> |
| 41 | #include <linux/scatterlist.h> |
Bartlomiej Zolnierkiewicz | 5c05ff6 | 2008-02-01 23:09:32 +0100 | [diff] [blame] | 42 | #include <linux/dma-mapping.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | |
| 44 | #include <asm/io.h> |
| 45 | #include <asm/irq.h> |
| 46 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | static const struct drive_list_entry drive_whitelist [] = { |
| 48 | |
Junio C Hamano | c2d3ce8 | 2007-07-09 23:17:56 +0200 | [diff] [blame] | 49 | { "Micropolis 2112A" , NULL }, |
| 50 | { "CONNER CTMA 4000" , NULL }, |
| 51 | { "CONNER CTT8000-A" , NULL }, |
| 52 | { "ST34342A" , NULL }, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | { NULL , NULL } |
| 54 | }; |
| 55 | |
| 56 | static const struct drive_list_entry drive_blacklist [] = { |
| 57 | |
Junio C Hamano | c2d3ce8 | 2007-07-09 23:17:56 +0200 | [diff] [blame] | 58 | { "WDC AC11000H" , NULL }, |
| 59 | { "WDC AC22100H" , NULL }, |
| 60 | { "WDC AC32500H" , NULL }, |
| 61 | { "WDC AC33100H" , NULL }, |
| 62 | { "WDC AC31600H" , NULL }, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | { "WDC AC32100H" , "24.09P07" }, |
| 64 | { "WDC AC23200L" , "21.10N21" }, |
Junio C Hamano | c2d3ce8 | 2007-07-09 23:17:56 +0200 | [diff] [blame] | 65 | { "Compaq CRD-8241B" , NULL }, |
| 66 | { "CRD-8400B" , NULL }, |
| 67 | { "CRD-8480B", NULL }, |
| 68 | { "CRD-8482B", NULL }, |
| 69 | { "CRD-84" , NULL }, |
| 70 | { "SanDisk SDP3B" , NULL }, |
| 71 | { "SanDisk SDP3B-64" , NULL }, |
| 72 | { "SANYO CD-ROM CRD" , NULL }, |
| 73 | { "HITACHI CDR-8" , NULL }, |
| 74 | { "HITACHI CDR-8335" , NULL }, |
| 75 | { "HITACHI CDR-8435" , NULL }, |
| 76 | { "Toshiba CD-ROM XM-6202B" , NULL }, |
| 77 | { "TOSHIBA CD-ROM XM-1702BC", NULL }, |
| 78 | { "CD-532E-A" , NULL }, |
| 79 | { "E-IDE CD-ROM CR-840", NULL }, |
| 80 | { "CD-ROM Drive/F5A", NULL }, |
| 81 | { "WPI CDD-820", NULL }, |
| 82 | { "SAMSUNG CD-ROM SC-148C", NULL }, |
| 83 | { "SAMSUNG CD-ROM SC", NULL }, |
| 84 | { "ATAPI CD-ROM DRIVE 40X MAXIMUM", NULL }, |
| 85 | { "_NEC DV5800A", NULL }, |
Junio C Hamano | 5a6248c | 2007-05-24 02:42:38 +0200 | [diff] [blame] | 86 | { "SAMSUNG CD-ROM SN-124", "N001" }, |
Junio C Hamano | c2d3ce8 | 2007-07-09 23:17:56 +0200 | [diff] [blame] | 87 | { "Seagate STT20000A", NULL }, |
Bartlomiej Zolnierkiewicz | b0bc65b | 2007-11-27 21:35:56 +0100 | [diff] [blame] | 88 | { "CD-ROM CDR_U200", "1.09" }, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | { NULL , NULL } |
| 90 | |
| 91 | }; |
| 92 | |
| 93 | /** |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 94 | * ide_dma_intr - IDE DMA interrupt handler |
| 95 | * @drive: the drive the interrupt is for |
| 96 | * |
| 97 | * Handle an interrupt completing a read/write DMA transfer on an |
| 98 | * IDE device |
| 99 | */ |
| 100 | |
| 101 | ide_startstop_t ide_dma_intr (ide_drive_t *drive) |
| 102 | { |
Bartlomiej Zolnierkiewicz | b73c7ee | 2008-07-23 19:55:52 +0200 | [diff] [blame] | 103 | ide_hwif_t *hwif = drive->hwif; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | u8 stat = 0, dma_stat = 0; |
| 105 | |
Bartlomiej Zolnierkiewicz | b73c7ee | 2008-07-23 19:55:52 +0200 | [diff] [blame] | 106 | dma_stat = hwif->dma_ops->dma_end(drive); |
Bartlomiej Zolnierkiewicz | 374e042 | 2008-07-23 19:55:56 +0200 | [diff] [blame] | 107 | stat = hwif->tp_ops->read_status(hwif); |
Bartlomiej Zolnierkiewicz | c47137a | 2008-02-06 02:57:51 +0100 | [diff] [blame] | 108 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) { |
| 110 | if (!dma_stat) { |
| 111 | struct request *rq = HWGROUP(drive)->rq; |
| 112 | |
Tejun Heo | 4d7a984 | 2008-01-26 20:13:11 +0100 | [diff] [blame] | 113 | task_end_request(drive, rq, stat); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | return ide_stopped; |
| 115 | } |
| 116 | printk(KERN_ERR "%s: dma_intr: bad DMA status (dma_stat=%x)\n", |
| 117 | drive->name, dma_stat); |
| 118 | } |
| 119 | return ide_error(drive, "dma_intr", stat); |
| 120 | } |
| 121 | |
| 122 | EXPORT_SYMBOL_GPL(ide_dma_intr); |
| 123 | |
Bartlomiej Zolnierkiewicz | 75d7d96 | 2007-10-13 17:47:50 +0200 | [diff] [blame] | 124 | static int ide_dma_good_drive(ide_drive_t *drive) |
| 125 | { |
| 126 | return ide_in_drive_list(drive->id, drive_whitelist); |
| 127 | } |
| 128 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | /** |
| 130 | * ide_build_sglist - map IDE scatter gather for DMA I/O |
| 131 | * @drive: the drive to build the DMA table for |
| 132 | * @rq: the request holding the sg list |
| 133 | * |
Bartlomiej Zolnierkiewicz | 5c05ff6 | 2008-02-01 23:09:32 +0100 | [diff] [blame] | 134 | * Perform the DMA mapping magic necessary to access the source or |
| 135 | * target buffers of a request via DMA. The lower layers of the |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 136 | * kernel provide the necessary cache management so that we can |
Bartlomiej Zolnierkiewicz | 5c05ff6 | 2008-02-01 23:09:32 +0100 | [diff] [blame] | 137 | * operate in a portable fashion. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | */ |
| 139 | |
| 140 | int ide_build_sglist(ide_drive_t *drive, struct request *rq) |
| 141 | { |
| 142 | ide_hwif_t *hwif = HWIF(drive); |
| 143 | struct scatterlist *sg = hwif->sg_table; |
| 144 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 145 | ide_map_sg(drive, rq); |
| 146 | |
| 147 | if (rq_data_dir(rq) == READ) |
Bartlomiej Zolnierkiewicz | 5c05ff6 | 2008-02-01 23:09:32 +0100 | [diff] [blame] | 148 | hwif->sg_dma_direction = DMA_FROM_DEVICE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 149 | else |
Bartlomiej Zolnierkiewicz | 5c05ff6 | 2008-02-01 23:09:32 +0100 | [diff] [blame] | 150 | hwif->sg_dma_direction = DMA_TO_DEVICE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 151 | |
Bartlomiej Zolnierkiewicz | 5c05ff6 | 2008-02-01 23:09:32 +0100 | [diff] [blame] | 152 | return dma_map_sg(hwif->dev, sg, hwif->sg_nents, |
| 153 | hwif->sg_dma_direction); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | } |
| 155 | |
| 156 | EXPORT_SYMBOL_GPL(ide_build_sglist); |
| 157 | |
Sergei Shtylyov | 8e882ba | 2008-02-11 00:32:14 +0100 | [diff] [blame] | 158 | #ifdef CONFIG_BLK_DEV_IDEDMA_SFF |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | /** |
| 160 | * ide_build_dmatable - build IDE DMA table |
| 161 | * |
| 162 | * ide_build_dmatable() prepares a dma request. We map the command |
| 163 | * to get the pci bus addresses of the buffers and then build up |
| 164 | * the PRD table that the IDE layer wants to be fed. The code |
| 165 | * knows about the 64K wrap bug in the CS5530. |
| 166 | * |
| 167 | * Returns the number of built PRD entries if all went okay, |
| 168 | * returns 0 otherwise. |
| 169 | * |
| 170 | * May also be invoked from trm290.c |
| 171 | */ |
| 172 | |
| 173 | int ide_build_dmatable (ide_drive_t *drive, struct request *rq) |
| 174 | { |
| 175 | ide_hwif_t *hwif = HWIF(drive); |
Harvey Harrison | 7fa897b | 2008-07-24 22:53:34 +0200 | [diff] [blame] | 176 | __le32 *table = (__le32 *)hwif->dmatable_cpu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 177 | unsigned int is_trm290 = (hwif->chipset == ide_trm290) ? 1 : 0; |
| 178 | unsigned int count = 0; |
| 179 | int i; |
| 180 | struct scatterlist *sg; |
| 181 | |
| 182 | hwif->sg_nents = i = ide_build_sglist(drive, rq); |
| 183 | |
| 184 | if (!i) |
| 185 | return 0; |
| 186 | |
| 187 | sg = hwif->sg_table; |
| 188 | while (i) { |
| 189 | u32 cur_addr; |
| 190 | u32 cur_len; |
| 191 | |
| 192 | cur_addr = sg_dma_address(sg); |
| 193 | cur_len = sg_dma_len(sg); |
| 194 | |
| 195 | /* |
| 196 | * Fill in the dma table, without crossing any 64kB boundaries. |
| 197 | * Most hardware requires 16-bit alignment of all blocks, |
| 198 | * but the trm290 requires 32-bit alignment. |
| 199 | */ |
| 200 | |
| 201 | while (cur_len) { |
| 202 | if (count++ >= PRD_ENTRIES) { |
| 203 | printk(KERN_ERR "%s: DMA table too small\n", drive->name); |
| 204 | goto use_pio_instead; |
| 205 | } else { |
| 206 | u32 xcount, bcount = 0x10000 - (cur_addr & 0xffff); |
| 207 | |
| 208 | if (bcount > cur_len) |
| 209 | bcount = cur_len; |
| 210 | *table++ = cpu_to_le32(cur_addr); |
| 211 | xcount = bcount & 0xffff; |
| 212 | if (is_trm290) |
| 213 | xcount = ((xcount >> 2) - 1) << 16; |
Sergei Shtylylov | 22e05b4 | 2008-10-05 18:23:27 +0200 | [diff] [blame] | 214 | else if (xcount == 0x0000) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | /* |
| 216 | * Most chipsets correctly interpret a length of 0x0000 as 64KB, |
| 217 | * but at least one (e.g. CS5530) misinterprets it as zero (!). |
| 218 | * So here we break the 64KB entry into two 32KB entries instead. |
| 219 | */ |
| 220 | if (count++ >= PRD_ENTRIES) { |
| 221 | printk(KERN_ERR "%s: DMA table too small\n", drive->name); |
| 222 | goto use_pio_instead; |
| 223 | } |
| 224 | *table++ = cpu_to_le32(0x8000); |
| 225 | *table++ = cpu_to_le32(cur_addr + 0x8000); |
| 226 | xcount = 0x8000; |
| 227 | } |
| 228 | *table++ = cpu_to_le32(xcount); |
| 229 | cur_addr += bcount; |
| 230 | cur_len -= bcount; |
| 231 | } |
| 232 | } |
| 233 | |
Jens Axboe | 55c16a7 | 2007-07-25 08:13:56 +0200 | [diff] [blame] | 234 | sg = sg_next(sg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 235 | i--; |
| 236 | } |
| 237 | |
| 238 | if (count) { |
| 239 | if (!is_trm290) |
| 240 | *--table |= cpu_to_le32(0x80000000); |
| 241 | return count; |
| 242 | } |
Bartlomiej Zolnierkiewicz | f6fb786 | 2008-02-01 23:09:31 +0100 | [diff] [blame] | 243 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 244 | printk(KERN_ERR "%s: empty DMA table?\n", drive->name); |
Bartlomiej Zolnierkiewicz | f6fb786 | 2008-02-01 23:09:31 +0100 | [diff] [blame] | 245 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 246 | use_pio_instead: |
Bartlomiej Zolnierkiewicz | f6fb786 | 2008-02-01 23:09:31 +0100 | [diff] [blame] | 247 | ide_destroy_dmatable(drive); |
| 248 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | return 0; /* revert to PIO for this request */ |
| 250 | } |
| 251 | |
| 252 | EXPORT_SYMBOL_GPL(ide_build_dmatable); |
Bartlomiej Zolnierkiewicz | 062f9f0 | 2008-02-01 23:09:32 +0100 | [diff] [blame] | 253 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | |
| 255 | /** |
| 256 | * ide_destroy_dmatable - clean up DMA mapping |
| 257 | * @drive: The drive to unmap |
| 258 | * |
| 259 | * Teardown mappings after DMA has completed. This must be called |
| 260 | * after the completion of each use of ide_build_dmatable and before |
| 261 | * the next use of ide_build_dmatable. Failure to do so will cause |
| 262 | * an oops as only one mapping can be live for each target at a given |
| 263 | * time. |
| 264 | */ |
| 265 | |
| 266 | void ide_destroy_dmatable (ide_drive_t *drive) |
| 267 | { |
Bartlomiej Zolnierkiewicz | 3650165 | 2008-02-01 23:09:31 +0100 | [diff] [blame] | 268 | ide_hwif_t *hwif = drive->hwif; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 269 | |
Bartlomiej Zolnierkiewicz | 5c05ff6 | 2008-02-01 23:09:32 +0100 | [diff] [blame] | 270 | dma_unmap_sg(hwif->dev, hwif->sg_table, hwif->sg_nents, |
Bartlomiej Zolnierkiewicz | 3650165 | 2008-02-01 23:09:31 +0100 | [diff] [blame] | 271 | hwif->sg_dma_direction); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | } |
| 273 | |
| 274 | EXPORT_SYMBOL_GPL(ide_destroy_dmatable); |
| 275 | |
Sergei Shtylyov | 8e882ba | 2008-02-11 00:32:14 +0100 | [diff] [blame] | 276 | #ifdef CONFIG_BLK_DEV_IDEDMA_SFF |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 277 | /** |
| 278 | * config_drive_for_dma - attempt to activate IDE DMA |
| 279 | * @drive: the drive to place in DMA mode |
| 280 | * |
| 281 | * If the drive supports at least mode 2 DMA or UDMA of any kind |
| 282 | * then attempt to place it into DMA mode. Drives that are known to |
| 283 | * support DMA but predate the DMA properties or that are known |
| 284 | * to have DMA handling bugs are also set up appropriately based |
| 285 | * on the good/bad drive lists. |
| 286 | */ |
| 287 | |
| 288 | static int config_drive_for_dma (ide_drive_t *drive) |
| 289 | { |
Bartlomiej Zolnierkiewicz | 1116fae | 2007-08-20 22:42:55 +0200 | [diff] [blame] | 290 | ide_hwif_t *hwif = drive->hwif; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | struct hd_driveid *id = drive->id; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 292 | |
Bartlomiej Zolnierkiewicz | 33c1002 | 2007-10-19 00:30:06 +0200 | [diff] [blame] | 293 | if (drive->media != ide_disk) { |
| 294 | if (hwif->host_flags & IDE_HFLAG_NO_ATAPI_DMA) |
Bartlomiej Zolnierkiewicz | bcbf6ee | 2007-11-05 21:42:30 +0100 | [diff] [blame] | 295 | return 0; |
Bartlomiej Zolnierkiewicz | 33c1002 | 2007-10-19 00:30:06 +0200 | [diff] [blame] | 296 | } |
Bartlomiej Zolnierkiewicz | 1116fae | 2007-08-20 22:42:55 +0200 | [diff] [blame] | 297 | |
Bartlomiej Zolnierkiewicz | 0ae2e17 | 2007-10-16 22:29:55 +0200 | [diff] [blame] | 298 | /* |
| 299 | * Enable DMA on any drive that has |
| 300 | * UltraDMA (mode 0/1/2/3/4/5/6) enabled |
| 301 | */ |
| 302 | if ((id->field_valid & 4) && ((id->dma_ultra >> 8) & 0x7f)) |
| 303 | return 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 304 | |
Bartlomiej Zolnierkiewicz | 0ae2e17 | 2007-10-16 22:29:55 +0200 | [diff] [blame] | 305 | /* |
| 306 | * Enable DMA on any drive that has mode2 DMA |
| 307 | * (multi or single) enabled |
| 308 | */ |
| 309 | if (id->field_valid & 2) /* regular DMA */ |
| 310 | if ((id->dma_mword & 0x404) == 0x404 || |
| 311 | (id->dma_1word & 0x404) == 0x404) |
| 312 | return 1; |
Bartlomiej Zolnierkiewicz | 3608b5d | 2007-02-17 02:40:26 +0100 | [diff] [blame] | 313 | |
Bartlomiej Zolnierkiewicz | 0ae2e17 | 2007-10-16 22:29:55 +0200 | [diff] [blame] | 314 | /* Consult the list of known "good" drives */ |
| 315 | if (ide_dma_good_drive(drive)) |
| 316 | return 1; |
| 317 | |
| 318 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | } |
| 320 | |
| 321 | /** |
| 322 | * dma_timer_expiry - handle a DMA timeout |
| 323 | * @drive: Drive that timed out |
| 324 | * |
| 325 | * An IDE DMA transfer timed out. In the event of an error we ask |
| 326 | * the driver to resolve the problem, if a DMA transfer is still |
| 327 | * in progress we continue to wait (arguably we need to add a |
| 328 | * secondary 'I don't care what the drive thinks' timeout here) |
| 329 | * Finally if we have an interrupt we let it complete the I/O. |
| 330 | * But only one time - we clear expiry and if it's still not |
| 331 | * completed after WAIT_CMD, we error and retry in PIO. |
| 332 | * This can occur if an interrupt is lost or due to hang or bugs. |
| 333 | */ |
| 334 | |
| 335 | static int dma_timer_expiry (ide_drive_t *drive) |
| 336 | { |
| 337 | ide_hwif_t *hwif = HWIF(drive); |
Bartlomiej Zolnierkiewicz | 374e042 | 2008-07-23 19:55:56 +0200 | [diff] [blame] | 338 | u8 dma_stat = hwif->tp_ops->read_sff_dma_status(hwif); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 339 | |
| 340 | printk(KERN_WARNING "%s: dma_timer_expiry: dma status == 0x%02x\n", |
| 341 | drive->name, dma_stat); |
| 342 | |
| 343 | if ((dma_stat & 0x18) == 0x18) /* BUSY Stupid Early Timer !! */ |
| 344 | return WAIT_CMD; |
| 345 | |
| 346 | HWGROUP(drive)->expiry = NULL; /* one free ride for now */ |
| 347 | |
| 348 | /* 1 dmaing, 2 error, 4 intr */ |
| 349 | if (dma_stat & 2) /* ERROR */ |
| 350 | return -1; |
| 351 | |
| 352 | if (dma_stat & 1) /* DMAing */ |
| 353 | return WAIT_CMD; |
| 354 | |
| 355 | if (dma_stat & 4) /* Got an Interrupt */ |
| 356 | return WAIT_CMD; |
| 357 | |
| 358 | return 0; /* Status is unknown -- reset the bus */ |
| 359 | } |
| 360 | |
| 361 | /** |
Bartlomiej Zolnierkiewicz | 15ce926 | 2008-01-26 20:13:03 +0100 | [diff] [blame] | 362 | * ide_dma_host_set - Enable/disable DMA on a host |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 363 | * @drive: drive to control |
| 364 | * |
Bartlomiej Zolnierkiewicz | 15ce926 | 2008-01-26 20:13:03 +0100 | [diff] [blame] | 365 | * Enable/disable DMA on an IDE controller following generic |
| 366 | * bus-mastering IDE controller behaviour. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 367 | */ |
| 368 | |
Bartlomiej Zolnierkiewicz | 15ce926 | 2008-01-26 20:13:03 +0100 | [diff] [blame] | 369 | void ide_dma_host_set(ide_drive_t *drive, int on) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 370 | { |
| 371 | ide_hwif_t *hwif = HWIF(drive); |
| 372 | u8 unit = (drive->select.b.unit & 0x01); |
Bartlomiej Zolnierkiewicz | 374e042 | 2008-07-23 19:55:56 +0200 | [diff] [blame] | 373 | u8 dma_stat = hwif->tp_ops->read_sff_dma_status(hwif); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 374 | |
Bartlomiej Zolnierkiewicz | 15ce926 | 2008-01-26 20:13:03 +0100 | [diff] [blame] | 375 | if (on) |
| 376 | dma_stat |= (1 << (5 + unit)); |
| 377 | else |
| 378 | dma_stat &= ~(1 << (5 + unit)); |
| 379 | |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 380 | if (hwif->host_flags & IDE_HFLAG_MMIO) |
Bartlomiej Zolnierkiewicz | cab7f8e | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 381 | writeb(dma_stat, |
| 382 | (void __iomem *)(hwif->dma_base + ATA_DMA_STATUS)); |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 383 | else |
Bartlomiej Zolnierkiewicz | cab7f8e | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 384 | outb(dma_stat, hwif->dma_base + ATA_DMA_STATUS); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 385 | } |
| 386 | |
Bartlomiej Zolnierkiewicz | 15ce926 | 2008-01-26 20:13:03 +0100 | [diff] [blame] | 387 | EXPORT_SYMBOL_GPL(ide_dma_host_set); |
Sergei Shtylyov | 8e882ba | 2008-02-11 00:32:14 +0100 | [diff] [blame] | 388 | #endif /* CONFIG_BLK_DEV_IDEDMA_SFF */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 389 | |
| 390 | /** |
Bartlomiej Zolnierkiewicz | 7469aaf | 2007-02-17 02:40:26 +0100 | [diff] [blame] | 391 | * ide_dma_off_quietly - Generic DMA kill |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 392 | * @drive: drive to control |
| 393 | * |
| 394 | * Turn off the current DMA on this IDE controller. |
| 395 | */ |
| 396 | |
Bartlomiej Zolnierkiewicz | 7469aaf | 2007-02-17 02:40:26 +0100 | [diff] [blame] | 397 | void ide_dma_off_quietly(ide_drive_t *drive) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 398 | { |
| 399 | drive->using_dma = 0; |
| 400 | ide_toggle_bounce(drive, 0); |
| 401 | |
Bartlomiej Zolnierkiewicz | 5e37bdc | 2008-04-26 22:25:24 +0200 | [diff] [blame] | 402 | drive->hwif->dma_ops->dma_host_set(drive, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 403 | } |
| 404 | |
Bartlomiej Zolnierkiewicz | 7469aaf | 2007-02-17 02:40:26 +0100 | [diff] [blame] | 405 | EXPORT_SYMBOL(ide_dma_off_quietly); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 406 | |
| 407 | /** |
Bartlomiej Zolnierkiewicz | 7469aaf | 2007-02-17 02:40:26 +0100 | [diff] [blame] | 408 | * ide_dma_off - disable DMA on a device |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 409 | * @drive: drive to disable DMA on |
| 410 | * |
| 411 | * Disable IDE DMA for a device on this IDE controller. |
| 412 | * Inform the user that DMA has been disabled. |
| 413 | */ |
| 414 | |
Bartlomiej Zolnierkiewicz | 7469aaf | 2007-02-17 02:40:26 +0100 | [diff] [blame] | 415 | void ide_dma_off(ide_drive_t *drive) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 416 | { |
| 417 | printk(KERN_INFO "%s: DMA disabled\n", drive->name); |
Bartlomiej Zolnierkiewicz | 4a546e0 | 2008-01-26 20:13:01 +0100 | [diff] [blame] | 418 | ide_dma_off_quietly(drive); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 419 | } |
| 420 | |
Bartlomiej Zolnierkiewicz | 7469aaf | 2007-02-17 02:40:26 +0100 | [diff] [blame] | 421 | EXPORT_SYMBOL(ide_dma_off); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 422 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 423 | /** |
Bartlomiej Zolnierkiewicz | 4a546e0 | 2008-01-26 20:13:01 +0100 | [diff] [blame] | 424 | * ide_dma_on - Enable DMA on a device |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 425 | * @drive: drive to enable DMA on |
| 426 | * |
| 427 | * Enable IDE DMA for a device on this IDE controller. |
| 428 | */ |
Bartlomiej Zolnierkiewicz | 4a546e0 | 2008-01-26 20:13:01 +0100 | [diff] [blame] | 429 | |
| 430 | void ide_dma_on(ide_drive_t *drive) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 431 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 432 | drive->using_dma = 1; |
| 433 | ide_toggle_bounce(drive, 1); |
| 434 | |
Bartlomiej Zolnierkiewicz | 5e37bdc | 2008-04-26 22:25:24 +0200 | [diff] [blame] | 435 | drive->hwif->dma_ops->dma_host_set(drive, 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 436 | } |
| 437 | |
Sergei Shtylyov | 8e882ba | 2008-02-11 00:32:14 +0100 | [diff] [blame] | 438 | #ifdef CONFIG_BLK_DEV_IDEDMA_SFF |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 439 | /** |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 440 | * ide_dma_setup - begin a DMA phase |
| 441 | * @drive: target device |
| 442 | * |
| 443 | * Build an IDE DMA PRD (IDE speak for scatter gather table) |
| 444 | * and then set up the DMA transfer registers for a device |
| 445 | * that follows generic IDE PCI DMA behaviour. Controllers can |
| 446 | * override this function if they need to |
| 447 | * |
| 448 | * Returns 0 on success. If a PIO fallback is required then 1 |
| 449 | * is returned. |
| 450 | */ |
| 451 | |
| 452 | int ide_dma_setup(ide_drive_t *drive) |
| 453 | { |
| 454 | ide_hwif_t *hwif = drive->hwif; |
| 455 | struct request *rq = HWGROUP(drive)->rq; |
| 456 | unsigned int reading; |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 457 | u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 458 | u8 dma_stat; |
| 459 | |
| 460 | if (rq_data_dir(rq)) |
| 461 | reading = 0; |
| 462 | else |
| 463 | reading = 1 << 3; |
| 464 | |
| 465 | /* fall back to pio! */ |
| 466 | if (!ide_build_dmatable(drive, rq)) { |
| 467 | ide_map_sg(drive, rq); |
| 468 | return 1; |
| 469 | } |
| 470 | |
| 471 | /* PRD table */ |
Bartlomiej Zolnierkiewicz | 1357214 | 2008-07-15 21:21:49 +0200 | [diff] [blame] | 472 | if (hwif->host_flags & IDE_HFLAG_MMIO) |
Bartlomiej Zolnierkiewicz | 55224bc | 2008-04-28 23:44:42 +0200 | [diff] [blame] | 473 | writel(hwif->dmatable_dma, |
| 474 | (void __iomem *)(hwif->dma_base + ATA_DMA_TABLE_OFS)); |
Bartlomiej Zolnierkiewicz | 0ecdca2 | 2007-02-17 02:40:25 +0100 | [diff] [blame] | 475 | else |
Bartlomiej Zolnierkiewicz | 55224bc | 2008-04-28 23:44:42 +0200 | [diff] [blame] | 476 | outl(hwif->dmatable_dma, hwif->dma_base + ATA_DMA_TABLE_OFS); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 477 | |
| 478 | /* specify r/w */ |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 479 | if (mmio) |
Bartlomiej Zolnierkiewicz | cab7f8e | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 480 | writeb(reading, (void __iomem *)(hwif->dma_base + ATA_DMA_CMD)); |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 481 | else |
Bartlomiej Zolnierkiewicz | cab7f8e | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 482 | outb(reading, hwif->dma_base + ATA_DMA_CMD); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 483 | |
Bartlomiej Zolnierkiewicz | b2f951a | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 484 | /* read DMA status for INTR & ERROR flags */ |
Bartlomiej Zolnierkiewicz | 374e042 | 2008-07-23 19:55:56 +0200 | [diff] [blame] | 485 | dma_stat = hwif->tp_ops->read_sff_dma_status(hwif); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 486 | |
| 487 | /* clear INTR & ERROR flags */ |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 488 | if (mmio) |
Bartlomiej Zolnierkiewicz | cab7f8e | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 489 | writeb(dma_stat | 6, |
| 490 | (void __iomem *)(hwif->dma_base + ATA_DMA_STATUS)); |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 491 | else |
Bartlomiej Zolnierkiewicz | cab7f8e | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 492 | outb(dma_stat | 6, hwif->dma_base + ATA_DMA_STATUS); |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 493 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 494 | drive->waiting_for_dma = 1; |
| 495 | return 0; |
| 496 | } |
| 497 | |
| 498 | EXPORT_SYMBOL_GPL(ide_dma_setup); |
| 499 | |
Bartlomiej Zolnierkiewicz | f37afda | 2008-04-26 22:25:24 +0200 | [diff] [blame] | 500 | void ide_dma_exec_cmd(ide_drive_t *drive, u8 command) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 501 | { |
| 502 | /* issue cmd to drive */ |
| 503 | ide_execute_command(drive, command, &ide_dma_intr, 2*WAIT_CMD, dma_timer_expiry); |
| 504 | } |
Bartlomiej Zolnierkiewicz | f37afda | 2008-04-26 22:25:24 +0200 | [diff] [blame] | 505 | EXPORT_SYMBOL_GPL(ide_dma_exec_cmd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 506 | |
| 507 | void ide_dma_start(ide_drive_t *drive) |
| 508 | { |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 509 | ide_hwif_t *hwif = drive->hwif; |
| 510 | u8 dma_cmd; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 511 | |
| 512 | /* Note that this is done *after* the cmd has |
| 513 | * been issued to the drive, as per the BM-IDE spec. |
| 514 | * The Promise Ultra33 doesn't work correctly when |
| 515 | * we do this part before issuing the drive cmd. |
| 516 | */ |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 517 | if (hwif->host_flags & IDE_HFLAG_MMIO) { |
Bartlomiej Zolnierkiewicz | cab7f8e | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 518 | dma_cmd = readb((void __iomem *)(hwif->dma_base + ATA_DMA_CMD)); |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 519 | /* start DMA */ |
Bartlomiej Zolnierkiewicz | cab7f8e | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 520 | writeb(dma_cmd | 1, |
| 521 | (void __iomem *)(hwif->dma_base + ATA_DMA_CMD)); |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 522 | } else { |
Bartlomiej Zolnierkiewicz | cab7f8e | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 523 | dma_cmd = inb(hwif->dma_base + ATA_DMA_CMD); |
| 524 | outb(dma_cmd | 1, hwif->dma_base + ATA_DMA_CMD); |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 525 | } |
| 526 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 527 | hwif->dma = 1; |
| 528 | wmb(); |
| 529 | } |
| 530 | |
| 531 | EXPORT_SYMBOL_GPL(ide_dma_start); |
| 532 | |
| 533 | /* returns 1 on error, 0 otherwise */ |
| 534 | int __ide_dma_end (ide_drive_t *drive) |
| 535 | { |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 536 | ide_hwif_t *hwif = drive->hwif; |
| 537 | u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 538 | u8 dma_stat = 0, dma_cmd = 0; |
| 539 | |
| 540 | drive->waiting_for_dma = 0; |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 541 | |
| 542 | if (mmio) { |
| 543 | /* get DMA command mode */ |
Bartlomiej Zolnierkiewicz | cab7f8e | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 544 | dma_cmd = readb((void __iomem *)(hwif->dma_base + ATA_DMA_CMD)); |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 545 | /* stop DMA */ |
Bartlomiej Zolnierkiewicz | cab7f8e | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 546 | writeb(dma_cmd & ~1, |
| 547 | (void __iomem *)(hwif->dma_base + ATA_DMA_CMD)); |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 548 | } else { |
Bartlomiej Zolnierkiewicz | cab7f8e | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 549 | dma_cmd = inb(hwif->dma_base + ATA_DMA_CMD); |
| 550 | outb(dma_cmd & ~1, hwif->dma_base + ATA_DMA_CMD); |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 551 | } |
| 552 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 553 | /* get DMA status */ |
Bartlomiej Zolnierkiewicz | 374e042 | 2008-07-23 19:55:56 +0200 | [diff] [blame] | 554 | dma_stat = hwif->tp_ops->read_sff_dma_status(hwif); |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 555 | |
| 556 | if (mmio) |
| 557 | /* clear the INTR & ERROR bits */ |
Bartlomiej Zolnierkiewicz | cab7f8e | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 558 | writeb(dma_stat | 6, |
| 559 | (void __iomem *)(hwif->dma_base + ATA_DMA_STATUS)); |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 560 | else |
Bartlomiej Zolnierkiewicz | cab7f8e | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 561 | outb(dma_stat | 6, hwif->dma_base + ATA_DMA_STATUS); |
Bartlomiej Zolnierkiewicz | ab86f91 | 2008-07-23 19:55:50 +0200 | [diff] [blame] | 562 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 563 | /* purge DMA mappings */ |
| 564 | ide_destroy_dmatable(drive); |
| 565 | /* verify good DMA status */ |
| 566 | hwif->dma = 0; |
| 567 | wmb(); |
| 568 | return (dma_stat & 7) != 4 ? (0x10 | dma_stat) : 0; |
| 569 | } |
| 570 | |
| 571 | EXPORT_SYMBOL(__ide_dma_end); |
| 572 | |
| 573 | /* returns 1 if dma irq issued, 0 otherwise */ |
Bartlomiej Zolnierkiewicz | f37afda | 2008-04-26 22:25:24 +0200 | [diff] [blame] | 574 | int ide_dma_test_irq(ide_drive_t *drive) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 575 | { |
| 576 | ide_hwif_t *hwif = HWIF(drive); |
Bartlomiej Zolnierkiewicz | 374e042 | 2008-07-23 19:55:56 +0200 | [diff] [blame] | 577 | u8 dma_stat = hwif->tp_ops->read_sff_dma_status(hwif); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 578 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 579 | /* return 1 if INTR asserted */ |
| 580 | if ((dma_stat & 4) == 4) |
| 581 | return 1; |
| 582 | if (!drive->waiting_for_dma) |
| 583 | printk(KERN_WARNING "%s: (%s) called while not waiting\n", |
Harvey Harrison | eb63963 | 2008-04-26 22:25:20 +0200 | [diff] [blame] | 584 | drive->name, __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 585 | return 0; |
| 586 | } |
Bartlomiej Zolnierkiewicz | f37afda | 2008-04-26 22:25:24 +0200 | [diff] [blame] | 587 | EXPORT_SYMBOL_GPL(ide_dma_test_irq); |
Bartlomiej Zolnierkiewicz | 0ae2e17 | 2007-10-16 22:29:55 +0200 | [diff] [blame] | 588 | #else |
| 589 | static inline int config_drive_for_dma(ide_drive_t *drive) { return 0; } |
Sergei Shtylyov | 8e882ba | 2008-02-11 00:32:14 +0100 | [diff] [blame] | 590 | #endif /* CONFIG_BLK_DEV_IDEDMA_SFF */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 591 | |
| 592 | int __ide_dma_bad_drive (ide_drive_t *drive) |
| 593 | { |
| 594 | struct hd_driveid *id = drive->id; |
| 595 | |
Jordan Crouse | 65e5f2e | 2005-12-15 02:16:18 +0100 | [diff] [blame] | 596 | int blacklist = ide_in_drive_list(id, drive_blacklist); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 597 | if (blacklist) { |
| 598 | printk(KERN_WARNING "%s: Disabling (U)DMA for %s (blacklisted)\n", |
| 599 | drive->name, id->model); |
| 600 | return blacklist; |
| 601 | } |
| 602 | return 0; |
| 603 | } |
| 604 | |
| 605 | EXPORT_SYMBOL(__ide_dma_bad_drive); |
| 606 | |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 607 | static const u8 xfer_mode_bases[] = { |
| 608 | XFER_UDMA_0, |
| 609 | XFER_MW_DMA_0, |
| 610 | XFER_SW_DMA_0, |
| 611 | }; |
| 612 | |
Bartlomiej Zolnierkiewicz | 7670df7 | 2007-10-11 23:53:59 +0200 | [diff] [blame] | 613 | static unsigned int ide_get_mode_mask(ide_drive_t *drive, u8 base, u8 req_mode) |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 614 | { |
| 615 | struct hd_driveid *id = drive->id; |
| 616 | ide_hwif_t *hwif = drive->hwif; |
Bartlomiej Zolnierkiewicz | ac95bee | 2008-04-26 22:25:14 +0200 | [diff] [blame] | 617 | const struct ide_port_ops *port_ops = hwif->port_ops; |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 618 | unsigned int mask = 0; |
| 619 | |
| 620 | switch(base) { |
| 621 | case XFER_UDMA_0: |
| 622 | if ((id->field_valid & 4) == 0) |
| 623 | break; |
| 624 | |
Bartlomiej Zolnierkiewicz | ac95bee | 2008-04-26 22:25:14 +0200 | [diff] [blame] | 625 | if (port_ops && port_ops->udma_filter) |
| 626 | mask = port_ops->udma_filter(drive); |
Sergei Shtylyov | 851dd33 | 2007-10-11 23:53:59 +0200 | [diff] [blame] | 627 | else |
| 628 | mask = hwif->ultra_mask; |
| 629 | mask &= id->dma_ultra; |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 630 | |
Bartlomiej Zolnierkiewicz | 7670df7 | 2007-10-11 23:53:59 +0200 | [diff] [blame] | 631 | /* |
| 632 | * avoid false cable warning from eighty_ninty_three() |
| 633 | */ |
| 634 | if (req_mode > XFER_UDMA_2) { |
| 635 | if ((mask & 0x78) && (eighty_ninty_three(drive) == 0)) |
| 636 | mask &= 0x07; |
| 637 | } |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 638 | break; |
| 639 | case XFER_MW_DMA_0: |
Sergei Shtylyov | b4e4436 | 2007-10-11 23:53:58 +0200 | [diff] [blame] | 640 | if ((id->field_valid & 2) == 0) |
| 641 | break; |
Bartlomiej Zolnierkiewicz | ac95bee | 2008-04-26 22:25:14 +0200 | [diff] [blame] | 642 | if (port_ops && port_ops->mdma_filter) |
| 643 | mask = port_ops->mdma_filter(drive); |
Sergei Shtylyov | b4e4436 | 2007-10-11 23:53:58 +0200 | [diff] [blame] | 644 | else |
| 645 | mask = hwif->mwdma_mask; |
| 646 | mask &= id->dma_mword; |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 647 | break; |
| 648 | case XFER_SW_DMA_0: |
Bartlomiej Zolnierkiewicz | 15a4f94 | 2007-07-09 23:17:57 +0200 | [diff] [blame] | 649 | if (id->field_valid & 2) { |
Bartlomiej Zolnierkiewicz | 3649c06 | 2007-05-16 00:51:46 +0200 | [diff] [blame] | 650 | mask = id->dma_1word & hwif->swdma_mask; |
Bartlomiej Zolnierkiewicz | 15a4f94 | 2007-07-09 23:17:57 +0200 | [diff] [blame] | 651 | } else if (id->tDMA) { |
Bartlomiej Zolnierkiewicz | 367fdcb | 2008-08-05 18:16:55 +0200 | [diff] [blame] | 652 | u8 mode = id->tDMA; |
Bartlomiej Zolnierkiewicz | 15a4f94 | 2007-07-09 23:17:57 +0200 | [diff] [blame] | 653 | |
| 654 | /* |
| 655 | * if the mode is valid convert it to the mask |
| 656 | * (the maximum allowed mode is XFER_SW_DMA_2) |
| 657 | */ |
| 658 | if (mode <= 2) |
| 659 | mask = ((2 << mode) - 1) & hwif->swdma_mask; |
| 660 | } |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 661 | break; |
| 662 | default: |
| 663 | BUG(); |
| 664 | break; |
| 665 | } |
| 666 | |
| 667 | return mask; |
| 668 | } |
| 669 | |
| 670 | /** |
Bartlomiej Zolnierkiewicz | 7670df7 | 2007-10-11 23:53:59 +0200 | [diff] [blame] | 671 | * ide_find_dma_mode - compute DMA speed |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 672 | * @drive: IDE device |
Bartlomiej Zolnierkiewicz | 7670df7 | 2007-10-11 23:53:59 +0200 | [diff] [blame] | 673 | * @req_mode: requested mode |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 674 | * |
Bartlomiej Zolnierkiewicz | 7670df7 | 2007-10-11 23:53:59 +0200 | [diff] [blame] | 675 | * Checks the drive/host capabilities and finds the speed to use for |
| 676 | * the DMA transfer. The speed is then limited by the requested mode. |
| 677 | * |
| 678 | * Returns 0 if the drive/host combination is incapable of DMA transfers |
| 679 | * or if the requested mode is not a DMA mode. |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 680 | */ |
| 681 | |
Bartlomiej Zolnierkiewicz | 7670df7 | 2007-10-11 23:53:59 +0200 | [diff] [blame] | 682 | u8 ide_find_dma_mode(ide_drive_t *drive, u8 req_mode) |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 683 | { |
| 684 | ide_hwif_t *hwif = drive->hwif; |
| 685 | unsigned int mask; |
| 686 | int x, i; |
| 687 | u8 mode = 0; |
| 688 | |
Bartlomiej Zolnierkiewicz | 33c1002 | 2007-10-19 00:30:06 +0200 | [diff] [blame] | 689 | if (drive->media != ide_disk) { |
| 690 | if (hwif->host_flags & IDE_HFLAG_NO_ATAPI_DMA) |
| 691 | return 0; |
| 692 | } |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 693 | |
| 694 | for (i = 0; i < ARRAY_SIZE(xfer_mode_bases); i++) { |
Bartlomiej Zolnierkiewicz | 7670df7 | 2007-10-11 23:53:59 +0200 | [diff] [blame] | 695 | if (req_mode < xfer_mode_bases[i]) |
| 696 | continue; |
| 697 | mask = ide_get_mode_mask(drive, xfer_mode_bases[i], req_mode); |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 698 | x = fls(mask) - 1; |
| 699 | if (x >= 0) { |
| 700 | mode = xfer_mode_bases[i] + x; |
| 701 | break; |
| 702 | } |
| 703 | } |
| 704 | |
Bartlomiej Zolnierkiewicz | 75d7d96 | 2007-10-13 17:47:50 +0200 | [diff] [blame] | 705 | if (hwif->chipset == ide_acorn && mode == 0) { |
| 706 | /* |
| 707 | * is this correct? |
| 708 | */ |
| 709 | if (ide_dma_good_drive(drive) && drive->id->eide_dma_time < 150) |
| 710 | mode = XFER_MW_DMA_1; |
| 711 | } |
| 712 | |
Bartlomiej Zolnierkiewicz | 3ab7efe | 2007-12-12 23:31:58 +0100 | [diff] [blame] | 713 | mode = min(mode, req_mode); |
| 714 | |
| 715 | printk(KERN_INFO "%s: %s mode selected\n", drive->name, |
Bartlomiej Zolnierkiewicz | d34887d | 2007-11-05 21:42:27 +0100 | [diff] [blame] | 716 | mode ? ide_xfer_verbose(mode) : "no DMA"); |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 717 | |
Bartlomiej Zolnierkiewicz | 3ab7efe | 2007-12-12 23:31:58 +0100 | [diff] [blame] | 718 | return mode; |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 719 | } |
| 720 | |
Bartlomiej Zolnierkiewicz | 7670df7 | 2007-10-11 23:53:59 +0200 | [diff] [blame] | 721 | EXPORT_SYMBOL_GPL(ide_find_dma_mode); |
Bartlomiej Zolnierkiewicz | 2d5eaa6 | 2007-05-10 00:01:08 +0200 | [diff] [blame] | 722 | |
Bartlomiej Zolnierkiewicz | 0ae2e17 | 2007-10-16 22:29:55 +0200 | [diff] [blame] | 723 | static int ide_tune_dma(ide_drive_t *drive) |
Bartlomiej Zolnierkiewicz | 29e744d | 2007-05-10 00:01:09 +0200 | [diff] [blame] | 724 | { |
Bartlomiej Zolnierkiewicz | 8704de8 | 2008-01-26 20:13:00 +0100 | [diff] [blame] | 725 | ide_hwif_t *hwif = drive->hwif; |
Bartlomiej Zolnierkiewicz | 29e744d | 2007-05-10 00:01:09 +0200 | [diff] [blame] | 726 | u8 speed; |
| 727 | |
Bartlomiej Zolnierkiewicz | 931ee0d | 2008-07-15 21:21:47 +0200 | [diff] [blame] | 728 | if (drive->nodma || (drive->id->capability & 1) == 0) |
Bartlomiej Zolnierkiewicz | 122ab08 | 2007-05-16 00:51:46 +0200 | [diff] [blame] | 729 | return 0; |
| 730 | |
| 731 | /* consult the list of known "bad" drives */ |
| 732 | if (__ide_dma_bad_drive(drive)) |
Bartlomiej Zolnierkiewicz | 29e744d | 2007-05-10 00:01:09 +0200 | [diff] [blame] | 733 | return 0; |
| 734 | |
Bartlomiej Zolnierkiewicz | 3ab7efe | 2007-12-12 23:31:58 +0100 | [diff] [blame] | 735 | if (ide_id_dma_bug(drive)) |
| 736 | return 0; |
| 737 | |
Bartlomiej Zolnierkiewicz | 8704de8 | 2008-01-26 20:13:00 +0100 | [diff] [blame] | 738 | if (hwif->host_flags & IDE_HFLAG_TRUST_BIOS_FOR_DMA) |
Bartlomiej Zolnierkiewicz | 0ae2e17 | 2007-10-16 22:29:55 +0200 | [diff] [blame] | 739 | return config_drive_for_dma(drive); |
| 740 | |
Bartlomiej Zolnierkiewicz | 29e744d | 2007-05-10 00:01:09 +0200 | [diff] [blame] | 741 | speed = ide_max_dma_mode(drive); |
| 742 | |
Bartlomiej Zolnierkiewicz | 951784b | 2008-04-26 17:36:38 +0200 | [diff] [blame] | 743 | if (!speed) |
| 744 | return 0; |
Bartlomiej Zolnierkiewicz | 29e744d | 2007-05-10 00:01:09 +0200 | [diff] [blame] | 745 | |
Bartlomiej Zolnierkiewicz | 88b2b32 | 2007-10-13 17:47:51 +0200 | [diff] [blame] | 746 | if (ide_set_dma_mode(drive, speed)) |
Bartlomiej Zolnierkiewicz | 4728d54 | 2007-05-16 00:51:46 +0200 | [diff] [blame] | 747 | return 0; |
Bartlomiej Zolnierkiewicz | 29e744d | 2007-05-10 00:01:09 +0200 | [diff] [blame] | 748 | |
Bartlomiej Zolnierkiewicz | 4728d54 | 2007-05-16 00:51:46 +0200 | [diff] [blame] | 749 | return 1; |
Bartlomiej Zolnierkiewicz | 29e744d | 2007-05-10 00:01:09 +0200 | [diff] [blame] | 750 | } |
| 751 | |
Bartlomiej Zolnierkiewicz | 0ae2e17 | 2007-10-16 22:29:55 +0200 | [diff] [blame] | 752 | static int ide_dma_check(ide_drive_t *drive) |
| 753 | { |
| 754 | ide_hwif_t *hwif = drive->hwif; |
Bartlomiej Zolnierkiewicz | 0ae2e17 | 2007-10-16 22:29:55 +0200 | [diff] [blame] | 755 | |
Bartlomiej Zolnierkiewicz | ba4b2e6 | 2008-07-23 19:55:55 +0200 | [diff] [blame] | 756 | if (ide_tune_dma(drive)) |
Bartlomiej Zolnierkiewicz | 0ae2e17 | 2007-10-16 22:29:55 +0200 | [diff] [blame] | 757 | return 0; |
| 758 | |
| 759 | /* TODO: always do PIO fallback */ |
| 760 | if (hwif->host_flags & IDE_HFLAG_TRUST_BIOS_FOR_DMA) |
| 761 | return -1; |
| 762 | |
| 763 | ide_set_max_pio(drive); |
| 764 | |
Bartlomiej Zolnierkiewicz | ba4b2e6 | 2008-07-23 19:55:55 +0200 | [diff] [blame] | 765 | return -1; |
Bartlomiej Zolnierkiewicz | 0ae2e17 | 2007-10-16 22:29:55 +0200 | [diff] [blame] | 766 | } |
| 767 | |
Bartlomiej Zolnierkiewicz | 3ab7efe | 2007-12-12 23:31:58 +0100 | [diff] [blame] | 768 | int ide_id_dma_bug(ide_drive_t *drive) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 769 | { |
Bartlomiej Zolnierkiewicz | 3ab7efe | 2007-12-12 23:31:58 +0100 | [diff] [blame] | 770 | struct hd_driveid *id = drive->id; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 771 | |
| 772 | if (id->field_valid & 4) { |
| 773 | if ((id->dma_ultra >> 8) && (id->dma_mword >> 8)) |
Bartlomiej Zolnierkiewicz | 3ab7efe | 2007-12-12 23:31:58 +0100 | [diff] [blame] | 774 | goto err_out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 775 | } else if (id->field_valid & 2) { |
| 776 | if ((id->dma_mword >> 8) && (id->dma_1word >> 8)) |
Bartlomiej Zolnierkiewicz | 3ab7efe | 2007-12-12 23:31:58 +0100 | [diff] [blame] | 777 | goto err_out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 778 | } |
Bartlomiej Zolnierkiewicz | 3ab7efe | 2007-12-12 23:31:58 +0100 | [diff] [blame] | 779 | return 0; |
| 780 | err_out: |
| 781 | printk(KERN_ERR "%s: bad DMA info in identify block\n", drive->name); |
| 782 | return 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 783 | } |
| 784 | |
Bartlomiej Zolnierkiewicz | 3608b5d | 2007-02-17 02:40:26 +0100 | [diff] [blame] | 785 | int ide_set_dma(ide_drive_t *drive) |
| 786 | { |
Bartlomiej Zolnierkiewicz | 3608b5d | 2007-02-17 02:40:26 +0100 | [diff] [blame] | 787 | int rc; |
| 788 | |
Bartlomiej Zolnierkiewicz | 7b90599 | 2008-01-25 22:17:19 +0100 | [diff] [blame] | 789 | /* |
| 790 | * Force DMAing for the beginning of the check. |
| 791 | * Some chipsets appear to do interesting |
| 792 | * things, if not checked and cleared. |
| 793 | * PARANOIA!!! |
| 794 | */ |
Bartlomiej Zolnierkiewicz | 4a546e0 | 2008-01-26 20:13:01 +0100 | [diff] [blame] | 795 | ide_dma_off_quietly(drive); |
Bartlomiej Zolnierkiewicz | 7b90599 | 2008-01-25 22:17:19 +0100 | [diff] [blame] | 796 | |
Bartlomiej Zolnierkiewicz | 0ae2e17 | 2007-10-16 22:29:55 +0200 | [diff] [blame] | 797 | rc = ide_dma_check(drive); |
Bartlomiej Zolnierkiewicz | 7b90599 | 2008-01-25 22:17:19 +0100 | [diff] [blame] | 798 | if (rc) |
| 799 | return rc; |
Bartlomiej Zolnierkiewicz | 3608b5d | 2007-02-17 02:40:26 +0100 | [diff] [blame] | 800 | |
Bartlomiej Zolnierkiewicz | 4a546e0 | 2008-01-26 20:13:01 +0100 | [diff] [blame] | 801 | ide_dma_on(drive); |
| 802 | |
| 803 | return 0; |
Bartlomiej Zolnierkiewicz | 3608b5d | 2007-02-17 02:40:26 +0100 | [diff] [blame] | 804 | } |
| 805 | |
Bartlomiej Zolnierkiewicz | 578cfa0 | 2008-02-02 19:56:47 +0100 | [diff] [blame] | 806 | void ide_check_dma_crc(ide_drive_t *drive) |
| 807 | { |
| 808 | u8 mode; |
| 809 | |
| 810 | ide_dma_off_quietly(drive); |
| 811 | drive->crc_count = 0; |
| 812 | mode = drive->current_speed; |
| 813 | /* |
| 814 | * Don't try non Ultra-DMA modes without iCRC's. Force the |
| 815 | * device to PIO and make the user enable SWDMA/MWDMA modes. |
| 816 | */ |
| 817 | if (mode > XFER_UDMA_0 && mode <= XFER_UDMA_7) |
| 818 | mode--; |
| 819 | else |
| 820 | mode = XFER_PIO_4; |
| 821 | ide_set_xfer_rate(drive, mode); |
| 822 | if (drive->current_speed >= XFER_SW_DMA_0) |
| 823 | ide_dma_on(drive); |
| 824 | } |
| 825 | |
Sergei Shtylyov | 8e882ba | 2008-02-11 00:32:14 +0100 | [diff] [blame] | 826 | #ifdef CONFIG_BLK_DEV_IDEDMA_SFF |
Sergei Shtylyov | 841d2a9 | 2007-07-09 23:17:54 +0200 | [diff] [blame] | 827 | void ide_dma_lost_irq (ide_drive_t *drive) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 828 | { |
| 829 | printk("%s: DMA interrupt recovery\n", drive->name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 830 | } |
| 831 | |
Sergei Shtylyov | 841d2a9 | 2007-07-09 23:17:54 +0200 | [diff] [blame] | 832 | EXPORT_SYMBOL(ide_dma_lost_irq); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 833 | |
Sergei Shtylyov | c283f5d | 2007-07-09 23:17:54 +0200 | [diff] [blame] | 834 | void ide_dma_timeout (ide_drive_t *drive) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 835 | { |
Sergei Shtylyov | c283f5d | 2007-07-09 23:17:54 +0200 | [diff] [blame] | 836 | ide_hwif_t *hwif = HWIF(drive); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 837 | |
Sergei Shtylyov | c283f5d | 2007-07-09 23:17:54 +0200 | [diff] [blame] | 838 | printk(KERN_ERR "%s: timeout waiting for DMA\n", drive->name); |
| 839 | |
Bartlomiej Zolnierkiewicz | 5e37bdc | 2008-04-26 22:25:24 +0200 | [diff] [blame] | 840 | if (hwif->dma_ops->dma_test_irq(drive)) |
Sergei Shtylyov | c283f5d | 2007-07-09 23:17:54 +0200 | [diff] [blame] | 841 | return; |
| 842 | |
Bartlomiej Zolnierkiewicz | 5e37bdc | 2008-04-26 22:25:24 +0200 | [diff] [blame] | 843 | hwif->dma_ops->dma_end(drive); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 844 | } |
| 845 | |
Sergei Shtylyov | c283f5d | 2007-07-09 23:17:54 +0200 | [diff] [blame] | 846 | EXPORT_SYMBOL(ide_dma_timeout); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 847 | |
Bartlomiej Zolnierkiewicz | 0d1bad2 | 2008-04-26 22:25:19 +0200 | [diff] [blame] | 848 | void ide_release_dma_engine(ide_hwif_t *hwif) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 849 | { |
| 850 | if (hwif->dmatable_cpu) { |
Bartlomiej Zolnierkiewicz | 3650165 | 2008-02-01 23:09:31 +0100 | [diff] [blame] | 851 | struct pci_dev *pdev = to_pci_dev(hwif->dev); |
| 852 | |
| 853 | pci_free_consistent(pdev, PRD_ENTRIES * PRD_BYTES, |
| 854 | hwif->dmatable_cpu, hwif->dmatable_dma); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 855 | hwif->dmatable_cpu = NULL; |
| 856 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 857 | } |
| 858 | |
Bartlomiej Zolnierkiewicz | b8e73fb | 2008-04-26 22:25:21 +0200 | [diff] [blame] | 859 | int ide_allocate_dma_engine(ide_hwif_t *hwif) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 860 | { |
Bartlomiej Zolnierkiewicz | 3650165 | 2008-02-01 23:09:31 +0100 | [diff] [blame] | 861 | struct pci_dev *pdev = to_pci_dev(hwif->dev); |
| 862 | |
| 863 | hwif->dmatable_cpu = pci_alloc_consistent(pdev, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 864 | PRD_ENTRIES * PRD_BYTES, |
| 865 | &hwif->dmatable_dma); |
| 866 | |
| 867 | if (hwif->dmatable_cpu) |
| 868 | return 0; |
| 869 | |
Sergei Shtylylov | dc844e0 | 2006-10-03 01:14:14 -0700 | [diff] [blame] | 870 | printk(KERN_ERR "%s: -- Error, unable to allocate DMA table.\n", |
Bartlomiej Zolnierkiewicz | 5e59c23 | 2008-04-26 22:25:20 +0200 | [diff] [blame] | 871 | hwif->name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 872 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 873 | return 1; |
| 874 | } |
Bartlomiej Zolnierkiewicz | b8e73fb | 2008-04-26 22:25:21 +0200 | [diff] [blame] | 875 | EXPORT_SYMBOL_GPL(ide_allocate_dma_engine); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 876 | |
Bartlomiej Zolnierkiewicz | 81e8d5a | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 877 | const struct ide_dma_ops sff_dma_ops = { |
Bartlomiej Zolnierkiewicz | 5e37bdc | 2008-04-26 22:25:24 +0200 | [diff] [blame] | 878 | .dma_host_set = ide_dma_host_set, |
| 879 | .dma_setup = ide_dma_setup, |
| 880 | .dma_exec_cmd = ide_dma_exec_cmd, |
| 881 | .dma_start = ide_dma_start, |
| 882 | .dma_end = __ide_dma_end, |
Bartlomiej Zolnierkiewicz | f37afda | 2008-04-26 22:25:24 +0200 | [diff] [blame] | 883 | .dma_test_irq = ide_dma_test_irq, |
Bartlomiej Zolnierkiewicz | 5e37bdc | 2008-04-26 22:25:24 +0200 | [diff] [blame] | 884 | .dma_timeout = ide_dma_timeout, |
| 885 | .dma_lost_irq = ide_dma_lost_irq, |
| 886 | }; |
Bartlomiej Zolnierkiewicz | 81e8d5a | 2008-07-23 19:55:51 +0200 | [diff] [blame] | 887 | EXPORT_SYMBOL_GPL(sff_dma_ops); |
Sergei Shtylyov | 8e882ba | 2008-02-11 00:32:14 +0100 | [diff] [blame] | 888 | #endif /* CONFIG_BLK_DEV_IDEDMA_SFF */ |