1c6fd2807SJeff Garzik /* 2c6fd2807SJeff Garzik * libata-core.c - helper library for ATA 3c6fd2807SJeff Garzik * 4c6fd2807SJeff Garzik * Maintained by: Jeff Garzik <jgarzik@pobox.com> 5c6fd2807SJeff Garzik * Please ALWAYS copy linux-ide@vger.kernel.org 6c6fd2807SJeff Garzik * on emails. 7c6fd2807SJeff Garzik * 8c6fd2807SJeff Garzik * Copyright 2003-2004 Red Hat, Inc. All rights reserved. 9c6fd2807SJeff Garzik * Copyright 2003-2004 Jeff Garzik 10c6fd2807SJeff Garzik * 11c6fd2807SJeff Garzik * 12c6fd2807SJeff Garzik * This program is free software; you can redistribute it and/or modify 13c6fd2807SJeff Garzik * it under the terms of the GNU General Public License as published by 14c6fd2807SJeff Garzik * the Free Software Foundation; either version 2, or (at your option) 15c6fd2807SJeff Garzik * any later version. 16c6fd2807SJeff Garzik * 17c6fd2807SJeff Garzik * This program is distributed in the hope that it will be useful, 18c6fd2807SJeff Garzik * but WITHOUT ANY WARRANTY; without even the implied warranty of 19c6fd2807SJeff Garzik * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20c6fd2807SJeff Garzik * GNU General Public License for more details. 21c6fd2807SJeff Garzik * 22c6fd2807SJeff Garzik * You should have received a copy of the GNU General Public License 23c6fd2807SJeff Garzik * along with this program; see the file COPYING. If not, write to 24c6fd2807SJeff Garzik * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 25c6fd2807SJeff Garzik * 26c6fd2807SJeff Garzik * 27c6fd2807SJeff Garzik * libata documentation is available via 'make {ps|pdf}docs', 28c6fd2807SJeff Garzik * as Documentation/DocBook/libata.* 29c6fd2807SJeff Garzik * 30c6fd2807SJeff Garzik * Hardware documentation available from http://www.t13.org/ and 31c6fd2807SJeff Garzik * http://www.sata-io.org/ 32c6fd2807SJeff Garzik * 33c6fd2807SJeff Garzik */ 34c6fd2807SJeff Garzik 35c6fd2807SJeff Garzik #include <linux/kernel.h> 36c6fd2807SJeff Garzik #include <linux/module.h> 37c6fd2807SJeff Garzik #include <linux/pci.h> 38c6fd2807SJeff Garzik #include <linux/init.h> 39c6fd2807SJeff Garzik #include <linux/list.h> 40c6fd2807SJeff Garzik #include <linux/mm.h> 41c6fd2807SJeff Garzik #include <linux/highmem.h> 42c6fd2807SJeff Garzik #include <linux/spinlock.h> 43c6fd2807SJeff Garzik #include <linux/blkdev.h> 44c6fd2807SJeff Garzik #include <linux/delay.h> 45c6fd2807SJeff Garzik #include <linux/timer.h> 46c6fd2807SJeff Garzik #include <linux/interrupt.h> 47c6fd2807SJeff Garzik #include <linux/completion.h> 48c6fd2807SJeff Garzik #include <linux/suspend.h> 49c6fd2807SJeff Garzik #include <linux/workqueue.h> 50c6fd2807SJeff Garzik #include <linux/jiffies.h> 51c6fd2807SJeff Garzik #include <linux/scatterlist.h> 52c6fd2807SJeff Garzik #include <scsi/scsi.h> 53c6fd2807SJeff Garzik #include <scsi/scsi_cmnd.h> 54c6fd2807SJeff Garzik #include <scsi/scsi_host.h> 55c6fd2807SJeff Garzik #include <linux/libata.h> 56c6fd2807SJeff Garzik #include <asm/io.h> 57c6fd2807SJeff Garzik #include <asm/semaphore.h> 58c6fd2807SJeff Garzik #include <asm/byteorder.h> 59c6fd2807SJeff Garzik 60c6fd2807SJeff Garzik #include "libata.h" 61c6fd2807SJeff Garzik 62c6fd2807SJeff Garzik /* debounce timing parameters in msecs { interval, duration, timeout } */ 63c6fd2807SJeff Garzik const unsigned long sata_deb_timing_normal[] = { 5, 100, 2000 }; 64c6fd2807SJeff Garzik const unsigned long sata_deb_timing_hotplug[] = { 25, 500, 2000 }; 65c6fd2807SJeff Garzik const unsigned long sata_deb_timing_long[] = { 100, 2000, 5000 }; 66c6fd2807SJeff Garzik 67c6fd2807SJeff Garzik static unsigned int ata_dev_init_params(struct ata_device *dev, 68c6fd2807SJeff Garzik u16 heads, u16 sectors); 69c6fd2807SJeff Garzik static unsigned int ata_dev_set_xfermode(struct ata_device *dev); 70c6fd2807SJeff Garzik static void ata_dev_xfermask(struct ata_device *dev); 71c6fd2807SJeff Garzik 72c6fd2807SJeff Garzik static unsigned int ata_unique_id = 1; 73c6fd2807SJeff Garzik static struct workqueue_struct *ata_wq; 74c6fd2807SJeff Garzik 75c6fd2807SJeff Garzik struct workqueue_struct *ata_aux_wq; 76c6fd2807SJeff Garzik 77c6fd2807SJeff Garzik int atapi_enabled = 1; 78c6fd2807SJeff Garzik module_param(atapi_enabled, int, 0444); 79c6fd2807SJeff Garzik MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)"); 80c6fd2807SJeff Garzik 81c6fd2807SJeff Garzik int atapi_dmadir = 0; 82c6fd2807SJeff Garzik module_param(atapi_dmadir, int, 0444); 83c6fd2807SJeff Garzik MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)"); 84c6fd2807SJeff Garzik 85c6fd2807SJeff Garzik int libata_fua = 0; 86c6fd2807SJeff Garzik module_param_named(fua, libata_fua, int, 0444); 87c6fd2807SJeff Garzik MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)"); 88c6fd2807SJeff Garzik 89c6fd2807SJeff Garzik static int ata_probe_timeout = ATA_TMOUT_INTERNAL / HZ; 90c6fd2807SJeff Garzik module_param(ata_probe_timeout, int, 0444); 91c6fd2807SJeff Garzik MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)"); 92c6fd2807SJeff Garzik 93c6fd2807SJeff Garzik MODULE_AUTHOR("Jeff Garzik"); 94c6fd2807SJeff Garzik MODULE_DESCRIPTION("Library module for ATA devices"); 95c6fd2807SJeff Garzik MODULE_LICENSE("GPL"); 96c6fd2807SJeff Garzik MODULE_VERSION(DRV_VERSION); 97c6fd2807SJeff Garzik 98c6fd2807SJeff Garzik 99c6fd2807SJeff Garzik /** 100c6fd2807SJeff Garzik * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure 101c6fd2807SJeff Garzik * @tf: Taskfile to convert 102c6fd2807SJeff Garzik * @fis: Buffer into which data will output 103c6fd2807SJeff Garzik * @pmp: Port multiplier port 104c6fd2807SJeff Garzik * 105c6fd2807SJeff Garzik * Converts a standard ATA taskfile to a Serial ATA 106c6fd2807SJeff Garzik * FIS structure (Register - Host to Device). 107c6fd2807SJeff Garzik * 108c6fd2807SJeff Garzik * LOCKING: 109c6fd2807SJeff Garzik * Inherited from caller. 110c6fd2807SJeff Garzik */ 111c6fd2807SJeff Garzik 112c6fd2807SJeff Garzik void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp) 113c6fd2807SJeff Garzik { 114c6fd2807SJeff Garzik fis[0] = 0x27; /* Register - Host to Device FIS */ 115c6fd2807SJeff Garzik fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number, 116c6fd2807SJeff Garzik bit 7 indicates Command FIS */ 117c6fd2807SJeff Garzik fis[2] = tf->command; 118c6fd2807SJeff Garzik fis[3] = tf->feature; 119c6fd2807SJeff Garzik 120c6fd2807SJeff Garzik fis[4] = tf->lbal; 121c6fd2807SJeff Garzik fis[5] = tf->lbam; 122c6fd2807SJeff Garzik fis[6] = tf->lbah; 123c6fd2807SJeff Garzik fis[7] = tf->device; 124c6fd2807SJeff Garzik 125c6fd2807SJeff Garzik fis[8] = tf->hob_lbal; 126c6fd2807SJeff Garzik fis[9] = tf->hob_lbam; 127c6fd2807SJeff Garzik fis[10] = tf->hob_lbah; 128c6fd2807SJeff Garzik fis[11] = tf->hob_feature; 129c6fd2807SJeff Garzik 130c6fd2807SJeff Garzik fis[12] = tf->nsect; 131c6fd2807SJeff Garzik fis[13] = tf->hob_nsect; 132c6fd2807SJeff Garzik fis[14] = 0; 133c6fd2807SJeff Garzik fis[15] = tf->ctl; 134c6fd2807SJeff Garzik 135c6fd2807SJeff Garzik fis[16] = 0; 136c6fd2807SJeff Garzik fis[17] = 0; 137c6fd2807SJeff Garzik fis[18] = 0; 138c6fd2807SJeff Garzik fis[19] = 0; 139c6fd2807SJeff Garzik } 140c6fd2807SJeff Garzik 141c6fd2807SJeff Garzik /** 142c6fd2807SJeff Garzik * ata_tf_from_fis - Convert SATA FIS to ATA taskfile 143c6fd2807SJeff Garzik * @fis: Buffer from which data will be input 144c6fd2807SJeff Garzik * @tf: Taskfile to output 145c6fd2807SJeff Garzik * 146c6fd2807SJeff Garzik * Converts a serial ATA FIS structure to a standard ATA taskfile. 147c6fd2807SJeff Garzik * 148c6fd2807SJeff Garzik * LOCKING: 149c6fd2807SJeff Garzik * Inherited from caller. 150c6fd2807SJeff Garzik */ 151c6fd2807SJeff Garzik 152c6fd2807SJeff Garzik void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf) 153c6fd2807SJeff Garzik { 154c6fd2807SJeff Garzik tf->command = fis[2]; /* status */ 155c6fd2807SJeff Garzik tf->feature = fis[3]; /* error */ 156c6fd2807SJeff Garzik 157c6fd2807SJeff Garzik tf->lbal = fis[4]; 158c6fd2807SJeff Garzik tf->lbam = fis[5]; 159c6fd2807SJeff Garzik tf->lbah = fis[6]; 160c6fd2807SJeff Garzik tf->device = fis[7]; 161c6fd2807SJeff Garzik 162c6fd2807SJeff Garzik tf->hob_lbal = fis[8]; 163c6fd2807SJeff Garzik tf->hob_lbam = fis[9]; 164c6fd2807SJeff Garzik tf->hob_lbah = fis[10]; 165c6fd2807SJeff Garzik 166c6fd2807SJeff Garzik tf->nsect = fis[12]; 167c6fd2807SJeff Garzik tf->hob_nsect = fis[13]; 168c6fd2807SJeff Garzik } 169c6fd2807SJeff Garzik 170c6fd2807SJeff Garzik static const u8 ata_rw_cmds[] = { 171c6fd2807SJeff Garzik /* pio multi */ 172c6fd2807SJeff Garzik ATA_CMD_READ_MULTI, 173c6fd2807SJeff Garzik ATA_CMD_WRITE_MULTI, 174c6fd2807SJeff Garzik ATA_CMD_READ_MULTI_EXT, 175c6fd2807SJeff Garzik ATA_CMD_WRITE_MULTI_EXT, 176c6fd2807SJeff Garzik 0, 177c6fd2807SJeff Garzik 0, 178c6fd2807SJeff Garzik 0, 179c6fd2807SJeff Garzik ATA_CMD_WRITE_MULTI_FUA_EXT, 180c6fd2807SJeff Garzik /* pio */ 181c6fd2807SJeff Garzik ATA_CMD_PIO_READ, 182c6fd2807SJeff Garzik ATA_CMD_PIO_WRITE, 183c6fd2807SJeff Garzik ATA_CMD_PIO_READ_EXT, 184c6fd2807SJeff Garzik ATA_CMD_PIO_WRITE_EXT, 185c6fd2807SJeff Garzik 0, 186c6fd2807SJeff Garzik 0, 187c6fd2807SJeff Garzik 0, 188c6fd2807SJeff Garzik 0, 189c6fd2807SJeff Garzik /* dma */ 190c6fd2807SJeff Garzik ATA_CMD_READ, 191c6fd2807SJeff Garzik ATA_CMD_WRITE, 192c6fd2807SJeff Garzik ATA_CMD_READ_EXT, 193c6fd2807SJeff Garzik ATA_CMD_WRITE_EXT, 194c6fd2807SJeff Garzik 0, 195c6fd2807SJeff Garzik 0, 196c6fd2807SJeff Garzik 0, 197c6fd2807SJeff Garzik ATA_CMD_WRITE_FUA_EXT 198c6fd2807SJeff Garzik }; 199c6fd2807SJeff Garzik 200c6fd2807SJeff Garzik /** 201c6fd2807SJeff Garzik * ata_rwcmd_protocol - set taskfile r/w commands and protocol 202bd056d7eSTejun Heo * @tf: command to examine and configure 203bd056d7eSTejun Heo * @dev: device tf belongs to 204c6fd2807SJeff Garzik * 205c6fd2807SJeff Garzik * Examine the device configuration and tf->flags to calculate 206c6fd2807SJeff Garzik * the proper read/write commands and protocol to use. 207c6fd2807SJeff Garzik * 208c6fd2807SJeff Garzik * LOCKING: 209c6fd2807SJeff Garzik * caller. 210c6fd2807SJeff Garzik */ 211bd056d7eSTejun Heo static int ata_rwcmd_protocol(struct ata_taskfile *tf, struct ata_device *dev) 212c6fd2807SJeff Garzik { 213c6fd2807SJeff Garzik u8 cmd; 214c6fd2807SJeff Garzik 215c6fd2807SJeff Garzik int index, fua, lba48, write; 216c6fd2807SJeff Garzik 217c6fd2807SJeff Garzik fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0; 218c6fd2807SJeff Garzik lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0; 219c6fd2807SJeff Garzik write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0; 220c6fd2807SJeff Garzik 221c6fd2807SJeff Garzik if (dev->flags & ATA_DFLAG_PIO) { 222c6fd2807SJeff Garzik tf->protocol = ATA_PROT_PIO; 223c6fd2807SJeff Garzik index = dev->multi_count ? 0 : 8; 224bd056d7eSTejun Heo } else if (lba48 && (dev->ap->flags & ATA_FLAG_PIO_LBA48)) { 225c6fd2807SJeff Garzik /* Unable to use DMA due to host limitation */ 226c6fd2807SJeff Garzik tf->protocol = ATA_PROT_PIO; 227c6fd2807SJeff Garzik index = dev->multi_count ? 0 : 8; 228c6fd2807SJeff Garzik } else { 229c6fd2807SJeff Garzik tf->protocol = ATA_PROT_DMA; 230c6fd2807SJeff Garzik index = 16; 231c6fd2807SJeff Garzik } 232c6fd2807SJeff Garzik 233c6fd2807SJeff Garzik cmd = ata_rw_cmds[index + fua + lba48 + write]; 234c6fd2807SJeff Garzik if (cmd) { 235c6fd2807SJeff Garzik tf->command = cmd; 236c6fd2807SJeff Garzik return 0; 237c6fd2807SJeff Garzik } 238c6fd2807SJeff Garzik return -1; 239c6fd2807SJeff Garzik } 240c6fd2807SJeff Garzik 241c6fd2807SJeff Garzik /** 24235b649feSTejun Heo * ata_tf_read_block - Read block address from ATA taskfile 24335b649feSTejun Heo * @tf: ATA taskfile of interest 24435b649feSTejun Heo * @dev: ATA device @tf belongs to 24535b649feSTejun Heo * 24635b649feSTejun Heo * LOCKING: 24735b649feSTejun Heo * None. 24835b649feSTejun Heo * 24935b649feSTejun Heo * Read block address from @tf. This function can handle all 25035b649feSTejun Heo * three address formats - LBA, LBA48 and CHS. tf->protocol and 25135b649feSTejun Heo * flags select the address format to use. 25235b649feSTejun Heo * 25335b649feSTejun Heo * RETURNS: 25435b649feSTejun Heo * Block address read from @tf. 25535b649feSTejun Heo */ 25635b649feSTejun Heo u64 ata_tf_read_block(struct ata_taskfile *tf, struct ata_device *dev) 25735b649feSTejun Heo { 25835b649feSTejun Heo u64 block = 0; 25935b649feSTejun Heo 26035b649feSTejun Heo if (tf->flags & ATA_TFLAG_LBA) { 26135b649feSTejun Heo if (tf->flags & ATA_TFLAG_LBA48) { 26235b649feSTejun Heo block |= (u64)tf->hob_lbah << 40; 26335b649feSTejun Heo block |= (u64)tf->hob_lbam << 32; 26435b649feSTejun Heo block |= tf->hob_lbal << 24; 26535b649feSTejun Heo } else 26635b649feSTejun Heo block |= (tf->device & 0xf) << 24; 26735b649feSTejun Heo 26835b649feSTejun Heo block |= tf->lbah << 16; 26935b649feSTejun Heo block |= tf->lbam << 8; 27035b649feSTejun Heo block |= tf->lbal; 27135b649feSTejun Heo } else { 27235b649feSTejun Heo u32 cyl, head, sect; 27335b649feSTejun Heo 27435b649feSTejun Heo cyl = tf->lbam | (tf->lbah << 8); 27535b649feSTejun Heo head = tf->device & 0xf; 27635b649feSTejun Heo sect = tf->lbal; 27735b649feSTejun Heo 27835b649feSTejun Heo block = (cyl * dev->heads + head) * dev->sectors + sect; 27935b649feSTejun Heo } 28035b649feSTejun Heo 28135b649feSTejun Heo return block; 28235b649feSTejun Heo } 28335b649feSTejun Heo 28435b649feSTejun Heo /** 285bd056d7eSTejun Heo * ata_build_rw_tf - Build ATA taskfile for given read/write request 286bd056d7eSTejun Heo * @tf: Target ATA taskfile 287bd056d7eSTejun Heo * @dev: ATA device @tf belongs to 288bd056d7eSTejun Heo * @block: Block address 289bd056d7eSTejun Heo * @n_block: Number of blocks 290bd056d7eSTejun Heo * @tf_flags: RW/FUA etc... 291bd056d7eSTejun Heo * @tag: tag 292bd056d7eSTejun Heo * 293bd056d7eSTejun Heo * LOCKING: 294bd056d7eSTejun Heo * None. 295bd056d7eSTejun Heo * 296bd056d7eSTejun Heo * Build ATA taskfile @tf for read/write request described by 297bd056d7eSTejun Heo * @block, @n_block, @tf_flags and @tag on @dev. 298bd056d7eSTejun Heo * 299bd056d7eSTejun Heo * RETURNS: 300bd056d7eSTejun Heo * 301bd056d7eSTejun Heo * 0 on success, -ERANGE if the request is too large for @dev, 302bd056d7eSTejun Heo * -EINVAL if the request is invalid. 303bd056d7eSTejun Heo */ 304bd056d7eSTejun Heo int ata_build_rw_tf(struct ata_taskfile *tf, struct ata_device *dev, 305bd056d7eSTejun Heo u64 block, u32 n_block, unsigned int tf_flags, 306bd056d7eSTejun Heo unsigned int tag) 307bd056d7eSTejun Heo { 308bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 309bd056d7eSTejun Heo tf->flags |= tf_flags; 310bd056d7eSTejun Heo 311bd056d7eSTejun Heo if ((dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ_OFF | 31270e6ad0cSTejun Heo ATA_DFLAG_NCQ)) == ATA_DFLAG_NCQ && 31370e6ad0cSTejun Heo likely(tag != ATA_TAG_INTERNAL)) { 314bd056d7eSTejun Heo /* yay, NCQ */ 315bd056d7eSTejun Heo if (!lba_48_ok(block, n_block)) 316bd056d7eSTejun Heo return -ERANGE; 317bd056d7eSTejun Heo 318bd056d7eSTejun Heo tf->protocol = ATA_PROT_NCQ; 319bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48; 320bd056d7eSTejun Heo 321bd056d7eSTejun Heo if (tf->flags & ATA_TFLAG_WRITE) 322bd056d7eSTejun Heo tf->command = ATA_CMD_FPDMA_WRITE; 323bd056d7eSTejun Heo else 324bd056d7eSTejun Heo tf->command = ATA_CMD_FPDMA_READ; 325bd056d7eSTejun Heo 326bd056d7eSTejun Heo tf->nsect = tag << 3; 327bd056d7eSTejun Heo tf->hob_feature = (n_block >> 8) & 0xff; 328bd056d7eSTejun Heo tf->feature = n_block & 0xff; 329bd056d7eSTejun Heo 330bd056d7eSTejun Heo tf->hob_lbah = (block >> 40) & 0xff; 331bd056d7eSTejun Heo tf->hob_lbam = (block >> 32) & 0xff; 332bd056d7eSTejun Heo tf->hob_lbal = (block >> 24) & 0xff; 333bd056d7eSTejun Heo tf->lbah = (block >> 16) & 0xff; 334bd056d7eSTejun Heo tf->lbam = (block >> 8) & 0xff; 335bd056d7eSTejun Heo tf->lbal = block & 0xff; 336bd056d7eSTejun Heo 337bd056d7eSTejun Heo tf->device = 1 << 6; 338bd056d7eSTejun Heo if (tf->flags & ATA_TFLAG_FUA) 339bd056d7eSTejun Heo tf->device |= 1 << 7; 340bd056d7eSTejun Heo } else if (dev->flags & ATA_DFLAG_LBA) { 341bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_LBA; 342bd056d7eSTejun Heo 343bd056d7eSTejun Heo if (lba_28_ok(block, n_block)) { 344bd056d7eSTejun Heo /* use LBA28 */ 345bd056d7eSTejun Heo tf->device |= (block >> 24) & 0xf; 346bd056d7eSTejun Heo } else if (lba_48_ok(block, n_block)) { 347bd056d7eSTejun Heo if (!(dev->flags & ATA_DFLAG_LBA48)) 348bd056d7eSTejun Heo return -ERANGE; 349bd056d7eSTejun Heo 350bd056d7eSTejun Heo /* use LBA48 */ 351bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_LBA48; 352bd056d7eSTejun Heo 353bd056d7eSTejun Heo tf->hob_nsect = (n_block >> 8) & 0xff; 354bd056d7eSTejun Heo 355bd056d7eSTejun Heo tf->hob_lbah = (block >> 40) & 0xff; 356bd056d7eSTejun Heo tf->hob_lbam = (block >> 32) & 0xff; 357bd056d7eSTejun Heo tf->hob_lbal = (block >> 24) & 0xff; 358bd056d7eSTejun Heo } else 359bd056d7eSTejun Heo /* request too large even for LBA48 */ 360bd056d7eSTejun Heo return -ERANGE; 361bd056d7eSTejun Heo 362bd056d7eSTejun Heo if (unlikely(ata_rwcmd_protocol(tf, dev) < 0)) 363bd056d7eSTejun Heo return -EINVAL; 364bd056d7eSTejun Heo 365bd056d7eSTejun Heo tf->nsect = n_block & 0xff; 366bd056d7eSTejun Heo 367bd056d7eSTejun Heo tf->lbah = (block >> 16) & 0xff; 368bd056d7eSTejun Heo tf->lbam = (block >> 8) & 0xff; 369bd056d7eSTejun Heo tf->lbal = block & 0xff; 370bd056d7eSTejun Heo 371bd056d7eSTejun Heo tf->device |= ATA_LBA; 372bd056d7eSTejun Heo } else { 373bd056d7eSTejun Heo /* CHS */ 374bd056d7eSTejun Heo u32 sect, head, cyl, track; 375bd056d7eSTejun Heo 376bd056d7eSTejun Heo /* The request -may- be too large for CHS addressing. */ 377bd056d7eSTejun Heo if (!lba_28_ok(block, n_block)) 378bd056d7eSTejun Heo return -ERANGE; 379bd056d7eSTejun Heo 380bd056d7eSTejun Heo if (unlikely(ata_rwcmd_protocol(tf, dev) < 0)) 381bd056d7eSTejun Heo return -EINVAL; 382bd056d7eSTejun Heo 383bd056d7eSTejun Heo /* Convert LBA to CHS */ 384bd056d7eSTejun Heo track = (u32)block / dev->sectors; 385bd056d7eSTejun Heo cyl = track / dev->heads; 386bd056d7eSTejun Heo head = track % dev->heads; 387bd056d7eSTejun Heo sect = (u32)block % dev->sectors + 1; 388bd056d7eSTejun Heo 389bd056d7eSTejun Heo DPRINTK("block %u track %u cyl %u head %u sect %u\n", 390bd056d7eSTejun Heo (u32)block, track, cyl, head, sect); 391bd056d7eSTejun Heo 392bd056d7eSTejun Heo /* Check whether the converted CHS can fit. 393bd056d7eSTejun Heo Cylinder: 0-65535 394bd056d7eSTejun Heo Head: 0-15 395bd056d7eSTejun Heo Sector: 1-255*/ 396bd056d7eSTejun Heo if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect)) 397bd056d7eSTejun Heo return -ERANGE; 398bd056d7eSTejun Heo 399bd056d7eSTejun Heo tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */ 400bd056d7eSTejun Heo tf->lbal = sect; 401bd056d7eSTejun Heo tf->lbam = cyl; 402bd056d7eSTejun Heo tf->lbah = cyl >> 8; 403bd056d7eSTejun Heo tf->device |= head; 404bd056d7eSTejun Heo } 405bd056d7eSTejun Heo 406bd056d7eSTejun Heo return 0; 407bd056d7eSTejun Heo } 408bd056d7eSTejun Heo 409bd056d7eSTejun Heo /** 410c6fd2807SJeff Garzik * ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask 411c6fd2807SJeff Garzik * @pio_mask: pio_mask 412c6fd2807SJeff Garzik * @mwdma_mask: mwdma_mask 413c6fd2807SJeff Garzik * @udma_mask: udma_mask 414c6fd2807SJeff Garzik * 415c6fd2807SJeff Garzik * Pack @pio_mask, @mwdma_mask and @udma_mask into a single 416c6fd2807SJeff Garzik * unsigned int xfer_mask. 417c6fd2807SJeff Garzik * 418c6fd2807SJeff Garzik * LOCKING: 419c6fd2807SJeff Garzik * None. 420c6fd2807SJeff Garzik * 421c6fd2807SJeff Garzik * RETURNS: 422c6fd2807SJeff Garzik * Packed xfer_mask. 423c6fd2807SJeff Garzik */ 424c6fd2807SJeff Garzik static unsigned int ata_pack_xfermask(unsigned int pio_mask, 425c6fd2807SJeff Garzik unsigned int mwdma_mask, 426c6fd2807SJeff Garzik unsigned int udma_mask) 427c6fd2807SJeff Garzik { 428c6fd2807SJeff Garzik return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) | 429c6fd2807SJeff Garzik ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) | 430c6fd2807SJeff Garzik ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA); 431c6fd2807SJeff Garzik } 432c6fd2807SJeff Garzik 433c6fd2807SJeff Garzik /** 434c6fd2807SJeff Garzik * ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks 435c6fd2807SJeff Garzik * @xfer_mask: xfer_mask to unpack 436c6fd2807SJeff Garzik * @pio_mask: resulting pio_mask 437c6fd2807SJeff Garzik * @mwdma_mask: resulting mwdma_mask 438c6fd2807SJeff Garzik * @udma_mask: resulting udma_mask 439c6fd2807SJeff Garzik * 440c6fd2807SJeff Garzik * Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask. 441c6fd2807SJeff Garzik * Any NULL distination masks will be ignored. 442c6fd2807SJeff Garzik */ 443c6fd2807SJeff Garzik static void ata_unpack_xfermask(unsigned int xfer_mask, 444c6fd2807SJeff Garzik unsigned int *pio_mask, 445c6fd2807SJeff Garzik unsigned int *mwdma_mask, 446c6fd2807SJeff Garzik unsigned int *udma_mask) 447c6fd2807SJeff Garzik { 448c6fd2807SJeff Garzik if (pio_mask) 449c6fd2807SJeff Garzik *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO; 450c6fd2807SJeff Garzik if (mwdma_mask) 451c6fd2807SJeff Garzik *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA; 452c6fd2807SJeff Garzik if (udma_mask) 453c6fd2807SJeff Garzik *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA; 454c6fd2807SJeff Garzik } 455c6fd2807SJeff Garzik 456c6fd2807SJeff Garzik static const struct ata_xfer_ent { 457c6fd2807SJeff Garzik int shift, bits; 458c6fd2807SJeff Garzik u8 base; 459c6fd2807SJeff Garzik } ata_xfer_tbl[] = { 460c6fd2807SJeff Garzik { ATA_SHIFT_PIO, ATA_BITS_PIO, XFER_PIO_0 }, 461c6fd2807SJeff Garzik { ATA_SHIFT_MWDMA, ATA_BITS_MWDMA, XFER_MW_DMA_0 }, 462c6fd2807SJeff Garzik { ATA_SHIFT_UDMA, ATA_BITS_UDMA, XFER_UDMA_0 }, 463c6fd2807SJeff Garzik { -1, }, 464c6fd2807SJeff Garzik }; 465c6fd2807SJeff Garzik 466c6fd2807SJeff Garzik /** 467c6fd2807SJeff Garzik * ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask 468c6fd2807SJeff Garzik * @xfer_mask: xfer_mask of interest 469c6fd2807SJeff Garzik * 470c6fd2807SJeff Garzik * Return matching XFER_* value for @xfer_mask. Only the highest 471c6fd2807SJeff Garzik * bit of @xfer_mask is considered. 472c6fd2807SJeff Garzik * 473c6fd2807SJeff Garzik * LOCKING: 474c6fd2807SJeff Garzik * None. 475c6fd2807SJeff Garzik * 476c6fd2807SJeff Garzik * RETURNS: 477c6fd2807SJeff Garzik * Matching XFER_* value, 0 if no match found. 478c6fd2807SJeff Garzik */ 479c6fd2807SJeff Garzik static u8 ata_xfer_mask2mode(unsigned int xfer_mask) 480c6fd2807SJeff Garzik { 481c6fd2807SJeff Garzik int highbit = fls(xfer_mask) - 1; 482c6fd2807SJeff Garzik const struct ata_xfer_ent *ent; 483c6fd2807SJeff Garzik 484c6fd2807SJeff Garzik for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 485c6fd2807SJeff Garzik if (highbit >= ent->shift && highbit < ent->shift + ent->bits) 486c6fd2807SJeff Garzik return ent->base + highbit - ent->shift; 487c6fd2807SJeff Garzik return 0; 488c6fd2807SJeff Garzik } 489c6fd2807SJeff Garzik 490c6fd2807SJeff Garzik /** 491c6fd2807SJeff Garzik * ata_xfer_mode2mask - Find matching xfer_mask for XFER_* 492c6fd2807SJeff Garzik * @xfer_mode: XFER_* of interest 493c6fd2807SJeff Garzik * 494c6fd2807SJeff Garzik * Return matching xfer_mask for @xfer_mode. 495c6fd2807SJeff Garzik * 496c6fd2807SJeff Garzik * LOCKING: 497c6fd2807SJeff Garzik * None. 498c6fd2807SJeff Garzik * 499c6fd2807SJeff Garzik * RETURNS: 500c6fd2807SJeff Garzik * Matching xfer_mask, 0 if no match found. 501c6fd2807SJeff Garzik */ 502c6fd2807SJeff Garzik static unsigned int ata_xfer_mode2mask(u8 xfer_mode) 503c6fd2807SJeff Garzik { 504c6fd2807SJeff Garzik const struct ata_xfer_ent *ent; 505c6fd2807SJeff Garzik 506c6fd2807SJeff Garzik for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 507c6fd2807SJeff Garzik if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits) 508c6fd2807SJeff Garzik return 1 << (ent->shift + xfer_mode - ent->base); 509c6fd2807SJeff Garzik return 0; 510c6fd2807SJeff Garzik } 511c6fd2807SJeff Garzik 512c6fd2807SJeff Garzik /** 513c6fd2807SJeff Garzik * ata_xfer_mode2shift - Find matching xfer_shift for XFER_* 514c6fd2807SJeff Garzik * @xfer_mode: XFER_* of interest 515c6fd2807SJeff Garzik * 516c6fd2807SJeff Garzik * Return matching xfer_shift for @xfer_mode. 517c6fd2807SJeff Garzik * 518c6fd2807SJeff Garzik * LOCKING: 519c6fd2807SJeff Garzik * None. 520c6fd2807SJeff Garzik * 521c6fd2807SJeff Garzik * RETURNS: 522c6fd2807SJeff Garzik * Matching xfer_shift, -1 if no match found. 523c6fd2807SJeff Garzik */ 524c6fd2807SJeff Garzik static int ata_xfer_mode2shift(unsigned int xfer_mode) 525c6fd2807SJeff Garzik { 526c6fd2807SJeff Garzik const struct ata_xfer_ent *ent; 527c6fd2807SJeff Garzik 528c6fd2807SJeff Garzik for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 529c6fd2807SJeff Garzik if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits) 530c6fd2807SJeff Garzik return ent->shift; 531c6fd2807SJeff Garzik return -1; 532c6fd2807SJeff Garzik } 533c6fd2807SJeff Garzik 534c6fd2807SJeff Garzik /** 535c6fd2807SJeff Garzik * ata_mode_string - convert xfer_mask to string 536c6fd2807SJeff Garzik * @xfer_mask: mask of bits supported; only highest bit counts. 537c6fd2807SJeff Garzik * 538c6fd2807SJeff Garzik * Determine string which represents the highest speed 539c6fd2807SJeff Garzik * (highest bit in @modemask). 540c6fd2807SJeff Garzik * 541c6fd2807SJeff Garzik * LOCKING: 542c6fd2807SJeff Garzik * None. 543c6fd2807SJeff Garzik * 544c6fd2807SJeff Garzik * RETURNS: 545c6fd2807SJeff Garzik * Constant C string representing highest speed listed in 546c6fd2807SJeff Garzik * @mode_mask, or the constant C string "<n/a>". 547c6fd2807SJeff Garzik */ 548c6fd2807SJeff Garzik static const char *ata_mode_string(unsigned int xfer_mask) 549c6fd2807SJeff Garzik { 550c6fd2807SJeff Garzik static const char * const xfer_mode_str[] = { 551c6fd2807SJeff Garzik "PIO0", 552c6fd2807SJeff Garzik "PIO1", 553c6fd2807SJeff Garzik "PIO2", 554c6fd2807SJeff Garzik "PIO3", 555c6fd2807SJeff Garzik "PIO4", 556b352e57dSAlan Cox "PIO5", 557b352e57dSAlan Cox "PIO6", 558c6fd2807SJeff Garzik "MWDMA0", 559c6fd2807SJeff Garzik "MWDMA1", 560c6fd2807SJeff Garzik "MWDMA2", 561b352e57dSAlan Cox "MWDMA3", 562b352e57dSAlan Cox "MWDMA4", 563c6fd2807SJeff Garzik "UDMA/16", 564c6fd2807SJeff Garzik "UDMA/25", 565c6fd2807SJeff Garzik "UDMA/33", 566c6fd2807SJeff Garzik "UDMA/44", 567c6fd2807SJeff Garzik "UDMA/66", 568c6fd2807SJeff Garzik "UDMA/100", 569c6fd2807SJeff Garzik "UDMA/133", 570c6fd2807SJeff Garzik "UDMA7", 571c6fd2807SJeff Garzik }; 572c6fd2807SJeff Garzik int highbit; 573c6fd2807SJeff Garzik 574c6fd2807SJeff Garzik highbit = fls(xfer_mask) - 1; 575c6fd2807SJeff Garzik if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str)) 576c6fd2807SJeff Garzik return xfer_mode_str[highbit]; 577c6fd2807SJeff Garzik return "<n/a>"; 578c6fd2807SJeff Garzik } 579c6fd2807SJeff Garzik 580c6fd2807SJeff Garzik static const char *sata_spd_string(unsigned int spd) 581c6fd2807SJeff Garzik { 582c6fd2807SJeff Garzik static const char * const spd_str[] = { 583c6fd2807SJeff Garzik "1.5 Gbps", 584c6fd2807SJeff Garzik "3.0 Gbps", 585c6fd2807SJeff Garzik }; 586c6fd2807SJeff Garzik 587c6fd2807SJeff Garzik if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str)) 588c6fd2807SJeff Garzik return "<unknown>"; 589c6fd2807SJeff Garzik return spd_str[spd - 1]; 590c6fd2807SJeff Garzik } 591c6fd2807SJeff Garzik 592c6fd2807SJeff Garzik void ata_dev_disable(struct ata_device *dev) 593c6fd2807SJeff Garzik { 594c6fd2807SJeff Garzik if (ata_dev_enabled(dev) && ata_msg_drv(dev->ap)) { 595c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "disabled\n"); 596c6fd2807SJeff Garzik dev->class++; 597c6fd2807SJeff Garzik } 598c6fd2807SJeff Garzik } 599c6fd2807SJeff Garzik 600c6fd2807SJeff Garzik /** 601c6fd2807SJeff Garzik * ata_pio_devchk - PATA device presence detection 602c6fd2807SJeff Garzik * @ap: ATA channel to examine 603c6fd2807SJeff Garzik * @device: Device to examine (starting at zero) 604c6fd2807SJeff Garzik * 605c6fd2807SJeff Garzik * This technique was originally described in 606c6fd2807SJeff Garzik * Hale Landis's ATADRVR (www.ata-atapi.com), and 607c6fd2807SJeff Garzik * later found its way into the ATA/ATAPI spec. 608c6fd2807SJeff Garzik * 609c6fd2807SJeff Garzik * Write a pattern to the ATA shadow registers, 610c6fd2807SJeff Garzik * and if a device is present, it will respond by 611c6fd2807SJeff Garzik * correctly storing and echoing back the 612c6fd2807SJeff Garzik * ATA shadow register contents. 613c6fd2807SJeff Garzik * 614c6fd2807SJeff Garzik * LOCKING: 615c6fd2807SJeff Garzik * caller. 616c6fd2807SJeff Garzik */ 617c6fd2807SJeff Garzik 618c6fd2807SJeff Garzik static unsigned int ata_pio_devchk(struct ata_port *ap, 619c6fd2807SJeff Garzik unsigned int device) 620c6fd2807SJeff Garzik { 621c6fd2807SJeff Garzik struct ata_ioports *ioaddr = &ap->ioaddr; 622c6fd2807SJeff Garzik u8 nsect, lbal; 623c6fd2807SJeff Garzik 624c6fd2807SJeff Garzik ap->ops->dev_select(ap, device); 625c6fd2807SJeff Garzik 626c6fd2807SJeff Garzik outb(0x55, ioaddr->nsect_addr); 627c6fd2807SJeff Garzik outb(0xaa, ioaddr->lbal_addr); 628c6fd2807SJeff Garzik 629c6fd2807SJeff Garzik outb(0xaa, ioaddr->nsect_addr); 630c6fd2807SJeff Garzik outb(0x55, ioaddr->lbal_addr); 631c6fd2807SJeff Garzik 632c6fd2807SJeff Garzik outb(0x55, ioaddr->nsect_addr); 633c6fd2807SJeff Garzik outb(0xaa, ioaddr->lbal_addr); 634c6fd2807SJeff Garzik 635c6fd2807SJeff Garzik nsect = inb(ioaddr->nsect_addr); 636c6fd2807SJeff Garzik lbal = inb(ioaddr->lbal_addr); 637c6fd2807SJeff Garzik 638c6fd2807SJeff Garzik if ((nsect == 0x55) && (lbal == 0xaa)) 639c6fd2807SJeff Garzik return 1; /* we found a device */ 640c6fd2807SJeff Garzik 641c6fd2807SJeff Garzik return 0; /* nothing found */ 642c6fd2807SJeff Garzik } 643c6fd2807SJeff Garzik 644c6fd2807SJeff Garzik /** 645c6fd2807SJeff Garzik * ata_mmio_devchk - PATA device presence detection 646c6fd2807SJeff Garzik * @ap: ATA channel to examine 647c6fd2807SJeff Garzik * @device: Device to examine (starting at zero) 648c6fd2807SJeff Garzik * 649c6fd2807SJeff Garzik * This technique was originally described in 650c6fd2807SJeff Garzik * Hale Landis's ATADRVR (www.ata-atapi.com), and 651c6fd2807SJeff Garzik * later found its way into the ATA/ATAPI spec. 652c6fd2807SJeff Garzik * 653c6fd2807SJeff Garzik * Write a pattern to the ATA shadow registers, 654c6fd2807SJeff Garzik * and if a device is present, it will respond by 655c6fd2807SJeff Garzik * correctly storing and echoing back the 656c6fd2807SJeff Garzik * ATA shadow register contents. 657c6fd2807SJeff Garzik * 658c6fd2807SJeff Garzik * LOCKING: 659c6fd2807SJeff Garzik * caller. 660c6fd2807SJeff Garzik */ 661c6fd2807SJeff Garzik 662c6fd2807SJeff Garzik static unsigned int ata_mmio_devchk(struct ata_port *ap, 663c6fd2807SJeff Garzik unsigned int device) 664c6fd2807SJeff Garzik { 665c6fd2807SJeff Garzik struct ata_ioports *ioaddr = &ap->ioaddr; 666c6fd2807SJeff Garzik u8 nsect, lbal; 667c6fd2807SJeff Garzik 668c6fd2807SJeff Garzik ap->ops->dev_select(ap, device); 669c6fd2807SJeff Garzik 670c6fd2807SJeff Garzik writeb(0x55, (void __iomem *) ioaddr->nsect_addr); 671c6fd2807SJeff Garzik writeb(0xaa, (void __iomem *) ioaddr->lbal_addr); 672c6fd2807SJeff Garzik 673c6fd2807SJeff Garzik writeb(0xaa, (void __iomem *) ioaddr->nsect_addr); 674c6fd2807SJeff Garzik writeb(0x55, (void __iomem *) ioaddr->lbal_addr); 675c6fd2807SJeff Garzik 676c6fd2807SJeff Garzik writeb(0x55, (void __iomem *) ioaddr->nsect_addr); 677c6fd2807SJeff Garzik writeb(0xaa, (void __iomem *) ioaddr->lbal_addr); 678c6fd2807SJeff Garzik 679c6fd2807SJeff Garzik nsect = readb((void __iomem *) ioaddr->nsect_addr); 680c6fd2807SJeff Garzik lbal = readb((void __iomem *) ioaddr->lbal_addr); 681c6fd2807SJeff Garzik 682c6fd2807SJeff Garzik if ((nsect == 0x55) && (lbal == 0xaa)) 683c6fd2807SJeff Garzik return 1; /* we found a device */ 684c6fd2807SJeff Garzik 685c6fd2807SJeff Garzik return 0; /* nothing found */ 686c6fd2807SJeff Garzik } 687c6fd2807SJeff Garzik 688c6fd2807SJeff Garzik /** 689c6fd2807SJeff Garzik * ata_devchk - PATA device presence detection 690c6fd2807SJeff Garzik * @ap: ATA channel to examine 691c6fd2807SJeff Garzik * @device: Device to examine (starting at zero) 692c6fd2807SJeff Garzik * 693c6fd2807SJeff Garzik * Dispatch ATA device presence detection, depending 694c6fd2807SJeff Garzik * on whether we are using PIO or MMIO to talk to the 695c6fd2807SJeff Garzik * ATA shadow registers. 696c6fd2807SJeff Garzik * 697c6fd2807SJeff Garzik * LOCKING: 698c6fd2807SJeff Garzik * caller. 699c6fd2807SJeff Garzik */ 700c6fd2807SJeff Garzik 701c6fd2807SJeff Garzik static unsigned int ata_devchk(struct ata_port *ap, 702c6fd2807SJeff Garzik unsigned int device) 703c6fd2807SJeff Garzik { 704c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_MMIO) 705c6fd2807SJeff Garzik return ata_mmio_devchk(ap, device); 706c6fd2807SJeff Garzik return ata_pio_devchk(ap, device); 707c6fd2807SJeff Garzik } 708c6fd2807SJeff Garzik 709c6fd2807SJeff Garzik /** 710c6fd2807SJeff Garzik * ata_dev_classify - determine device type based on ATA-spec signature 711c6fd2807SJeff Garzik * @tf: ATA taskfile register set for device to be identified 712c6fd2807SJeff Garzik * 713c6fd2807SJeff Garzik * Determine from taskfile register contents whether a device is 714c6fd2807SJeff Garzik * ATA or ATAPI, as per "Signature and persistence" section 715c6fd2807SJeff Garzik * of ATA/PI spec (volume 1, sect 5.14). 716c6fd2807SJeff Garzik * 717c6fd2807SJeff Garzik * LOCKING: 718c6fd2807SJeff Garzik * None. 719c6fd2807SJeff Garzik * 720c6fd2807SJeff Garzik * RETURNS: 721c6fd2807SJeff Garzik * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN 722c6fd2807SJeff Garzik * the event of failure. 723c6fd2807SJeff Garzik */ 724c6fd2807SJeff Garzik 725c6fd2807SJeff Garzik unsigned int ata_dev_classify(const struct ata_taskfile *tf) 726c6fd2807SJeff Garzik { 727c6fd2807SJeff Garzik /* Apple's open source Darwin code hints that some devices only 728c6fd2807SJeff Garzik * put a proper signature into the LBA mid/high registers, 729c6fd2807SJeff Garzik * So, we only check those. It's sufficient for uniqueness. 730c6fd2807SJeff Garzik */ 731c6fd2807SJeff Garzik 732c6fd2807SJeff Garzik if (((tf->lbam == 0) && (tf->lbah == 0)) || 733c6fd2807SJeff Garzik ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) { 734c6fd2807SJeff Garzik DPRINTK("found ATA device by sig\n"); 735c6fd2807SJeff Garzik return ATA_DEV_ATA; 736c6fd2807SJeff Garzik } 737c6fd2807SJeff Garzik 738c6fd2807SJeff Garzik if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) || 739c6fd2807SJeff Garzik ((tf->lbam == 0x69) && (tf->lbah == 0x96))) { 740c6fd2807SJeff Garzik DPRINTK("found ATAPI device by sig\n"); 741c6fd2807SJeff Garzik return ATA_DEV_ATAPI; 742c6fd2807SJeff Garzik } 743c6fd2807SJeff Garzik 744c6fd2807SJeff Garzik DPRINTK("unknown device\n"); 745c6fd2807SJeff Garzik return ATA_DEV_UNKNOWN; 746c6fd2807SJeff Garzik } 747c6fd2807SJeff Garzik 748c6fd2807SJeff Garzik /** 749c6fd2807SJeff Garzik * ata_dev_try_classify - Parse returned ATA device signature 750c6fd2807SJeff Garzik * @ap: ATA channel to examine 751c6fd2807SJeff Garzik * @device: Device to examine (starting at zero) 752c6fd2807SJeff Garzik * @r_err: Value of error register on completion 753c6fd2807SJeff Garzik * 754c6fd2807SJeff Garzik * After an event -- SRST, E.D.D., or SATA COMRESET -- occurs, 755c6fd2807SJeff Garzik * an ATA/ATAPI-defined set of values is placed in the ATA 756c6fd2807SJeff Garzik * shadow registers, indicating the results of device detection 757c6fd2807SJeff Garzik * and diagnostics. 758c6fd2807SJeff Garzik * 759c6fd2807SJeff Garzik * Select the ATA device, and read the values from the ATA shadow 760c6fd2807SJeff Garzik * registers. Then parse according to the Error register value, 761c6fd2807SJeff Garzik * and the spec-defined values examined by ata_dev_classify(). 762c6fd2807SJeff Garzik * 763c6fd2807SJeff Garzik * LOCKING: 764c6fd2807SJeff Garzik * caller. 765c6fd2807SJeff Garzik * 766c6fd2807SJeff Garzik * RETURNS: 767c6fd2807SJeff Garzik * Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE. 768c6fd2807SJeff Garzik */ 769c6fd2807SJeff Garzik 770c6fd2807SJeff Garzik static unsigned int 771c6fd2807SJeff Garzik ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err) 772c6fd2807SJeff Garzik { 773c6fd2807SJeff Garzik struct ata_taskfile tf; 774c6fd2807SJeff Garzik unsigned int class; 775c6fd2807SJeff Garzik u8 err; 776c6fd2807SJeff Garzik 777c6fd2807SJeff Garzik ap->ops->dev_select(ap, device); 778c6fd2807SJeff Garzik 779c6fd2807SJeff Garzik memset(&tf, 0, sizeof(tf)); 780c6fd2807SJeff Garzik 781c6fd2807SJeff Garzik ap->ops->tf_read(ap, &tf); 782c6fd2807SJeff Garzik err = tf.feature; 783c6fd2807SJeff Garzik if (r_err) 784c6fd2807SJeff Garzik *r_err = err; 785c6fd2807SJeff Garzik 78693590859SAlan Cox /* see if device passed diags: if master then continue and warn later */ 78793590859SAlan Cox if (err == 0 && device == 0) 78893590859SAlan Cox /* diagnostic fail : do nothing _YET_ */ 78993590859SAlan Cox ap->device[device].horkage |= ATA_HORKAGE_DIAGNOSTIC; 79093590859SAlan Cox else if (err == 1) 791c6fd2807SJeff Garzik /* do nothing */ ; 792c6fd2807SJeff Garzik else if ((device == 0) && (err == 0x81)) 793c6fd2807SJeff Garzik /* do nothing */ ; 794c6fd2807SJeff Garzik else 795c6fd2807SJeff Garzik return ATA_DEV_NONE; 796c6fd2807SJeff Garzik 797c6fd2807SJeff Garzik /* determine if device is ATA or ATAPI */ 798c6fd2807SJeff Garzik class = ata_dev_classify(&tf); 799c6fd2807SJeff Garzik 800c6fd2807SJeff Garzik if (class == ATA_DEV_UNKNOWN) 801c6fd2807SJeff Garzik return ATA_DEV_NONE; 802c6fd2807SJeff Garzik if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0)) 803c6fd2807SJeff Garzik return ATA_DEV_NONE; 804c6fd2807SJeff Garzik return class; 805c6fd2807SJeff Garzik } 806c6fd2807SJeff Garzik 807c6fd2807SJeff Garzik /** 808c6fd2807SJeff Garzik * ata_id_string - Convert IDENTIFY DEVICE page into string 809c6fd2807SJeff Garzik * @id: IDENTIFY DEVICE results we will examine 810c6fd2807SJeff Garzik * @s: string into which data is output 811c6fd2807SJeff Garzik * @ofs: offset into identify device page 812c6fd2807SJeff Garzik * @len: length of string to return. must be an even number. 813c6fd2807SJeff Garzik * 814c6fd2807SJeff Garzik * The strings in the IDENTIFY DEVICE page are broken up into 815c6fd2807SJeff Garzik * 16-bit chunks. Run through the string, and output each 816c6fd2807SJeff Garzik * 8-bit chunk linearly, regardless of platform. 817c6fd2807SJeff Garzik * 818c6fd2807SJeff Garzik * LOCKING: 819c6fd2807SJeff Garzik * caller. 820c6fd2807SJeff Garzik */ 821c6fd2807SJeff Garzik 822c6fd2807SJeff Garzik void ata_id_string(const u16 *id, unsigned char *s, 823c6fd2807SJeff Garzik unsigned int ofs, unsigned int len) 824c6fd2807SJeff Garzik { 825c6fd2807SJeff Garzik unsigned int c; 826c6fd2807SJeff Garzik 827c6fd2807SJeff Garzik while (len > 0) { 828c6fd2807SJeff Garzik c = id[ofs] >> 8; 829c6fd2807SJeff Garzik *s = c; 830c6fd2807SJeff Garzik s++; 831c6fd2807SJeff Garzik 832c6fd2807SJeff Garzik c = id[ofs] & 0xff; 833c6fd2807SJeff Garzik *s = c; 834c6fd2807SJeff Garzik s++; 835c6fd2807SJeff Garzik 836c6fd2807SJeff Garzik ofs++; 837c6fd2807SJeff Garzik len -= 2; 838c6fd2807SJeff Garzik } 839c6fd2807SJeff Garzik } 840c6fd2807SJeff Garzik 841c6fd2807SJeff Garzik /** 842c6fd2807SJeff Garzik * ata_id_c_string - Convert IDENTIFY DEVICE page into C string 843c6fd2807SJeff Garzik * @id: IDENTIFY DEVICE results we will examine 844c6fd2807SJeff Garzik * @s: string into which data is output 845c6fd2807SJeff Garzik * @ofs: offset into identify device page 846c6fd2807SJeff Garzik * @len: length of string to return. must be an odd number. 847c6fd2807SJeff Garzik * 848c6fd2807SJeff Garzik * This function is identical to ata_id_string except that it 849c6fd2807SJeff Garzik * trims trailing spaces and terminates the resulting string with 850c6fd2807SJeff Garzik * null. @len must be actual maximum length (even number) + 1. 851c6fd2807SJeff Garzik * 852c6fd2807SJeff Garzik * LOCKING: 853c6fd2807SJeff Garzik * caller. 854c6fd2807SJeff Garzik */ 855c6fd2807SJeff Garzik void ata_id_c_string(const u16 *id, unsigned char *s, 856c6fd2807SJeff Garzik unsigned int ofs, unsigned int len) 857c6fd2807SJeff Garzik { 858c6fd2807SJeff Garzik unsigned char *p; 859c6fd2807SJeff Garzik 860c6fd2807SJeff Garzik WARN_ON(!(len & 1)); 861c6fd2807SJeff Garzik 862c6fd2807SJeff Garzik ata_id_string(id, s, ofs, len - 1); 863c6fd2807SJeff Garzik 864c6fd2807SJeff Garzik p = s + strnlen(s, len - 1); 865c6fd2807SJeff Garzik while (p > s && p[-1] == ' ') 866c6fd2807SJeff Garzik p--; 867c6fd2807SJeff Garzik *p = '\0'; 868c6fd2807SJeff Garzik } 869c6fd2807SJeff Garzik 870c6fd2807SJeff Garzik static u64 ata_id_n_sectors(const u16 *id) 871c6fd2807SJeff Garzik { 872c6fd2807SJeff Garzik if (ata_id_has_lba(id)) { 873c6fd2807SJeff Garzik if (ata_id_has_lba48(id)) 874c6fd2807SJeff Garzik return ata_id_u64(id, 100); 875c6fd2807SJeff Garzik else 876c6fd2807SJeff Garzik return ata_id_u32(id, 60); 877c6fd2807SJeff Garzik } else { 878c6fd2807SJeff Garzik if (ata_id_current_chs_valid(id)) 879c6fd2807SJeff Garzik return ata_id_u32(id, 57); 880c6fd2807SJeff Garzik else 881c6fd2807SJeff Garzik return id[1] * id[3] * id[6]; 882c6fd2807SJeff Garzik } 883c6fd2807SJeff Garzik } 884c6fd2807SJeff Garzik 885c6fd2807SJeff Garzik /** 886c6fd2807SJeff Garzik * ata_noop_dev_select - Select device 0/1 on ATA bus 887c6fd2807SJeff Garzik * @ap: ATA channel to manipulate 888c6fd2807SJeff Garzik * @device: ATA device (numbered from zero) to select 889c6fd2807SJeff Garzik * 890c6fd2807SJeff Garzik * This function performs no actual function. 891c6fd2807SJeff Garzik * 892c6fd2807SJeff Garzik * May be used as the dev_select() entry in ata_port_operations. 893c6fd2807SJeff Garzik * 894c6fd2807SJeff Garzik * LOCKING: 895c6fd2807SJeff Garzik * caller. 896c6fd2807SJeff Garzik */ 897c6fd2807SJeff Garzik void ata_noop_dev_select (struct ata_port *ap, unsigned int device) 898c6fd2807SJeff Garzik { 899c6fd2807SJeff Garzik } 900c6fd2807SJeff Garzik 901c6fd2807SJeff Garzik 902c6fd2807SJeff Garzik /** 903c6fd2807SJeff Garzik * ata_std_dev_select - Select device 0/1 on ATA bus 904c6fd2807SJeff Garzik * @ap: ATA channel to manipulate 905c6fd2807SJeff Garzik * @device: ATA device (numbered from zero) to select 906c6fd2807SJeff Garzik * 907c6fd2807SJeff Garzik * Use the method defined in the ATA specification to 908c6fd2807SJeff Garzik * make either device 0, or device 1, active on the 909c6fd2807SJeff Garzik * ATA channel. Works with both PIO and MMIO. 910c6fd2807SJeff Garzik * 911c6fd2807SJeff Garzik * May be used as the dev_select() entry in ata_port_operations. 912c6fd2807SJeff Garzik * 913c6fd2807SJeff Garzik * LOCKING: 914c6fd2807SJeff Garzik * caller. 915c6fd2807SJeff Garzik */ 916c6fd2807SJeff Garzik 917c6fd2807SJeff Garzik void ata_std_dev_select (struct ata_port *ap, unsigned int device) 918c6fd2807SJeff Garzik { 919c6fd2807SJeff Garzik u8 tmp; 920c6fd2807SJeff Garzik 921c6fd2807SJeff Garzik if (device == 0) 922c6fd2807SJeff Garzik tmp = ATA_DEVICE_OBS; 923c6fd2807SJeff Garzik else 924c6fd2807SJeff Garzik tmp = ATA_DEVICE_OBS | ATA_DEV1; 925c6fd2807SJeff Garzik 926c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_MMIO) { 927c6fd2807SJeff Garzik writeb(tmp, (void __iomem *) ap->ioaddr.device_addr); 928c6fd2807SJeff Garzik } else { 929c6fd2807SJeff Garzik outb(tmp, ap->ioaddr.device_addr); 930c6fd2807SJeff Garzik } 931c6fd2807SJeff Garzik ata_pause(ap); /* needed; also flushes, for mmio */ 932c6fd2807SJeff Garzik } 933c6fd2807SJeff Garzik 934c6fd2807SJeff Garzik /** 935c6fd2807SJeff Garzik * ata_dev_select - Select device 0/1 on ATA bus 936c6fd2807SJeff Garzik * @ap: ATA channel to manipulate 937c6fd2807SJeff Garzik * @device: ATA device (numbered from zero) to select 938c6fd2807SJeff Garzik * @wait: non-zero to wait for Status register BSY bit to clear 939c6fd2807SJeff Garzik * @can_sleep: non-zero if context allows sleeping 940c6fd2807SJeff Garzik * 941c6fd2807SJeff Garzik * Use the method defined in the ATA specification to 942c6fd2807SJeff Garzik * make either device 0, or device 1, active on the 943c6fd2807SJeff Garzik * ATA channel. 944c6fd2807SJeff Garzik * 945c6fd2807SJeff Garzik * This is a high-level version of ata_std_dev_select(), 946c6fd2807SJeff Garzik * which additionally provides the services of inserting 947c6fd2807SJeff Garzik * the proper pauses and status polling, where needed. 948c6fd2807SJeff Garzik * 949c6fd2807SJeff Garzik * LOCKING: 950c6fd2807SJeff Garzik * caller. 951c6fd2807SJeff Garzik */ 952c6fd2807SJeff Garzik 953c6fd2807SJeff Garzik void ata_dev_select(struct ata_port *ap, unsigned int device, 954c6fd2807SJeff Garzik unsigned int wait, unsigned int can_sleep) 955c6fd2807SJeff Garzik { 956c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 957c6fd2807SJeff Garzik ata_port_printk(ap, KERN_INFO, "ata_dev_select: ENTER, ata%u: " 958c6fd2807SJeff Garzik "device %u, wait %u\n", ap->id, device, wait); 959c6fd2807SJeff Garzik 960c6fd2807SJeff Garzik if (wait) 961c6fd2807SJeff Garzik ata_wait_idle(ap); 962c6fd2807SJeff Garzik 963c6fd2807SJeff Garzik ap->ops->dev_select(ap, device); 964c6fd2807SJeff Garzik 965c6fd2807SJeff Garzik if (wait) { 966c6fd2807SJeff Garzik if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI) 967c6fd2807SJeff Garzik msleep(150); 968c6fd2807SJeff Garzik ata_wait_idle(ap); 969c6fd2807SJeff Garzik } 970c6fd2807SJeff Garzik } 971c6fd2807SJeff Garzik 972c6fd2807SJeff Garzik /** 973c6fd2807SJeff Garzik * ata_dump_id - IDENTIFY DEVICE info debugging output 974c6fd2807SJeff Garzik * @id: IDENTIFY DEVICE page to dump 975c6fd2807SJeff Garzik * 976c6fd2807SJeff Garzik * Dump selected 16-bit words from the given IDENTIFY DEVICE 977c6fd2807SJeff Garzik * page. 978c6fd2807SJeff Garzik * 979c6fd2807SJeff Garzik * LOCKING: 980c6fd2807SJeff Garzik * caller. 981c6fd2807SJeff Garzik */ 982c6fd2807SJeff Garzik 983c6fd2807SJeff Garzik static inline void ata_dump_id(const u16 *id) 984c6fd2807SJeff Garzik { 985c6fd2807SJeff Garzik DPRINTK("49==0x%04x " 986c6fd2807SJeff Garzik "53==0x%04x " 987c6fd2807SJeff Garzik "63==0x%04x " 988c6fd2807SJeff Garzik "64==0x%04x " 989c6fd2807SJeff Garzik "75==0x%04x \n", 990c6fd2807SJeff Garzik id[49], 991c6fd2807SJeff Garzik id[53], 992c6fd2807SJeff Garzik id[63], 993c6fd2807SJeff Garzik id[64], 994c6fd2807SJeff Garzik id[75]); 995c6fd2807SJeff Garzik DPRINTK("80==0x%04x " 996c6fd2807SJeff Garzik "81==0x%04x " 997c6fd2807SJeff Garzik "82==0x%04x " 998c6fd2807SJeff Garzik "83==0x%04x " 999c6fd2807SJeff Garzik "84==0x%04x \n", 1000c6fd2807SJeff Garzik id[80], 1001c6fd2807SJeff Garzik id[81], 1002c6fd2807SJeff Garzik id[82], 1003c6fd2807SJeff Garzik id[83], 1004c6fd2807SJeff Garzik id[84]); 1005c6fd2807SJeff Garzik DPRINTK("88==0x%04x " 1006c6fd2807SJeff Garzik "93==0x%04x\n", 1007c6fd2807SJeff Garzik id[88], 1008c6fd2807SJeff Garzik id[93]); 1009c6fd2807SJeff Garzik } 1010c6fd2807SJeff Garzik 1011c6fd2807SJeff Garzik /** 1012c6fd2807SJeff Garzik * ata_id_xfermask - Compute xfermask from the given IDENTIFY data 1013c6fd2807SJeff Garzik * @id: IDENTIFY data to compute xfer mask from 1014c6fd2807SJeff Garzik * 1015c6fd2807SJeff Garzik * Compute the xfermask for this device. This is not as trivial 1016c6fd2807SJeff Garzik * as it seems if we must consider early devices correctly. 1017c6fd2807SJeff Garzik * 1018c6fd2807SJeff Garzik * FIXME: pre IDE drive timing (do we care ?). 1019c6fd2807SJeff Garzik * 1020c6fd2807SJeff Garzik * LOCKING: 1021c6fd2807SJeff Garzik * None. 1022c6fd2807SJeff Garzik * 1023c6fd2807SJeff Garzik * RETURNS: 1024c6fd2807SJeff Garzik * Computed xfermask 1025c6fd2807SJeff Garzik */ 1026c6fd2807SJeff Garzik static unsigned int ata_id_xfermask(const u16 *id) 1027c6fd2807SJeff Garzik { 1028c6fd2807SJeff Garzik unsigned int pio_mask, mwdma_mask, udma_mask; 1029c6fd2807SJeff Garzik 1030c6fd2807SJeff Garzik /* Usual case. Word 53 indicates word 64 is valid */ 1031c6fd2807SJeff Garzik if (id[ATA_ID_FIELD_VALID] & (1 << 1)) { 1032c6fd2807SJeff Garzik pio_mask = id[ATA_ID_PIO_MODES] & 0x03; 1033c6fd2807SJeff Garzik pio_mask <<= 3; 1034c6fd2807SJeff Garzik pio_mask |= 0x7; 1035c6fd2807SJeff Garzik } else { 1036c6fd2807SJeff Garzik /* If word 64 isn't valid then Word 51 high byte holds 1037c6fd2807SJeff Garzik * the PIO timing number for the maximum. Turn it into 1038c6fd2807SJeff Garzik * a mask. 1039c6fd2807SJeff Garzik */ 10407a0f1c8aSLennert Buytenhek u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF; 104146767aebSAlan Cox if (mode < 5) /* Valid PIO range */ 104246767aebSAlan Cox pio_mask = (2 << mode) - 1; 104346767aebSAlan Cox else 104446767aebSAlan Cox pio_mask = 1; 1045c6fd2807SJeff Garzik 1046c6fd2807SJeff Garzik /* But wait.. there's more. Design your standards by 1047c6fd2807SJeff Garzik * committee and you too can get a free iordy field to 1048c6fd2807SJeff Garzik * process. However its the speeds not the modes that 1049c6fd2807SJeff Garzik * are supported... Note drivers using the timing API 1050c6fd2807SJeff Garzik * will get this right anyway 1051c6fd2807SJeff Garzik */ 1052c6fd2807SJeff Garzik } 1053c6fd2807SJeff Garzik 1054c6fd2807SJeff Garzik mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07; 1055c6fd2807SJeff Garzik 1056b352e57dSAlan Cox if (ata_id_is_cfa(id)) { 1057b352e57dSAlan Cox /* 1058b352e57dSAlan Cox * Process compact flash extended modes 1059b352e57dSAlan Cox */ 1060b352e57dSAlan Cox int pio = id[163] & 0x7; 1061b352e57dSAlan Cox int dma = (id[163] >> 3) & 7; 1062b352e57dSAlan Cox 1063b352e57dSAlan Cox if (pio) 1064b352e57dSAlan Cox pio_mask |= (1 << 5); 1065b352e57dSAlan Cox if (pio > 1) 1066b352e57dSAlan Cox pio_mask |= (1 << 6); 1067b352e57dSAlan Cox if (dma) 1068b352e57dSAlan Cox mwdma_mask |= (1 << 3); 1069b352e57dSAlan Cox if (dma > 1) 1070b352e57dSAlan Cox mwdma_mask |= (1 << 4); 1071b352e57dSAlan Cox } 1072b352e57dSAlan Cox 1073c6fd2807SJeff Garzik udma_mask = 0; 1074c6fd2807SJeff Garzik if (id[ATA_ID_FIELD_VALID] & (1 << 2)) 1075c6fd2807SJeff Garzik udma_mask = id[ATA_ID_UDMA_MODES] & 0xff; 1076c6fd2807SJeff Garzik 1077c6fd2807SJeff Garzik return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask); 1078c6fd2807SJeff Garzik } 1079c6fd2807SJeff Garzik 1080c6fd2807SJeff Garzik /** 1081c6fd2807SJeff Garzik * ata_port_queue_task - Queue port_task 1082c6fd2807SJeff Garzik * @ap: The ata_port to queue port_task for 1083c6fd2807SJeff Garzik * @fn: workqueue function to be scheduled 108465f27f38SDavid Howells * @data: data for @fn to use 1085c6fd2807SJeff Garzik * @delay: delay time for workqueue function 1086c6fd2807SJeff Garzik * 1087c6fd2807SJeff Garzik * Schedule @fn(@data) for execution after @delay jiffies using 1088c6fd2807SJeff Garzik * port_task. There is one port_task per port and it's the 1089c6fd2807SJeff Garzik * user(low level driver)'s responsibility to make sure that only 1090c6fd2807SJeff Garzik * one task is active at any given time. 1091c6fd2807SJeff Garzik * 1092c6fd2807SJeff Garzik * libata core layer takes care of synchronization between 1093c6fd2807SJeff Garzik * port_task and EH. ata_port_queue_task() may be ignored for EH 1094c6fd2807SJeff Garzik * synchronization. 1095c6fd2807SJeff Garzik * 1096c6fd2807SJeff Garzik * LOCKING: 1097c6fd2807SJeff Garzik * Inherited from caller. 1098c6fd2807SJeff Garzik */ 109965f27f38SDavid Howells void ata_port_queue_task(struct ata_port *ap, work_func_t fn, void *data, 1100c6fd2807SJeff Garzik unsigned long delay) 1101c6fd2807SJeff Garzik { 1102c6fd2807SJeff Garzik int rc; 1103c6fd2807SJeff Garzik 1104c6fd2807SJeff Garzik if (ap->pflags & ATA_PFLAG_FLUSH_PORT_TASK) 1105c6fd2807SJeff Garzik return; 1106c6fd2807SJeff Garzik 110765f27f38SDavid Howells PREPARE_DELAYED_WORK(&ap->port_task, fn); 110865f27f38SDavid Howells ap->port_task_data = data; 1109c6fd2807SJeff Garzik 1110c6fd2807SJeff Garzik rc = queue_delayed_work(ata_wq, &ap->port_task, delay); 1111c6fd2807SJeff Garzik 1112c6fd2807SJeff Garzik /* rc == 0 means that another user is using port task */ 1113c6fd2807SJeff Garzik WARN_ON(rc == 0); 1114c6fd2807SJeff Garzik } 1115c6fd2807SJeff Garzik 1116c6fd2807SJeff Garzik /** 1117c6fd2807SJeff Garzik * ata_port_flush_task - Flush port_task 1118c6fd2807SJeff Garzik * @ap: The ata_port to flush port_task for 1119c6fd2807SJeff Garzik * 1120c6fd2807SJeff Garzik * After this function completes, port_task is guranteed not to 1121c6fd2807SJeff Garzik * be running or scheduled. 1122c6fd2807SJeff Garzik * 1123c6fd2807SJeff Garzik * LOCKING: 1124c6fd2807SJeff Garzik * Kernel thread context (may sleep) 1125c6fd2807SJeff Garzik */ 1126c6fd2807SJeff Garzik void ata_port_flush_task(struct ata_port *ap) 1127c6fd2807SJeff Garzik { 1128c6fd2807SJeff Garzik unsigned long flags; 1129c6fd2807SJeff Garzik 1130c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 1131c6fd2807SJeff Garzik 1132c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1133c6fd2807SJeff Garzik ap->pflags |= ATA_PFLAG_FLUSH_PORT_TASK; 1134c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1135c6fd2807SJeff Garzik 1136c6fd2807SJeff Garzik DPRINTK("flush #1\n"); 1137c6fd2807SJeff Garzik flush_workqueue(ata_wq); 1138c6fd2807SJeff Garzik 1139c6fd2807SJeff Garzik /* 1140c6fd2807SJeff Garzik * At this point, if a task is running, it's guaranteed to see 1141c6fd2807SJeff Garzik * the FLUSH flag; thus, it will never queue pio tasks again. 1142c6fd2807SJeff Garzik * Cancel and flush. 1143c6fd2807SJeff Garzik */ 1144c6fd2807SJeff Garzik if (!cancel_delayed_work(&ap->port_task)) { 1145c6fd2807SJeff Garzik if (ata_msg_ctl(ap)) 1146c6fd2807SJeff Garzik ata_port_printk(ap, KERN_DEBUG, "%s: flush #2\n", 1147c6fd2807SJeff Garzik __FUNCTION__); 1148c6fd2807SJeff Garzik flush_workqueue(ata_wq); 1149c6fd2807SJeff Garzik } 1150c6fd2807SJeff Garzik 1151c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1152c6fd2807SJeff Garzik ap->pflags &= ~ATA_PFLAG_FLUSH_PORT_TASK; 1153c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1154c6fd2807SJeff Garzik 1155c6fd2807SJeff Garzik if (ata_msg_ctl(ap)) 1156c6fd2807SJeff Garzik ata_port_printk(ap, KERN_DEBUG, "%s: EXIT\n", __FUNCTION__); 1157c6fd2807SJeff Garzik } 1158c6fd2807SJeff Garzik 11597102d230SAdrian Bunk static void ata_qc_complete_internal(struct ata_queued_cmd *qc) 1160c6fd2807SJeff Garzik { 1161c6fd2807SJeff Garzik struct completion *waiting = qc->private_data; 1162c6fd2807SJeff Garzik 1163c6fd2807SJeff Garzik complete(waiting); 1164c6fd2807SJeff Garzik } 1165c6fd2807SJeff Garzik 1166c6fd2807SJeff Garzik /** 11672432697bSTejun Heo * ata_exec_internal_sg - execute libata internal command 1168c6fd2807SJeff Garzik * @dev: Device to which the command is sent 1169c6fd2807SJeff Garzik * @tf: Taskfile registers for the command and the result 1170c6fd2807SJeff Garzik * @cdb: CDB for packet command 1171c6fd2807SJeff Garzik * @dma_dir: Data tranfer direction of the command 11722432697bSTejun Heo * @sg: sg list for the data buffer of the command 11732432697bSTejun Heo * @n_elem: Number of sg entries 1174c6fd2807SJeff Garzik * 1175c6fd2807SJeff Garzik * Executes libata internal command with timeout. @tf contains 1176c6fd2807SJeff Garzik * command on entry and result on return. Timeout and error 1177c6fd2807SJeff Garzik * conditions are reported via return value. No recovery action 1178c6fd2807SJeff Garzik * is taken after a command times out. It's caller's duty to 1179c6fd2807SJeff Garzik * clean up after timeout. 1180c6fd2807SJeff Garzik * 1181c6fd2807SJeff Garzik * LOCKING: 1182c6fd2807SJeff Garzik * None. Should be called with kernel context, might sleep. 1183c6fd2807SJeff Garzik * 1184c6fd2807SJeff Garzik * RETURNS: 1185c6fd2807SJeff Garzik * Zero on success, AC_ERR_* mask on failure 1186c6fd2807SJeff Garzik */ 11872432697bSTejun Heo unsigned ata_exec_internal_sg(struct ata_device *dev, 1188c6fd2807SJeff Garzik struct ata_taskfile *tf, const u8 *cdb, 11892432697bSTejun Heo int dma_dir, struct scatterlist *sg, 11902432697bSTejun Heo unsigned int n_elem) 1191c6fd2807SJeff Garzik { 1192c6fd2807SJeff Garzik struct ata_port *ap = dev->ap; 1193c6fd2807SJeff Garzik u8 command = tf->command; 1194c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 1195c6fd2807SJeff Garzik unsigned int tag, preempted_tag; 1196c6fd2807SJeff Garzik u32 preempted_sactive, preempted_qc_active; 1197c6fd2807SJeff Garzik DECLARE_COMPLETION_ONSTACK(wait); 1198c6fd2807SJeff Garzik unsigned long flags; 1199c6fd2807SJeff Garzik unsigned int err_mask; 1200c6fd2807SJeff Garzik int rc; 1201c6fd2807SJeff Garzik 1202c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1203c6fd2807SJeff Garzik 1204c6fd2807SJeff Garzik /* no internal command while frozen */ 1205c6fd2807SJeff Garzik if (ap->pflags & ATA_PFLAG_FROZEN) { 1206c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1207c6fd2807SJeff Garzik return AC_ERR_SYSTEM; 1208c6fd2807SJeff Garzik } 1209c6fd2807SJeff Garzik 1210c6fd2807SJeff Garzik /* initialize internal qc */ 1211c6fd2807SJeff Garzik 1212c6fd2807SJeff Garzik /* XXX: Tag 0 is used for drivers with legacy EH as some 1213c6fd2807SJeff Garzik * drivers choke if any other tag is given. This breaks 1214c6fd2807SJeff Garzik * ata_tag_internal() test for those drivers. Don't use new 1215c6fd2807SJeff Garzik * EH stuff without converting to it. 1216c6fd2807SJeff Garzik */ 1217c6fd2807SJeff Garzik if (ap->ops->error_handler) 1218c6fd2807SJeff Garzik tag = ATA_TAG_INTERNAL; 1219c6fd2807SJeff Garzik else 1220c6fd2807SJeff Garzik tag = 0; 1221c6fd2807SJeff Garzik 1222c6fd2807SJeff Garzik if (test_and_set_bit(tag, &ap->qc_allocated)) 1223c6fd2807SJeff Garzik BUG(); 1224c6fd2807SJeff Garzik qc = __ata_qc_from_tag(ap, tag); 1225c6fd2807SJeff Garzik 1226c6fd2807SJeff Garzik qc->tag = tag; 1227c6fd2807SJeff Garzik qc->scsicmd = NULL; 1228c6fd2807SJeff Garzik qc->ap = ap; 1229c6fd2807SJeff Garzik qc->dev = dev; 1230c6fd2807SJeff Garzik ata_qc_reinit(qc); 1231c6fd2807SJeff Garzik 1232c6fd2807SJeff Garzik preempted_tag = ap->active_tag; 1233c6fd2807SJeff Garzik preempted_sactive = ap->sactive; 1234c6fd2807SJeff Garzik preempted_qc_active = ap->qc_active; 1235c6fd2807SJeff Garzik ap->active_tag = ATA_TAG_POISON; 1236c6fd2807SJeff Garzik ap->sactive = 0; 1237c6fd2807SJeff Garzik ap->qc_active = 0; 1238c6fd2807SJeff Garzik 1239c6fd2807SJeff Garzik /* prepare & issue qc */ 1240c6fd2807SJeff Garzik qc->tf = *tf; 1241c6fd2807SJeff Garzik if (cdb) 1242c6fd2807SJeff Garzik memcpy(qc->cdb, cdb, ATAPI_CDB_LEN); 1243c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_RESULT_TF; 1244c6fd2807SJeff Garzik qc->dma_dir = dma_dir; 1245c6fd2807SJeff Garzik if (dma_dir != DMA_NONE) { 12462432697bSTejun Heo unsigned int i, buflen = 0; 12472432697bSTejun Heo 12482432697bSTejun Heo for (i = 0; i < n_elem; i++) 12492432697bSTejun Heo buflen += sg[i].length; 12502432697bSTejun Heo 12512432697bSTejun Heo ata_sg_init(qc, sg, n_elem); 1252c6fd2807SJeff Garzik qc->nsect = buflen / ATA_SECT_SIZE; 125349c80429SBrian King qc->nbytes = buflen; 1254c6fd2807SJeff Garzik } 1255c6fd2807SJeff Garzik 1256c6fd2807SJeff Garzik qc->private_data = &wait; 1257c6fd2807SJeff Garzik qc->complete_fn = ata_qc_complete_internal; 1258c6fd2807SJeff Garzik 1259c6fd2807SJeff Garzik ata_qc_issue(qc); 1260c6fd2807SJeff Garzik 1261c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1262c6fd2807SJeff Garzik 1263c6fd2807SJeff Garzik rc = wait_for_completion_timeout(&wait, ata_probe_timeout); 1264c6fd2807SJeff Garzik 1265c6fd2807SJeff Garzik ata_port_flush_task(ap); 1266c6fd2807SJeff Garzik 1267c6fd2807SJeff Garzik if (!rc) { 1268c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1269c6fd2807SJeff Garzik 1270c6fd2807SJeff Garzik /* We're racing with irq here. If we lose, the 1271c6fd2807SJeff Garzik * following test prevents us from completing the qc 1272c6fd2807SJeff Garzik * twice. If we win, the port is frozen and will be 1273c6fd2807SJeff Garzik * cleaned up by ->post_internal_cmd(). 1274c6fd2807SJeff Garzik */ 1275c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_ACTIVE) { 1276c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_TIMEOUT; 1277c6fd2807SJeff Garzik 1278c6fd2807SJeff Garzik if (ap->ops->error_handler) 1279c6fd2807SJeff Garzik ata_port_freeze(ap); 1280c6fd2807SJeff Garzik else 1281c6fd2807SJeff Garzik ata_qc_complete(qc); 1282c6fd2807SJeff Garzik 1283c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 1284c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 1285c6fd2807SJeff Garzik "qc timeout (cmd 0x%x)\n", command); 1286c6fd2807SJeff Garzik } 1287c6fd2807SJeff Garzik 1288c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1289c6fd2807SJeff Garzik } 1290c6fd2807SJeff Garzik 1291c6fd2807SJeff Garzik /* do post_internal_cmd */ 1292c6fd2807SJeff Garzik if (ap->ops->post_internal_cmd) 1293c6fd2807SJeff Garzik ap->ops->post_internal_cmd(qc); 1294c6fd2807SJeff Garzik 1295c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_FAILED && !qc->err_mask) { 1296c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 1297c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 1298c6fd2807SJeff Garzik "zero err_mask for failed " 1299c6fd2807SJeff Garzik "internal command, assuming AC_ERR_OTHER\n"); 1300c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_OTHER; 1301c6fd2807SJeff Garzik } 1302c6fd2807SJeff Garzik 1303c6fd2807SJeff Garzik /* finish up */ 1304c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1305c6fd2807SJeff Garzik 1306c6fd2807SJeff Garzik *tf = qc->result_tf; 1307c6fd2807SJeff Garzik err_mask = qc->err_mask; 1308c6fd2807SJeff Garzik 1309c6fd2807SJeff Garzik ata_qc_free(qc); 1310c6fd2807SJeff Garzik ap->active_tag = preempted_tag; 1311c6fd2807SJeff Garzik ap->sactive = preempted_sactive; 1312c6fd2807SJeff Garzik ap->qc_active = preempted_qc_active; 1313c6fd2807SJeff Garzik 1314c6fd2807SJeff Garzik /* XXX - Some LLDDs (sata_mv) disable port on command failure. 1315c6fd2807SJeff Garzik * Until those drivers are fixed, we detect the condition 1316c6fd2807SJeff Garzik * here, fail the command with AC_ERR_SYSTEM and reenable the 1317c6fd2807SJeff Garzik * port. 1318c6fd2807SJeff Garzik * 1319c6fd2807SJeff Garzik * Note that this doesn't change any behavior as internal 1320c6fd2807SJeff Garzik * command failure results in disabling the device in the 1321c6fd2807SJeff Garzik * higher layer for LLDDs without new reset/EH callbacks. 1322c6fd2807SJeff Garzik * 1323c6fd2807SJeff Garzik * Kill the following code as soon as those drivers are fixed. 1324c6fd2807SJeff Garzik */ 1325c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_DISABLED) { 1326c6fd2807SJeff Garzik err_mask |= AC_ERR_SYSTEM; 1327c6fd2807SJeff Garzik ata_port_probe(ap); 1328c6fd2807SJeff Garzik } 1329c6fd2807SJeff Garzik 1330c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1331c6fd2807SJeff Garzik 1332c6fd2807SJeff Garzik return err_mask; 1333c6fd2807SJeff Garzik } 1334c6fd2807SJeff Garzik 1335c6fd2807SJeff Garzik /** 133633480a0eSTejun Heo * ata_exec_internal - execute libata internal command 13372432697bSTejun Heo * @dev: Device to which the command is sent 13382432697bSTejun Heo * @tf: Taskfile registers for the command and the result 13392432697bSTejun Heo * @cdb: CDB for packet command 13402432697bSTejun Heo * @dma_dir: Data tranfer direction of the command 13412432697bSTejun Heo * @buf: Data buffer of the command 13422432697bSTejun Heo * @buflen: Length of data buffer 13432432697bSTejun Heo * 13442432697bSTejun Heo * Wrapper around ata_exec_internal_sg() which takes simple 13452432697bSTejun Heo * buffer instead of sg list. 13462432697bSTejun Heo * 13472432697bSTejun Heo * LOCKING: 13482432697bSTejun Heo * None. Should be called with kernel context, might sleep. 13492432697bSTejun Heo * 13502432697bSTejun Heo * RETURNS: 13512432697bSTejun Heo * Zero on success, AC_ERR_* mask on failure 13522432697bSTejun Heo */ 13532432697bSTejun Heo unsigned ata_exec_internal(struct ata_device *dev, 13542432697bSTejun Heo struct ata_taskfile *tf, const u8 *cdb, 13552432697bSTejun Heo int dma_dir, void *buf, unsigned int buflen) 13562432697bSTejun Heo { 135733480a0eSTejun Heo struct scatterlist *psg = NULL, sg; 135833480a0eSTejun Heo unsigned int n_elem = 0; 13592432697bSTejun Heo 136033480a0eSTejun Heo if (dma_dir != DMA_NONE) { 136133480a0eSTejun Heo WARN_ON(!buf); 13622432697bSTejun Heo sg_init_one(&sg, buf, buflen); 136333480a0eSTejun Heo psg = &sg; 136433480a0eSTejun Heo n_elem++; 136533480a0eSTejun Heo } 13662432697bSTejun Heo 136733480a0eSTejun Heo return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem); 13682432697bSTejun Heo } 13692432697bSTejun Heo 13702432697bSTejun Heo /** 1371c6fd2807SJeff Garzik * ata_do_simple_cmd - execute simple internal command 1372c6fd2807SJeff Garzik * @dev: Device to which the command is sent 1373c6fd2807SJeff Garzik * @cmd: Opcode to execute 1374c6fd2807SJeff Garzik * 1375c6fd2807SJeff Garzik * Execute a 'simple' command, that only consists of the opcode 1376c6fd2807SJeff Garzik * 'cmd' itself, without filling any other registers 1377c6fd2807SJeff Garzik * 1378c6fd2807SJeff Garzik * LOCKING: 1379c6fd2807SJeff Garzik * Kernel thread context (may sleep). 1380c6fd2807SJeff Garzik * 1381c6fd2807SJeff Garzik * RETURNS: 1382c6fd2807SJeff Garzik * Zero on success, AC_ERR_* mask on failure 1383c6fd2807SJeff Garzik */ 1384c6fd2807SJeff Garzik unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd) 1385c6fd2807SJeff Garzik { 1386c6fd2807SJeff Garzik struct ata_taskfile tf; 1387c6fd2807SJeff Garzik 1388c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 1389c6fd2807SJeff Garzik 1390c6fd2807SJeff Garzik tf.command = cmd; 1391c6fd2807SJeff Garzik tf.flags |= ATA_TFLAG_DEVICE; 1392c6fd2807SJeff Garzik tf.protocol = ATA_PROT_NODATA; 1393c6fd2807SJeff Garzik 1394c6fd2807SJeff Garzik return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0); 1395c6fd2807SJeff Garzik } 1396c6fd2807SJeff Garzik 1397c6fd2807SJeff Garzik /** 1398c6fd2807SJeff Garzik * ata_pio_need_iordy - check if iordy needed 1399c6fd2807SJeff Garzik * @adev: ATA device 1400c6fd2807SJeff Garzik * 1401c6fd2807SJeff Garzik * Check if the current speed of the device requires IORDY. Used 1402c6fd2807SJeff Garzik * by various controllers for chip configuration. 1403c6fd2807SJeff Garzik */ 1404c6fd2807SJeff Garzik 1405c6fd2807SJeff Garzik unsigned int ata_pio_need_iordy(const struct ata_device *adev) 1406c6fd2807SJeff Garzik { 1407c6fd2807SJeff Garzik int pio; 1408c6fd2807SJeff Garzik int speed = adev->pio_mode - XFER_PIO_0; 1409c6fd2807SJeff Garzik 1410c6fd2807SJeff Garzik if (speed < 2) 1411c6fd2807SJeff Garzik return 0; 1412c6fd2807SJeff Garzik if (speed > 2) 1413c6fd2807SJeff Garzik return 1; 1414c6fd2807SJeff Garzik 1415c6fd2807SJeff Garzik /* If we have no drive specific rule, then PIO 2 is non IORDY */ 1416c6fd2807SJeff Garzik 1417c6fd2807SJeff Garzik if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */ 1418c6fd2807SJeff Garzik pio = adev->id[ATA_ID_EIDE_PIO]; 1419c6fd2807SJeff Garzik /* Is the speed faster than the drive allows non IORDY ? */ 1420c6fd2807SJeff Garzik if (pio) { 1421c6fd2807SJeff Garzik /* This is cycle times not frequency - watch the logic! */ 1422c6fd2807SJeff Garzik if (pio > 240) /* PIO2 is 240nS per cycle */ 1423c6fd2807SJeff Garzik return 1; 1424c6fd2807SJeff Garzik return 0; 1425c6fd2807SJeff Garzik } 1426c6fd2807SJeff Garzik } 1427c6fd2807SJeff Garzik return 0; 1428c6fd2807SJeff Garzik } 1429c6fd2807SJeff Garzik 1430c6fd2807SJeff Garzik /** 1431c6fd2807SJeff Garzik * ata_dev_read_id - Read ID data from the specified device 1432c6fd2807SJeff Garzik * @dev: target device 1433c6fd2807SJeff Garzik * @p_class: pointer to class of the target device (may be changed) 1434bff04647STejun Heo * @flags: ATA_READID_* flags 1435c6fd2807SJeff Garzik * @id: buffer to read IDENTIFY data into 1436c6fd2807SJeff Garzik * 1437c6fd2807SJeff Garzik * Read ID data from the specified device. ATA_CMD_ID_ATA is 1438c6fd2807SJeff Garzik * performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI 1439c6fd2807SJeff Garzik * devices. This function also issues ATA_CMD_INIT_DEV_PARAMS 1440c6fd2807SJeff Garzik * for pre-ATA4 drives. 1441c6fd2807SJeff Garzik * 1442c6fd2807SJeff Garzik * LOCKING: 1443c6fd2807SJeff Garzik * Kernel thread context (may sleep) 1444c6fd2807SJeff Garzik * 1445c6fd2807SJeff Garzik * RETURNS: 1446c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 1447c6fd2807SJeff Garzik */ 1448c6fd2807SJeff Garzik int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class, 1449bff04647STejun Heo unsigned int flags, u16 *id) 1450c6fd2807SJeff Garzik { 1451c6fd2807SJeff Garzik struct ata_port *ap = dev->ap; 1452c6fd2807SJeff Garzik unsigned int class = *p_class; 1453c6fd2807SJeff Garzik struct ata_taskfile tf; 1454c6fd2807SJeff Garzik unsigned int err_mask = 0; 1455c6fd2807SJeff Garzik const char *reason; 1456c6fd2807SJeff Garzik int rc; 1457c6fd2807SJeff Garzik 1458c6fd2807SJeff Garzik if (ata_msg_ctl(ap)) 1459c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER, host %u, dev %u\n", 1460c6fd2807SJeff Garzik __FUNCTION__, ap->id, dev->devno); 1461c6fd2807SJeff Garzik 1462c6fd2807SJeff Garzik ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */ 1463c6fd2807SJeff Garzik 1464c6fd2807SJeff Garzik retry: 1465c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 1466c6fd2807SJeff Garzik 1467c6fd2807SJeff Garzik switch (class) { 1468c6fd2807SJeff Garzik case ATA_DEV_ATA: 1469c6fd2807SJeff Garzik tf.command = ATA_CMD_ID_ATA; 1470c6fd2807SJeff Garzik break; 1471c6fd2807SJeff Garzik case ATA_DEV_ATAPI: 1472c6fd2807SJeff Garzik tf.command = ATA_CMD_ID_ATAPI; 1473c6fd2807SJeff Garzik break; 1474c6fd2807SJeff Garzik default: 1475c6fd2807SJeff Garzik rc = -ENODEV; 1476c6fd2807SJeff Garzik reason = "unsupported class"; 1477c6fd2807SJeff Garzik goto err_out; 1478c6fd2807SJeff Garzik } 1479c6fd2807SJeff Garzik 1480c6fd2807SJeff Garzik tf.protocol = ATA_PROT_PIO; 1481800b3996STejun Heo tf.flags |= ATA_TFLAG_POLLING; /* for polling presence detection */ 1482c6fd2807SJeff Garzik 1483c6fd2807SJeff Garzik err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE, 1484c6fd2807SJeff Garzik id, sizeof(id[0]) * ATA_ID_WORDS); 1485c6fd2807SJeff Garzik if (err_mask) { 1486800b3996STejun Heo if (err_mask & AC_ERR_NODEV_HINT) { 148755a8e2c8STejun Heo DPRINTK("ata%u.%d: NODEV after polling detection\n", 148855a8e2c8STejun Heo ap->id, dev->devno); 148955a8e2c8STejun Heo return -ENOENT; 149055a8e2c8STejun Heo } 149155a8e2c8STejun Heo 1492c6fd2807SJeff Garzik rc = -EIO; 1493c6fd2807SJeff Garzik reason = "I/O error"; 1494c6fd2807SJeff Garzik goto err_out; 1495c6fd2807SJeff Garzik } 1496c6fd2807SJeff Garzik 1497c6fd2807SJeff Garzik swap_buf_le16(id, ATA_ID_WORDS); 1498c6fd2807SJeff Garzik 1499c6fd2807SJeff Garzik /* sanity check */ 1500c6fd2807SJeff Garzik rc = -EINVAL; 1501c6fd2807SJeff Garzik reason = "device reports illegal type"; 15024a3381feSJeff Garzik 15034a3381feSJeff Garzik if (class == ATA_DEV_ATA) { 15044a3381feSJeff Garzik if (!ata_id_is_ata(id) && !ata_id_is_cfa(id)) 15054a3381feSJeff Garzik goto err_out; 15064a3381feSJeff Garzik } else { 15074a3381feSJeff Garzik if (ata_id_is_ata(id)) 1508c6fd2807SJeff Garzik goto err_out; 1509c6fd2807SJeff Garzik } 1510c6fd2807SJeff Garzik 1511bff04647STejun Heo if ((flags & ATA_READID_POSTRESET) && class == ATA_DEV_ATA) { 1512c6fd2807SJeff Garzik /* 1513c6fd2807SJeff Garzik * The exact sequence expected by certain pre-ATA4 drives is: 1514c6fd2807SJeff Garzik * SRST RESET 1515c6fd2807SJeff Garzik * IDENTIFY 1516c6fd2807SJeff Garzik * INITIALIZE DEVICE PARAMETERS 1517c6fd2807SJeff Garzik * anything else.. 1518c6fd2807SJeff Garzik * Some drives were very specific about that exact sequence. 1519c6fd2807SJeff Garzik */ 1520c6fd2807SJeff Garzik if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) { 1521c6fd2807SJeff Garzik err_mask = ata_dev_init_params(dev, id[3], id[6]); 1522c6fd2807SJeff Garzik if (err_mask) { 1523c6fd2807SJeff Garzik rc = -EIO; 1524c6fd2807SJeff Garzik reason = "INIT_DEV_PARAMS failed"; 1525c6fd2807SJeff Garzik goto err_out; 1526c6fd2807SJeff Garzik } 1527c6fd2807SJeff Garzik 1528c6fd2807SJeff Garzik /* current CHS translation info (id[53-58]) might be 1529c6fd2807SJeff Garzik * changed. reread the identify device info. 1530c6fd2807SJeff Garzik */ 1531bff04647STejun Heo flags &= ~ATA_READID_POSTRESET; 1532c6fd2807SJeff Garzik goto retry; 1533c6fd2807SJeff Garzik } 1534c6fd2807SJeff Garzik } 1535c6fd2807SJeff Garzik 1536c6fd2807SJeff Garzik *p_class = class; 1537c6fd2807SJeff Garzik 1538c6fd2807SJeff Garzik return 0; 1539c6fd2807SJeff Garzik 1540c6fd2807SJeff Garzik err_out: 1541c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 1542c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "failed to IDENTIFY " 1543c6fd2807SJeff Garzik "(%s, err_mask=0x%x)\n", reason, err_mask); 1544c6fd2807SJeff Garzik return rc; 1545c6fd2807SJeff Garzik } 1546c6fd2807SJeff Garzik 1547c6fd2807SJeff Garzik static inline u8 ata_dev_knobble(struct ata_device *dev) 1548c6fd2807SJeff Garzik { 1549c6fd2807SJeff Garzik return ((dev->ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id))); 1550c6fd2807SJeff Garzik } 1551c6fd2807SJeff Garzik 1552c6fd2807SJeff Garzik static void ata_dev_config_ncq(struct ata_device *dev, 1553c6fd2807SJeff Garzik char *desc, size_t desc_sz) 1554c6fd2807SJeff Garzik { 1555c6fd2807SJeff Garzik struct ata_port *ap = dev->ap; 1556c6fd2807SJeff Garzik int hdepth = 0, ddepth = ata_id_queue_depth(dev->id); 1557c6fd2807SJeff Garzik 1558c6fd2807SJeff Garzik if (!ata_id_has_ncq(dev->id)) { 1559c6fd2807SJeff Garzik desc[0] = '\0'; 1560c6fd2807SJeff Garzik return; 1561c6fd2807SJeff Garzik } 15626919a0a6SAlan Cox if (ata_device_blacklisted(dev) & ATA_HORKAGE_NONCQ) { 15636919a0a6SAlan Cox snprintf(desc, desc_sz, "NCQ (not used)"); 15646919a0a6SAlan Cox return; 15656919a0a6SAlan Cox } 1566c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_NCQ) { 1567cca3974eSJeff Garzik hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE - 1); 1568c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_NCQ; 1569c6fd2807SJeff Garzik } 1570c6fd2807SJeff Garzik 1571c6fd2807SJeff Garzik if (hdepth >= ddepth) 1572c6fd2807SJeff Garzik snprintf(desc, desc_sz, "NCQ (depth %d)", ddepth); 1573c6fd2807SJeff Garzik else 1574c6fd2807SJeff Garzik snprintf(desc, desc_sz, "NCQ (depth %d/%d)", hdepth, ddepth); 1575c6fd2807SJeff Garzik } 1576c6fd2807SJeff Garzik 1577c6fd2807SJeff Garzik static void ata_set_port_max_cmd_len(struct ata_port *ap) 1578c6fd2807SJeff Garzik { 1579c6fd2807SJeff Garzik int i; 1580c6fd2807SJeff Garzik 1581cca3974eSJeff Garzik if (ap->scsi_host) { 1582cca3974eSJeff Garzik unsigned int len = 0; 1583cca3974eSJeff Garzik 1584c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_DEVICES; i++) 1585cca3974eSJeff Garzik len = max(len, ap->device[i].cdb_len); 1586cca3974eSJeff Garzik 1587cca3974eSJeff Garzik ap->scsi_host->max_cmd_len = len; 1588c6fd2807SJeff Garzik } 1589c6fd2807SJeff Garzik } 1590c6fd2807SJeff Garzik 1591c6fd2807SJeff Garzik /** 1592c6fd2807SJeff Garzik * ata_dev_configure - Configure the specified ATA/ATAPI device 1593c6fd2807SJeff Garzik * @dev: Target device to configure 1594c6fd2807SJeff Garzik * 1595c6fd2807SJeff Garzik * Configure @dev according to @dev->id. Generic and low-level 1596c6fd2807SJeff Garzik * driver specific fixups are also applied. 1597c6fd2807SJeff Garzik * 1598c6fd2807SJeff Garzik * LOCKING: 1599c6fd2807SJeff Garzik * Kernel thread context (may sleep) 1600c6fd2807SJeff Garzik * 1601c6fd2807SJeff Garzik * RETURNS: 1602c6fd2807SJeff Garzik * 0 on success, -errno otherwise 1603c6fd2807SJeff Garzik */ 1604efdaedc4STejun Heo int ata_dev_configure(struct ata_device *dev) 1605c6fd2807SJeff Garzik { 1606c6fd2807SJeff Garzik struct ata_port *ap = dev->ap; 1607efdaedc4STejun Heo int print_info = ap->eh_context.i.flags & ATA_EHI_PRINTINFO; 1608c6fd2807SJeff Garzik const u16 *id = dev->id; 1609c6fd2807SJeff Garzik unsigned int xfer_mask; 1610b352e57dSAlan Cox char revbuf[7]; /* XYZ-99\0 */ 1611c6fd2807SJeff Garzik int rc; 1612c6fd2807SJeff Garzik 1613c6fd2807SJeff Garzik if (!ata_dev_enabled(dev) && ata_msg_info(ap)) { 1614c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, 1615c6fd2807SJeff Garzik "%s: ENTER/EXIT (host %u, dev %u) -- nodev\n", 1616c6fd2807SJeff Garzik __FUNCTION__, ap->id, dev->devno); 1617c6fd2807SJeff Garzik return 0; 1618c6fd2807SJeff Garzik } 1619c6fd2807SJeff Garzik 1620c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 1621c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER, host %u, dev %u\n", 1622c6fd2807SJeff Garzik __FUNCTION__, ap->id, dev->devno); 1623c6fd2807SJeff Garzik 1624c6fd2807SJeff Garzik /* print device capabilities */ 1625c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 1626c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_DEBUG, 1627c6fd2807SJeff Garzik "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x " 1628c6fd2807SJeff Garzik "85:%04x 86:%04x 87:%04x 88:%04x\n", 1629c6fd2807SJeff Garzik __FUNCTION__, 1630c6fd2807SJeff Garzik id[49], id[82], id[83], id[84], 1631c6fd2807SJeff Garzik id[85], id[86], id[87], id[88]); 1632c6fd2807SJeff Garzik 1633c6fd2807SJeff Garzik /* initialize to-be-configured parameters */ 1634c6fd2807SJeff Garzik dev->flags &= ~ATA_DFLAG_CFG_MASK; 1635c6fd2807SJeff Garzik dev->max_sectors = 0; 1636c6fd2807SJeff Garzik dev->cdb_len = 0; 1637c6fd2807SJeff Garzik dev->n_sectors = 0; 1638c6fd2807SJeff Garzik dev->cylinders = 0; 1639c6fd2807SJeff Garzik dev->heads = 0; 1640c6fd2807SJeff Garzik dev->sectors = 0; 1641c6fd2807SJeff Garzik 1642c6fd2807SJeff Garzik /* 1643c6fd2807SJeff Garzik * common ATA, ATAPI feature tests 1644c6fd2807SJeff Garzik */ 1645c6fd2807SJeff Garzik 1646c6fd2807SJeff Garzik /* find max transfer mode; for printk only */ 1647c6fd2807SJeff Garzik xfer_mask = ata_id_xfermask(id); 1648c6fd2807SJeff Garzik 1649c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 1650c6fd2807SJeff Garzik ata_dump_id(id); 1651c6fd2807SJeff Garzik 1652c6fd2807SJeff Garzik /* ATA-specific feature tests */ 1653c6fd2807SJeff Garzik if (dev->class == ATA_DEV_ATA) { 1654b352e57dSAlan Cox if (ata_id_is_cfa(id)) { 1655b352e57dSAlan Cox if (id[162] & 1) /* CPRM may make this media unusable */ 1656b352e57dSAlan Cox ata_dev_printk(dev, KERN_WARNING, "ata%u: device %u supports DRM functions and may not be fully accessable.\n", 1657b352e57dSAlan Cox ap->id, dev->devno); 1658b352e57dSAlan Cox snprintf(revbuf, 7, "CFA"); 1659b352e57dSAlan Cox } 1660b352e57dSAlan Cox else 1661b352e57dSAlan Cox snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id)); 1662b352e57dSAlan Cox 1663c6fd2807SJeff Garzik dev->n_sectors = ata_id_n_sectors(id); 1664c6fd2807SJeff Garzik 1665c6fd2807SJeff Garzik if (ata_id_has_lba(id)) { 1666c6fd2807SJeff Garzik const char *lba_desc; 1667c6fd2807SJeff Garzik char ncq_desc[20]; 1668c6fd2807SJeff Garzik 1669c6fd2807SJeff Garzik lba_desc = "LBA"; 1670c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_LBA; 1671c6fd2807SJeff Garzik if (ata_id_has_lba48(id)) { 1672c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_LBA48; 1673c6fd2807SJeff Garzik lba_desc = "LBA48"; 16746fc49adbSTejun Heo 16756fc49adbSTejun Heo if (dev->n_sectors >= (1UL << 28) && 16766fc49adbSTejun Heo ata_id_has_flush_ext(id)) 16776fc49adbSTejun Heo dev->flags |= ATA_DFLAG_FLUSH_EXT; 1678c6fd2807SJeff Garzik } 1679c6fd2807SJeff Garzik 1680c6fd2807SJeff Garzik /* config NCQ */ 1681c6fd2807SJeff Garzik ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc)); 1682c6fd2807SJeff Garzik 1683c6fd2807SJeff Garzik /* print device info to dmesg */ 1684c6fd2807SJeff Garzik if (ata_msg_drv(ap) && print_info) 1685b352e57dSAlan Cox ata_dev_printk(dev, KERN_INFO, "%s, " 1686c6fd2807SJeff Garzik "max %s, %Lu sectors: %s %s\n", 1687b352e57dSAlan Cox revbuf, 1688c6fd2807SJeff Garzik ata_mode_string(xfer_mask), 1689c6fd2807SJeff Garzik (unsigned long long)dev->n_sectors, 1690c6fd2807SJeff Garzik lba_desc, ncq_desc); 1691c6fd2807SJeff Garzik } else { 1692c6fd2807SJeff Garzik /* CHS */ 1693c6fd2807SJeff Garzik 1694c6fd2807SJeff Garzik /* Default translation */ 1695c6fd2807SJeff Garzik dev->cylinders = id[1]; 1696c6fd2807SJeff Garzik dev->heads = id[3]; 1697c6fd2807SJeff Garzik dev->sectors = id[6]; 1698c6fd2807SJeff Garzik 1699c6fd2807SJeff Garzik if (ata_id_current_chs_valid(id)) { 1700c6fd2807SJeff Garzik /* Current CHS translation is valid. */ 1701c6fd2807SJeff Garzik dev->cylinders = id[54]; 1702c6fd2807SJeff Garzik dev->heads = id[55]; 1703c6fd2807SJeff Garzik dev->sectors = id[56]; 1704c6fd2807SJeff Garzik } 1705c6fd2807SJeff Garzik 1706c6fd2807SJeff Garzik /* print device info to dmesg */ 1707c6fd2807SJeff Garzik if (ata_msg_drv(ap) && print_info) 1708b352e57dSAlan Cox ata_dev_printk(dev, KERN_INFO, "%s, " 1709c6fd2807SJeff Garzik "max %s, %Lu sectors: CHS %u/%u/%u\n", 1710b352e57dSAlan Cox revbuf, 1711c6fd2807SJeff Garzik ata_mode_string(xfer_mask), 1712c6fd2807SJeff Garzik (unsigned long long)dev->n_sectors, 1713c6fd2807SJeff Garzik dev->cylinders, dev->heads, 1714c6fd2807SJeff Garzik dev->sectors); 1715c6fd2807SJeff Garzik } 1716c6fd2807SJeff Garzik 1717c6fd2807SJeff Garzik if (dev->id[59] & 0x100) { 1718c6fd2807SJeff Garzik dev->multi_count = dev->id[59] & 0xff; 1719c6fd2807SJeff Garzik if (ata_msg_drv(ap) && print_info) 1720c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, 1721c6fd2807SJeff Garzik "ata%u: dev %u multi count %u\n", 1722c6fd2807SJeff Garzik ap->id, dev->devno, dev->multi_count); 1723c6fd2807SJeff Garzik } 1724c6fd2807SJeff Garzik 1725c6fd2807SJeff Garzik dev->cdb_len = 16; 1726c6fd2807SJeff Garzik } 1727c6fd2807SJeff Garzik 1728c6fd2807SJeff Garzik /* ATAPI-specific feature tests */ 1729c6fd2807SJeff Garzik else if (dev->class == ATA_DEV_ATAPI) { 1730c6fd2807SJeff Garzik char *cdb_intr_string = ""; 1731c6fd2807SJeff Garzik 1732c6fd2807SJeff Garzik rc = atapi_cdb_len(id); 1733c6fd2807SJeff Garzik if ((rc < 12) || (rc > ATAPI_CDB_LEN)) { 1734c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 1735c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 1736c6fd2807SJeff Garzik "unsupported CDB len\n"); 1737c6fd2807SJeff Garzik rc = -EINVAL; 1738c6fd2807SJeff Garzik goto err_out_nosup; 1739c6fd2807SJeff Garzik } 1740c6fd2807SJeff Garzik dev->cdb_len = (unsigned int) rc; 1741c6fd2807SJeff Garzik 1742c6fd2807SJeff Garzik if (ata_id_cdb_intr(dev->id)) { 1743c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_CDB_INTR; 1744c6fd2807SJeff Garzik cdb_intr_string = ", CDB intr"; 1745c6fd2807SJeff Garzik } 1746c6fd2807SJeff Garzik 1747c6fd2807SJeff Garzik /* print device info to dmesg */ 1748c6fd2807SJeff Garzik if (ata_msg_drv(ap) && print_info) 1749c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "ATAPI, max %s%s\n", 1750c6fd2807SJeff Garzik ata_mode_string(xfer_mask), 1751c6fd2807SJeff Garzik cdb_intr_string); 1752c6fd2807SJeff Garzik } 1753c6fd2807SJeff Garzik 1754914ed354STejun Heo /* determine max_sectors */ 1755914ed354STejun Heo dev->max_sectors = ATA_MAX_SECTORS; 1756914ed354STejun Heo if (dev->flags & ATA_DFLAG_LBA48) 1757914ed354STejun Heo dev->max_sectors = ATA_MAX_SECTORS_LBA48; 1758914ed354STejun Heo 175993590859SAlan Cox if (dev->horkage & ATA_HORKAGE_DIAGNOSTIC) { 176093590859SAlan Cox /* Let the user know. We don't want to disallow opens for 176193590859SAlan Cox rescue purposes, or in case the vendor is just a blithering 176293590859SAlan Cox idiot */ 176393590859SAlan Cox if (print_info) { 176493590859SAlan Cox ata_dev_printk(dev, KERN_WARNING, 176593590859SAlan Cox "Drive reports diagnostics failure. This may indicate a drive\n"); 176693590859SAlan Cox ata_dev_printk(dev, KERN_WARNING, 176793590859SAlan Cox "fault or invalid emulation. Contact drive vendor for information.\n"); 176893590859SAlan Cox } 176993590859SAlan Cox } 177093590859SAlan Cox 1771c6fd2807SJeff Garzik ata_set_port_max_cmd_len(ap); 1772c6fd2807SJeff Garzik 1773c6fd2807SJeff Garzik /* limit bridge transfers to udma5, 200 sectors */ 1774c6fd2807SJeff Garzik if (ata_dev_knobble(dev)) { 1775c6fd2807SJeff Garzik if (ata_msg_drv(ap) && print_info) 1776c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, 1777c6fd2807SJeff Garzik "applying bridge limits\n"); 1778c6fd2807SJeff Garzik dev->udma_mask &= ATA_UDMA5; 1779c6fd2807SJeff Garzik dev->max_sectors = ATA_MAX_SECTORS; 1780c6fd2807SJeff Garzik } 1781c6fd2807SJeff Garzik 1782c6fd2807SJeff Garzik if (ap->ops->dev_config) 1783c6fd2807SJeff Garzik ap->ops->dev_config(ap, dev); 1784c6fd2807SJeff Garzik 1785c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 1786c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_DEBUG, "%s: EXIT, drv_stat = 0x%x\n", 1787c6fd2807SJeff Garzik __FUNCTION__, ata_chk_status(ap)); 1788c6fd2807SJeff Garzik return 0; 1789c6fd2807SJeff Garzik 1790c6fd2807SJeff Garzik err_out_nosup: 1791c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 1792c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_DEBUG, 1793c6fd2807SJeff Garzik "%s: EXIT, err\n", __FUNCTION__); 1794c6fd2807SJeff Garzik return rc; 1795c6fd2807SJeff Garzik } 1796c6fd2807SJeff Garzik 1797c6fd2807SJeff Garzik /** 1798c6fd2807SJeff Garzik * ata_bus_probe - Reset and probe ATA bus 1799c6fd2807SJeff Garzik * @ap: Bus to probe 1800c6fd2807SJeff Garzik * 1801c6fd2807SJeff Garzik * Master ATA bus probing function. Initiates a hardware-dependent 1802c6fd2807SJeff Garzik * bus reset, then attempts to identify any devices found on 1803c6fd2807SJeff Garzik * the bus. 1804c6fd2807SJeff Garzik * 1805c6fd2807SJeff Garzik * LOCKING: 1806c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 1807c6fd2807SJeff Garzik * 1808c6fd2807SJeff Garzik * RETURNS: 1809c6fd2807SJeff Garzik * Zero on success, negative errno otherwise. 1810c6fd2807SJeff Garzik */ 1811c6fd2807SJeff Garzik 1812c6fd2807SJeff Garzik int ata_bus_probe(struct ata_port *ap) 1813c6fd2807SJeff Garzik { 1814c6fd2807SJeff Garzik unsigned int classes[ATA_MAX_DEVICES]; 1815c6fd2807SJeff Garzik int tries[ATA_MAX_DEVICES]; 1816c6fd2807SJeff Garzik int i, rc, down_xfermask; 1817c6fd2807SJeff Garzik struct ata_device *dev; 1818c6fd2807SJeff Garzik 1819c6fd2807SJeff Garzik ata_port_probe(ap); 1820c6fd2807SJeff Garzik 1821c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_DEVICES; i++) 1822c6fd2807SJeff Garzik tries[i] = ATA_PROBE_MAX_TRIES; 1823c6fd2807SJeff Garzik 1824c6fd2807SJeff Garzik retry: 1825c6fd2807SJeff Garzik down_xfermask = 0; 1826c6fd2807SJeff Garzik 1827c6fd2807SJeff Garzik /* reset and determine device classes */ 1828c6fd2807SJeff Garzik ap->ops->phy_reset(ap); 1829c6fd2807SJeff Garzik 1830c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_DEVICES; i++) { 1831c6fd2807SJeff Garzik dev = &ap->device[i]; 1832c6fd2807SJeff Garzik 1833c6fd2807SJeff Garzik if (!(ap->flags & ATA_FLAG_DISABLED) && 1834c6fd2807SJeff Garzik dev->class != ATA_DEV_UNKNOWN) 1835c6fd2807SJeff Garzik classes[dev->devno] = dev->class; 1836c6fd2807SJeff Garzik else 1837c6fd2807SJeff Garzik classes[dev->devno] = ATA_DEV_NONE; 1838c6fd2807SJeff Garzik 1839c6fd2807SJeff Garzik dev->class = ATA_DEV_UNKNOWN; 1840c6fd2807SJeff Garzik } 1841c6fd2807SJeff Garzik 1842c6fd2807SJeff Garzik ata_port_probe(ap); 1843c6fd2807SJeff Garzik 1844c6fd2807SJeff Garzik /* after the reset the device state is PIO 0 and the controller 1845c6fd2807SJeff Garzik state is undefined. Record the mode */ 1846c6fd2807SJeff Garzik 1847c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_DEVICES; i++) 1848c6fd2807SJeff Garzik ap->device[i].pio_mode = XFER_PIO_0; 1849c6fd2807SJeff Garzik 1850c6fd2807SJeff Garzik /* read IDENTIFY page and configure devices */ 1851c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_DEVICES; i++) { 1852c6fd2807SJeff Garzik dev = &ap->device[i]; 1853c6fd2807SJeff Garzik 1854c6fd2807SJeff Garzik if (tries[i]) 1855c6fd2807SJeff Garzik dev->class = classes[i]; 1856c6fd2807SJeff Garzik 1857c6fd2807SJeff Garzik if (!ata_dev_enabled(dev)) 1858c6fd2807SJeff Garzik continue; 1859c6fd2807SJeff Garzik 1860bff04647STejun Heo rc = ata_dev_read_id(dev, &dev->class, ATA_READID_POSTRESET, 1861bff04647STejun Heo dev->id); 1862c6fd2807SJeff Garzik if (rc) 1863c6fd2807SJeff Garzik goto fail; 1864c6fd2807SJeff Garzik 1865efdaedc4STejun Heo ap->eh_context.i.flags |= ATA_EHI_PRINTINFO; 1866efdaedc4STejun Heo rc = ata_dev_configure(dev); 1867efdaedc4STejun Heo ap->eh_context.i.flags &= ~ATA_EHI_PRINTINFO; 1868c6fd2807SJeff Garzik if (rc) 1869c6fd2807SJeff Garzik goto fail; 1870c6fd2807SJeff Garzik } 1871c6fd2807SJeff Garzik 1872c6fd2807SJeff Garzik /* configure transfer mode */ 1873c6fd2807SJeff Garzik rc = ata_set_mode(ap, &dev); 1874c6fd2807SJeff Garzik if (rc) { 1875c6fd2807SJeff Garzik down_xfermask = 1; 1876c6fd2807SJeff Garzik goto fail; 1877c6fd2807SJeff Garzik } 1878c6fd2807SJeff Garzik 1879c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_DEVICES; i++) 1880c6fd2807SJeff Garzik if (ata_dev_enabled(&ap->device[i])) 1881c6fd2807SJeff Garzik return 0; 1882c6fd2807SJeff Garzik 1883c6fd2807SJeff Garzik /* no device present, disable port */ 1884c6fd2807SJeff Garzik ata_port_disable(ap); 1885c6fd2807SJeff Garzik ap->ops->port_disable(ap); 1886c6fd2807SJeff Garzik return -ENODEV; 1887c6fd2807SJeff Garzik 1888c6fd2807SJeff Garzik fail: 1889c6fd2807SJeff Garzik switch (rc) { 1890c6fd2807SJeff Garzik case -EINVAL: 1891c6fd2807SJeff Garzik case -ENODEV: 1892c6fd2807SJeff Garzik tries[dev->devno] = 0; 1893c6fd2807SJeff Garzik break; 1894c6fd2807SJeff Garzik case -EIO: 1895c6fd2807SJeff Garzik sata_down_spd_limit(ap); 1896c6fd2807SJeff Garzik /* fall through */ 1897c6fd2807SJeff Garzik default: 1898c6fd2807SJeff Garzik tries[dev->devno]--; 1899c6fd2807SJeff Garzik if (down_xfermask && 1900c6fd2807SJeff Garzik ata_down_xfermask_limit(dev, tries[dev->devno] == 1)) 1901c6fd2807SJeff Garzik tries[dev->devno] = 0; 1902c6fd2807SJeff Garzik } 1903c6fd2807SJeff Garzik 1904c6fd2807SJeff Garzik if (!tries[dev->devno]) { 1905c6fd2807SJeff Garzik ata_down_xfermask_limit(dev, 1); 1906c6fd2807SJeff Garzik ata_dev_disable(dev); 1907c6fd2807SJeff Garzik } 1908c6fd2807SJeff Garzik 1909c6fd2807SJeff Garzik goto retry; 1910c6fd2807SJeff Garzik } 1911c6fd2807SJeff Garzik 1912c6fd2807SJeff Garzik /** 1913c6fd2807SJeff Garzik * ata_port_probe - Mark port as enabled 1914c6fd2807SJeff Garzik * @ap: Port for which we indicate enablement 1915c6fd2807SJeff Garzik * 1916c6fd2807SJeff Garzik * Modify @ap data structure such that the system 1917c6fd2807SJeff Garzik * thinks that the entire port is enabled. 1918c6fd2807SJeff Garzik * 1919cca3974eSJeff Garzik * LOCKING: host lock, or some other form of 1920c6fd2807SJeff Garzik * serialization. 1921c6fd2807SJeff Garzik */ 1922c6fd2807SJeff Garzik 1923c6fd2807SJeff Garzik void ata_port_probe(struct ata_port *ap) 1924c6fd2807SJeff Garzik { 1925c6fd2807SJeff Garzik ap->flags &= ~ATA_FLAG_DISABLED; 1926c6fd2807SJeff Garzik } 1927c6fd2807SJeff Garzik 1928c6fd2807SJeff Garzik /** 1929c6fd2807SJeff Garzik * sata_print_link_status - Print SATA link status 1930c6fd2807SJeff Garzik * @ap: SATA port to printk link status about 1931c6fd2807SJeff Garzik * 1932c6fd2807SJeff Garzik * This function prints link speed and status of a SATA link. 1933c6fd2807SJeff Garzik * 1934c6fd2807SJeff Garzik * LOCKING: 1935c6fd2807SJeff Garzik * None. 1936c6fd2807SJeff Garzik */ 1937c6fd2807SJeff Garzik static void sata_print_link_status(struct ata_port *ap) 1938c6fd2807SJeff Garzik { 1939c6fd2807SJeff Garzik u32 sstatus, scontrol, tmp; 1940c6fd2807SJeff Garzik 1941c6fd2807SJeff Garzik if (sata_scr_read(ap, SCR_STATUS, &sstatus)) 1942c6fd2807SJeff Garzik return; 1943c6fd2807SJeff Garzik sata_scr_read(ap, SCR_CONTROL, &scontrol); 1944c6fd2807SJeff Garzik 1945c6fd2807SJeff Garzik if (ata_port_online(ap)) { 1946c6fd2807SJeff Garzik tmp = (sstatus >> 4) & 0xf; 1947c6fd2807SJeff Garzik ata_port_printk(ap, KERN_INFO, 1948c6fd2807SJeff Garzik "SATA link up %s (SStatus %X SControl %X)\n", 1949c6fd2807SJeff Garzik sata_spd_string(tmp), sstatus, scontrol); 1950c6fd2807SJeff Garzik } else { 1951c6fd2807SJeff Garzik ata_port_printk(ap, KERN_INFO, 1952c6fd2807SJeff Garzik "SATA link down (SStatus %X SControl %X)\n", 1953c6fd2807SJeff Garzik sstatus, scontrol); 1954c6fd2807SJeff Garzik } 1955c6fd2807SJeff Garzik } 1956c6fd2807SJeff Garzik 1957c6fd2807SJeff Garzik /** 1958c6fd2807SJeff Garzik * __sata_phy_reset - Wake/reset a low-level SATA PHY 1959c6fd2807SJeff Garzik * @ap: SATA port associated with target SATA PHY. 1960c6fd2807SJeff Garzik * 1961c6fd2807SJeff Garzik * This function issues commands to standard SATA Sxxx 1962c6fd2807SJeff Garzik * PHY registers, to wake up the phy (and device), and 1963c6fd2807SJeff Garzik * clear any reset condition. 1964c6fd2807SJeff Garzik * 1965c6fd2807SJeff Garzik * LOCKING: 1966c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 1967c6fd2807SJeff Garzik * 1968c6fd2807SJeff Garzik */ 1969c6fd2807SJeff Garzik void __sata_phy_reset(struct ata_port *ap) 1970c6fd2807SJeff Garzik { 1971c6fd2807SJeff Garzik u32 sstatus; 1972c6fd2807SJeff Garzik unsigned long timeout = jiffies + (HZ * 5); 1973c6fd2807SJeff Garzik 1974c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_SATA_RESET) { 1975c6fd2807SJeff Garzik /* issue phy wake/reset */ 1976c6fd2807SJeff Garzik sata_scr_write_flush(ap, SCR_CONTROL, 0x301); 1977c6fd2807SJeff Garzik /* Couldn't find anything in SATA I/II specs, but 1978c6fd2807SJeff Garzik * AHCI-1.1 10.4.2 says at least 1 ms. */ 1979c6fd2807SJeff Garzik mdelay(1); 1980c6fd2807SJeff Garzik } 1981c6fd2807SJeff Garzik /* phy wake/clear reset */ 1982c6fd2807SJeff Garzik sata_scr_write_flush(ap, SCR_CONTROL, 0x300); 1983c6fd2807SJeff Garzik 1984c6fd2807SJeff Garzik /* wait for phy to become ready, if necessary */ 1985c6fd2807SJeff Garzik do { 1986c6fd2807SJeff Garzik msleep(200); 1987c6fd2807SJeff Garzik sata_scr_read(ap, SCR_STATUS, &sstatus); 1988c6fd2807SJeff Garzik if ((sstatus & 0xf) != 1) 1989c6fd2807SJeff Garzik break; 1990c6fd2807SJeff Garzik } while (time_before(jiffies, timeout)); 1991c6fd2807SJeff Garzik 1992c6fd2807SJeff Garzik /* print link status */ 1993c6fd2807SJeff Garzik sata_print_link_status(ap); 1994c6fd2807SJeff Garzik 1995c6fd2807SJeff Garzik /* TODO: phy layer with polling, timeouts, etc. */ 1996c6fd2807SJeff Garzik if (!ata_port_offline(ap)) 1997c6fd2807SJeff Garzik ata_port_probe(ap); 1998c6fd2807SJeff Garzik else 1999c6fd2807SJeff Garzik ata_port_disable(ap); 2000c6fd2807SJeff Garzik 2001c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_DISABLED) 2002c6fd2807SJeff Garzik return; 2003c6fd2807SJeff Garzik 2004c6fd2807SJeff Garzik if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) { 2005c6fd2807SJeff Garzik ata_port_disable(ap); 2006c6fd2807SJeff Garzik return; 2007c6fd2807SJeff Garzik } 2008c6fd2807SJeff Garzik 2009c6fd2807SJeff Garzik ap->cbl = ATA_CBL_SATA; 2010c6fd2807SJeff Garzik } 2011c6fd2807SJeff Garzik 2012c6fd2807SJeff Garzik /** 2013c6fd2807SJeff Garzik * sata_phy_reset - Reset SATA bus. 2014c6fd2807SJeff Garzik * @ap: SATA port associated with target SATA PHY. 2015c6fd2807SJeff Garzik * 2016c6fd2807SJeff Garzik * This function resets the SATA bus, and then probes 2017c6fd2807SJeff Garzik * the bus for devices. 2018c6fd2807SJeff Garzik * 2019c6fd2807SJeff Garzik * LOCKING: 2020c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 2021c6fd2807SJeff Garzik * 2022c6fd2807SJeff Garzik */ 2023c6fd2807SJeff Garzik void sata_phy_reset(struct ata_port *ap) 2024c6fd2807SJeff Garzik { 2025c6fd2807SJeff Garzik __sata_phy_reset(ap); 2026c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_DISABLED) 2027c6fd2807SJeff Garzik return; 2028c6fd2807SJeff Garzik ata_bus_reset(ap); 2029c6fd2807SJeff Garzik } 2030c6fd2807SJeff Garzik 2031c6fd2807SJeff Garzik /** 2032c6fd2807SJeff Garzik * ata_dev_pair - return other device on cable 2033c6fd2807SJeff Garzik * @adev: device 2034c6fd2807SJeff Garzik * 2035c6fd2807SJeff Garzik * Obtain the other device on the same cable, or if none is 2036c6fd2807SJeff Garzik * present NULL is returned 2037c6fd2807SJeff Garzik */ 2038c6fd2807SJeff Garzik 2039c6fd2807SJeff Garzik struct ata_device *ata_dev_pair(struct ata_device *adev) 2040c6fd2807SJeff Garzik { 2041c6fd2807SJeff Garzik struct ata_port *ap = adev->ap; 2042c6fd2807SJeff Garzik struct ata_device *pair = &ap->device[1 - adev->devno]; 2043c6fd2807SJeff Garzik if (!ata_dev_enabled(pair)) 2044c6fd2807SJeff Garzik return NULL; 2045c6fd2807SJeff Garzik return pair; 2046c6fd2807SJeff Garzik } 2047c6fd2807SJeff Garzik 2048c6fd2807SJeff Garzik /** 2049c6fd2807SJeff Garzik * ata_port_disable - Disable port. 2050c6fd2807SJeff Garzik * @ap: Port to be disabled. 2051c6fd2807SJeff Garzik * 2052c6fd2807SJeff Garzik * Modify @ap data structure such that the system 2053c6fd2807SJeff Garzik * thinks that the entire port is disabled, and should 2054c6fd2807SJeff Garzik * never attempt to probe or communicate with devices 2055c6fd2807SJeff Garzik * on this port. 2056c6fd2807SJeff Garzik * 2057cca3974eSJeff Garzik * LOCKING: host lock, or some other form of 2058c6fd2807SJeff Garzik * serialization. 2059c6fd2807SJeff Garzik */ 2060c6fd2807SJeff Garzik 2061c6fd2807SJeff Garzik void ata_port_disable(struct ata_port *ap) 2062c6fd2807SJeff Garzik { 2063c6fd2807SJeff Garzik ap->device[0].class = ATA_DEV_NONE; 2064c6fd2807SJeff Garzik ap->device[1].class = ATA_DEV_NONE; 2065c6fd2807SJeff Garzik ap->flags |= ATA_FLAG_DISABLED; 2066c6fd2807SJeff Garzik } 2067c6fd2807SJeff Garzik 2068c6fd2807SJeff Garzik /** 2069c6fd2807SJeff Garzik * sata_down_spd_limit - adjust SATA spd limit downward 2070c6fd2807SJeff Garzik * @ap: Port to adjust SATA spd limit for 2071c6fd2807SJeff Garzik * 2072c6fd2807SJeff Garzik * Adjust SATA spd limit of @ap downward. Note that this 2073c6fd2807SJeff Garzik * function only adjusts the limit. The change must be applied 2074c6fd2807SJeff Garzik * using sata_set_spd(). 2075c6fd2807SJeff Garzik * 2076c6fd2807SJeff Garzik * LOCKING: 2077c6fd2807SJeff Garzik * Inherited from caller. 2078c6fd2807SJeff Garzik * 2079c6fd2807SJeff Garzik * RETURNS: 2080c6fd2807SJeff Garzik * 0 on success, negative errno on failure 2081c6fd2807SJeff Garzik */ 2082c6fd2807SJeff Garzik int sata_down_spd_limit(struct ata_port *ap) 2083c6fd2807SJeff Garzik { 2084c6fd2807SJeff Garzik u32 sstatus, spd, mask; 2085c6fd2807SJeff Garzik int rc, highbit; 2086c6fd2807SJeff Garzik 2087c6fd2807SJeff Garzik rc = sata_scr_read(ap, SCR_STATUS, &sstatus); 2088c6fd2807SJeff Garzik if (rc) 2089c6fd2807SJeff Garzik return rc; 2090c6fd2807SJeff Garzik 2091c6fd2807SJeff Garzik mask = ap->sata_spd_limit; 2092c6fd2807SJeff Garzik if (mask <= 1) 2093c6fd2807SJeff Garzik return -EINVAL; 2094c6fd2807SJeff Garzik highbit = fls(mask) - 1; 2095c6fd2807SJeff Garzik mask &= ~(1 << highbit); 2096c6fd2807SJeff Garzik 2097c6fd2807SJeff Garzik spd = (sstatus >> 4) & 0xf; 2098c6fd2807SJeff Garzik if (spd <= 1) 2099c6fd2807SJeff Garzik return -EINVAL; 2100c6fd2807SJeff Garzik spd--; 2101c6fd2807SJeff Garzik mask &= (1 << spd) - 1; 2102c6fd2807SJeff Garzik if (!mask) 2103c6fd2807SJeff Garzik return -EINVAL; 2104c6fd2807SJeff Garzik 2105c6fd2807SJeff Garzik ap->sata_spd_limit = mask; 2106c6fd2807SJeff Garzik 2107c6fd2807SJeff Garzik ata_port_printk(ap, KERN_WARNING, "limiting SATA link speed to %s\n", 2108c6fd2807SJeff Garzik sata_spd_string(fls(mask))); 2109c6fd2807SJeff Garzik 2110c6fd2807SJeff Garzik return 0; 2111c6fd2807SJeff Garzik } 2112c6fd2807SJeff Garzik 2113c6fd2807SJeff Garzik static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol) 2114c6fd2807SJeff Garzik { 2115c6fd2807SJeff Garzik u32 spd, limit; 2116c6fd2807SJeff Garzik 2117c6fd2807SJeff Garzik if (ap->sata_spd_limit == UINT_MAX) 2118c6fd2807SJeff Garzik limit = 0; 2119c6fd2807SJeff Garzik else 2120c6fd2807SJeff Garzik limit = fls(ap->sata_spd_limit); 2121c6fd2807SJeff Garzik 2122c6fd2807SJeff Garzik spd = (*scontrol >> 4) & 0xf; 2123c6fd2807SJeff Garzik *scontrol = (*scontrol & ~0xf0) | ((limit & 0xf) << 4); 2124c6fd2807SJeff Garzik 2125c6fd2807SJeff Garzik return spd != limit; 2126c6fd2807SJeff Garzik } 2127c6fd2807SJeff Garzik 2128c6fd2807SJeff Garzik /** 2129c6fd2807SJeff Garzik * sata_set_spd_needed - is SATA spd configuration needed 2130c6fd2807SJeff Garzik * @ap: Port in question 2131c6fd2807SJeff Garzik * 2132c6fd2807SJeff Garzik * Test whether the spd limit in SControl matches 2133c6fd2807SJeff Garzik * @ap->sata_spd_limit. This function is used to determine 2134c6fd2807SJeff Garzik * whether hardreset is necessary to apply SATA spd 2135c6fd2807SJeff Garzik * configuration. 2136c6fd2807SJeff Garzik * 2137c6fd2807SJeff Garzik * LOCKING: 2138c6fd2807SJeff Garzik * Inherited from caller. 2139c6fd2807SJeff Garzik * 2140c6fd2807SJeff Garzik * RETURNS: 2141c6fd2807SJeff Garzik * 1 if SATA spd configuration is needed, 0 otherwise. 2142c6fd2807SJeff Garzik */ 2143c6fd2807SJeff Garzik int sata_set_spd_needed(struct ata_port *ap) 2144c6fd2807SJeff Garzik { 2145c6fd2807SJeff Garzik u32 scontrol; 2146c6fd2807SJeff Garzik 2147c6fd2807SJeff Garzik if (sata_scr_read(ap, SCR_CONTROL, &scontrol)) 2148c6fd2807SJeff Garzik return 0; 2149c6fd2807SJeff Garzik 2150c6fd2807SJeff Garzik return __sata_set_spd_needed(ap, &scontrol); 2151c6fd2807SJeff Garzik } 2152c6fd2807SJeff Garzik 2153c6fd2807SJeff Garzik /** 2154c6fd2807SJeff Garzik * sata_set_spd - set SATA spd according to spd limit 2155c6fd2807SJeff Garzik * @ap: Port to set SATA spd for 2156c6fd2807SJeff Garzik * 2157c6fd2807SJeff Garzik * Set SATA spd of @ap according to sata_spd_limit. 2158c6fd2807SJeff Garzik * 2159c6fd2807SJeff Garzik * LOCKING: 2160c6fd2807SJeff Garzik * Inherited from caller. 2161c6fd2807SJeff Garzik * 2162c6fd2807SJeff Garzik * RETURNS: 2163c6fd2807SJeff Garzik * 0 if spd doesn't need to be changed, 1 if spd has been 2164c6fd2807SJeff Garzik * changed. Negative errno if SCR registers are inaccessible. 2165c6fd2807SJeff Garzik */ 2166c6fd2807SJeff Garzik int sata_set_spd(struct ata_port *ap) 2167c6fd2807SJeff Garzik { 2168c6fd2807SJeff Garzik u32 scontrol; 2169c6fd2807SJeff Garzik int rc; 2170c6fd2807SJeff Garzik 2171c6fd2807SJeff Garzik if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol))) 2172c6fd2807SJeff Garzik return rc; 2173c6fd2807SJeff Garzik 2174c6fd2807SJeff Garzik if (!__sata_set_spd_needed(ap, &scontrol)) 2175c6fd2807SJeff Garzik return 0; 2176c6fd2807SJeff Garzik 2177c6fd2807SJeff Garzik if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol))) 2178c6fd2807SJeff Garzik return rc; 2179c6fd2807SJeff Garzik 2180c6fd2807SJeff Garzik return 1; 2181c6fd2807SJeff Garzik } 2182c6fd2807SJeff Garzik 2183c6fd2807SJeff Garzik /* 2184c6fd2807SJeff Garzik * This mode timing computation functionality is ported over from 2185c6fd2807SJeff Garzik * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik 2186c6fd2807SJeff Garzik */ 2187c6fd2807SJeff Garzik /* 2188b352e57dSAlan Cox * PIO 0-4, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds). 2189c6fd2807SJeff Garzik * These were taken from ATA/ATAPI-6 standard, rev 0a, except 2190b352e57dSAlan Cox * for UDMA6, which is currently supported only by Maxtor drives. 2191b352e57dSAlan Cox * 2192b352e57dSAlan Cox * For PIO 5/6 MWDMA 3/4 see the CFA specification 3.0. 2193c6fd2807SJeff Garzik */ 2194c6fd2807SJeff Garzik 2195c6fd2807SJeff Garzik static const struct ata_timing ata_timing[] = { 2196c6fd2807SJeff Garzik 2197c6fd2807SJeff Garzik { XFER_UDMA_6, 0, 0, 0, 0, 0, 0, 0, 15 }, 2198c6fd2807SJeff Garzik { XFER_UDMA_5, 0, 0, 0, 0, 0, 0, 0, 20 }, 2199c6fd2807SJeff Garzik { XFER_UDMA_4, 0, 0, 0, 0, 0, 0, 0, 30 }, 2200c6fd2807SJeff Garzik { XFER_UDMA_3, 0, 0, 0, 0, 0, 0, 0, 45 }, 2201c6fd2807SJeff Garzik 2202b352e57dSAlan Cox { XFER_MW_DMA_4, 25, 0, 0, 0, 55, 20, 80, 0 }, 2203b352e57dSAlan Cox { XFER_MW_DMA_3, 25, 0, 0, 0, 65, 25, 100, 0 }, 2204c6fd2807SJeff Garzik { XFER_UDMA_2, 0, 0, 0, 0, 0, 0, 0, 60 }, 2205c6fd2807SJeff Garzik { XFER_UDMA_1, 0, 0, 0, 0, 0, 0, 0, 80 }, 2206c6fd2807SJeff Garzik { XFER_UDMA_0, 0, 0, 0, 0, 0, 0, 0, 120 }, 2207c6fd2807SJeff Garzik 2208c6fd2807SJeff Garzik /* { XFER_UDMA_SLOW, 0, 0, 0, 0, 0, 0, 0, 150 }, */ 2209c6fd2807SJeff Garzik 2210c6fd2807SJeff Garzik { XFER_MW_DMA_2, 25, 0, 0, 0, 70, 25, 120, 0 }, 2211c6fd2807SJeff Garzik { XFER_MW_DMA_1, 45, 0, 0, 0, 80, 50, 150, 0 }, 2212c6fd2807SJeff Garzik { XFER_MW_DMA_0, 60, 0, 0, 0, 215, 215, 480, 0 }, 2213c6fd2807SJeff Garzik 2214c6fd2807SJeff Garzik { XFER_SW_DMA_2, 60, 0, 0, 0, 120, 120, 240, 0 }, 2215c6fd2807SJeff Garzik { XFER_SW_DMA_1, 90, 0, 0, 0, 240, 240, 480, 0 }, 2216c6fd2807SJeff Garzik { XFER_SW_DMA_0, 120, 0, 0, 0, 480, 480, 960, 0 }, 2217c6fd2807SJeff Garzik 2218b352e57dSAlan Cox { XFER_PIO_6, 10, 55, 20, 80, 55, 20, 80, 0 }, 2219b352e57dSAlan Cox { XFER_PIO_5, 15, 65, 25, 100, 65, 25, 100, 0 }, 2220c6fd2807SJeff Garzik { XFER_PIO_4, 25, 70, 25, 120, 70, 25, 120, 0 }, 2221c6fd2807SJeff Garzik { XFER_PIO_3, 30, 80, 70, 180, 80, 70, 180, 0 }, 2222c6fd2807SJeff Garzik 2223c6fd2807SJeff Garzik { XFER_PIO_2, 30, 290, 40, 330, 100, 90, 240, 0 }, 2224c6fd2807SJeff Garzik { XFER_PIO_1, 50, 290, 93, 383, 125, 100, 383, 0 }, 2225c6fd2807SJeff Garzik { XFER_PIO_0, 70, 290, 240, 600, 165, 150, 600, 0 }, 2226c6fd2807SJeff Garzik 2227c6fd2807SJeff Garzik /* { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960, 0 }, */ 2228c6fd2807SJeff Garzik 2229c6fd2807SJeff Garzik { 0xFF } 2230c6fd2807SJeff Garzik }; 2231c6fd2807SJeff Garzik 2232c6fd2807SJeff Garzik #define ENOUGH(v,unit) (((v)-1)/(unit)+1) 2233c6fd2807SJeff Garzik #define EZ(v,unit) ((v)?ENOUGH(v,unit):0) 2234c6fd2807SJeff Garzik 2235c6fd2807SJeff Garzik static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT) 2236c6fd2807SJeff Garzik { 2237c6fd2807SJeff Garzik q->setup = EZ(t->setup * 1000, T); 2238c6fd2807SJeff Garzik q->act8b = EZ(t->act8b * 1000, T); 2239c6fd2807SJeff Garzik q->rec8b = EZ(t->rec8b * 1000, T); 2240c6fd2807SJeff Garzik q->cyc8b = EZ(t->cyc8b * 1000, T); 2241c6fd2807SJeff Garzik q->active = EZ(t->active * 1000, T); 2242c6fd2807SJeff Garzik q->recover = EZ(t->recover * 1000, T); 2243c6fd2807SJeff Garzik q->cycle = EZ(t->cycle * 1000, T); 2244c6fd2807SJeff Garzik q->udma = EZ(t->udma * 1000, UT); 2245c6fd2807SJeff Garzik } 2246c6fd2807SJeff Garzik 2247c6fd2807SJeff Garzik void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b, 2248c6fd2807SJeff Garzik struct ata_timing *m, unsigned int what) 2249c6fd2807SJeff Garzik { 2250c6fd2807SJeff Garzik if (what & ATA_TIMING_SETUP ) m->setup = max(a->setup, b->setup); 2251c6fd2807SJeff Garzik if (what & ATA_TIMING_ACT8B ) m->act8b = max(a->act8b, b->act8b); 2252c6fd2807SJeff Garzik if (what & ATA_TIMING_REC8B ) m->rec8b = max(a->rec8b, b->rec8b); 2253c6fd2807SJeff Garzik if (what & ATA_TIMING_CYC8B ) m->cyc8b = max(a->cyc8b, b->cyc8b); 2254c6fd2807SJeff Garzik if (what & ATA_TIMING_ACTIVE ) m->active = max(a->active, b->active); 2255c6fd2807SJeff Garzik if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover); 2256c6fd2807SJeff Garzik if (what & ATA_TIMING_CYCLE ) m->cycle = max(a->cycle, b->cycle); 2257c6fd2807SJeff Garzik if (what & ATA_TIMING_UDMA ) m->udma = max(a->udma, b->udma); 2258c6fd2807SJeff Garzik } 2259c6fd2807SJeff Garzik 2260c6fd2807SJeff Garzik static const struct ata_timing* ata_timing_find_mode(unsigned short speed) 2261c6fd2807SJeff Garzik { 2262c6fd2807SJeff Garzik const struct ata_timing *t; 2263c6fd2807SJeff Garzik 2264c6fd2807SJeff Garzik for (t = ata_timing; t->mode != speed; t++) 2265c6fd2807SJeff Garzik if (t->mode == 0xFF) 2266c6fd2807SJeff Garzik return NULL; 2267c6fd2807SJeff Garzik return t; 2268c6fd2807SJeff Garzik } 2269c6fd2807SJeff Garzik 2270c6fd2807SJeff Garzik int ata_timing_compute(struct ata_device *adev, unsigned short speed, 2271c6fd2807SJeff Garzik struct ata_timing *t, int T, int UT) 2272c6fd2807SJeff Garzik { 2273c6fd2807SJeff Garzik const struct ata_timing *s; 2274c6fd2807SJeff Garzik struct ata_timing p; 2275c6fd2807SJeff Garzik 2276c6fd2807SJeff Garzik /* 2277c6fd2807SJeff Garzik * Find the mode. 2278c6fd2807SJeff Garzik */ 2279c6fd2807SJeff Garzik 2280c6fd2807SJeff Garzik if (!(s = ata_timing_find_mode(speed))) 2281c6fd2807SJeff Garzik return -EINVAL; 2282c6fd2807SJeff Garzik 2283c6fd2807SJeff Garzik memcpy(t, s, sizeof(*s)); 2284c6fd2807SJeff Garzik 2285c6fd2807SJeff Garzik /* 2286c6fd2807SJeff Garzik * If the drive is an EIDE drive, it can tell us it needs extended 2287c6fd2807SJeff Garzik * PIO/MW_DMA cycle timing. 2288c6fd2807SJeff Garzik */ 2289c6fd2807SJeff Garzik 2290c6fd2807SJeff Garzik if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */ 2291c6fd2807SJeff Garzik memset(&p, 0, sizeof(p)); 2292c6fd2807SJeff Garzik if(speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) { 2293c6fd2807SJeff Garzik if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO]; 2294c6fd2807SJeff Garzik else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY]; 2295c6fd2807SJeff Garzik } else if(speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) { 2296c6fd2807SJeff Garzik p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN]; 2297c6fd2807SJeff Garzik } 2298c6fd2807SJeff Garzik ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B); 2299c6fd2807SJeff Garzik } 2300c6fd2807SJeff Garzik 2301c6fd2807SJeff Garzik /* 2302c6fd2807SJeff Garzik * Convert the timing to bus clock counts. 2303c6fd2807SJeff Garzik */ 2304c6fd2807SJeff Garzik 2305c6fd2807SJeff Garzik ata_timing_quantize(t, t, T, UT); 2306c6fd2807SJeff Garzik 2307c6fd2807SJeff Garzik /* 2308c6fd2807SJeff Garzik * Even in DMA/UDMA modes we still use PIO access for IDENTIFY, 2309c6fd2807SJeff Garzik * S.M.A.R.T * and some other commands. We have to ensure that the 2310c6fd2807SJeff Garzik * DMA cycle timing is slower/equal than the fastest PIO timing. 2311c6fd2807SJeff Garzik */ 2312c6fd2807SJeff Garzik 2313fd3367afSAlan if (speed > XFER_PIO_6) { 2314c6fd2807SJeff Garzik ata_timing_compute(adev, adev->pio_mode, &p, T, UT); 2315c6fd2807SJeff Garzik ata_timing_merge(&p, t, t, ATA_TIMING_ALL); 2316c6fd2807SJeff Garzik } 2317c6fd2807SJeff Garzik 2318c6fd2807SJeff Garzik /* 2319c6fd2807SJeff Garzik * Lengthen active & recovery time so that cycle time is correct. 2320c6fd2807SJeff Garzik */ 2321c6fd2807SJeff Garzik 2322c6fd2807SJeff Garzik if (t->act8b + t->rec8b < t->cyc8b) { 2323c6fd2807SJeff Garzik t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2; 2324c6fd2807SJeff Garzik t->rec8b = t->cyc8b - t->act8b; 2325c6fd2807SJeff Garzik } 2326c6fd2807SJeff Garzik 2327c6fd2807SJeff Garzik if (t->active + t->recover < t->cycle) { 2328c6fd2807SJeff Garzik t->active += (t->cycle - (t->active + t->recover)) / 2; 2329c6fd2807SJeff Garzik t->recover = t->cycle - t->active; 2330c6fd2807SJeff Garzik } 2331c6fd2807SJeff Garzik 2332c6fd2807SJeff Garzik return 0; 2333c6fd2807SJeff Garzik } 2334c6fd2807SJeff Garzik 2335c6fd2807SJeff Garzik /** 2336c6fd2807SJeff Garzik * ata_down_xfermask_limit - adjust dev xfer masks downward 2337c6fd2807SJeff Garzik * @dev: Device to adjust xfer masks 2338c6fd2807SJeff Garzik * @force_pio0: Force PIO0 2339c6fd2807SJeff Garzik * 2340c6fd2807SJeff Garzik * Adjust xfer masks of @dev downward. Note that this function 2341c6fd2807SJeff Garzik * does not apply the change. Invoking ata_set_mode() afterwards 2342c6fd2807SJeff Garzik * will apply the limit. 2343c6fd2807SJeff Garzik * 2344c6fd2807SJeff Garzik * LOCKING: 2345c6fd2807SJeff Garzik * Inherited from caller. 2346c6fd2807SJeff Garzik * 2347c6fd2807SJeff Garzik * RETURNS: 2348c6fd2807SJeff Garzik * 0 on success, negative errno on failure 2349c6fd2807SJeff Garzik */ 2350c6fd2807SJeff Garzik int ata_down_xfermask_limit(struct ata_device *dev, int force_pio0) 2351c6fd2807SJeff Garzik { 2352c6fd2807SJeff Garzik unsigned long xfer_mask; 2353c6fd2807SJeff Garzik int highbit; 2354c6fd2807SJeff Garzik 2355c6fd2807SJeff Garzik xfer_mask = ata_pack_xfermask(dev->pio_mask, dev->mwdma_mask, 2356c6fd2807SJeff Garzik dev->udma_mask); 2357c6fd2807SJeff Garzik 2358c6fd2807SJeff Garzik if (!xfer_mask) 2359c6fd2807SJeff Garzik goto fail; 2360c6fd2807SJeff Garzik /* don't gear down to MWDMA from UDMA, go directly to PIO */ 2361c6fd2807SJeff Garzik if (xfer_mask & ATA_MASK_UDMA) 2362c6fd2807SJeff Garzik xfer_mask &= ~ATA_MASK_MWDMA; 2363c6fd2807SJeff Garzik 2364c6fd2807SJeff Garzik highbit = fls(xfer_mask) - 1; 2365c6fd2807SJeff Garzik xfer_mask &= ~(1 << highbit); 2366c6fd2807SJeff Garzik if (force_pio0) 2367c6fd2807SJeff Garzik xfer_mask &= 1 << ATA_SHIFT_PIO; 2368c6fd2807SJeff Garzik if (!xfer_mask) 2369c6fd2807SJeff Garzik goto fail; 2370c6fd2807SJeff Garzik 2371c6fd2807SJeff Garzik ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask, 2372c6fd2807SJeff Garzik &dev->udma_mask); 2373c6fd2807SJeff Garzik 2374c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "limiting speed to %s\n", 2375c6fd2807SJeff Garzik ata_mode_string(xfer_mask)); 2376c6fd2807SJeff Garzik 2377c6fd2807SJeff Garzik return 0; 2378c6fd2807SJeff Garzik 2379c6fd2807SJeff Garzik fail: 2380c6fd2807SJeff Garzik return -EINVAL; 2381c6fd2807SJeff Garzik } 2382c6fd2807SJeff Garzik 2383c6fd2807SJeff Garzik static int ata_dev_set_mode(struct ata_device *dev) 2384c6fd2807SJeff Garzik { 2385baa1e78aSTejun Heo struct ata_eh_context *ehc = &dev->ap->eh_context; 2386c6fd2807SJeff Garzik unsigned int err_mask; 2387c6fd2807SJeff Garzik int rc; 2388c6fd2807SJeff Garzik 2389c6fd2807SJeff Garzik dev->flags &= ~ATA_DFLAG_PIO; 2390c6fd2807SJeff Garzik if (dev->xfer_shift == ATA_SHIFT_PIO) 2391c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_PIO; 2392c6fd2807SJeff Garzik 2393c6fd2807SJeff Garzik err_mask = ata_dev_set_xfermode(dev); 2394c6fd2807SJeff Garzik if (err_mask) { 2395c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_ERR, "failed to set xfermode " 2396c6fd2807SJeff Garzik "(err_mask=0x%x)\n", err_mask); 2397c6fd2807SJeff Garzik return -EIO; 2398c6fd2807SJeff Garzik } 2399c6fd2807SJeff Garzik 2400baa1e78aSTejun Heo ehc->i.flags |= ATA_EHI_POST_SETMODE; 2401c6fd2807SJeff Garzik rc = ata_dev_revalidate(dev, 0); 2402baa1e78aSTejun Heo ehc->i.flags &= ~ATA_EHI_POST_SETMODE; 2403c6fd2807SJeff Garzik if (rc) 2404c6fd2807SJeff Garzik return rc; 2405c6fd2807SJeff Garzik 2406c6fd2807SJeff Garzik DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n", 2407c6fd2807SJeff Garzik dev->xfer_shift, (int)dev->xfer_mode); 2408c6fd2807SJeff Garzik 2409c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "configured for %s\n", 2410c6fd2807SJeff Garzik ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode))); 2411c6fd2807SJeff Garzik return 0; 2412c6fd2807SJeff Garzik } 2413c6fd2807SJeff Garzik 2414c6fd2807SJeff Garzik /** 2415c6fd2807SJeff Garzik * ata_set_mode - Program timings and issue SET FEATURES - XFER 2416c6fd2807SJeff Garzik * @ap: port on which timings will be programmed 2417c6fd2807SJeff Garzik * @r_failed_dev: out paramter for failed device 2418c6fd2807SJeff Garzik * 2419c6fd2807SJeff Garzik * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If 2420c6fd2807SJeff Garzik * ata_set_mode() fails, pointer to the failing device is 2421c6fd2807SJeff Garzik * returned in @r_failed_dev. 2422c6fd2807SJeff Garzik * 2423c6fd2807SJeff Garzik * LOCKING: 2424c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 2425c6fd2807SJeff Garzik * 2426c6fd2807SJeff Garzik * RETURNS: 2427c6fd2807SJeff Garzik * 0 on success, negative errno otherwise 2428c6fd2807SJeff Garzik */ 2429c6fd2807SJeff Garzik int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev) 2430c6fd2807SJeff Garzik { 2431c6fd2807SJeff Garzik struct ata_device *dev; 2432c6fd2807SJeff Garzik int i, rc = 0, used_dma = 0, found = 0; 2433c6fd2807SJeff Garzik 2434c6fd2807SJeff Garzik /* has private set_mode? */ 2435b229a7b0SAlan if (ap->ops->set_mode) 2436b229a7b0SAlan return ap->ops->set_mode(ap, r_failed_dev); 2437c6fd2807SJeff Garzik 2438c6fd2807SJeff Garzik /* step 1: calculate xfer_mask */ 2439c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_DEVICES; i++) { 2440c6fd2807SJeff Garzik unsigned int pio_mask, dma_mask; 2441c6fd2807SJeff Garzik 2442c6fd2807SJeff Garzik dev = &ap->device[i]; 2443c6fd2807SJeff Garzik 2444c6fd2807SJeff Garzik if (!ata_dev_enabled(dev)) 2445c6fd2807SJeff Garzik continue; 2446c6fd2807SJeff Garzik 2447c6fd2807SJeff Garzik ata_dev_xfermask(dev); 2448c6fd2807SJeff Garzik 2449c6fd2807SJeff Garzik pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0); 2450c6fd2807SJeff Garzik dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask); 2451c6fd2807SJeff Garzik dev->pio_mode = ata_xfer_mask2mode(pio_mask); 2452c6fd2807SJeff Garzik dev->dma_mode = ata_xfer_mask2mode(dma_mask); 2453c6fd2807SJeff Garzik 2454c6fd2807SJeff Garzik found = 1; 2455c6fd2807SJeff Garzik if (dev->dma_mode) 2456c6fd2807SJeff Garzik used_dma = 1; 2457c6fd2807SJeff Garzik } 2458c6fd2807SJeff Garzik if (!found) 2459c6fd2807SJeff Garzik goto out; 2460c6fd2807SJeff Garzik 2461c6fd2807SJeff Garzik /* step 2: always set host PIO timings */ 2462c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_DEVICES; i++) { 2463c6fd2807SJeff Garzik dev = &ap->device[i]; 2464c6fd2807SJeff Garzik if (!ata_dev_enabled(dev)) 2465c6fd2807SJeff Garzik continue; 2466c6fd2807SJeff Garzik 2467c6fd2807SJeff Garzik if (!dev->pio_mode) { 2468c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "no PIO support\n"); 2469c6fd2807SJeff Garzik rc = -EINVAL; 2470c6fd2807SJeff Garzik goto out; 2471c6fd2807SJeff Garzik } 2472c6fd2807SJeff Garzik 2473c6fd2807SJeff Garzik dev->xfer_mode = dev->pio_mode; 2474c6fd2807SJeff Garzik dev->xfer_shift = ATA_SHIFT_PIO; 2475c6fd2807SJeff Garzik if (ap->ops->set_piomode) 2476c6fd2807SJeff Garzik ap->ops->set_piomode(ap, dev); 2477c6fd2807SJeff Garzik } 2478c6fd2807SJeff Garzik 2479c6fd2807SJeff Garzik /* step 3: set host DMA timings */ 2480c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_DEVICES; i++) { 2481c6fd2807SJeff Garzik dev = &ap->device[i]; 2482c6fd2807SJeff Garzik 2483c6fd2807SJeff Garzik if (!ata_dev_enabled(dev) || !dev->dma_mode) 2484c6fd2807SJeff Garzik continue; 2485c6fd2807SJeff Garzik 2486c6fd2807SJeff Garzik dev->xfer_mode = dev->dma_mode; 2487c6fd2807SJeff Garzik dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode); 2488c6fd2807SJeff Garzik if (ap->ops->set_dmamode) 2489c6fd2807SJeff Garzik ap->ops->set_dmamode(ap, dev); 2490c6fd2807SJeff Garzik } 2491c6fd2807SJeff Garzik 2492c6fd2807SJeff Garzik /* step 4: update devices' xfer mode */ 2493c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_DEVICES; i++) { 2494c6fd2807SJeff Garzik dev = &ap->device[i]; 2495c6fd2807SJeff Garzik 2496c6fd2807SJeff Garzik /* don't udpate suspended devices' xfer mode */ 2497c6fd2807SJeff Garzik if (!ata_dev_ready(dev)) 2498c6fd2807SJeff Garzik continue; 2499c6fd2807SJeff Garzik 2500c6fd2807SJeff Garzik rc = ata_dev_set_mode(dev); 2501c6fd2807SJeff Garzik if (rc) 2502c6fd2807SJeff Garzik goto out; 2503c6fd2807SJeff Garzik } 2504c6fd2807SJeff Garzik 2505c6fd2807SJeff Garzik /* Record simplex status. If we selected DMA then the other 2506c6fd2807SJeff Garzik * host channels are not permitted to do so. 2507c6fd2807SJeff Garzik */ 2508cca3974eSJeff Garzik if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX)) 2509cca3974eSJeff Garzik ap->host->simplex_claimed = 1; 2510c6fd2807SJeff Garzik 2511c6fd2807SJeff Garzik /* step5: chip specific finalisation */ 2512c6fd2807SJeff Garzik if (ap->ops->post_set_mode) 2513c6fd2807SJeff Garzik ap->ops->post_set_mode(ap); 2514c6fd2807SJeff Garzik 2515c6fd2807SJeff Garzik out: 2516c6fd2807SJeff Garzik if (rc) 2517c6fd2807SJeff Garzik *r_failed_dev = dev; 2518c6fd2807SJeff Garzik return rc; 2519c6fd2807SJeff Garzik } 2520c6fd2807SJeff Garzik 2521c6fd2807SJeff Garzik /** 2522c6fd2807SJeff Garzik * ata_tf_to_host - issue ATA taskfile to host controller 2523c6fd2807SJeff Garzik * @ap: port to which command is being issued 2524c6fd2807SJeff Garzik * @tf: ATA taskfile register set 2525c6fd2807SJeff Garzik * 2526c6fd2807SJeff Garzik * Issues ATA taskfile register set to ATA host controller, 2527c6fd2807SJeff Garzik * with proper synchronization with interrupt handler and 2528c6fd2807SJeff Garzik * other threads. 2529c6fd2807SJeff Garzik * 2530c6fd2807SJeff Garzik * LOCKING: 2531cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 2532c6fd2807SJeff Garzik */ 2533c6fd2807SJeff Garzik 2534c6fd2807SJeff Garzik static inline void ata_tf_to_host(struct ata_port *ap, 2535c6fd2807SJeff Garzik const struct ata_taskfile *tf) 2536c6fd2807SJeff Garzik { 2537c6fd2807SJeff Garzik ap->ops->tf_load(ap, tf); 2538c6fd2807SJeff Garzik ap->ops->exec_command(ap, tf); 2539c6fd2807SJeff Garzik } 2540c6fd2807SJeff Garzik 2541c6fd2807SJeff Garzik /** 2542c6fd2807SJeff Garzik * ata_busy_sleep - sleep until BSY clears, or timeout 2543c6fd2807SJeff Garzik * @ap: port containing status register to be polled 2544c6fd2807SJeff Garzik * @tmout_pat: impatience timeout 2545c6fd2807SJeff Garzik * @tmout: overall timeout 2546c6fd2807SJeff Garzik * 2547c6fd2807SJeff Garzik * Sleep until ATA Status register bit BSY clears, 2548c6fd2807SJeff Garzik * or a timeout occurs. 2549c6fd2807SJeff Garzik * 2550d1adc1bbSTejun Heo * LOCKING: 2551d1adc1bbSTejun Heo * Kernel thread context (may sleep). 2552d1adc1bbSTejun Heo * 2553d1adc1bbSTejun Heo * RETURNS: 2554d1adc1bbSTejun Heo * 0 on success, -errno otherwise. 2555c6fd2807SJeff Garzik */ 2556d1adc1bbSTejun Heo int ata_busy_sleep(struct ata_port *ap, 2557c6fd2807SJeff Garzik unsigned long tmout_pat, unsigned long tmout) 2558c6fd2807SJeff Garzik { 2559c6fd2807SJeff Garzik unsigned long timer_start, timeout; 2560c6fd2807SJeff Garzik u8 status; 2561c6fd2807SJeff Garzik 2562c6fd2807SJeff Garzik status = ata_busy_wait(ap, ATA_BUSY, 300); 2563c6fd2807SJeff Garzik timer_start = jiffies; 2564c6fd2807SJeff Garzik timeout = timer_start + tmout_pat; 2565d1adc1bbSTejun Heo while (status != 0xff && (status & ATA_BUSY) && 2566d1adc1bbSTejun Heo time_before(jiffies, timeout)) { 2567c6fd2807SJeff Garzik msleep(50); 2568c6fd2807SJeff Garzik status = ata_busy_wait(ap, ATA_BUSY, 3); 2569c6fd2807SJeff Garzik } 2570c6fd2807SJeff Garzik 2571d1adc1bbSTejun Heo if (status != 0xff && (status & ATA_BUSY)) 2572c6fd2807SJeff Garzik ata_port_printk(ap, KERN_WARNING, 257335aa7a43SJeff Garzik "port is slow to respond, please be patient " 257435aa7a43SJeff Garzik "(Status 0x%x)\n", status); 2575c6fd2807SJeff Garzik 2576c6fd2807SJeff Garzik timeout = timer_start + tmout; 2577d1adc1bbSTejun Heo while (status != 0xff && (status & ATA_BUSY) && 2578d1adc1bbSTejun Heo time_before(jiffies, timeout)) { 2579c6fd2807SJeff Garzik msleep(50); 2580c6fd2807SJeff Garzik status = ata_chk_status(ap); 2581c6fd2807SJeff Garzik } 2582c6fd2807SJeff Garzik 2583d1adc1bbSTejun Heo if (status == 0xff) 2584d1adc1bbSTejun Heo return -ENODEV; 2585d1adc1bbSTejun Heo 2586c6fd2807SJeff Garzik if (status & ATA_BUSY) { 2587c6fd2807SJeff Garzik ata_port_printk(ap, KERN_ERR, "port failed to respond " 258835aa7a43SJeff Garzik "(%lu secs, Status 0x%x)\n", 258935aa7a43SJeff Garzik tmout / HZ, status); 2590d1adc1bbSTejun Heo return -EBUSY; 2591c6fd2807SJeff Garzik } 2592c6fd2807SJeff Garzik 2593c6fd2807SJeff Garzik return 0; 2594c6fd2807SJeff Garzik } 2595c6fd2807SJeff Garzik 2596c6fd2807SJeff Garzik static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask) 2597c6fd2807SJeff Garzik { 2598c6fd2807SJeff Garzik struct ata_ioports *ioaddr = &ap->ioaddr; 2599c6fd2807SJeff Garzik unsigned int dev0 = devmask & (1 << 0); 2600c6fd2807SJeff Garzik unsigned int dev1 = devmask & (1 << 1); 2601c6fd2807SJeff Garzik unsigned long timeout; 2602c6fd2807SJeff Garzik 2603c6fd2807SJeff Garzik /* if device 0 was found in ata_devchk, wait for its 2604c6fd2807SJeff Garzik * BSY bit to clear 2605c6fd2807SJeff Garzik */ 2606c6fd2807SJeff Garzik if (dev0) 2607c6fd2807SJeff Garzik ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT); 2608c6fd2807SJeff Garzik 2609c6fd2807SJeff Garzik /* if device 1 was found in ata_devchk, wait for 2610c6fd2807SJeff Garzik * register access, then wait for BSY to clear 2611c6fd2807SJeff Garzik */ 2612c6fd2807SJeff Garzik timeout = jiffies + ATA_TMOUT_BOOT; 2613c6fd2807SJeff Garzik while (dev1) { 2614c6fd2807SJeff Garzik u8 nsect, lbal; 2615c6fd2807SJeff Garzik 2616c6fd2807SJeff Garzik ap->ops->dev_select(ap, 1); 2617c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_MMIO) { 2618c6fd2807SJeff Garzik nsect = readb((void __iomem *) ioaddr->nsect_addr); 2619c6fd2807SJeff Garzik lbal = readb((void __iomem *) ioaddr->lbal_addr); 2620c6fd2807SJeff Garzik } else { 2621c6fd2807SJeff Garzik nsect = inb(ioaddr->nsect_addr); 2622c6fd2807SJeff Garzik lbal = inb(ioaddr->lbal_addr); 2623c6fd2807SJeff Garzik } 2624c6fd2807SJeff Garzik if ((nsect == 1) && (lbal == 1)) 2625c6fd2807SJeff Garzik break; 2626c6fd2807SJeff Garzik if (time_after(jiffies, timeout)) { 2627c6fd2807SJeff Garzik dev1 = 0; 2628c6fd2807SJeff Garzik break; 2629c6fd2807SJeff Garzik } 2630c6fd2807SJeff Garzik msleep(50); /* give drive a breather */ 2631c6fd2807SJeff Garzik } 2632c6fd2807SJeff Garzik if (dev1) 2633c6fd2807SJeff Garzik ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT); 2634c6fd2807SJeff Garzik 2635c6fd2807SJeff Garzik /* is all this really necessary? */ 2636c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 2637c6fd2807SJeff Garzik if (dev1) 2638c6fd2807SJeff Garzik ap->ops->dev_select(ap, 1); 2639c6fd2807SJeff Garzik if (dev0) 2640c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 2641c6fd2807SJeff Garzik } 2642c6fd2807SJeff Garzik 2643c6fd2807SJeff Garzik static unsigned int ata_bus_softreset(struct ata_port *ap, 2644c6fd2807SJeff Garzik unsigned int devmask) 2645c6fd2807SJeff Garzik { 2646c6fd2807SJeff Garzik struct ata_ioports *ioaddr = &ap->ioaddr; 2647c6fd2807SJeff Garzik 2648c6fd2807SJeff Garzik DPRINTK("ata%u: bus reset via SRST\n", ap->id); 2649c6fd2807SJeff Garzik 2650c6fd2807SJeff Garzik /* software reset. causes dev0 to be selected */ 2651c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_MMIO) { 2652c6fd2807SJeff Garzik writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr); 2653c6fd2807SJeff Garzik udelay(20); /* FIXME: flush */ 2654c6fd2807SJeff Garzik writeb(ap->ctl | ATA_SRST, (void __iomem *) ioaddr->ctl_addr); 2655c6fd2807SJeff Garzik udelay(20); /* FIXME: flush */ 2656c6fd2807SJeff Garzik writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr); 2657c6fd2807SJeff Garzik } else { 2658c6fd2807SJeff Garzik outb(ap->ctl, ioaddr->ctl_addr); 2659c6fd2807SJeff Garzik udelay(10); 2660c6fd2807SJeff Garzik outb(ap->ctl | ATA_SRST, ioaddr->ctl_addr); 2661c6fd2807SJeff Garzik udelay(10); 2662c6fd2807SJeff Garzik outb(ap->ctl, ioaddr->ctl_addr); 2663c6fd2807SJeff Garzik } 2664c6fd2807SJeff Garzik 2665c6fd2807SJeff Garzik /* spec mandates ">= 2ms" before checking status. 2666c6fd2807SJeff Garzik * We wait 150ms, because that was the magic delay used for 2667c6fd2807SJeff Garzik * ATAPI devices in Hale Landis's ATADRVR, for the period of time 2668c6fd2807SJeff Garzik * between when the ATA command register is written, and then 2669c6fd2807SJeff Garzik * status is checked. Because waiting for "a while" before 2670c6fd2807SJeff Garzik * checking status is fine, post SRST, we perform this magic 2671c6fd2807SJeff Garzik * delay here as well. 2672c6fd2807SJeff Garzik * 2673c6fd2807SJeff Garzik * Old drivers/ide uses the 2mS rule and then waits for ready 2674c6fd2807SJeff Garzik */ 2675c6fd2807SJeff Garzik msleep(150); 2676c6fd2807SJeff Garzik 2677c6fd2807SJeff Garzik /* Before we perform post reset processing we want to see if 2678c6fd2807SJeff Garzik * the bus shows 0xFF because the odd clown forgets the D7 2679c6fd2807SJeff Garzik * pulldown resistor. 2680c6fd2807SJeff Garzik */ 2681d1adc1bbSTejun Heo if (ata_check_status(ap) == 0xFF) 2682d1adc1bbSTejun Heo return 0; 2683c6fd2807SJeff Garzik 2684c6fd2807SJeff Garzik ata_bus_post_reset(ap, devmask); 2685c6fd2807SJeff Garzik 2686c6fd2807SJeff Garzik return 0; 2687c6fd2807SJeff Garzik } 2688c6fd2807SJeff Garzik 2689c6fd2807SJeff Garzik /** 2690c6fd2807SJeff Garzik * ata_bus_reset - reset host port and associated ATA channel 2691c6fd2807SJeff Garzik * @ap: port to reset 2692c6fd2807SJeff Garzik * 2693c6fd2807SJeff Garzik * This is typically the first time we actually start issuing 2694c6fd2807SJeff Garzik * commands to the ATA channel. We wait for BSY to clear, then 2695c6fd2807SJeff Garzik * issue EXECUTE DEVICE DIAGNOSTIC command, polling for its 2696c6fd2807SJeff Garzik * result. Determine what devices, if any, are on the channel 2697c6fd2807SJeff Garzik * by looking at the device 0/1 error register. Look at the signature 2698c6fd2807SJeff Garzik * stored in each device's taskfile registers, to determine if 2699c6fd2807SJeff Garzik * the device is ATA or ATAPI. 2700c6fd2807SJeff Garzik * 2701c6fd2807SJeff Garzik * LOCKING: 2702c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 2703cca3974eSJeff Garzik * Obtains host lock. 2704c6fd2807SJeff Garzik * 2705c6fd2807SJeff Garzik * SIDE EFFECTS: 2706c6fd2807SJeff Garzik * Sets ATA_FLAG_DISABLED if bus reset fails. 2707c6fd2807SJeff Garzik */ 2708c6fd2807SJeff Garzik 2709c6fd2807SJeff Garzik void ata_bus_reset(struct ata_port *ap) 2710c6fd2807SJeff Garzik { 2711c6fd2807SJeff Garzik struct ata_ioports *ioaddr = &ap->ioaddr; 2712c6fd2807SJeff Garzik unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS; 2713c6fd2807SJeff Garzik u8 err; 2714c6fd2807SJeff Garzik unsigned int dev0, dev1 = 0, devmask = 0; 2715c6fd2807SJeff Garzik 2716c6fd2807SJeff Garzik DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no); 2717c6fd2807SJeff Garzik 2718c6fd2807SJeff Garzik /* determine if device 0/1 are present */ 2719c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_SATA_RESET) 2720c6fd2807SJeff Garzik dev0 = 1; 2721c6fd2807SJeff Garzik else { 2722c6fd2807SJeff Garzik dev0 = ata_devchk(ap, 0); 2723c6fd2807SJeff Garzik if (slave_possible) 2724c6fd2807SJeff Garzik dev1 = ata_devchk(ap, 1); 2725c6fd2807SJeff Garzik } 2726c6fd2807SJeff Garzik 2727c6fd2807SJeff Garzik if (dev0) 2728c6fd2807SJeff Garzik devmask |= (1 << 0); 2729c6fd2807SJeff Garzik if (dev1) 2730c6fd2807SJeff Garzik devmask |= (1 << 1); 2731c6fd2807SJeff Garzik 2732c6fd2807SJeff Garzik /* select device 0 again */ 2733c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 2734c6fd2807SJeff Garzik 2735c6fd2807SJeff Garzik /* issue bus reset */ 2736c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_SRST) 2737c6fd2807SJeff Garzik if (ata_bus_softreset(ap, devmask)) 2738c6fd2807SJeff Garzik goto err_out; 2739c6fd2807SJeff Garzik 2740c6fd2807SJeff Garzik /* 2741c6fd2807SJeff Garzik * determine by signature whether we have ATA or ATAPI devices 2742c6fd2807SJeff Garzik */ 2743c6fd2807SJeff Garzik ap->device[0].class = ata_dev_try_classify(ap, 0, &err); 2744c6fd2807SJeff Garzik if ((slave_possible) && (err != 0x81)) 2745c6fd2807SJeff Garzik ap->device[1].class = ata_dev_try_classify(ap, 1, &err); 2746c6fd2807SJeff Garzik 2747c6fd2807SJeff Garzik /* re-enable interrupts */ 2748c6fd2807SJeff Garzik if (ap->ioaddr.ctl_addr) /* FIXME: hack. create a hook instead */ 2749c6fd2807SJeff Garzik ata_irq_on(ap); 2750c6fd2807SJeff Garzik 2751c6fd2807SJeff Garzik /* is double-select really necessary? */ 2752c6fd2807SJeff Garzik if (ap->device[1].class != ATA_DEV_NONE) 2753c6fd2807SJeff Garzik ap->ops->dev_select(ap, 1); 2754c6fd2807SJeff Garzik if (ap->device[0].class != ATA_DEV_NONE) 2755c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 2756c6fd2807SJeff Garzik 2757c6fd2807SJeff Garzik /* if no devices were detected, disable this port */ 2758c6fd2807SJeff Garzik if ((ap->device[0].class == ATA_DEV_NONE) && 2759c6fd2807SJeff Garzik (ap->device[1].class == ATA_DEV_NONE)) 2760c6fd2807SJeff Garzik goto err_out; 2761c6fd2807SJeff Garzik 2762c6fd2807SJeff Garzik if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) { 2763c6fd2807SJeff Garzik /* set up device control for ATA_FLAG_SATA_RESET */ 2764c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_MMIO) 2765c6fd2807SJeff Garzik writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr); 2766c6fd2807SJeff Garzik else 2767c6fd2807SJeff Garzik outb(ap->ctl, ioaddr->ctl_addr); 2768c6fd2807SJeff Garzik } 2769c6fd2807SJeff Garzik 2770c6fd2807SJeff Garzik DPRINTK("EXIT\n"); 2771c6fd2807SJeff Garzik return; 2772c6fd2807SJeff Garzik 2773c6fd2807SJeff Garzik err_out: 2774c6fd2807SJeff Garzik ata_port_printk(ap, KERN_ERR, "disabling port\n"); 2775c6fd2807SJeff Garzik ap->ops->port_disable(ap); 2776c6fd2807SJeff Garzik 2777c6fd2807SJeff Garzik DPRINTK("EXIT\n"); 2778c6fd2807SJeff Garzik } 2779c6fd2807SJeff Garzik 2780c6fd2807SJeff Garzik /** 2781c6fd2807SJeff Garzik * sata_phy_debounce - debounce SATA phy status 2782c6fd2807SJeff Garzik * @ap: ATA port to debounce SATA phy status for 2783c6fd2807SJeff Garzik * @params: timing parameters { interval, duratinon, timeout } in msec 2784c6fd2807SJeff Garzik * 2785c6fd2807SJeff Garzik * Make sure SStatus of @ap reaches stable state, determined by 2786c6fd2807SJeff Garzik * holding the same value where DET is not 1 for @duration polled 2787c6fd2807SJeff Garzik * every @interval, before @timeout. Timeout constraints the 2788c6fd2807SJeff Garzik * beginning of the stable state. Because, after hot unplugging, 2789c6fd2807SJeff Garzik * DET gets stuck at 1 on some controllers, this functions waits 2790c6fd2807SJeff Garzik * until timeout then returns 0 if DET is stable at 1. 2791c6fd2807SJeff Garzik * 2792c6fd2807SJeff Garzik * LOCKING: 2793c6fd2807SJeff Garzik * Kernel thread context (may sleep) 2794c6fd2807SJeff Garzik * 2795c6fd2807SJeff Garzik * RETURNS: 2796c6fd2807SJeff Garzik * 0 on success, -errno on failure. 2797c6fd2807SJeff Garzik */ 2798c6fd2807SJeff Garzik int sata_phy_debounce(struct ata_port *ap, const unsigned long *params) 2799c6fd2807SJeff Garzik { 2800c6fd2807SJeff Garzik unsigned long interval_msec = params[0]; 2801c6fd2807SJeff Garzik unsigned long duration = params[1] * HZ / 1000; 2802c6fd2807SJeff Garzik unsigned long timeout = jiffies + params[2] * HZ / 1000; 2803c6fd2807SJeff Garzik unsigned long last_jiffies; 2804c6fd2807SJeff Garzik u32 last, cur; 2805c6fd2807SJeff Garzik int rc; 2806c6fd2807SJeff Garzik 2807c6fd2807SJeff Garzik if ((rc = sata_scr_read(ap, SCR_STATUS, &cur))) 2808c6fd2807SJeff Garzik return rc; 2809c6fd2807SJeff Garzik cur &= 0xf; 2810c6fd2807SJeff Garzik 2811c6fd2807SJeff Garzik last = cur; 2812c6fd2807SJeff Garzik last_jiffies = jiffies; 2813c6fd2807SJeff Garzik 2814c6fd2807SJeff Garzik while (1) { 2815c6fd2807SJeff Garzik msleep(interval_msec); 2816c6fd2807SJeff Garzik if ((rc = sata_scr_read(ap, SCR_STATUS, &cur))) 2817c6fd2807SJeff Garzik return rc; 2818c6fd2807SJeff Garzik cur &= 0xf; 2819c6fd2807SJeff Garzik 2820c6fd2807SJeff Garzik /* DET stable? */ 2821c6fd2807SJeff Garzik if (cur == last) { 2822c6fd2807SJeff Garzik if (cur == 1 && time_before(jiffies, timeout)) 2823c6fd2807SJeff Garzik continue; 2824c6fd2807SJeff Garzik if (time_after(jiffies, last_jiffies + duration)) 2825c6fd2807SJeff Garzik return 0; 2826c6fd2807SJeff Garzik continue; 2827c6fd2807SJeff Garzik } 2828c6fd2807SJeff Garzik 2829c6fd2807SJeff Garzik /* unstable, start over */ 2830c6fd2807SJeff Garzik last = cur; 2831c6fd2807SJeff Garzik last_jiffies = jiffies; 2832c6fd2807SJeff Garzik 2833c6fd2807SJeff Garzik /* check timeout */ 2834c6fd2807SJeff Garzik if (time_after(jiffies, timeout)) 2835c6fd2807SJeff Garzik return -EBUSY; 2836c6fd2807SJeff Garzik } 2837c6fd2807SJeff Garzik } 2838c6fd2807SJeff Garzik 2839c6fd2807SJeff Garzik /** 2840c6fd2807SJeff Garzik * sata_phy_resume - resume SATA phy 2841c6fd2807SJeff Garzik * @ap: ATA port to resume SATA phy for 2842c6fd2807SJeff Garzik * @params: timing parameters { interval, duratinon, timeout } in msec 2843c6fd2807SJeff Garzik * 2844c6fd2807SJeff Garzik * Resume SATA phy of @ap and debounce it. 2845c6fd2807SJeff Garzik * 2846c6fd2807SJeff Garzik * LOCKING: 2847c6fd2807SJeff Garzik * Kernel thread context (may sleep) 2848c6fd2807SJeff Garzik * 2849c6fd2807SJeff Garzik * RETURNS: 2850c6fd2807SJeff Garzik * 0 on success, -errno on failure. 2851c6fd2807SJeff Garzik */ 2852c6fd2807SJeff Garzik int sata_phy_resume(struct ata_port *ap, const unsigned long *params) 2853c6fd2807SJeff Garzik { 2854c6fd2807SJeff Garzik u32 scontrol; 2855c6fd2807SJeff Garzik int rc; 2856c6fd2807SJeff Garzik 2857c6fd2807SJeff Garzik if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol))) 2858c6fd2807SJeff Garzik return rc; 2859c6fd2807SJeff Garzik 2860c6fd2807SJeff Garzik scontrol = (scontrol & 0x0f0) | 0x300; 2861c6fd2807SJeff Garzik 2862c6fd2807SJeff Garzik if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol))) 2863c6fd2807SJeff Garzik return rc; 2864c6fd2807SJeff Garzik 2865c6fd2807SJeff Garzik /* Some PHYs react badly if SStatus is pounded immediately 2866c6fd2807SJeff Garzik * after resuming. Delay 200ms before debouncing. 2867c6fd2807SJeff Garzik */ 2868c6fd2807SJeff Garzik msleep(200); 2869c6fd2807SJeff Garzik 2870c6fd2807SJeff Garzik return sata_phy_debounce(ap, params); 2871c6fd2807SJeff Garzik } 2872c6fd2807SJeff Garzik 2873c6fd2807SJeff Garzik static void ata_wait_spinup(struct ata_port *ap) 2874c6fd2807SJeff Garzik { 2875c6fd2807SJeff Garzik struct ata_eh_context *ehc = &ap->eh_context; 2876c6fd2807SJeff Garzik unsigned long end, secs; 2877c6fd2807SJeff Garzik int rc; 2878c6fd2807SJeff Garzik 2879c6fd2807SJeff Garzik /* first, debounce phy if SATA */ 2880c6fd2807SJeff Garzik if (ap->cbl == ATA_CBL_SATA) { 2881c6fd2807SJeff Garzik rc = sata_phy_debounce(ap, sata_deb_timing_hotplug); 2882c6fd2807SJeff Garzik 2883c6fd2807SJeff Garzik /* if debounced successfully and offline, no need to wait */ 2884c6fd2807SJeff Garzik if ((rc == 0 || rc == -EOPNOTSUPP) && ata_port_offline(ap)) 2885c6fd2807SJeff Garzik return; 2886c6fd2807SJeff Garzik } 2887c6fd2807SJeff Garzik 2888c6fd2807SJeff Garzik /* okay, let's give the drive time to spin up */ 2889c6fd2807SJeff Garzik end = ehc->i.hotplug_timestamp + ATA_SPINUP_WAIT * HZ / 1000; 2890c6fd2807SJeff Garzik secs = ((end - jiffies) + HZ - 1) / HZ; 2891c6fd2807SJeff Garzik 2892c6fd2807SJeff Garzik if (time_after(jiffies, end)) 2893c6fd2807SJeff Garzik return; 2894c6fd2807SJeff Garzik 2895c6fd2807SJeff Garzik if (secs > 5) 2896c6fd2807SJeff Garzik ata_port_printk(ap, KERN_INFO, "waiting for device to spin up " 2897c6fd2807SJeff Garzik "(%lu secs)\n", secs); 2898c6fd2807SJeff Garzik 2899c6fd2807SJeff Garzik schedule_timeout_uninterruptible(end - jiffies); 2900c6fd2807SJeff Garzik } 2901c6fd2807SJeff Garzik 2902c6fd2807SJeff Garzik /** 2903c6fd2807SJeff Garzik * ata_std_prereset - prepare for reset 2904c6fd2807SJeff Garzik * @ap: ATA port to be reset 2905c6fd2807SJeff Garzik * 2906c6fd2807SJeff Garzik * @ap is about to be reset. Initialize it. 2907c6fd2807SJeff Garzik * 2908c6fd2807SJeff Garzik * LOCKING: 2909c6fd2807SJeff Garzik * Kernel thread context (may sleep) 2910c6fd2807SJeff Garzik * 2911c6fd2807SJeff Garzik * RETURNS: 2912c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 2913c6fd2807SJeff Garzik */ 2914c6fd2807SJeff Garzik int ata_std_prereset(struct ata_port *ap) 2915c6fd2807SJeff Garzik { 2916c6fd2807SJeff Garzik struct ata_eh_context *ehc = &ap->eh_context; 2917c6fd2807SJeff Garzik const unsigned long *timing = sata_ehc_deb_timing(ehc); 2918c6fd2807SJeff Garzik int rc; 2919c6fd2807SJeff Garzik 2920c6fd2807SJeff Garzik /* handle link resume & hotplug spinup */ 2921c6fd2807SJeff Garzik if ((ehc->i.flags & ATA_EHI_RESUME_LINK) && 2922c6fd2807SJeff Garzik (ap->flags & ATA_FLAG_HRST_TO_RESUME)) 2923c6fd2807SJeff Garzik ehc->i.action |= ATA_EH_HARDRESET; 2924c6fd2807SJeff Garzik 2925c6fd2807SJeff Garzik if ((ehc->i.flags & ATA_EHI_HOTPLUGGED) && 2926c6fd2807SJeff Garzik (ap->flags & ATA_FLAG_SKIP_D2H_BSY)) 2927c6fd2807SJeff Garzik ata_wait_spinup(ap); 2928c6fd2807SJeff Garzik 2929c6fd2807SJeff Garzik /* if we're about to do hardreset, nothing more to do */ 2930c6fd2807SJeff Garzik if (ehc->i.action & ATA_EH_HARDRESET) 2931c6fd2807SJeff Garzik return 0; 2932c6fd2807SJeff Garzik 2933c6fd2807SJeff Garzik /* if SATA, resume phy */ 2934c6fd2807SJeff Garzik if (ap->cbl == ATA_CBL_SATA) { 2935c6fd2807SJeff Garzik rc = sata_phy_resume(ap, timing); 2936c6fd2807SJeff Garzik if (rc && rc != -EOPNOTSUPP) { 2937c6fd2807SJeff Garzik /* phy resume failed */ 2938c6fd2807SJeff Garzik ata_port_printk(ap, KERN_WARNING, "failed to resume " 2939c6fd2807SJeff Garzik "link for reset (errno=%d)\n", rc); 2940c6fd2807SJeff Garzik return rc; 2941c6fd2807SJeff Garzik } 2942c6fd2807SJeff Garzik } 2943c6fd2807SJeff Garzik 2944c6fd2807SJeff Garzik /* Wait for !BSY if the controller can wait for the first D2H 2945c6fd2807SJeff Garzik * Reg FIS and we don't know that no device is attached. 2946c6fd2807SJeff Garzik */ 2947c6fd2807SJeff Garzik if (!(ap->flags & ATA_FLAG_SKIP_D2H_BSY) && !ata_port_offline(ap)) 2948c6fd2807SJeff Garzik ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT); 2949c6fd2807SJeff Garzik 2950c6fd2807SJeff Garzik return 0; 2951c6fd2807SJeff Garzik } 2952c6fd2807SJeff Garzik 2953c6fd2807SJeff Garzik /** 2954c6fd2807SJeff Garzik * ata_std_softreset - reset host port via ATA SRST 2955c6fd2807SJeff Garzik * @ap: port to reset 2956c6fd2807SJeff Garzik * @classes: resulting classes of attached devices 2957c6fd2807SJeff Garzik * 2958c6fd2807SJeff Garzik * Reset host port using ATA SRST. 2959c6fd2807SJeff Garzik * 2960c6fd2807SJeff Garzik * LOCKING: 2961c6fd2807SJeff Garzik * Kernel thread context (may sleep) 2962c6fd2807SJeff Garzik * 2963c6fd2807SJeff Garzik * RETURNS: 2964c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 2965c6fd2807SJeff Garzik */ 2966c6fd2807SJeff Garzik int ata_std_softreset(struct ata_port *ap, unsigned int *classes) 2967c6fd2807SJeff Garzik { 2968c6fd2807SJeff Garzik unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS; 2969c6fd2807SJeff Garzik unsigned int devmask = 0, err_mask; 2970c6fd2807SJeff Garzik u8 err; 2971c6fd2807SJeff Garzik 2972c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 2973c6fd2807SJeff Garzik 2974c6fd2807SJeff Garzik if (ata_port_offline(ap)) { 2975c6fd2807SJeff Garzik classes[0] = ATA_DEV_NONE; 2976c6fd2807SJeff Garzik goto out; 2977c6fd2807SJeff Garzik } 2978c6fd2807SJeff Garzik 2979c6fd2807SJeff Garzik /* determine if device 0/1 are present */ 2980c6fd2807SJeff Garzik if (ata_devchk(ap, 0)) 2981c6fd2807SJeff Garzik devmask |= (1 << 0); 2982c6fd2807SJeff Garzik if (slave_possible && ata_devchk(ap, 1)) 2983c6fd2807SJeff Garzik devmask |= (1 << 1); 2984c6fd2807SJeff Garzik 2985c6fd2807SJeff Garzik /* select device 0 again */ 2986c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 2987c6fd2807SJeff Garzik 2988c6fd2807SJeff Garzik /* issue bus reset */ 2989c6fd2807SJeff Garzik DPRINTK("about to softreset, devmask=%x\n", devmask); 2990c6fd2807SJeff Garzik err_mask = ata_bus_softreset(ap, devmask); 2991c6fd2807SJeff Garzik if (err_mask) { 2992c6fd2807SJeff Garzik ata_port_printk(ap, KERN_ERR, "SRST failed (err_mask=0x%x)\n", 2993c6fd2807SJeff Garzik err_mask); 2994c6fd2807SJeff Garzik return -EIO; 2995c6fd2807SJeff Garzik } 2996c6fd2807SJeff Garzik 2997c6fd2807SJeff Garzik /* determine by signature whether we have ATA or ATAPI devices */ 2998c6fd2807SJeff Garzik classes[0] = ata_dev_try_classify(ap, 0, &err); 2999c6fd2807SJeff Garzik if (slave_possible && err != 0x81) 3000c6fd2807SJeff Garzik classes[1] = ata_dev_try_classify(ap, 1, &err); 3001c6fd2807SJeff Garzik 3002c6fd2807SJeff Garzik out: 3003c6fd2807SJeff Garzik DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]); 3004c6fd2807SJeff Garzik return 0; 3005c6fd2807SJeff Garzik } 3006c6fd2807SJeff Garzik 3007c6fd2807SJeff Garzik /** 3008b6103f6dSTejun Heo * sata_port_hardreset - reset port via SATA phy reset 3009c6fd2807SJeff Garzik * @ap: port to reset 3010b6103f6dSTejun Heo * @timing: timing parameters { interval, duratinon, timeout } in msec 3011c6fd2807SJeff Garzik * 3012c6fd2807SJeff Garzik * SATA phy-reset host port using DET bits of SControl register. 3013c6fd2807SJeff Garzik * 3014c6fd2807SJeff Garzik * LOCKING: 3015c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3016c6fd2807SJeff Garzik * 3017c6fd2807SJeff Garzik * RETURNS: 3018c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 3019c6fd2807SJeff Garzik */ 3020b6103f6dSTejun Heo int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing) 3021c6fd2807SJeff Garzik { 3022c6fd2807SJeff Garzik u32 scontrol; 3023c6fd2807SJeff Garzik int rc; 3024c6fd2807SJeff Garzik 3025c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 3026c6fd2807SJeff Garzik 3027c6fd2807SJeff Garzik if (sata_set_spd_needed(ap)) { 3028c6fd2807SJeff Garzik /* SATA spec says nothing about how to reconfigure 3029c6fd2807SJeff Garzik * spd. To be on the safe side, turn off phy during 3030c6fd2807SJeff Garzik * reconfiguration. This works for at least ICH7 AHCI 3031c6fd2807SJeff Garzik * and Sil3124. 3032c6fd2807SJeff Garzik */ 3033c6fd2807SJeff Garzik if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol))) 3034b6103f6dSTejun Heo goto out; 3035c6fd2807SJeff Garzik 3036cea0d336SJeff Garzik scontrol = (scontrol & 0x0f0) | 0x304; 3037c6fd2807SJeff Garzik 3038c6fd2807SJeff Garzik if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol))) 3039b6103f6dSTejun Heo goto out; 3040c6fd2807SJeff Garzik 3041c6fd2807SJeff Garzik sata_set_spd(ap); 3042c6fd2807SJeff Garzik } 3043c6fd2807SJeff Garzik 3044c6fd2807SJeff Garzik /* issue phy wake/reset */ 3045c6fd2807SJeff Garzik if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol))) 3046b6103f6dSTejun Heo goto out; 3047c6fd2807SJeff Garzik 3048c6fd2807SJeff Garzik scontrol = (scontrol & 0x0f0) | 0x301; 3049c6fd2807SJeff Garzik 3050c6fd2807SJeff Garzik if ((rc = sata_scr_write_flush(ap, SCR_CONTROL, scontrol))) 3051b6103f6dSTejun Heo goto out; 3052c6fd2807SJeff Garzik 3053c6fd2807SJeff Garzik /* Couldn't find anything in SATA I/II specs, but AHCI-1.1 3054c6fd2807SJeff Garzik * 10.4.2 says at least 1 ms. 3055c6fd2807SJeff Garzik */ 3056c6fd2807SJeff Garzik msleep(1); 3057c6fd2807SJeff Garzik 3058c6fd2807SJeff Garzik /* bring phy back */ 3059b6103f6dSTejun Heo rc = sata_phy_resume(ap, timing); 3060b6103f6dSTejun Heo out: 3061b6103f6dSTejun Heo DPRINTK("EXIT, rc=%d\n", rc); 3062b6103f6dSTejun Heo return rc; 3063b6103f6dSTejun Heo } 3064b6103f6dSTejun Heo 3065b6103f6dSTejun Heo /** 3066b6103f6dSTejun Heo * sata_std_hardreset - reset host port via SATA phy reset 3067b6103f6dSTejun Heo * @ap: port to reset 3068b6103f6dSTejun Heo * @class: resulting class of attached device 3069b6103f6dSTejun Heo * 3070b6103f6dSTejun Heo * SATA phy-reset host port using DET bits of SControl register, 3071b6103f6dSTejun Heo * wait for !BSY and classify the attached device. 3072b6103f6dSTejun Heo * 3073b6103f6dSTejun Heo * LOCKING: 3074b6103f6dSTejun Heo * Kernel thread context (may sleep) 3075b6103f6dSTejun Heo * 3076b6103f6dSTejun Heo * RETURNS: 3077b6103f6dSTejun Heo * 0 on success, -errno otherwise. 3078b6103f6dSTejun Heo */ 3079b6103f6dSTejun Heo int sata_std_hardreset(struct ata_port *ap, unsigned int *class) 3080b6103f6dSTejun Heo { 3081b6103f6dSTejun Heo const unsigned long *timing = sata_ehc_deb_timing(&ap->eh_context); 3082b6103f6dSTejun Heo int rc; 3083b6103f6dSTejun Heo 3084b6103f6dSTejun Heo DPRINTK("ENTER\n"); 3085b6103f6dSTejun Heo 3086b6103f6dSTejun Heo /* do hardreset */ 3087b6103f6dSTejun Heo rc = sata_port_hardreset(ap, timing); 3088b6103f6dSTejun Heo if (rc) { 3089b6103f6dSTejun Heo ata_port_printk(ap, KERN_ERR, 3090b6103f6dSTejun Heo "COMRESET failed (errno=%d)\n", rc); 3091b6103f6dSTejun Heo return rc; 3092b6103f6dSTejun Heo } 3093c6fd2807SJeff Garzik 3094c6fd2807SJeff Garzik /* TODO: phy layer with polling, timeouts, etc. */ 3095c6fd2807SJeff Garzik if (ata_port_offline(ap)) { 3096c6fd2807SJeff Garzik *class = ATA_DEV_NONE; 3097c6fd2807SJeff Garzik DPRINTK("EXIT, link offline\n"); 3098c6fd2807SJeff Garzik return 0; 3099c6fd2807SJeff Garzik } 3100c6fd2807SJeff Garzik 3101c6fd2807SJeff Garzik if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) { 3102c6fd2807SJeff Garzik ata_port_printk(ap, KERN_ERR, 3103c6fd2807SJeff Garzik "COMRESET failed (device not ready)\n"); 3104c6fd2807SJeff Garzik return -EIO; 3105c6fd2807SJeff Garzik } 3106c6fd2807SJeff Garzik 3107c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); /* probably unnecessary */ 3108c6fd2807SJeff Garzik 3109c6fd2807SJeff Garzik *class = ata_dev_try_classify(ap, 0, NULL); 3110c6fd2807SJeff Garzik 3111c6fd2807SJeff Garzik DPRINTK("EXIT, class=%u\n", *class); 3112c6fd2807SJeff Garzik return 0; 3113c6fd2807SJeff Garzik } 3114c6fd2807SJeff Garzik 3115c6fd2807SJeff Garzik /** 3116c6fd2807SJeff Garzik * ata_std_postreset - standard postreset callback 3117c6fd2807SJeff Garzik * @ap: the target ata_port 3118c6fd2807SJeff Garzik * @classes: classes of attached devices 3119c6fd2807SJeff Garzik * 3120c6fd2807SJeff Garzik * This function is invoked after a successful reset. Note that 3121c6fd2807SJeff Garzik * the device might have been reset more than once using 3122c6fd2807SJeff Garzik * different reset methods before postreset is invoked. 3123c6fd2807SJeff Garzik * 3124c6fd2807SJeff Garzik * LOCKING: 3125c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3126c6fd2807SJeff Garzik */ 3127c6fd2807SJeff Garzik void ata_std_postreset(struct ata_port *ap, unsigned int *classes) 3128c6fd2807SJeff Garzik { 3129c6fd2807SJeff Garzik u32 serror; 3130c6fd2807SJeff Garzik 3131c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 3132c6fd2807SJeff Garzik 3133c6fd2807SJeff Garzik /* print link status */ 3134c6fd2807SJeff Garzik sata_print_link_status(ap); 3135c6fd2807SJeff Garzik 3136c6fd2807SJeff Garzik /* clear SError */ 3137c6fd2807SJeff Garzik if (sata_scr_read(ap, SCR_ERROR, &serror) == 0) 3138c6fd2807SJeff Garzik sata_scr_write(ap, SCR_ERROR, serror); 3139c6fd2807SJeff Garzik 3140c6fd2807SJeff Garzik /* re-enable interrupts */ 3141c6fd2807SJeff Garzik if (!ap->ops->error_handler) { 3142c6fd2807SJeff Garzik /* FIXME: hack. create a hook instead */ 3143c6fd2807SJeff Garzik if (ap->ioaddr.ctl_addr) 3144c6fd2807SJeff Garzik ata_irq_on(ap); 3145c6fd2807SJeff Garzik } 3146c6fd2807SJeff Garzik 3147c6fd2807SJeff Garzik /* is double-select really necessary? */ 3148c6fd2807SJeff Garzik if (classes[0] != ATA_DEV_NONE) 3149c6fd2807SJeff Garzik ap->ops->dev_select(ap, 1); 3150c6fd2807SJeff Garzik if (classes[1] != ATA_DEV_NONE) 3151c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 3152c6fd2807SJeff Garzik 3153c6fd2807SJeff Garzik /* bail out if no device is present */ 3154c6fd2807SJeff Garzik if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) { 3155c6fd2807SJeff Garzik DPRINTK("EXIT, no device\n"); 3156c6fd2807SJeff Garzik return; 3157c6fd2807SJeff Garzik } 3158c6fd2807SJeff Garzik 3159c6fd2807SJeff Garzik /* set up device control */ 3160c6fd2807SJeff Garzik if (ap->ioaddr.ctl_addr) { 3161c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_MMIO) 3162c6fd2807SJeff Garzik writeb(ap->ctl, (void __iomem *) ap->ioaddr.ctl_addr); 3163c6fd2807SJeff Garzik else 3164c6fd2807SJeff Garzik outb(ap->ctl, ap->ioaddr.ctl_addr); 3165c6fd2807SJeff Garzik } 3166c6fd2807SJeff Garzik 3167c6fd2807SJeff Garzik DPRINTK("EXIT\n"); 3168c6fd2807SJeff Garzik } 3169c6fd2807SJeff Garzik 3170c6fd2807SJeff Garzik /** 3171c6fd2807SJeff Garzik * ata_dev_same_device - Determine whether new ID matches configured device 3172c6fd2807SJeff Garzik * @dev: device to compare against 3173c6fd2807SJeff Garzik * @new_class: class of the new device 3174c6fd2807SJeff Garzik * @new_id: IDENTIFY page of the new device 3175c6fd2807SJeff Garzik * 3176c6fd2807SJeff Garzik * Compare @new_class and @new_id against @dev and determine 3177c6fd2807SJeff Garzik * whether @dev is the device indicated by @new_class and 3178c6fd2807SJeff Garzik * @new_id. 3179c6fd2807SJeff Garzik * 3180c6fd2807SJeff Garzik * LOCKING: 3181c6fd2807SJeff Garzik * None. 3182c6fd2807SJeff Garzik * 3183c6fd2807SJeff Garzik * RETURNS: 3184c6fd2807SJeff Garzik * 1 if @dev matches @new_class and @new_id, 0 otherwise. 3185c6fd2807SJeff Garzik */ 3186c6fd2807SJeff Garzik static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class, 3187c6fd2807SJeff Garzik const u16 *new_id) 3188c6fd2807SJeff Garzik { 3189c6fd2807SJeff Garzik const u16 *old_id = dev->id; 3190a0cf733bSTejun Heo unsigned char model[2][ATA_ID_PROD_LEN + 1]; 3191a0cf733bSTejun Heo unsigned char serial[2][ATA_ID_SERNO_LEN + 1]; 3192c6fd2807SJeff Garzik u64 new_n_sectors; 3193c6fd2807SJeff Garzik 3194c6fd2807SJeff Garzik if (dev->class != new_class) { 3195c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "class mismatch %d != %d\n", 3196c6fd2807SJeff Garzik dev->class, new_class); 3197c6fd2807SJeff Garzik return 0; 3198c6fd2807SJeff Garzik } 3199c6fd2807SJeff Garzik 3200a0cf733bSTejun Heo ata_id_c_string(old_id, model[0], ATA_ID_PROD, sizeof(model[0])); 3201a0cf733bSTejun Heo ata_id_c_string(new_id, model[1], ATA_ID_PROD, sizeof(model[1])); 3202a0cf733bSTejun Heo ata_id_c_string(old_id, serial[0], ATA_ID_SERNO, sizeof(serial[0])); 3203a0cf733bSTejun Heo ata_id_c_string(new_id, serial[1], ATA_ID_SERNO, sizeof(serial[1])); 3204c6fd2807SJeff Garzik new_n_sectors = ata_id_n_sectors(new_id); 3205c6fd2807SJeff Garzik 3206c6fd2807SJeff Garzik if (strcmp(model[0], model[1])) { 3207c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "model number mismatch " 3208c6fd2807SJeff Garzik "'%s' != '%s'\n", model[0], model[1]); 3209c6fd2807SJeff Garzik return 0; 3210c6fd2807SJeff Garzik } 3211c6fd2807SJeff Garzik 3212c6fd2807SJeff Garzik if (strcmp(serial[0], serial[1])) { 3213c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "serial number mismatch " 3214c6fd2807SJeff Garzik "'%s' != '%s'\n", serial[0], serial[1]); 3215c6fd2807SJeff Garzik return 0; 3216c6fd2807SJeff Garzik } 3217c6fd2807SJeff Garzik 3218c6fd2807SJeff Garzik if (dev->class == ATA_DEV_ATA && dev->n_sectors != new_n_sectors) { 3219c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "n_sectors mismatch " 3220c6fd2807SJeff Garzik "%llu != %llu\n", 3221c6fd2807SJeff Garzik (unsigned long long)dev->n_sectors, 3222c6fd2807SJeff Garzik (unsigned long long)new_n_sectors); 3223c6fd2807SJeff Garzik return 0; 3224c6fd2807SJeff Garzik } 3225c6fd2807SJeff Garzik 3226c6fd2807SJeff Garzik return 1; 3227c6fd2807SJeff Garzik } 3228c6fd2807SJeff Garzik 3229c6fd2807SJeff Garzik /** 3230c6fd2807SJeff Garzik * ata_dev_revalidate - Revalidate ATA device 3231c6fd2807SJeff Garzik * @dev: device to revalidate 3232bff04647STejun Heo * @readid_flags: read ID flags 3233c6fd2807SJeff Garzik * 3234c6fd2807SJeff Garzik * Re-read IDENTIFY page and make sure @dev is still attached to 3235c6fd2807SJeff Garzik * the port. 3236c6fd2807SJeff Garzik * 3237c6fd2807SJeff Garzik * LOCKING: 3238c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3239c6fd2807SJeff Garzik * 3240c6fd2807SJeff Garzik * RETURNS: 3241c6fd2807SJeff Garzik * 0 on success, negative errno otherwise 3242c6fd2807SJeff Garzik */ 3243bff04647STejun Heo int ata_dev_revalidate(struct ata_device *dev, unsigned int readid_flags) 3244c6fd2807SJeff Garzik { 3245c6fd2807SJeff Garzik unsigned int class = dev->class; 3246c6fd2807SJeff Garzik u16 *id = (void *)dev->ap->sector_buf; 3247c6fd2807SJeff Garzik int rc; 3248c6fd2807SJeff Garzik 3249c6fd2807SJeff Garzik if (!ata_dev_enabled(dev)) { 3250c6fd2807SJeff Garzik rc = -ENODEV; 3251c6fd2807SJeff Garzik goto fail; 3252c6fd2807SJeff Garzik } 3253c6fd2807SJeff Garzik 3254c6fd2807SJeff Garzik /* read ID data */ 3255bff04647STejun Heo rc = ata_dev_read_id(dev, &class, readid_flags, id); 3256c6fd2807SJeff Garzik if (rc) 3257c6fd2807SJeff Garzik goto fail; 3258c6fd2807SJeff Garzik 3259c6fd2807SJeff Garzik /* is the device still there? */ 3260c6fd2807SJeff Garzik if (!ata_dev_same_device(dev, class, id)) { 3261c6fd2807SJeff Garzik rc = -ENODEV; 3262c6fd2807SJeff Garzik goto fail; 3263c6fd2807SJeff Garzik } 3264c6fd2807SJeff Garzik 3265c6fd2807SJeff Garzik memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS); 3266c6fd2807SJeff Garzik 3267c6fd2807SJeff Garzik /* configure device according to the new ID */ 3268efdaedc4STejun Heo rc = ata_dev_configure(dev); 3269c6fd2807SJeff Garzik if (rc == 0) 3270c6fd2807SJeff Garzik return 0; 3271c6fd2807SJeff Garzik 3272c6fd2807SJeff Garzik fail: 3273c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_ERR, "revalidation failed (errno=%d)\n", rc); 3274c6fd2807SJeff Garzik return rc; 3275c6fd2807SJeff Garzik } 3276c6fd2807SJeff Garzik 32776919a0a6SAlan Cox struct ata_blacklist_entry { 32786919a0a6SAlan Cox const char *model_num; 32796919a0a6SAlan Cox const char *model_rev; 32806919a0a6SAlan Cox unsigned long horkage; 32816919a0a6SAlan Cox }; 32826919a0a6SAlan Cox 32836919a0a6SAlan Cox static const struct ata_blacklist_entry ata_device_blacklist [] = { 32846919a0a6SAlan Cox /* Devices with DMA related problems under Linux */ 32856919a0a6SAlan Cox { "WDC AC11000H", NULL, ATA_HORKAGE_NODMA }, 32866919a0a6SAlan Cox { "WDC AC22100H", NULL, ATA_HORKAGE_NODMA }, 32876919a0a6SAlan Cox { "WDC AC32500H", NULL, ATA_HORKAGE_NODMA }, 32886919a0a6SAlan Cox { "WDC AC33100H", NULL, ATA_HORKAGE_NODMA }, 32896919a0a6SAlan Cox { "WDC AC31600H", NULL, ATA_HORKAGE_NODMA }, 32906919a0a6SAlan Cox { "WDC AC32100H", "24.09P07", ATA_HORKAGE_NODMA }, 32916919a0a6SAlan Cox { "WDC AC23200L", "21.10N21", ATA_HORKAGE_NODMA }, 32926919a0a6SAlan Cox { "Compaq CRD-8241B", NULL, ATA_HORKAGE_NODMA }, 32936919a0a6SAlan Cox { "CRD-8400B", NULL, ATA_HORKAGE_NODMA }, 32946919a0a6SAlan Cox { "CRD-8480B", NULL, ATA_HORKAGE_NODMA }, 32956919a0a6SAlan Cox { "CRD-8482B", NULL, ATA_HORKAGE_NODMA }, 32966919a0a6SAlan Cox { "CRD-84", NULL, ATA_HORKAGE_NODMA }, 32976919a0a6SAlan Cox { "SanDisk SDP3B", NULL, ATA_HORKAGE_NODMA }, 32986919a0a6SAlan Cox { "SanDisk SDP3B-64", NULL, ATA_HORKAGE_NODMA }, 32996919a0a6SAlan Cox { "SANYO CD-ROM CRD", NULL, ATA_HORKAGE_NODMA }, 33006919a0a6SAlan Cox { "HITACHI CDR-8", NULL, ATA_HORKAGE_NODMA }, 33016919a0a6SAlan Cox { "HITACHI CDR-8335", NULL, ATA_HORKAGE_NODMA }, 33026919a0a6SAlan Cox { "HITACHI CDR-8435", NULL, ATA_HORKAGE_NODMA }, 33036919a0a6SAlan Cox { "Toshiba CD-ROM XM-6202B", NULL, ATA_HORKAGE_NODMA }, 33046919a0a6SAlan Cox { "TOSHIBA CD-ROM XM-1702BC", NULL, ATA_HORKAGE_NODMA }, 33056919a0a6SAlan Cox { "CD-532E-A", NULL, ATA_HORKAGE_NODMA }, 33066919a0a6SAlan Cox { "E-IDE CD-ROM CR-840",NULL, ATA_HORKAGE_NODMA }, 33076919a0a6SAlan Cox { "CD-ROM Drive/F5A", NULL, ATA_HORKAGE_NODMA }, 33086919a0a6SAlan Cox { "WPI CDD-820", NULL, ATA_HORKAGE_NODMA }, 33096919a0a6SAlan Cox { "SAMSUNG CD-ROM SC-148C", NULL, ATA_HORKAGE_NODMA }, 33106919a0a6SAlan Cox { "SAMSUNG CD-ROM SC", NULL, ATA_HORKAGE_NODMA }, 33116919a0a6SAlan Cox { "SanDisk SDP3B-64", NULL, ATA_HORKAGE_NODMA }, 33126919a0a6SAlan Cox { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA }, 33136919a0a6SAlan Cox { "_NEC DV5800A", NULL, ATA_HORKAGE_NODMA }, 33146919a0a6SAlan Cox { "SAMSUNG CD-ROM SN-124","N001", ATA_HORKAGE_NODMA }, 33156919a0a6SAlan Cox 33166919a0a6SAlan Cox /* Devices we expect to fail diagnostics */ 33176919a0a6SAlan Cox 33186919a0a6SAlan Cox /* Devices where NCQ should be avoided */ 33196919a0a6SAlan Cox /* NCQ is slow */ 33206919a0a6SAlan Cox { "WDC WD740ADFD-00", NULL, ATA_HORKAGE_NONCQ }, 33216919a0a6SAlan Cox 33226919a0a6SAlan Cox /* Devices with NCQ limits */ 33236919a0a6SAlan Cox 33246919a0a6SAlan Cox /* End Marker */ 33256919a0a6SAlan Cox { } 3326c6fd2807SJeff Garzik }; 3327c6fd2807SJeff Garzik 33286919a0a6SAlan Cox unsigned long ata_device_blacklisted(const struct ata_device *dev) 3329c6fd2807SJeff Garzik { 33308bfa79fcSTejun Heo unsigned char model_num[ATA_ID_PROD_LEN + 1]; 33318bfa79fcSTejun Heo unsigned char model_rev[ATA_ID_FW_REV_LEN + 1]; 33326919a0a6SAlan Cox const struct ata_blacklist_entry *ad = ata_device_blacklist; 3333c6fd2807SJeff Garzik 33348bfa79fcSTejun Heo ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num)); 33358bfa79fcSTejun Heo ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev)); 3336c6fd2807SJeff Garzik 33376919a0a6SAlan Cox while (ad->model_num) { 33388bfa79fcSTejun Heo if (!strcmp(ad->model_num, model_num)) { 33396919a0a6SAlan Cox if (ad->model_rev == NULL) 33406919a0a6SAlan Cox return ad->horkage; 33418bfa79fcSTejun Heo if (!strcmp(ad->model_rev, model_rev)) 33426919a0a6SAlan Cox return ad->horkage; 3343c6fd2807SJeff Garzik } 33446919a0a6SAlan Cox ad++; 3345c6fd2807SJeff Garzik } 3346c6fd2807SJeff Garzik return 0; 3347c6fd2807SJeff Garzik } 3348c6fd2807SJeff Garzik 33496919a0a6SAlan Cox static int ata_dma_blacklisted(const struct ata_device *dev) 33506919a0a6SAlan Cox { 33516919a0a6SAlan Cox /* We don't support polling DMA. 33526919a0a6SAlan Cox * DMA blacklist those ATAPI devices with CDB-intr (and use PIO) 33536919a0a6SAlan Cox * if the LLDD handles only interrupts in the HSM_ST_LAST state. 33546919a0a6SAlan Cox */ 33556919a0a6SAlan Cox if ((dev->ap->flags & ATA_FLAG_PIO_POLLING) && 33566919a0a6SAlan Cox (dev->flags & ATA_DFLAG_CDB_INTR)) 33576919a0a6SAlan Cox return 1; 33586919a0a6SAlan Cox return (ata_device_blacklisted(dev) & ATA_HORKAGE_NODMA) ? 1 : 0; 33596919a0a6SAlan Cox } 33606919a0a6SAlan Cox 3361c6fd2807SJeff Garzik /** 3362c6fd2807SJeff Garzik * ata_dev_xfermask - Compute supported xfermask of the given device 3363c6fd2807SJeff Garzik * @dev: Device to compute xfermask for 3364c6fd2807SJeff Garzik * 3365c6fd2807SJeff Garzik * Compute supported xfermask of @dev and store it in 3366c6fd2807SJeff Garzik * dev->*_mask. This function is responsible for applying all 3367c6fd2807SJeff Garzik * known limits including host controller limits, device 3368c6fd2807SJeff Garzik * blacklist, etc... 3369c6fd2807SJeff Garzik * 3370c6fd2807SJeff Garzik * LOCKING: 3371c6fd2807SJeff Garzik * None. 3372c6fd2807SJeff Garzik */ 3373c6fd2807SJeff Garzik static void ata_dev_xfermask(struct ata_device *dev) 3374c6fd2807SJeff Garzik { 3375c6fd2807SJeff Garzik struct ata_port *ap = dev->ap; 3376cca3974eSJeff Garzik struct ata_host *host = ap->host; 3377c6fd2807SJeff Garzik unsigned long xfer_mask; 3378c6fd2807SJeff Garzik 3379c6fd2807SJeff Garzik /* controller modes available */ 3380c6fd2807SJeff Garzik xfer_mask = ata_pack_xfermask(ap->pio_mask, 3381c6fd2807SJeff Garzik ap->mwdma_mask, ap->udma_mask); 3382c6fd2807SJeff Garzik 3383c6fd2807SJeff Garzik /* Apply cable rule here. Don't apply it early because when 3384c6fd2807SJeff Garzik * we handle hot plug the cable type can itself change. 3385c6fd2807SJeff Garzik */ 3386c6fd2807SJeff Garzik if (ap->cbl == ATA_CBL_PATA40) 3387c6fd2807SJeff Garzik xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA); 3388fc085150SAlan Cox /* Apply drive side cable rule. Unknown or 80 pin cables reported 3389fc085150SAlan Cox * host side are checked drive side as well. Cases where we know a 3390fc085150SAlan Cox * 40wire cable is used safely for 80 are not checked here. 3391fc085150SAlan Cox */ 3392fc085150SAlan Cox if (ata_drive_40wire(dev->id) && (ap->cbl == ATA_CBL_PATA_UNK || ap->cbl == ATA_CBL_PATA80)) 3393fc085150SAlan Cox xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA); 3394fc085150SAlan Cox 3395c6fd2807SJeff Garzik 3396c6fd2807SJeff Garzik xfer_mask &= ata_pack_xfermask(dev->pio_mask, 3397c6fd2807SJeff Garzik dev->mwdma_mask, dev->udma_mask); 3398c6fd2807SJeff Garzik xfer_mask &= ata_id_xfermask(dev->id); 3399c6fd2807SJeff Garzik 3400b352e57dSAlan Cox /* 3401b352e57dSAlan Cox * CFA Advanced TrueIDE timings are not allowed on a shared 3402b352e57dSAlan Cox * cable 3403b352e57dSAlan Cox */ 3404b352e57dSAlan Cox if (ata_dev_pair(dev)) { 3405b352e57dSAlan Cox /* No PIO5 or PIO6 */ 3406b352e57dSAlan Cox xfer_mask &= ~(0x03 << (ATA_SHIFT_PIO + 5)); 3407b352e57dSAlan Cox /* No MWDMA3 or MWDMA 4 */ 3408b352e57dSAlan Cox xfer_mask &= ~(0x03 << (ATA_SHIFT_MWDMA + 3)); 3409b352e57dSAlan Cox } 3410b352e57dSAlan Cox 3411c6fd2807SJeff Garzik if (ata_dma_blacklisted(dev)) { 3412c6fd2807SJeff Garzik xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA); 3413c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 3414c6fd2807SJeff Garzik "device is on DMA blacklist, disabling DMA\n"); 3415c6fd2807SJeff Garzik } 3416c6fd2807SJeff Garzik 3417cca3974eSJeff Garzik if ((host->flags & ATA_HOST_SIMPLEX) && host->simplex_claimed) { 3418c6fd2807SJeff Garzik xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA); 3419c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "simplex DMA is claimed by " 3420c6fd2807SJeff Garzik "other device, disabling DMA\n"); 3421c6fd2807SJeff Garzik } 3422c6fd2807SJeff Garzik 3423c6fd2807SJeff Garzik if (ap->ops->mode_filter) 3424c6fd2807SJeff Garzik xfer_mask = ap->ops->mode_filter(ap, dev, xfer_mask); 3425c6fd2807SJeff Garzik 3426c6fd2807SJeff Garzik ata_unpack_xfermask(xfer_mask, &dev->pio_mask, 3427c6fd2807SJeff Garzik &dev->mwdma_mask, &dev->udma_mask); 3428c6fd2807SJeff Garzik } 3429c6fd2807SJeff Garzik 3430c6fd2807SJeff Garzik /** 3431c6fd2807SJeff Garzik * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command 3432c6fd2807SJeff Garzik * @dev: Device to which command will be sent 3433c6fd2807SJeff Garzik * 3434c6fd2807SJeff Garzik * Issue SET FEATURES - XFER MODE command to device @dev 3435c6fd2807SJeff Garzik * on port @ap. 3436c6fd2807SJeff Garzik * 3437c6fd2807SJeff Garzik * LOCKING: 3438c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 3439c6fd2807SJeff Garzik * 3440c6fd2807SJeff Garzik * RETURNS: 3441c6fd2807SJeff Garzik * 0 on success, AC_ERR_* mask otherwise. 3442c6fd2807SJeff Garzik */ 3443c6fd2807SJeff Garzik 3444c6fd2807SJeff Garzik static unsigned int ata_dev_set_xfermode(struct ata_device *dev) 3445c6fd2807SJeff Garzik { 3446c6fd2807SJeff Garzik struct ata_taskfile tf; 3447c6fd2807SJeff Garzik unsigned int err_mask; 3448c6fd2807SJeff Garzik 3449c6fd2807SJeff Garzik /* set up set-features taskfile */ 3450c6fd2807SJeff Garzik DPRINTK("set features - xfer mode\n"); 3451c6fd2807SJeff Garzik 3452c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 3453c6fd2807SJeff Garzik tf.command = ATA_CMD_SET_FEATURES; 3454c6fd2807SJeff Garzik tf.feature = SETFEATURES_XFER; 3455c6fd2807SJeff Garzik tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 3456c6fd2807SJeff Garzik tf.protocol = ATA_PROT_NODATA; 3457c6fd2807SJeff Garzik tf.nsect = dev->xfer_mode; 3458c6fd2807SJeff Garzik 3459c6fd2807SJeff Garzik err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0); 3460c6fd2807SJeff Garzik 3461c6fd2807SJeff Garzik DPRINTK("EXIT, err_mask=%x\n", err_mask); 3462c6fd2807SJeff Garzik return err_mask; 3463c6fd2807SJeff Garzik } 3464c6fd2807SJeff Garzik 3465c6fd2807SJeff Garzik /** 3466c6fd2807SJeff Garzik * ata_dev_init_params - Issue INIT DEV PARAMS command 3467c6fd2807SJeff Garzik * @dev: Device to which command will be sent 3468c6fd2807SJeff Garzik * @heads: Number of heads (taskfile parameter) 3469c6fd2807SJeff Garzik * @sectors: Number of sectors (taskfile parameter) 3470c6fd2807SJeff Garzik * 3471c6fd2807SJeff Garzik * LOCKING: 3472c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3473c6fd2807SJeff Garzik * 3474c6fd2807SJeff Garzik * RETURNS: 3475c6fd2807SJeff Garzik * 0 on success, AC_ERR_* mask otherwise. 3476c6fd2807SJeff Garzik */ 3477c6fd2807SJeff Garzik static unsigned int ata_dev_init_params(struct ata_device *dev, 3478c6fd2807SJeff Garzik u16 heads, u16 sectors) 3479c6fd2807SJeff Garzik { 3480c6fd2807SJeff Garzik struct ata_taskfile tf; 3481c6fd2807SJeff Garzik unsigned int err_mask; 3482c6fd2807SJeff Garzik 3483c6fd2807SJeff Garzik /* Number of sectors per track 1-255. Number of heads 1-16 */ 3484c6fd2807SJeff Garzik if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16) 3485c6fd2807SJeff Garzik return AC_ERR_INVALID; 3486c6fd2807SJeff Garzik 3487c6fd2807SJeff Garzik /* set up init dev params taskfile */ 3488c6fd2807SJeff Garzik DPRINTK("init dev params \n"); 3489c6fd2807SJeff Garzik 3490c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 3491c6fd2807SJeff Garzik tf.command = ATA_CMD_INIT_DEV_PARAMS; 3492c6fd2807SJeff Garzik tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 3493c6fd2807SJeff Garzik tf.protocol = ATA_PROT_NODATA; 3494c6fd2807SJeff Garzik tf.nsect = sectors; 3495c6fd2807SJeff Garzik tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */ 3496c6fd2807SJeff Garzik 3497c6fd2807SJeff Garzik err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0); 3498c6fd2807SJeff Garzik 3499c6fd2807SJeff Garzik DPRINTK("EXIT, err_mask=%x\n", err_mask); 3500c6fd2807SJeff Garzik return err_mask; 3501c6fd2807SJeff Garzik } 3502c6fd2807SJeff Garzik 3503c6fd2807SJeff Garzik /** 3504c6fd2807SJeff Garzik * ata_sg_clean - Unmap DMA memory associated with command 3505c6fd2807SJeff Garzik * @qc: Command containing DMA memory to be released 3506c6fd2807SJeff Garzik * 3507c6fd2807SJeff Garzik * Unmap all mapped DMA memory associated with this command. 3508c6fd2807SJeff Garzik * 3509c6fd2807SJeff Garzik * LOCKING: 3510cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 3511c6fd2807SJeff Garzik */ 351270e6ad0cSTejun Heo void ata_sg_clean(struct ata_queued_cmd *qc) 3513c6fd2807SJeff Garzik { 3514c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 3515c6fd2807SJeff Garzik struct scatterlist *sg = qc->__sg; 3516c6fd2807SJeff Garzik int dir = qc->dma_dir; 3517c6fd2807SJeff Garzik void *pad_buf = NULL; 3518c6fd2807SJeff Garzik 3519c6fd2807SJeff Garzik WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP)); 3520c6fd2807SJeff Garzik WARN_ON(sg == NULL); 3521c6fd2807SJeff Garzik 3522c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_SINGLE) 3523c6fd2807SJeff Garzik WARN_ON(qc->n_elem > 1); 3524c6fd2807SJeff Garzik 3525c6fd2807SJeff Garzik VPRINTK("unmapping %u sg elements\n", qc->n_elem); 3526c6fd2807SJeff Garzik 3527c6fd2807SJeff Garzik /* if we padded the buffer out to 32-bit bound, and data 3528c6fd2807SJeff Garzik * xfer direction is from-device, we must copy from the 3529c6fd2807SJeff Garzik * pad buffer back into the supplied buffer 3530c6fd2807SJeff Garzik */ 3531c6fd2807SJeff Garzik if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE)) 3532c6fd2807SJeff Garzik pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ); 3533c6fd2807SJeff Garzik 3534c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_SG) { 3535c6fd2807SJeff Garzik if (qc->n_elem) 3536c6fd2807SJeff Garzik dma_unmap_sg(ap->dev, sg, qc->n_elem, dir); 3537c6fd2807SJeff Garzik /* restore last sg */ 3538c6fd2807SJeff Garzik sg[qc->orig_n_elem - 1].length += qc->pad_len; 3539c6fd2807SJeff Garzik if (pad_buf) { 3540c6fd2807SJeff Garzik struct scatterlist *psg = &qc->pad_sgent; 3541c6fd2807SJeff Garzik void *addr = kmap_atomic(psg->page, KM_IRQ0); 3542c6fd2807SJeff Garzik memcpy(addr + psg->offset, pad_buf, qc->pad_len); 3543c6fd2807SJeff Garzik kunmap_atomic(addr, KM_IRQ0); 3544c6fd2807SJeff Garzik } 3545c6fd2807SJeff Garzik } else { 3546c6fd2807SJeff Garzik if (qc->n_elem) 3547c6fd2807SJeff Garzik dma_unmap_single(ap->dev, 3548c6fd2807SJeff Garzik sg_dma_address(&sg[0]), sg_dma_len(&sg[0]), 3549c6fd2807SJeff Garzik dir); 3550c6fd2807SJeff Garzik /* restore sg */ 3551c6fd2807SJeff Garzik sg->length += qc->pad_len; 3552c6fd2807SJeff Garzik if (pad_buf) 3553c6fd2807SJeff Garzik memcpy(qc->buf_virt + sg->length - qc->pad_len, 3554c6fd2807SJeff Garzik pad_buf, qc->pad_len); 3555c6fd2807SJeff Garzik } 3556c6fd2807SJeff Garzik 3557c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_DMAMAP; 3558c6fd2807SJeff Garzik qc->__sg = NULL; 3559c6fd2807SJeff Garzik } 3560c6fd2807SJeff Garzik 3561c6fd2807SJeff Garzik /** 3562c6fd2807SJeff Garzik * ata_fill_sg - Fill PCI IDE PRD table 3563c6fd2807SJeff Garzik * @qc: Metadata associated with taskfile to be transferred 3564c6fd2807SJeff Garzik * 3565c6fd2807SJeff Garzik * Fill PCI IDE PRD (scatter-gather) table with segments 3566c6fd2807SJeff Garzik * associated with the current disk command. 3567c6fd2807SJeff Garzik * 3568c6fd2807SJeff Garzik * LOCKING: 3569cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 3570c6fd2807SJeff Garzik * 3571c6fd2807SJeff Garzik */ 3572c6fd2807SJeff Garzik static void ata_fill_sg(struct ata_queued_cmd *qc) 3573c6fd2807SJeff Garzik { 3574c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 3575c6fd2807SJeff Garzik struct scatterlist *sg; 3576c6fd2807SJeff Garzik unsigned int idx; 3577c6fd2807SJeff Garzik 3578c6fd2807SJeff Garzik WARN_ON(qc->__sg == NULL); 3579c6fd2807SJeff Garzik WARN_ON(qc->n_elem == 0 && qc->pad_len == 0); 3580c6fd2807SJeff Garzik 3581c6fd2807SJeff Garzik idx = 0; 3582c6fd2807SJeff Garzik ata_for_each_sg(sg, qc) { 3583c6fd2807SJeff Garzik u32 addr, offset; 3584c6fd2807SJeff Garzik u32 sg_len, len; 3585c6fd2807SJeff Garzik 3586c6fd2807SJeff Garzik /* determine if physical DMA addr spans 64K boundary. 3587c6fd2807SJeff Garzik * Note h/w doesn't support 64-bit, so we unconditionally 3588c6fd2807SJeff Garzik * truncate dma_addr_t to u32. 3589c6fd2807SJeff Garzik */ 3590c6fd2807SJeff Garzik addr = (u32) sg_dma_address(sg); 3591c6fd2807SJeff Garzik sg_len = sg_dma_len(sg); 3592c6fd2807SJeff Garzik 3593c6fd2807SJeff Garzik while (sg_len) { 3594c6fd2807SJeff Garzik offset = addr & 0xffff; 3595c6fd2807SJeff Garzik len = sg_len; 3596c6fd2807SJeff Garzik if ((offset + sg_len) > 0x10000) 3597c6fd2807SJeff Garzik len = 0x10000 - offset; 3598c6fd2807SJeff Garzik 3599c6fd2807SJeff Garzik ap->prd[idx].addr = cpu_to_le32(addr); 3600c6fd2807SJeff Garzik ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff); 3601c6fd2807SJeff Garzik VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len); 3602c6fd2807SJeff Garzik 3603c6fd2807SJeff Garzik idx++; 3604c6fd2807SJeff Garzik sg_len -= len; 3605c6fd2807SJeff Garzik addr += len; 3606c6fd2807SJeff Garzik } 3607c6fd2807SJeff Garzik } 3608c6fd2807SJeff Garzik 3609c6fd2807SJeff Garzik if (idx) 3610c6fd2807SJeff Garzik ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT); 3611c6fd2807SJeff Garzik } 3612c6fd2807SJeff Garzik /** 3613c6fd2807SJeff Garzik * ata_check_atapi_dma - Check whether ATAPI DMA can be supported 3614c6fd2807SJeff Garzik * @qc: Metadata associated with taskfile to check 3615c6fd2807SJeff Garzik * 3616c6fd2807SJeff Garzik * Allow low-level driver to filter ATA PACKET commands, returning 3617c6fd2807SJeff Garzik * a status indicating whether or not it is OK to use DMA for the 3618c6fd2807SJeff Garzik * supplied PACKET command. 3619c6fd2807SJeff Garzik * 3620c6fd2807SJeff Garzik * LOCKING: 3621cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 3622c6fd2807SJeff Garzik * 3623c6fd2807SJeff Garzik * RETURNS: 0 when ATAPI DMA can be used 3624c6fd2807SJeff Garzik * nonzero otherwise 3625c6fd2807SJeff Garzik */ 3626c6fd2807SJeff Garzik int ata_check_atapi_dma(struct ata_queued_cmd *qc) 3627c6fd2807SJeff Garzik { 3628c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 3629c6fd2807SJeff Garzik int rc = 0; /* Assume ATAPI DMA is OK by default */ 3630c6fd2807SJeff Garzik 3631c6fd2807SJeff Garzik if (ap->ops->check_atapi_dma) 3632c6fd2807SJeff Garzik rc = ap->ops->check_atapi_dma(qc); 3633c6fd2807SJeff Garzik 3634c6fd2807SJeff Garzik return rc; 3635c6fd2807SJeff Garzik } 3636c6fd2807SJeff Garzik /** 3637c6fd2807SJeff Garzik * ata_qc_prep - Prepare taskfile for submission 3638c6fd2807SJeff Garzik * @qc: Metadata associated with taskfile to be prepared 3639c6fd2807SJeff Garzik * 3640c6fd2807SJeff Garzik * Prepare ATA taskfile for submission. 3641c6fd2807SJeff Garzik * 3642c6fd2807SJeff Garzik * LOCKING: 3643cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 3644c6fd2807SJeff Garzik */ 3645c6fd2807SJeff Garzik void ata_qc_prep(struct ata_queued_cmd *qc) 3646c6fd2807SJeff Garzik { 3647c6fd2807SJeff Garzik if (!(qc->flags & ATA_QCFLAG_DMAMAP)) 3648c6fd2807SJeff Garzik return; 3649c6fd2807SJeff Garzik 3650c6fd2807SJeff Garzik ata_fill_sg(qc); 3651c6fd2807SJeff Garzik } 3652c6fd2807SJeff Garzik 3653c6fd2807SJeff Garzik void ata_noop_qc_prep(struct ata_queued_cmd *qc) { } 3654c6fd2807SJeff Garzik 3655c6fd2807SJeff Garzik /** 3656c6fd2807SJeff Garzik * ata_sg_init_one - Associate command with memory buffer 3657c6fd2807SJeff Garzik * @qc: Command to be associated 3658c6fd2807SJeff Garzik * @buf: Memory buffer 3659c6fd2807SJeff Garzik * @buflen: Length of memory buffer, in bytes. 3660c6fd2807SJeff Garzik * 3661c6fd2807SJeff Garzik * Initialize the data-related elements of queued_cmd @qc 3662c6fd2807SJeff Garzik * to point to a single memory buffer, @buf of byte length @buflen. 3663c6fd2807SJeff Garzik * 3664c6fd2807SJeff Garzik * LOCKING: 3665cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 3666c6fd2807SJeff Garzik */ 3667c6fd2807SJeff Garzik 3668c6fd2807SJeff Garzik void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen) 3669c6fd2807SJeff Garzik { 3670c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_SINGLE; 3671c6fd2807SJeff Garzik 3672c6fd2807SJeff Garzik qc->__sg = &qc->sgent; 3673c6fd2807SJeff Garzik qc->n_elem = 1; 3674c6fd2807SJeff Garzik qc->orig_n_elem = 1; 3675c6fd2807SJeff Garzik qc->buf_virt = buf; 3676c6fd2807SJeff Garzik qc->nbytes = buflen; 3677c6fd2807SJeff Garzik 367861c0596cSTejun Heo sg_init_one(&qc->sgent, buf, buflen); 3679c6fd2807SJeff Garzik } 3680c6fd2807SJeff Garzik 3681c6fd2807SJeff Garzik /** 3682c6fd2807SJeff Garzik * ata_sg_init - Associate command with scatter-gather table. 3683c6fd2807SJeff Garzik * @qc: Command to be associated 3684c6fd2807SJeff Garzik * @sg: Scatter-gather table. 3685c6fd2807SJeff Garzik * @n_elem: Number of elements in s/g table. 3686c6fd2807SJeff Garzik * 3687c6fd2807SJeff Garzik * Initialize the data-related elements of queued_cmd @qc 3688c6fd2807SJeff Garzik * to point to a scatter-gather table @sg, containing @n_elem 3689c6fd2807SJeff Garzik * elements. 3690c6fd2807SJeff Garzik * 3691c6fd2807SJeff Garzik * LOCKING: 3692cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 3693c6fd2807SJeff Garzik */ 3694c6fd2807SJeff Garzik 3695c6fd2807SJeff Garzik void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg, 3696c6fd2807SJeff Garzik unsigned int n_elem) 3697c6fd2807SJeff Garzik { 3698c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_SG; 3699c6fd2807SJeff Garzik qc->__sg = sg; 3700c6fd2807SJeff Garzik qc->n_elem = n_elem; 3701c6fd2807SJeff Garzik qc->orig_n_elem = n_elem; 3702c6fd2807SJeff Garzik } 3703c6fd2807SJeff Garzik 3704c6fd2807SJeff Garzik /** 3705c6fd2807SJeff Garzik * ata_sg_setup_one - DMA-map the memory buffer associated with a command. 3706c6fd2807SJeff Garzik * @qc: Command with memory buffer to be mapped. 3707c6fd2807SJeff Garzik * 3708c6fd2807SJeff Garzik * DMA-map the memory buffer associated with queued_cmd @qc. 3709c6fd2807SJeff Garzik * 3710c6fd2807SJeff Garzik * LOCKING: 3711cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 3712c6fd2807SJeff Garzik * 3713c6fd2807SJeff Garzik * RETURNS: 3714c6fd2807SJeff Garzik * Zero on success, negative on error. 3715c6fd2807SJeff Garzik */ 3716c6fd2807SJeff Garzik 3717c6fd2807SJeff Garzik static int ata_sg_setup_one(struct ata_queued_cmd *qc) 3718c6fd2807SJeff Garzik { 3719c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 3720c6fd2807SJeff Garzik int dir = qc->dma_dir; 3721c6fd2807SJeff Garzik struct scatterlist *sg = qc->__sg; 3722c6fd2807SJeff Garzik dma_addr_t dma_address; 3723c6fd2807SJeff Garzik int trim_sg = 0; 3724c6fd2807SJeff Garzik 3725c6fd2807SJeff Garzik /* we must lengthen transfers to end on a 32-bit boundary */ 3726c6fd2807SJeff Garzik qc->pad_len = sg->length & 3; 3727c6fd2807SJeff Garzik if (qc->pad_len) { 3728c6fd2807SJeff Garzik void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ); 3729c6fd2807SJeff Garzik struct scatterlist *psg = &qc->pad_sgent; 3730c6fd2807SJeff Garzik 3731c6fd2807SJeff Garzik WARN_ON(qc->dev->class != ATA_DEV_ATAPI); 3732c6fd2807SJeff Garzik 3733c6fd2807SJeff Garzik memset(pad_buf, 0, ATA_DMA_PAD_SZ); 3734c6fd2807SJeff Garzik 3735c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_WRITE) 3736c6fd2807SJeff Garzik memcpy(pad_buf, qc->buf_virt + sg->length - qc->pad_len, 3737c6fd2807SJeff Garzik qc->pad_len); 3738c6fd2807SJeff Garzik 3739c6fd2807SJeff Garzik sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ); 3740c6fd2807SJeff Garzik sg_dma_len(psg) = ATA_DMA_PAD_SZ; 3741c6fd2807SJeff Garzik /* trim sg */ 3742c6fd2807SJeff Garzik sg->length -= qc->pad_len; 3743c6fd2807SJeff Garzik if (sg->length == 0) 3744c6fd2807SJeff Garzik trim_sg = 1; 3745c6fd2807SJeff Garzik 3746c6fd2807SJeff Garzik DPRINTK("padding done, sg->length=%u pad_len=%u\n", 3747c6fd2807SJeff Garzik sg->length, qc->pad_len); 3748c6fd2807SJeff Garzik } 3749c6fd2807SJeff Garzik 3750c6fd2807SJeff Garzik if (trim_sg) { 3751c6fd2807SJeff Garzik qc->n_elem--; 3752c6fd2807SJeff Garzik goto skip_map; 3753c6fd2807SJeff Garzik } 3754c6fd2807SJeff Garzik 3755c6fd2807SJeff Garzik dma_address = dma_map_single(ap->dev, qc->buf_virt, 3756c6fd2807SJeff Garzik sg->length, dir); 3757c6fd2807SJeff Garzik if (dma_mapping_error(dma_address)) { 3758c6fd2807SJeff Garzik /* restore sg */ 3759c6fd2807SJeff Garzik sg->length += qc->pad_len; 3760c6fd2807SJeff Garzik return -1; 3761c6fd2807SJeff Garzik } 3762c6fd2807SJeff Garzik 3763c6fd2807SJeff Garzik sg_dma_address(sg) = dma_address; 3764c6fd2807SJeff Garzik sg_dma_len(sg) = sg->length; 3765c6fd2807SJeff Garzik 3766c6fd2807SJeff Garzik skip_map: 3767c6fd2807SJeff Garzik DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg), 3768c6fd2807SJeff Garzik qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read"); 3769c6fd2807SJeff Garzik 3770c6fd2807SJeff Garzik return 0; 3771c6fd2807SJeff Garzik } 3772c6fd2807SJeff Garzik 3773c6fd2807SJeff Garzik /** 3774c6fd2807SJeff Garzik * ata_sg_setup - DMA-map the scatter-gather table associated with a command. 3775c6fd2807SJeff Garzik * @qc: Command with scatter-gather table to be mapped. 3776c6fd2807SJeff Garzik * 3777c6fd2807SJeff Garzik * DMA-map the scatter-gather table associated with queued_cmd @qc. 3778c6fd2807SJeff Garzik * 3779c6fd2807SJeff Garzik * LOCKING: 3780cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 3781c6fd2807SJeff Garzik * 3782c6fd2807SJeff Garzik * RETURNS: 3783c6fd2807SJeff Garzik * Zero on success, negative on error. 3784c6fd2807SJeff Garzik * 3785c6fd2807SJeff Garzik */ 3786c6fd2807SJeff Garzik 3787c6fd2807SJeff Garzik static int ata_sg_setup(struct ata_queued_cmd *qc) 3788c6fd2807SJeff Garzik { 3789c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 3790c6fd2807SJeff Garzik struct scatterlist *sg = qc->__sg; 3791c6fd2807SJeff Garzik struct scatterlist *lsg = &sg[qc->n_elem - 1]; 3792c6fd2807SJeff Garzik int n_elem, pre_n_elem, dir, trim_sg = 0; 3793c6fd2807SJeff Garzik 3794c6fd2807SJeff Garzik VPRINTK("ENTER, ata%u\n", ap->id); 3795c6fd2807SJeff Garzik WARN_ON(!(qc->flags & ATA_QCFLAG_SG)); 3796c6fd2807SJeff Garzik 3797c6fd2807SJeff Garzik /* we must lengthen transfers to end on a 32-bit boundary */ 3798c6fd2807SJeff Garzik qc->pad_len = lsg->length & 3; 3799c6fd2807SJeff Garzik if (qc->pad_len) { 3800c6fd2807SJeff Garzik void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ); 3801c6fd2807SJeff Garzik struct scatterlist *psg = &qc->pad_sgent; 3802c6fd2807SJeff Garzik unsigned int offset; 3803c6fd2807SJeff Garzik 3804c6fd2807SJeff Garzik WARN_ON(qc->dev->class != ATA_DEV_ATAPI); 3805c6fd2807SJeff Garzik 3806c6fd2807SJeff Garzik memset(pad_buf, 0, ATA_DMA_PAD_SZ); 3807c6fd2807SJeff Garzik 3808c6fd2807SJeff Garzik /* 3809c6fd2807SJeff Garzik * psg->page/offset are used to copy to-be-written 3810c6fd2807SJeff Garzik * data in this function or read data in ata_sg_clean. 3811c6fd2807SJeff Garzik */ 3812c6fd2807SJeff Garzik offset = lsg->offset + lsg->length - qc->pad_len; 3813c6fd2807SJeff Garzik psg->page = nth_page(lsg->page, offset >> PAGE_SHIFT); 3814c6fd2807SJeff Garzik psg->offset = offset_in_page(offset); 3815c6fd2807SJeff Garzik 3816c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_WRITE) { 3817c6fd2807SJeff Garzik void *addr = kmap_atomic(psg->page, KM_IRQ0); 3818c6fd2807SJeff Garzik memcpy(pad_buf, addr + psg->offset, qc->pad_len); 3819c6fd2807SJeff Garzik kunmap_atomic(addr, KM_IRQ0); 3820c6fd2807SJeff Garzik } 3821c6fd2807SJeff Garzik 3822c6fd2807SJeff Garzik sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ); 3823c6fd2807SJeff Garzik sg_dma_len(psg) = ATA_DMA_PAD_SZ; 3824c6fd2807SJeff Garzik /* trim last sg */ 3825c6fd2807SJeff Garzik lsg->length -= qc->pad_len; 3826c6fd2807SJeff Garzik if (lsg->length == 0) 3827c6fd2807SJeff Garzik trim_sg = 1; 3828c6fd2807SJeff Garzik 3829c6fd2807SJeff Garzik DPRINTK("padding done, sg[%d].length=%u pad_len=%u\n", 3830c6fd2807SJeff Garzik qc->n_elem - 1, lsg->length, qc->pad_len); 3831c6fd2807SJeff Garzik } 3832c6fd2807SJeff Garzik 3833c6fd2807SJeff Garzik pre_n_elem = qc->n_elem; 3834c6fd2807SJeff Garzik if (trim_sg && pre_n_elem) 3835c6fd2807SJeff Garzik pre_n_elem--; 3836c6fd2807SJeff Garzik 3837c6fd2807SJeff Garzik if (!pre_n_elem) { 3838c6fd2807SJeff Garzik n_elem = 0; 3839c6fd2807SJeff Garzik goto skip_map; 3840c6fd2807SJeff Garzik } 3841c6fd2807SJeff Garzik 3842c6fd2807SJeff Garzik dir = qc->dma_dir; 3843c6fd2807SJeff Garzik n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir); 3844c6fd2807SJeff Garzik if (n_elem < 1) { 3845c6fd2807SJeff Garzik /* restore last sg */ 3846c6fd2807SJeff Garzik lsg->length += qc->pad_len; 3847c6fd2807SJeff Garzik return -1; 3848c6fd2807SJeff Garzik } 3849c6fd2807SJeff Garzik 3850c6fd2807SJeff Garzik DPRINTK("%d sg elements mapped\n", n_elem); 3851c6fd2807SJeff Garzik 3852c6fd2807SJeff Garzik skip_map: 3853c6fd2807SJeff Garzik qc->n_elem = n_elem; 3854c6fd2807SJeff Garzik 3855c6fd2807SJeff Garzik return 0; 3856c6fd2807SJeff Garzik } 3857c6fd2807SJeff Garzik 3858c6fd2807SJeff Garzik /** 3859c6fd2807SJeff Garzik * swap_buf_le16 - swap halves of 16-bit words in place 3860c6fd2807SJeff Garzik * @buf: Buffer to swap 3861c6fd2807SJeff Garzik * @buf_words: Number of 16-bit words in buffer. 3862c6fd2807SJeff Garzik * 3863c6fd2807SJeff Garzik * Swap halves of 16-bit words if needed to convert from 3864c6fd2807SJeff Garzik * little-endian byte order to native cpu byte order, or 3865c6fd2807SJeff Garzik * vice-versa. 3866c6fd2807SJeff Garzik * 3867c6fd2807SJeff Garzik * LOCKING: 3868c6fd2807SJeff Garzik * Inherited from caller. 3869c6fd2807SJeff Garzik */ 3870c6fd2807SJeff Garzik void swap_buf_le16(u16 *buf, unsigned int buf_words) 3871c6fd2807SJeff Garzik { 3872c6fd2807SJeff Garzik #ifdef __BIG_ENDIAN 3873c6fd2807SJeff Garzik unsigned int i; 3874c6fd2807SJeff Garzik 3875c6fd2807SJeff Garzik for (i = 0; i < buf_words; i++) 3876c6fd2807SJeff Garzik buf[i] = le16_to_cpu(buf[i]); 3877c6fd2807SJeff Garzik #endif /* __BIG_ENDIAN */ 3878c6fd2807SJeff Garzik } 3879c6fd2807SJeff Garzik 3880c6fd2807SJeff Garzik /** 3881c6fd2807SJeff Garzik * ata_mmio_data_xfer - Transfer data by MMIO 3882c6fd2807SJeff Garzik * @adev: device for this I/O 3883c6fd2807SJeff Garzik * @buf: data buffer 3884c6fd2807SJeff Garzik * @buflen: buffer length 3885c6fd2807SJeff Garzik * @write_data: read/write 3886c6fd2807SJeff Garzik * 3887c6fd2807SJeff Garzik * Transfer data from/to the device data register by MMIO. 3888c6fd2807SJeff Garzik * 3889c6fd2807SJeff Garzik * LOCKING: 3890c6fd2807SJeff Garzik * Inherited from caller. 3891c6fd2807SJeff Garzik */ 3892c6fd2807SJeff Garzik 3893c6fd2807SJeff Garzik void ata_mmio_data_xfer(struct ata_device *adev, unsigned char *buf, 3894c6fd2807SJeff Garzik unsigned int buflen, int write_data) 3895c6fd2807SJeff Garzik { 3896c6fd2807SJeff Garzik struct ata_port *ap = adev->ap; 3897c6fd2807SJeff Garzik unsigned int i; 3898c6fd2807SJeff Garzik unsigned int words = buflen >> 1; 3899c6fd2807SJeff Garzik u16 *buf16 = (u16 *) buf; 3900c6fd2807SJeff Garzik void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr; 3901c6fd2807SJeff Garzik 3902c6fd2807SJeff Garzik /* Transfer multiple of 2 bytes */ 3903c6fd2807SJeff Garzik if (write_data) { 3904c6fd2807SJeff Garzik for (i = 0; i < words; i++) 3905c6fd2807SJeff Garzik writew(le16_to_cpu(buf16[i]), mmio); 3906c6fd2807SJeff Garzik } else { 3907c6fd2807SJeff Garzik for (i = 0; i < words; i++) 3908c6fd2807SJeff Garzik buf16[i] = cpu_to_le16(readw(mmio)); 3909c6fd2807SJeff Garzik } 3910c6fd2807SJeff Garzik 3911c6fd2807SJeff Garzik /* Transfer trailing 1 byte, if any. */ 3912c6fd2807SJeff Garzik if (unlikely(buflen & 0x01)) { 3913c6fd2807SJeff Garzik u16 align_buf[1] = { 0 }; 3914c6fd2807SJeff Garzik unsigned char *trailing_buf = buf + buflen - 1; 3915c6fd2807SJeff Garzik 3916c6fd2807SJeff Garzik if (write_data) { 3917c6fd2807SJeff Garzik memcpy(align_buf, trailing_buf, 1); 3918c6fd2807SJeff Garzik writew(le16_to_cpu(align_buf[0]), mmio); 3919c6fd2807SJeff Garzik } else { 3920c6fd2807SJeff Garzik align_buf[0] = cpu_to_le16(readw(mmio)); 3921c6fd2807SJeff Garzik memcpy(trailing_buf, align_buf, 1); 3922c6fd2807SJeff Garzik } 3923c6fd2807SJeff Garzik } 3924c6fd2807SJeff Garzik } 3925c6fd2807SJeff Garzik 3926c6fd2807SJeff Garzik /** 3927c6fd2807SJeff Garzik * ata_pio_data_xfer - Transfer data by PIO 3928c6fd2807SJeff Garzik * @adev: device to target 3929c6fd2807SJeff Garzik * @buf: data buffer 3930c6fd2807SJeff Garzik * @buflen: buffer length 3931c6fd2807SJeff Garzik * @write_data: read/write 3932c6fd2807SJeff Garzik * 3933c6fd2807SJeff Garzik * Transfer data from/to the device data register by PIO. 3934c6fd2807SJeff Garzik * 3935c6fd2807SJeff Garzik * LOCKING: 3936c6fd2807SJeff Garzik * Inherited from caller. 3937c6fd2807SJeff Garzik */ 3938c6fd2807SJeff Garzik 3939c6fd2807SJeff Garzik void ata_pio_data_xfer(struct ata_device *adev, unsigned char *buf, 3940c6fd2807SJeff Garzik unsigned int buflen, int write_data) 3941c6fd2807SJeff Garzik { 3942c6fd2807SJeff Garzik struct ata_port *ap = adev->ap; 3943c6fd2807SJeff Garzik unsigned int words = buflen >> 1; 3944c6fd2807SJeff Garzik 3945c6fd2807SJeff Garzik /* Transfer multiple of 2 bytes */ 3946c6fd2807SJeff Garzik if (write_data) 3947c6fd2807SJeff Garzik outsw(ap->ioaddr.data_addr, buf, words); 3948c6fd2807SJeff Garzik else 3949c6fd2807SJeff Garzik insw(ap->ioaddr.data_addr, buf, words); 3950c6fd2807SJeff Garzik 3951c6fd2807SJeff Garzik /* Transfer trailing 1 byte, if any. */ 3952c6fd2807SJeff Garzik if (unlikely(buflen & 0x01)) { 3953c6fd2807SJeff Garzik u16 align_buf[1] = { 0 }; 3954c6fd2807SJeff Garzik unsigned char *trailing_buf = buf + buflen - 1; 3955c6fd2807SJeff Garzik 3956c6fd2807SJeff Garzik if (write_data) { 3957c6fd2807SJeff Garzik memcpy(align_buf, trailing_buf, 1); 3958c6fd2807SJeff Garzik outw(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr); 3959c6fd2807SJeff Garzik } else { 3960c6fd2807SJeff Garzik align_buf[0] = cpu_to_le16(inw(ap->ioaddr.data_addr)); 3961c6fd2807SJeff Garzik memcpy(trailing_buf, align_buf, 1); 3962c6fd2807SJeff Garzik } 3963c6fd2807SJeff Garzik } 3964c6fd2807SJeff Garzik } 3965c6fd2807SJeff Garzik 3966c6fd2807SJeff Garzik /** 3967c6fd2807SJeff Garzik * ata_pio_data_xfer_noirq - Transfer data by PIO 3968c6fd2807SJeff Garzik * @adev: device to target 3969c6fd2807SJeff Garzik * @buf: data buffer 3970c6fd2807SJeff Garzik * @buflen: buffer length 3971c6fd2807SJeff Garzik * @write_data: read/write 3972c6fd2807SJeff Garzik * 3973c6fd2807SJeff Garzik * Transfer data from/to the device data register by PIO. Do the 3974c6fd2807SJeff Garzik * transfer with interrupts disabled. 3975c6fd2807SJeff Garzik * 3976c6fd2807SJeff Garzik * LOCKING: 3977c6fd2807SJeff Garzik * Inherited from caller. 3978c6fd2807SJeff Garzik */ 3979c6fd2807SJeff Garzik 3980c6fd2807SJeff Garzik void ata_pio_data_xfer_noirq(struct ata_device *adev, unsigned char *buf, 3981c6fd2807SJeff Garzik unsigned int buflen, int write_data) 3982c6fd2807SJeff Garzik { 3983c6fd2807SJeff Garzik unsigned long flags; 3984c6fd2807SJeff Garzik local_irq_save(flags); 3985c6fd2807SJeff Garzik ata_pio_data_xfer(adev, buf, buflen, write_data); 3986c6fd2807SJeff Garzik local_irq_restore(flags); 3987c6fd2807SJeff Garzik } 3988c6fd2807SJeff Garzik 3989c6fd2807SJeff Garzik 3990c6fd2807SJeff Garzik /** 3991c6fd2807SJeff Garzik * ata_pio_sector - Transfer ATA_SECT_SIZE (512 bytes) of data. 3992c6fd2807SJeff Garzik * @qc: Command on going 3993c6fd2807SJeff Garzik * 3994c6fd2807SJeff Garzik * Transfer ATA_SECT_SIZE of data from/to the ATA device. 3995c6fd2807SJeff Garzik * 3996c6fd2807SJeff Garzik * LOCKING: 3997c6fd2807SJeff Garzik * Inherited from caller. 3998c6fd2807SJeff Garzik */ 3999c6fd2807SJeff Garzik 4000c6fd2807SJeff Garzik static void ata_pio_sector(struct ata_queued_cmd *qc) 4001c6fd2807SJeff Garzik { 4002c6fd2807SJeff Garzik int do_write = (qc->tf.flags & ATA_TFLAG_WRITE); 4003c6fd2807SJeff Garzik struct scatterlist *sg = qc->__sg; 4004c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4005c6fd2807SJeff Garzik struct page *page; 4006c6fd2807SJeff Garzik unsigned int offset; 4007c6fd2807SJeff Garzik unsigned char *buf; 4008c6fd2807SJeff Garzik 4009c6fd2807SJeff Garzik if (qc->cursect == (qc->nsect - 1)) 4010c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4011c6fd2807SJeff Garzik 4012c6fd2807SJeff Garzik page = sg[qc->cursg].page; 4013c6fd2807SJeff Garzik offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE; 4014c6fd2807SJeff Garzik 4015c6fd2807SJeff Garzik /* get the current page and offset */ 4016c6fd2807SJeff Garzik page = nth_page(page, (offset >> PAGE_SHIFT)); 4017c6fd2807SJeff Garzik offset %= PAGE_SIZE; 4018c6fd2807SJeff Garzik 4019c6fd2807SJeff Garzik DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read"); 4020c6fd2807SJeff Garzik 4021c6fd2807SJeff Garzik if (PageHighMem(page)) { 4022c6fd2807SJeff Garzik unsigned long flags; 4023c6fd2807SJeff Garzik 4024c6fd2807SJeff Garzik /* FIXME: use a bounce buffer */ 4025c6fd2807SJeff Garzik local_irq_save(flags); 4026c6fd2807SJeff Garzik buf = kmap_atomic(page, KM_IRQ0); 4027c6fd2807SJeff Garzik 4028c6fd2807SJeff Garzik /* do the actual data transfer */ 4029c6fd2807SJeff Garzik ap->ops->data_xfer(qc->dev, buf + offset, ATA_SECT_SIZE, do_write); 4030c6fd2807SJeff Garzik 4031c6fd2807SJeff Garzik kunmap_atomic(buf, KM_IRQ0); 4032c6fd2807SJeff Garzik local_irq_restore(flags); 4033c6fd2807SJeff Garzik } else { 4034c6fd2807SJeff Garzik buf = page_address(page); 4035c6fd2807SJeff Garzik ap->ops->data_xfer(qc->dev, buf + offset, ATA_SECT_SIZE, do_write); 4036c6fd2807SJeff Garzik } 4037c6fd2807SJeff Garzik 4038c6fd2807SJeff Garzik qc->cursect++; 4039c6fd2807SJeff Garzik qc->cursg_ofs++; 4040c6fd2807SJeff Garzik 4041c6fd2807SJeff Garzik if ((qc->cursg_ofs * ATA_SECT_SIZE) == (&sg[qc->cursg])->length) { 4042c6fd2807SJeff Garzik qc->cursg++; 4043c6fd2807SJeff Garzik qc->cursg_ofs = 0; 4044c6fd2807SJeff Garzik } 4045c6fd2807SJeff Garzik } 4046c6fd2807SJeff Garzik 4047c6fd2807SJeff Garzik /** 4048c6fd2807SJeff Garzik * ata_pio_sectors - Transfer one or many 512-byte sectors. 4049c6fd2807SJeff Garzik * @qc: Command on going 4050c6fd2807SJeff Garzik * 4051c6fd2807SJeff Garzik * Transfer one or many ATA_SECT_SIZE of data from/to the 4052c6fd2807SJeff Garzik * ATA device for the DRQ request. 4053c6fd2807SJeff Garzik * 4054c6fd2807SJeff Garzik * LOCKING: 4055c6fd2807SJeff Garzik * Inherited from caller. 4056c6fd2807SJeff Garzik */ 4057c6fd2807SJeff Garzik 4058c6fd2807SJeff Garzik static void ata_pio_sectors(struct ata_queued_cmd *qc) 4059c6fd2807SJeff Garzik { 4060c6fd2807SJeff Garzik if (is_multi_taskfile(&qc->tf)) { 4061c6fd2807SJeff Garzik /* READ/WRITE MULTIPLE */ 4062c6fd2807SJeff Garzik unsigned int nsect; 4063c6fd2807SJeff Garzik 4064c6fd2807SJeff Garzik WARN_ON(qc->dev->multi_count == 0); 4065c6fd2807SJeff Garzik 4066c6fd2807SJeff Garzik nsect = min(qc->nsect - qc->cursect, qc->dev->multi_count); 4067c6fd2807SJeff Garzik while (nsect--) 4068c6fd2807SJeff Garzik ata_pio_sector(qc); 4069c6fd2807SJeff Garzik } else 4070c6fd2807SJeff Garzik ata_pio_sector(qc); 4071c6fd2807SJeff Garzik } 4072c6fd2807SJeff Garzik 4073c6fd2807SJeff Garzik /** 4074c6fd2807SJeff Garzik * atapi_send_cdb - Write CDB bytes to hardware 4075c6fd2807SJeff Garzik * @ap: Port to which ATAPI device is attached. 4076c6fd2807SJeff Garzik * @qc: Taskfile currently active 4077c6fd2807SJeff Garzik * 4078c6fd2807SJeff Garzik * When device has indicated its readiness to accept 4079c6fd2807SJeff Garzik * a CDB, this function is called. Send the CDB. 4080c6fd2807SJeff Garzik * 4081c6fd2807SJeff Garzik * LOCKING: 4082c6fd2807SJeff Garzik * caller. 4083c6fd2807SJeff Garzik */ 4084c6fd2807SJeff Garzik 4085c6fd2807SJeff Garzik static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc) 4086c6fd2807SJeff Garzik { 4087c6fd2807SJeff Garzik /* send SCSI cdb */ 4088c6fd2807SJeff Garzik DPRINTK("send cdb\n"); 4089c6fd2807SJeff Garzik WARN_ON(qc->dev->cdb_len < 12); 4090c6fd2807SJeff Garzik 4091c6fd2807SJeff Garzik ap->ops->data_xfer(qc->dev, qc->cdb, qc->dev->cdb_len, 1); 4092c6fd2807SJeff Garzik ata_altstatus(ap); /* flush */ 4093c6fd2807SJeff Garzik 4094c6fd2807SJeff Garzik switch (qc->tf.protocol) { 4095c6fd2807SJeff Garzik case ATA_PROT_ATAPI: 4096c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST; 4097c6fd2807SJeff Garzik break; 4098c6fd2807SJeff Garzik case ATA_PROT_ATAPI_NODATA: 4099c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4100c6fd2807SJeff Garzik break; 4101c6fd2807SJeff Garzik case ATA_PROT_ATAPI_DMA: 4102c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4103c6fd2807SJeff Garzik /* initiate bmdma */ 4104c6fd2807SJeff Garzik ap->ops->bmdma_start(qc); 4105c6fd2807SJeff Garzik break; 4106c6fd2807SJeff Garzik } 4107c6fd2807SJeff Garzik } 4108c6fd2807SJeff Garzik 4109c6fd2807SJeff Garzik /** 4110c6fd2807SJeff Garzik * __atapi_pio_bytes - Transfer data from/to the ATAPI device. 4111c6fd2807SJeff Garzik * @qc: Command on going 4112c6fd2807SJeff Garzik * @bytes: number of bytes 4113c6fd2807SJeff Garzik * 4114c6fd2807SJeff Garzik * Transfer Transfer data from/to the ATAPI device. 4115c6fd2807SJeff Garzik * 4116c6fd2807SJeff Garzik * LOCKING: 4117c6fd2807SJeff Garzik * Inherited from caller. 4118c6fd2807SJeff Garzik * 4119c6fd2807SJeff Garzik */ 4120c6fd2807SJeff Garzik 4121c6fd2807SJeff Garzik static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes) 4122c6fd2807SJeff Garzik { 4123c6fd2807SJeff Garzik int do_write = (qc->tf.flags & ATA_TFLAG_WRITE); 4124c6fd2807SJeff Garzik struct scatterlist *sg = qc->__sg; 4125c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4126c6fd2807SJeff Garzik struct page *page; 4127c6fd2807SJeff Garzik unsigned char *buf; 4128c6fd2807SJeff Garzik unsigned int offset, count; 4129c6fd2807SJeff Garzik 4130c6fd2807SJeff Garzik if (qc->curbytes + bytes >= qc->nbytes) 4131c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4132c6fd2807SJeff Garzik 4133c6fd2807SJeff Garzik next_sg: 4134c6fd2807SJeff Garzik if (unlikely(qc->cursg >= qc->n_elem)) { 4135c6fd2807SJeff Garzik /* 4136c6fd2807SJeff Garzik * The end of qc->sg is reached and the device expects 4137c6fd2807SJeff Garzik * more data to transfer. In order not to overrun qc->sg 4138c6fd2807SJeff Garzik * and fulfill length specified in the byte count register, 4139c6fd2807SJeff Garzik * - for read case, discard trailing data from the device 4140c6fd2807SJeff Garzik * - for write case, padding zero data to the device 4141c6fd2807SJeff Garzik */ 4142c6fd2807SJeff Garzik u16 pad_buf[1] = { 0 }; 4143c6fd2807SJeff Garzik unsigned int words = bytes >> 1; 4144c6fd2807SJeff Garzik unsigned int i; 4145c6fd2807SJeff Garzik 4146c6fd2807SJeff Garzik if (words) /* warning if bytes > 1 */ 4147c6fd2807SJeff Garzik ata_dev_printk(qc->dev, KERN_WARNING, 4148c6fd2807SJeff Garzik "%u bytes trailing data\n", bytes); 4149c6fd2807SJeff Garzik 4150c6fd2807SJeff Garzik for (i = 0; i < words; i++) 4151c6fd2807SJeff Garzik ap->ops->data_xfer(qc->dev, (unsigned char*)pad_buf, 2, do_write); 4152c6fd2807SJeff Garzik 4153c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4154c6fd2807SJeff Garzik return; 4155c6fd2807SJeff Garzik } 4156c6fd2807SJeff Garzik 4157c6fd2807SJeff Garzik sg = &qc->__sg[qc->cursg]; 4158c6fd2807SJeff Garzik 4159c6fd2807SJeff Garzik page = sg->page; 4160c6fd2807SJeff Garzik offset = sg->offset + qc->cursg_ofs; 4161c6fd2807SJeff Garzik 4162c6fd2807SJeff Garzik /* get the current page and offset */ 4163c6fd2807SJeff Garzik page = nth_page(page, (offset >> PAGE_SHIFT)); 4164c6fd2807SJeff Garzik offset %= PAGE_SIZE; 4165c6fd2807SJeff Garzik 4166c6fd2807SJeff Garzik /* don't overrun current sg */ 4167c6fd2807SJeff Garzik count = min(sg->length - qc->cursg_ofs, bytes); 4168c6fd2807SJeff Garzik 4169c6fd2807SJeff Garzik /* don't cross page boundaries */ 4170c6fd2807SJeff Garzik count = min(count, (unsigned int)PAGE_SIZE - offset); 4171c6fd2807SJeff Garzik 4172c6fd2807SJeff Garzik DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read"); 4173c6fd2807SJeff Garzik 4174c6fd2807SJeff Garzik if (PageHighMem(page)) { 4175c6fd2807SJeff Garzik unsigned long flags; 4176c6fd2807SJeff Garzik 4177c6fd2807SJeff Garzik /* FIXME: use bounce buffer */ 4178c6fd2807SJeff Garzik local_irq_save(flags); 4179c6fd2807SJeff Garzik buf = kmap_atomic(page, KM_IRQ0); 4180c6fd2807SJeff Garzik 4181c6fd2807SJeff Garzik /* do the actual data transfer */ 4182c6fd2807SJeff Garzik ap->ops->data_xfer(qc->dev, buf + offset, count, do_write); 4183c6fd2807SJeff Garzik 4184c6fd2807SJeff Garzik kunmap_atomic(buf, KM_IRQ0); 4185c6fd2807SJeff Garzik local_irq_restore(flags); 4186c6fd2807SJeff Garzik } else { 4187c6fd2807SJeff Garzik buf = page_address(page); 4188c6fd2807SJeff Garzik ap->ops->data_xfer(qc->dev, buf + offset, count, do_write); 4189c6fd2807SJeff Garzik } 4190c6fd2807SJeff Garzik 4191c6fd2807SJeff Garzik bytes -= count; 4192c6fd2807SJeff Garzik qc->curbytes += count; 4193c6fd2807SJeff Garzik qc->cursg_ofs += count; 4194c6fd2807SJeff Garzik 4195c6fd2807SJeff Garzik if (qc->cursg_ofs == sg->length) { 4196c6fd2807SJeff Garzik qc->cursg++; 4197c6fd2807SJeff Garzik qc->cursg_ofs = 0; 4198c6fd2807SJeff Garzik } 4199c6fd2807SJeff Garzik 4200c6fd2807SJeff Garzik if (bytes) 4201c6fd2807SJeff Garzik goto next_sg; 4202c6fd2807SJeff Garzik } 4203c6fd2807SJeff Garzik 4204c6fd2807SJeff Garzik /** 4205c6fd2807SJeff Garzik * atapi_pio_bytes - Transfer data from/to the ATAPI device. 4206c6fd2807SJeff Garzik * @qc: Command on going 4207c6fd2807SJeff Garzik * 4208c6fd2807SJeff Garzik * Transfer Transfer data from/to the ATAPI device. 4209c6fd2807SJeff Garzik * 4210c6fd2807SJeff Garzik * LOCKING: 4211c6fd2807SJeff Garzik * Inherited from caller. 4212c6fd2807SJeff Garzik */ 4213c6fd2807SJeff Garzik 4214c6fd2807SJeff Garzik static void atapi_pio_bytes(struct ata_queued_cmd *qc) 4215c6fd2807SJeff Garzik { 4216c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4217c6fd2807SJeff Garzik struct ata_device *dev = qc->dev; 4218c6fd2807SJeff Garzik unsigned int ireason, bc_lo, bc_hi, bytes; 4219c6fd2807SJeff Garzik int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0; 4220c6fd2807SJeff Garzik 4221c6fd2807SJeff Garzik /* Abuse qc->result_tf for temp storage of intermediate TF 4222c6fd2807SJeff Garzik * here to save some kernel stack usage. 4223c6fd2807SJeff Garzik * For normal completion, qc->result_tf is not relevant. For 4224c6fd2807SJeff Garzik * error, qc->result_tf is later overwritten by ata_qc_complete(). 4225c6fd2807SJeff Garzik * So, the correctness of qc->result_tf is not affected. 4226c6fd2807SJeff Garzik */ 4227c6fd2807SJeff Garzik ap->ops->tf_read(ap, &qc->result_tf); 4228c6fd2807SJeff Garzik ireason = qc->result_tf.nsect; 4229c6fd2807SJeff Garzik bc_lo = qc->result_tf.lbam; 4230c6fd2807SJeff Garzik bc_hi = qc->result_tf.lbah; 4231c6fd2807SJeff Garzik bytes = (bc_hi << 8) | bc_lo; 4232c6fd2807SJeff Garzik 4233c6fd2807SJeff Garzik /* shall be cleared to zero, indicating xfer of data */ 4234c6fd2807SJeff Garzik if (ireason & (1 << 0)) 4235c6fd2807SJeff Garzik goto err_out; 4236c6fd2807SJeff Garzik 4237c6fd2807SJeff Garzik /* make sure transfer direction matches expected */ 4238c6fd2807SJeff Garzik i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0; 4239c6fd2807SJeff Garzik if (do_write != i_write) 4240c6fd2807SJeff Garzik goto err_out; 4241c6fd2807SJeff Garzik 4242c6fd2807SJeff Garzik VPRINTK("ata%u: xfering %d bytes\n", ap->id, bytes); 4243c6fd2807SJeff Garzik 4244c6fd2807SJeff Garzik __atapi_pio_bytes(qc, bytes); 4245c6fd2807SJeff Garzik 4246c6fd2807SJeff Garzik return; 4247c6fd2807SJeff Garzik 4248c6fd2807SJeff Garzik err_out: 4249c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "ATAPI check failed\n"); 4250c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HSM; 4251c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 4252c6fd2807SJeff Garzik } 4253c6fd2807SJeff Garzik 4254c6fd2807SJeff Garzik /** 4255c6fd2807SJeff Garzik * ata_hsm_ok_in_wq - Check if the qc can be handled in the workqueue. 4256c6fd2807SJeff Garzik * @ap: the target ata_port 4257c6fd2807SJeff Garzik * @qc: qc on going 4258c6fd2807SJeff Garzik * 4259c6fd2807SJeff Garzik * RETURNS: 4260c6fd2807SJeff Garzik * 1 if ok in workqueue, 0 otherwise. 4261c6fd2807SJeff Garzik */ 4262c6fd2807SJeff Garzik 4263c6fd2807SJeff Garzik static inline int ata_hsm_ok_in_wq(struct ata_port *ap, struct ata_queued_cmd *qc) 4264c6fd2807SJeff Garzik { 4265c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 4266c6fd2807SJeff Garzik return 1; 4267c6fd2807SJeff Garzik 4268c6fd2807SJeff Garzik if (ap->hsm_task_state == HSM_ST_FIRST) { 4269c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_PIO && 4270c6fd2807SJeff Garzik (qc->tf.flags & ATA_TFLAG_WRITE)) 4271c6fd2807SJeff Garzik return 1; 4272c6fd2807SJeff Garzik 4273c6fd2807SJeff Garzik if (is_atapi_taskfile(&qc->tf) && 4274c6fd2807SJeff Garzik !(qc->dev->flags & ATA_DFLAG_CDB_INTR)) 4275c6fd2807SJeff Garzik return 1; 4276c6fd2807SJeff Garzik } 4277c6fd2807SJeff Garzik 4278c6fd2807SJeff Garzik return 0; 4279c6fd2807SJeff Garzik } 4280c6fd2807SJeff Garzik 4281c6fd2807SJeff Garzik /** 4282c6fd2807SJeff Garzik * ata_hsm_qc_complete - finish a qc running on standard HSM 4283c6fd2807SJeff Garzik * @qc: Command to complete 4284c6fd2807SJeff Garzik * @in_wq: 1 if called from workqueue, 0 otherwise 4285c6fd2807SJeff Garzik * 4286c6fd2807SJeff Garzik * Finish @qc which is running on standard HSM. 4287c6fd2807SJeff Garzik * 4288c6fd2807SJeff Garzik * LOCKING: 4289cca3974eSJeff Garzik * If @in_wq is zero, spin_lock_irqsave(host lock). 4290c6fd2807SJeff Garzik * Otherwise, none on entry and grabs host lock. 4291c6fd2807SJeff Garzik */ 4292c6fd2807SJeff Garzik static void ata_hsm_qc_complete(struct ata_queued_cmd *qc, int in_wq) 4293c6fd2807SJeff Garzik { 4294c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4295c6fd2807SJeff Garzik unsigned long flags; 4296c6fd2807SJeff Garzik 4297c6fd2807SJeff Garzik if (ap->ops->error_handler) { 4298c6fd2807SJeff Garzik if (in_wq) { 4299c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 4300c6fd2807SJeff Garzik 4301cca3974eSJeff Garzik /* EH might have kicked in while host lock is 4302cca3974eSJeff Garzik * released. 4303c6fd2807SJeff Garzik */ 4304c6fd2807SJeff Garzik qc = ata_qc_from_tag(ap, qc->tag); 4305c6fd2807SJeff Garzik if (qc) { 4306c6fd2807SJeff Garzik if (likely(!(qc->err_mask & AC_ERR_HSM))) { 4307c6fd2807SJeff Garzik ata_irq_on(ap); 4308c6fd2807SJeff Garzik ata_qc_complete(qc); 4309c6fd2807SJeff Garzik } else 4310c6fd2807SJeff Garzik ata_port_freeze(ap); 4311c6fd2807SJeff Garzik } 4312c6fd2807SJeff Garzik 4313c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 4314c6fd2807SJeff Garzik } else { 4315c6fd2807SJeff Garzik if (likely(!(qc->err_mask & AC_ERR_HSM))) 4316c6fd2807SJeff Garzik ata_qc_complete(qc); 4317c6fd2807SJeff Garzik else 4318c6fd2807SJeff Garzik ata_port_freeze(ap); 4319c6fd2807SJeff Garzik } 4320c6fd2807SJeff Garzik } else { 4321c6fd2807SJeff Garzik if (in_wq) { 4322c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 4323c6fd2807SJeff Garzik ata_irq_on(ap); 4324c6fd2807SJeff Garzik ata_qc_complete(qc); 4325c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 4326c6fd2807SJeff Garzik } else 4327c6fd2807SJeff Garzik ata_qc_complete(qc); 4328c6fd2807SJeff Garzik } 4329c6fd2807SJeff Garzik 4330c6fd2807SJeff Garzik ata_altstatus(ap); /* flush */ 4331c6fd2807SJeff Garzik } 4332c6fd2807SJeff Garzik 4333c6fd2807SJeff Garzik /** 4334c6fd2807SJeff Garzik * ata_hsm_move - move the HSM to the next state. 4335c6fd2807SJeff Garzik * @ap: the target ata_port 4336c6fd2807SJeff Garzik * @qc: qc on going 4337c6fd2807SJeff Garzik * @status: current device status 4338c6fd2807SJeff Garzik * @in_wq: 1 if called from workqueue, 0 otherwise 4339c6fd2807SJeff Garzik * 4340c6fd2807SJeff Garzik * RETURNS: 4341c6fd2807SJeff Garzik * 1 when poll next status needed, 0 otherwise. 4342c6fd2807SJeff Garzik */ 4343c6fd2807SJeff Garzik int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc, 4344c6fd2807SJeff Garzik u8 status, int in_wq) 4345c6fd2807SJeff Garzik { 4346c6fd2807SJeff Garzik unsigned long flags = 0; 4347c6fd2807SJeff Garzik int poll_next; 4348c6fd2807SJeff Garzik 4349c6fd2807SJeff Garzik WARN_ON((qc->flags & ATA_QCFLAG_ACTIVE) == 0); 4350c6fd2807SJeff Garzik 4351c6fd2807SJeff Garzik /* Make sure ata_qc_issue_prot() does not throw things 4352c6fd2807SJeff Garzik * like DMA polling into the workqueue. Notice that 4353c6fd2807SJeff Garzik * in_wq is not equivalent to (qc->tf.flags & ATA_TFLAG_POLLING). 4354c6fd2807SJeff Garzik */ 4355c6fd2807SJeff Garzik WARN_ON(in_wq != ata_hsm_ok_in_wq(ap, qc)); 4356c6fd2807SJeff Garzik 4357c6fd2807SJeff Garzik fsm_start: 4358c6fd2807SJeff Garzik DPRINTK("ata%u: protocol %d task_state %d (dev_stat 0x%X)\n", 4359c6fd2807SJeff Garzik ap->id, qc->tf.protocol, ap->hsm_task_state, status); 4360c6fd2807SJeff Garzik 4361c6fd2807SJeff Garzik switch (ap->hsm_task_state) { 4362c6fd2807SJeff Garzik case HSM_ST_FIRST: 4363c6fd2807SJeff Garzik /* Send first data block or PACKET CDB */ 4364c6fd2807SJeff Garzik 4365c6fd2807SJeff Garzik /* If polling, we will stay in the work queue after 4366c6fd2807SJeff Garzik * sending the data. Otherwise, interrupt handler 4367c6fd2807SJeff Garzik * takes over after sending the data. 4368c6fd2807SJeff Garzik */ 4369c6fd2807SJeff Garzik poll_next = (qc->tf.flags & ATA_TFLAG_POLLING); 4370c6fd2807SJeff Garzik 4371c6fd2807SJeff Garzik /* check device status */ 4372c6fd2807SJeff Garzik if (unlikely((status & ATA_DRQ) == 0)) { 4373c6fd2807SJeff Garzik /* handle BSY=0, DRQ=0 as error */ 4374c6fd2807SJeff Garzik if (likely(status & (ATA_ERR | ATA_DF))) 4375c6fd2807SJeff Garzik /* device stops HSM for abort/error */ 4376c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_DEV; 4377c6fd2807SJeff Garzik else 4378c6fd2807SJeff Garzik /* HSM violation. Let EH handle this */ 4379c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HSM; 4380c6fd2807SJeff Garzik 4381c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 4382c6fd2807SJeff Garzik goto fsm_start; 4383c6fd2807SJeff Garzik } 4384c6fd2807SJeff Garzik 4385c6fd2807SJeff Garzik /* Device should not ask for data transfer (DRQ=1) 4386c6fd2807SJeff Garzik * when it finds something wrong. 4387c6fd2807SJeff Garzik * We ignore DRQ here and stop the HSM by 4388c6fd2807SJeff Garzik * changing hsm_task_state to HSM_ST_ERR and 4389c6fd2807SJeff Garzik * let the EH abort the command or reset the device. 4390c6fd2807SJeff Garzik */ 4391c6fd2807SJeff Garzik if (unlikely(status & (ATA_ERR | ATA_DF))) { 4392c6fd2807SJeff Garzik printk(KERN_WARNING "ata%d: DRQ=1 with device error, dev_stat 0x%X\n", 4393c6fd2807SJeff Garzik ap->id, status); 4394c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HSM; 4395c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 4396c6fd2807SJeff Garzik goto fsm_start; 4397c6fd2807SJeff Garzik } 4398c6fd2807SJeff Garzik 4399c6fd2807SJeff Garzik /* Send the CDB (atapi) or the first data block (ata pio out). 4400c6fd2807SJeff Garzik * During the state transition, interrupt handler shouldn't 4401c6fd2807SJeff Garzik * be invoked before the data transfer is complete and 4402c6fd2807SJeff Garzik * hsm_task_state is changed. Hence, the following locking. 4403c6fd2807SJeff Garzik */ 4404c6fd2807SJeff Garzik if (in_wq) 4405c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 4406c6fd2807SJeff Garzik 4407c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_PIO) { 4408c6fd2807SJeff Garzik /* PIO data out protocol. 4409c6fd2807SJeff Garzik * send first data block. 4410c6fd2807SJeff Garzik */ 4411c6fd2807SJeff Garzik 4412c6fd2807SJeff Garzik /* ata_pio_sectors() might change the state 4413c6fd2807SJeff Garzik * to HSM_ST_LAST. so, the state is changed here 4414c6fd2807SJeff Garzik * before ata_pio_sectors(). 4415c6fd2807SJeff Garzik */ 4416c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST; 4417c6fd2807SJeff Garzik ata_pio_sectors(qc); 4418c6fd2807SJeff Garzik ata_altstatus(ap); /* flush */ 4419c6fd2807SJeff Garzik } else 4420c6fd2807SJeff Garzik /* send CDB */ 4421c6fd2807SJeff Garzik atapi_send_cdb(ap, qc); 4422c6fd2807SJeff Garzik 4423c6fd2807SJeff Garzik if (in_wq) 4424c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 4425c6fd2807SJeff Garzik 4426c6fd2807SJeff Garzik /* if polling, ata_pio_task() handles the rest. 4427c6fd2807SJeff Garzik * otherwise, interrupt handler takes over from here. 4428c6fd2807SJeff Garzik */ 4429c6fd2807SJeff Garzik break; 4430c6fd2807SJeff Garzik 4431c6fd2807SJeff Garzik case HSM_ST: 4432c6fd2807SJeff Garzik /* complete command or read/write the data register */ 4433c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_ATAPI) { 4434c6fd2807SJeff Garzik /* ATAPI PIO protocol */ 4435c6fd2807SJeff Garzik if ((status & ATA_DRQ) == 0) { 4436c6fd2807SJeff Garzik /* No more data to transfer or device error. 4437c6fd2807SJeff Garzik * Device error will be tagged in HSM_ST_LAST. 4438c6fd2807SJeff Garzik */ 4439c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4440c6fd2807SJeff Garzik goto fsm_start; 4441c6fd2807SJeff Garzik } 4442c6fd2807SJeff Garzik 4443c6fd2807SJeff Garzik /* Device should not ask for data transfer (DRQ=1) 4444c6fd2807SJeff Garzik * when it finds something wrong. 4445c6fd2807SJeff Garzik * We ignore DRQ here and stop the HSM by 4446c6fd2807SJeff Garzik * changing hsm_task_state to HSM_ST_ERR and 4447c6fd2807SJeff Garzik * let the EH abort the command or reset the device. 4448c6fd2807SJeff Garzik */ 4449c6fd2807SJeff Garzik if (unlikely(status & (ATA_ERR | ATA_DF))) { 4450c6fd2807SJeff Garzik printk(KERN_WARNING "ata%d: DRQ=1 with device error, dev_stat 0x%X\n", 4451c6fd2807SJeff Garzik ap->id, status); 4452c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HSM; 4453c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 4454c6fd2807SJeff Garzik goto fsm_start; 4455c6fd2807SJeff Garzik } 4456c6fd2807SJeff Garzik 4457c6fd2807SJeff Garzik atapi_pio_bytes(qc); 4458c6fd2807SJeff Garzik 4459c6fd2807SJeff Garzik if (unlikely(ap->hsm_task_state == HSM_ST_ERR)) 4460c6fd2807SJeff Garzik /* bad ireason reported by device */ 4461c6fd2807SJeff Garzik goto fsm_start; 4462c6fd2807SJeff Garzik 4463c6fd2807SJeff Garzik } else { 4464c6fd2807SJeff Garzik /* ATA PIO protocol */ 4465c6fd2807SJeff Garzik if (unlikely((status & ATA_DRQ) == 0)) { 4466c6fd2807SJeff Garzik /* handle BSY=0, DRQ=0 as error */ 4467c6fd2807SJeff Garzik if (likely(status & (ATA_ERR | ATA_DF))) 4468c6fd2807SJeff Garzik /* device stops HSM for abort/error */ 4469c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_DEV; 4470c6fd2807SJeff Garzik else 447155a8e2c8STejun Heo /* HSM violation. Let EH handle this. 447255a8e2c8STejun Heo * Phantom devices also trigger this 447355a8e2c8STejun Heo * condition. Mark hint. 447455a8e2c8STejun Heo */ 447555a8e2c8STejun Heo qc->err_mask |= AC_ERR_HSM | 447655a8e2c8STejun Heo AC_ERR_NODEV_HINT; 4477c6fd2807SJeff Garzik 4478c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 4479c6fd2807SJeff Garzik goto fsm_start; 4480c6fd2807SJeff Garzik } 4481c6fd2807SJeff Garzik 4482c6fd2807SJeff Garzik /* For PIO reads, some devices may ask for 4483c6fd2807SJeff Garzik * data transfer (DRQ=1) alone with ERR=1. 4484c6fd2807SJeff Garzik * We respect DRQ here and transfer one 4485c6fd2807SJeff Garzik * block of junk data before changing the 4486c6fd2807SJeff Garzik * hsm_task_state to HSM_ST_ERR. 4487c6fd2807SJeff Garzik * 4488c6fd2807SJeff Garzik * For PIO writes, ERR=1 DRQ=1 doesn't make 4489c6fd2807SJeff Garzik * sense since the data block has been 4490c6fd2807SJeff Garzik * transferred to the device. 4491c6fd2807SJeff Garzik */ 4492c6fd2807SJeff Garzik if (unlikely(status & (ATA_ERR | ATA_DF))) { 4493c6fd2807SJeff Garzik /* data might be corrputed */ 4494c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_DEV; 4495c6fd2807SJeff Garzik 4496c6fd2807SJeff Garzik if (!(qc->tf.flags & ATA_TFLAG_WRITE)) { 4497c6fd2807SJeff Garzik ata_pio_sectors(qc); 4498c6fd2807SJeff Garzik ata_altstatus(ap); 4499c6fd2807SJeff Garzik status = ata_wait_idle(ap); 4500c6fd2807SJeff Garzik } 4501c6fd2807SJeff Garzik 4502c6fd2807SJeff Garzik if (status & (ATA_BUSY | ATA_DRQ)) 4503c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HSM; 4504c6fd2807SJeff Garzik 4505c6fd2807SJeff Garzik /* ata_pio_sectors() might change the 4506c6fd2807SJeff Garzik * state to HSM_ST_LAST. so, the state 4507c6fd2807SJeff Garzik * is changed after ata_pio_sectors(). 4508c6fd2807SJeff Garzik */ 4509c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 4510c6fd2807SJeff Garzik goto fsm_start; 4511c6fd2807SJeff Garzik } 4512c6fd2807SJeff Garzik 4513c6fd2807SJeff Garzik ata_pio_sectors(qc); 4514c6fd2807SJeff Garzik 4515c6fd2807SJeff Garzik if (ap->hsm_task_state == HSM_ST_LAST && 4516c6fd2807SJeff Garzik (!(qc->tf.flags & ATA_TFLAG_WRITE))) { 4517c6fd2807SJeff Garzik /* all data read */ 4518c6fd2807SJeff Garzik ata_altstatus(ap); 4519c6fd2807SJeff Garzik status = ata_wait_idle(ap); 4520c6fd2807SJeff Garzik goto fsm_start; 4521c6fd2807SJeff Garzik } 4522c6fd2807SJeff Garzik } 4523c6fd2807SJeff Garzik 4524c6fd2807SJeff Garzik ata_altstatus(ap); /* flush */ 4525c6fd2807SJeff Garzik poll_next = 1; 4526c6fd2807SJeff Garzik break; 4527c6fd2807SJeff Garzik 4528c6fd2807SJeff Garzik case HSM_ST_LAST: 4529c6fd2807SJeff Garzik if (unlikely(!ata_ok(status))) { 4530c6fd2807SJeff Garzik qc->err_mask |= __ac_err_mask(status); 4531c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 4532c6fd2807SJeff Garzik goto fsm_start; 4533c6fd2807SJeff Garzik } 4534c6fd2807SJeff Garzik 4535c6fd2807SJeff Garzik /* no more data to transfer */ 4536c6fd2807SJeff Garzik DPRINTK("ata%u: dev %u command complete, drv_stat 0x%x\n", 4537c6fd2807SJeff Garzik ap->id, qc->dev->devno, status); 4538c6fd2807SJeff Garzik 4539c6fd2807SJeff Garzik WARN_ON(qc->err_mask); 4540c6fd2807SJeff Garzik 4541c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_IDLE; 4542c6fd2807SJeff Garzik 4543c6fd2807SJeff Garzik /* complete taskfile transaction */ 4544c6fd2807SJeff Garzik ata_hsm_qc_complete(qc, in_wq); 4545c6fd2807SJeff Garzik 4546c6fd2807SJeff Garzik poll_next = 0; 4547c6fd2807SJeff Garzik break; 4548c6fd2807SJeff Garzik 4549c6fd2807SJeff Garzik case HSM_ST_ERR: 4550c6fd2807SJeff Garzik /* make sure qc->err_mask is available to 4551c6fd2807SJeff Garzik * know what's wrong and recover 4552c6fd2807SJeff Garzik */ 4553c6fd2807SJeff Garzik WARN_ON(qc->err_mask == 0); 4554c6fd2807SJeff Garzik 4555c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_IDLE; 4556c6fd2807SJeff Garzik 4557c6fd2807SJeff Garzik /* complete taskfile transaction */ 4558c6fd2807SJeff Garzik ata_hsm_qc_complete(qc, in_wq); 4559c6fd2807SJeff Garzik 4560c6fd2807SJeff Garzik poll_next = 0; 4561c6fd2807SJeff Garzik break; 4562c6fd2807SJeff Garzik default: 4563c6fd2807SJeff Garzik poll_next = 0; 4564c6fd2807SJeff Garzik BUG(); 4565c6fd2807SJeff Garzik } 4566c6fd2807SJeff Garzik 4567c6fd2807SJeff Garzik return poll_next; 4568c6fd2807SJeff Garzik } 4569c6fd2807SJeff Garzik 457065f27f38SDavid Howells static void ata_pio_task(struct work_struct *work) 4571c6fd2807SJeff Garzik { 457265f27f38SDavid Howells struct ata_port *ap = 457365f27f38SDavid Howells container_of(work, struct ata_port, port_task.work); 457465f27f38SDavid Howells struct ata_queued_cmd *qc = ap->port_task_data; 4575c6fd2807SJeff Garzik u8 status; 4576c6fd2807SJeff Garzik int poll_next; 4577c6fd2807SJeff Garzik 4578c6fd2807SJeff Garzik fsm_start: 4579c6fd2807SJeff Garzik WARN_ON(ap->hsm_task_state == HSM_ST_IDLE); 4580c6fd2807SJeff Garzik 4581c6fd2807SJeff Garzik /* 4582c6fd2807SJeff Garzik * This is purely heuristic. This is a fast path. 4583c6fd2807SJeff Garzik * Sometimes when we enter, BSY will be cleared in 4584c6fd2807SJeff Garzik * a chk-status or two. If not, the drive is probably seeking 4585c6fd2807SJeff Garzik * or something. Snooze for a couple msecs, then 4586c6fd2807SJeff Garzik * chk-status again. If still busy, queue delayed work. 4587c6fd2807SJeff Garzik */ 4588c6fd2807SJeff Garzik status = ata_busy_wait(ap, ATA_BUSY, 5); 4589c6fd2807SJeff Garzik if (status & ATA_BUSY) { 4590c6fd2807SJeff Garzik msleep(2); 4591c6fd2807SJeff Garzik status = ata_busy_wait(ap, ATA_BUSY, 10); 4592c6fd2807SJeff Garzik if (status & ATA_BUSY) { 4593c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, ATA_SHORT_PAUSE); 4594c6fd2807SJeff Garzik return; 4595c6fd2807SJeff Garzik } 4596c6fd2807SJeff Garzik } 4597c6fd2807SJeff Garzik 4598c6fd2807SJeff Garzik /* move the HSM */ 4599c6fd2807SJeff Garzik poll_next = ata_hsm_move(ap, qc, status, 1); 4600c6fd2807SJeff Garzik 4601c6fd2807SJeff Garzik /* another command or interrupt handler 4602c6fd2807SJeff Garzik * may be running at this point. 4603c6fd2807SJeff Garzik */ 4604c6fd2807SJeff Garzik if (poll_next) 4605c6fd2807SJeff Garzik goto fsm_start; 4606c6fd2807SJeff Garzik } 4607c6fd2807SJeff Garzik 4608c6fd2807SJeff Garzik /** 4609c6fd2807SJeff Garzik * ata_qc_new - Request an available ATA command, for queueing 4610c6fd2807SJeff Garzik * @ap: Port associated with device @dev 4611c6fd2807SJeff Garzik * @dev: Device from whom we request an available command structure 4612c6fd2807SJeff Garzik * 4613c6fd2807SJeff Garzik * LOCKING: 4614c6fd2807SJeff Garzik * None. 4615c6fd2807SJeff Garzik */ 4616c6fd2807SJeff Garzik 4617c6fd2807SJeff Garzik static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap) 4618c6fd2807SJeff Garzik { 4619c6fd2807SJeff Garzik struct ata_queued_cmd *qc = NULL; 4620c6fd2807SJeff Garzik unsigned int i; 4621c6fd2807SJeff Garzik 4622c6fd2807SJeff Garzik /* no command while frozen */ 4623c6fd2807SJeff Garzik if (unlikely(ap->pflags & ATA_PFLAG_FROZEN)) 4624c6fd2807SJeff Garzik return NULL; 4625c6fd2807SJeff Garzik 4626c6fd2807SJeff Garzik /* the last tag is reserved for internal command. */ 4627c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_QUEUE - 1; i++) 4628c6fd2807SJeff Garzik if (!test_and_set_bit(i, &ap->qc_allocated)) { 4629c6fd2807SJeff Garzik qc = __ata_qc_from_tag(ap, i); 4630c6fd2807SJeff Garzik break; 4631c6fd2807SJeff Garzik } 4632c6fd2807SJeff Garzik 4633c6fd2807SJeff Garzik if (qc) 4634c6fd2807SJeff Garzik qc->tag = i; 4635c6fd2807SJeff Garzik 4636c6fd2807SJeff Garzik return qc; 4637c6fd2807SJeff Garzik } 4638c6fd2807SJeff Garzik 4639c6fd2807SJeff Garzik /** 4640c6fd2807SJeff Garzik * ata_qc_new_init - Request an available ATA command, and initialize it 4641c6fd2807SJeff Garzik * @dev: Device from whom we request an available command structure 4642c6fd2807SJeff Garzik * 4643c6fd2807SJeff Garzik * LOCKING: 4644c6fd2807SJeff Garzik * None. 4645c6fd2807SJeff Garzik */ 4646c6fd2807SJeff Garzik 4647c6fd2807SJeff Garzik struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev) 4648c6fd2807SJeff Garzik { 4649c6fd2807SJeff Garzik struct ata_port *ap = dev->ap; 4650c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 4651c6fd2807SJeff Garzik 4652c6fd2807SJeff Garzik qc = ata_qc_new(ap); 4653c6fd2807SJeff Garzik if (qc) { 4654c6fd2807SJeff Garzik qc->scsicmd = NULL; 4655c6fd2807SJeff Garzik qc->ap = ap; 4656c6fd2807SJeff Garzik qc->dev = dev; 4657c6fd2807SJeff Garzik 4658c6fd2807SJeff Garzik ata_qc_reinit(qc); 4659c6fd2807SJeff Garzik } 4660c6fd2807SJeff Garzik 4661c6fd2807SJeff Garzik return qc; 4662c6fd2807SJeff Garzik } 4663c6fd2807SJeff Garzik 4664c6fd2807SJeff Garzik /** 4665c6fd2807SJeff Garzik * ata_qc_free - free unused ata_queued_cmd 4666c6fd2807SJeff Garzik * @qc: Command to complete 4667c6fd2807SJeff Garzik * 4668c6fd2807SJeff Garzik * Designed to free unused ata_queued_cmd object 4669c6fd2807SJeff Garzik * in case something prevents using it. 4670c6fd2807SJeff Garzik * 4671c6fd2807SJeff Garzik * LOCKING: 4672cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4673c6fd2807SJeff Garzik */ 4674c6fd2807SJeff Garzik void ata_qc_free(struct ata_queued_cmd *qc) 4675c6fd2807SJeff Garzik { 4676c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4677c6fd2807SJeff Garzik unsigned int tag; 4678c6fd2807SJeff Garzik 4679c6fd2807SJeff Garzik WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */ 4680c6fd2807SJeff Garzik 4681c6fd2807SJeff Garzik qc->flags = 0; 4682c6fd2807SJeff Garzik tag = qc->tag; 4683c6fd2807SJeff Garzik if (likely(ata_tag_valid(tag))) { 4684c6fd2807SJeff Garzik qc->tag = ATA_TAG_POISON; 4685c6fd2807SJeff Garzik clear_bit(tag, &ap->qc_allocated); 4686c6fd2807SJeff Garzik } 4687c6fd2807SJeff Garzik } 4688c6fd2807SJeff Garzik 4689c6fd2807SJeff Garzik void __ata_qc_complete(struct ata_queued_cmd *qc) 4690c6fd2807SJeff Garzik { 4691c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4692c6fd2807SJeff Garzik 4693c6fd2807SJeff Garzik WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */ 4694c6fd2807SJeff Garzik WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE)); 4695c6fd2807SJeff Garzik 4696c6fd2807SJeff Garzik if (likely(qc->flags & ATA_QCFLAG_DMAMAP)) 4697c6fd2807SJeff Garzik ata_sg_clean(qc); 4698c6fd2807SJeff Garzik 4699c6fd2807SJeff Garzik /* command should be marked inactive atomically with qc completion */ 4700c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_NCQ) 4701c6fd2807SJeff Garzik ap->sactive &= ~(1 << qc->tag); 4702c6fd2807SJeff Garzik else 4703c6fd2807SJeff Garzik ap->active_tag = ATA_TAG_POISON; 4704c6fd2807SJeff Garzik 4705c6fd2807SJeff Garzik /* atapi: mark qc as inactive to prevent the interrupt handler 4706c6fd2807SJeff Garzik * from completing the command twice later, before the error handler 4707c6fd2807SJeff Garzik * is called. (when rc != 0 and atapi request sense is needed) 4708c6fd2807SJeff Garzik */ 4709c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_ACTIVE; 4710c6fd2807SJeff Garzik ap->qc_active &= ~(1 << qc->tag); 4711c6fd2807SJeff Garzik 4712c6fd2807SJeff Garzik /* call completion callback */ 4713c6fd2807SJeff Garzik qc->complete_fn(qc); 4714c6fd2807SJeff Garzik } 4715c6fd2807SJeff Garzik 471639599a53STejun Heo static void fill_result_tf(struct ata_queued_cmd *qc) 471739599a53STejun Heo { 471839599a53STejun Heo struct ata_port *ap = qc->ap; 471939599a53STejun Heo 472039599a53STejun Heo ap->ops->tf_read(ap, &qc->result_tf); 472139599a53STejun Heo qc->result_tf.flags = qc->tf.flags; 472239599a53STejun Heo } 472339599a53STejun Heo 4724c6fd2807SJeff Garzik /** 4725c6fd2807SJeff Garzik * ata_qc_complete - Complete an active ATA command 4726c6fd2807SJeff Garzik * @qc: Command to complete 4727c6fd2807SJeff Garzik * @err_mask: ATA Status register contents 4728c6fd2807SJeff Garzik * 4729c6fd2807SJeff Garzik * Indicate to the mid and upper layers that an ATA 4730c6fd2807SJeff Garzik * command has completed, with either an ok or not-ok status. 4731c6fd2807SJeff Garzik * 4732c6fd2807SJeff Garzik * LOCKING: 4733cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4734c6fd2807SJeff Garzik */ 4735c6fd2807SJeff Garzik void ata_qc_complete(struct ata_queued_cmd *qc) 4736c6fd2807SJeff Garzik { 4737c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4738c6fd2807SJeff Garzik 4739c6fd2807SJeff Garzik /* XXX: New EH and old EH use different mechanisms to 4740c6fd2807SJeff Garzik * synchronize EH with regular execution path. 4741c6fd2807SJeff Garzik * 4742c6fd2807SJeff Garzik * In new EH, a failed qc is marked with ATA_QCFLAG_FAILED. 4743c6fd2807SJeff Garzik * Normal execution path is responsible for not accessing a 4744c6fd2807SJeff Garzik * failed qc. libata core enforces the rule by returning NULL 4745c6fd2807SJeff Garzik * from ata_qc_from_tag() for failed qcs. 4746c6fd2807SJeff Garzik * 4747c6fd2807SJeff Garzik * Old EH depends on ata_qc_complete() nullifying completion 4748c6fd2807SJeff Garzik * requests if ATA_QCFLAG_EH_SCHEDULED is set. Old EH does 4749c6fd2807SJeff Garzik * not synchronize with interrupt handler. Only PIO task is 4750c6fd2807SJeff Garzik * taken care of. 4751c6fd2807SJeff Garzik */ 4752c6fd2807SJeff Garzik if (ap->ops->error_handler) { 4753c6fd2807SJeff Garzik WARN_ON(ap->pflags & ATA_PFLAG_FROZEN); 4754c6fd2807SJeff Garzik 4755c6fd2807SJeff Garzik if (unlikely(qc->err_mask)) 4756c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_FAILED; 4757c6fd2807SJeff Garzik 4758c6fd2807SJeff Garzik if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) { 4759c6fd2807SJeff Garzik if (!ata_tag_internal(qc->tag)) { 4760c6fd2807SJeff Garzik /* always fill result TF for failed qc */ 476139599a53STejun Heo fill_result_tf(qc); 4762c6fd2807SJeff Garzik ata_qc_schedule_eh(qc); 4763c6fd2807SJeff Garzik return; 4764c6fd2807SJeff Garzik } 4765c6fd2807SJeff Garzik } 4766c6fd2807SJeff Garzik 4767c6fd2807SJeff Garzik /* read result TF if requested */ 4768c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_RESULT_TF) 476939599a53STejun Heo fill_result_tf(qc); 4770c6fd2807SJeff Garzik 4771c6fd2807SJeff Garzik __ata_qc_complete(qc); 4772c6fd2807SJeff Garzik } else { 4773c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_EH_SCHEDULED) 4774c6fd2807SJeff Garzik return; 4775c6fd2807SJeff Garzik 4776c6fd2807SJeff Garzik /* read result TF if failed or requested */ 4777c6fd2807SJeff Garzik if (qc->err_mask || qc->flags & ATA_QCFLAG_RESULT_TF) 477839599a53STejun Heo fill_result_tf(qc); 4779c6fd2807SJeff Garzik 4780c6fd2807SJeff Garzik __ata_qc_complete(qc); 4781c6fd2807SJeff Garzik } 4782c6fd2807SJeff Garzik } 4783c6fd2807SJeff Garzik 4784c6fd2807SJeff Garzik /** 4785c6fd2807SJeff Garzik * ata_qc_complete_multiple - Complete multiple qcs successfully 4786c6fd2807SJeff Garzik * @ap: port in question 4787c6fd2807SJeff Garzik * @qc_active: new qc_active mask 4788c6fd2807SJeff Garzik * @finish_qc: LLDD callback invoked before completing a qc 4789c6fd2807SJeff Garzik * 4790c6fd2807SJeff Garzik * Complete in-flight commands. This functions is meant to be 4791c6fd2807SJeff Garzik * called from low-level driver's interrupt routine to complete 4792c6fd2807SJeff Garzik * requests normally. ap->qc_active and @qc_active is compared 4793c6fd2807SJeff Garzik * and commands are completed accordingly. 4794c6fd2807SJeff Garzik * 4795c6fd2807SJeff Garzik * LOCKING: 4796cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4797c6fd2807SJeff Garzik * 4798c6fd2807SJeff Garzik * RETURNS: 4799c6fd2807SJeff Garzik * Number of completed commands on success, -errno otherwise. 4800c6fd2807SJeff Garzik */ 4801c6fd2807SJeff Garzik int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active, 4802c6fd2807SJeff Garzik void (*finish_qc)(struct ata_queued_cmd *)) 4803c6fd2807SJeff Garzik { 4804c6fd2807SJeff Garzik int nr_done = 0; 4805c6fd2807SJeff Garzik u32 done_mask; 4806c6fd2807SJeff Garzik int i; 4807c6fd2807SJeff Garzik 4808c6fd2807SJeff Garzik done_mask = ap->qc_active ^ qc_active; 4809c6fd2807SJeff Garzik 4810c6fd2807SJeff Garzik if (unlikely(done_mask & qc_active)) { 4811c6fd2807SJeff Garzik ata_port_printk(ap, KERN_ERR, "illegal qc_active transition " 4812c6fd2807SJeff Garzik "(%08x->%08x)\n", ap->qc_active, qc_active); 4813c6fd2807SJeff Garzik return -EINVAL; 4814c6fd2807SJeff Garzik } 4815c6fd2807SJeff Garzik 4816c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_QUEUE; i++) { 4817c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 4818c6fd2807SJeff Garzik 4819c6fd2807SJeff Garzik if (!(done_mask & (1 << i))) 4820c6fd2807SJeff Garzik continue; 4821c6fd2807SJeff Garzik 4822c6fd2807SJeff Garzik if ((qc = ata_qc_from_tag(ap, i))) { 4823c6fd2807SJeff Garzik if (finish_qc) 4824c6fd2807SJeff Garzik finish_qc(qc); 4825c6fd2807SJeff Garzik ata_qc_complete(qc); 4826c6fd2807SJeff Garzik nr_done++; 4827c6fd2807SJeff Garzik } 4828c6fd2807SJeff Garzik } 4829c6fd2807SJeff Garzik 4830c6fd2807SJeff Garzik return nr_done; 4831c6fd2807SJeff Garzik } 4832c6fd2807SJeff Garzik 4833c6fd2807SJeff Garzik static inline int ata_should_dma_map(struct ata_queued_cmd *qc) 4834c6fd2807SJeff Garzik { 4835c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4836c6fd2807SJeff Garzik 4837c6fd2807SJeff Garzik switch (qc->tf.protocol) { 4838c6fd2807SJeff Garzik case ATA_PROT_NCQ: 4839c6fd2807SJeff Garzik case ATA_PROT_DMA: 4840c6fd2807SJeff Garzik case ATA_PROT_ATAPI_DMA: 4841c6fd2807SJeff Garzik return 1; 4842c6fd2807SJeff Garzik 4843c6fd2807SJeff Garzik case ATA_PROT_ATAPI: 4844c6fd2807SJeff Garzik case ATA_PROT_PIO: 4845c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_PIO_DMA) 4846c6fd2807SJeff Garzik return 1; 4847c6fd2807SJeff Garzik 4848c6fd2807SJeff Garzik /* fall through */ 4849c6fd2807SJeff Garzik 4850c6fd2807SJeff Garzik default: 4851c6fd2807SJeff Garzik return 0; 4852c6fd2807SJeff Garzik } 4853c6fd2807SJeff Garzik 4854c6fd2807SJeff Garzik /* never reached */ 4855c6fd2807SJeff Garzik } 4856c6fd2807SJeff Garzik 4857c6fd2807SJeff Garzik /** 4858c6fd2807SJeff Garzik * ata_qc_issue - issue taskfile to device 4859c6fd2807SJeff Garzik * @qc: command to issue to device 4860c6fd2807SJeff Garzik * 4861c6fd2807SJeff Garzik * Prepare an ATA command to submission to device. 4862c6fd2807SJeff Garzik * This includes mapping the data into a DMA-able 4863c6fd2807SJeff Garzik * area, filling in the S/G table, and finally 4864c6fd2807SJeff Garzik * writing the taskfile to hardware, starting the command. 4865c6fd2807SJeff Garzik * 4866c6fd2807SJeff Garzik * LOCKING: 4867cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4868c6fd2807SJeff Garzik */ 4869c6fd2807SJeff Garzik void ata_qc_issue(struct ata_queued_cmd *qc) 4870c6fd2807SJeff Garzik { 4871c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4872c6fd2807SJeff Garzik 4873c6fd2807SJeff Garzik /* Make sure only one non-NCQ command is outstanding. The 4874c6fd2807SJeff Garzik * check is skipped for old EH because it reuses active qc to 4875c6fd2807SJeff Garzik * request ATAPI sense. 4876c6fd2807SJeff Garzik */ 4877c6fd2807SJeff Garzik WARN_ON(ap->ops->error_handler && ata_tag_valid(ap->active_tag)); 4878c6fd2807SJeff Garzik 4879c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_NCQ) { 4880c6fd2807SJeff Garzik WARN_ON(ap->sactive & (1 << qc->tag)); 4881c6fd2807SJeff Garzik ap->sactive |= 1 << qc->tag; 4882c6fd2807SJeff Garzik } else { 4883c6fd2807SJeff Garzik WARN_ON(ap->sactive); 4884c6fd2807SJeff Garzik ap->active_tag = qc->tag; 4885c6fd2807SJeff Garzik } 4886c6fd2807SJeff Garzik 4887c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_ACTIVE; 4888c6fd2807SJeff Garzik ap->qc_active |= 1 << qc->tag; 4889c6fd2807SJeff Garzik 4890c6fd2807SJeff Garzik if (ata_should_dma_map(qc)) { 4891c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_SG) { 4892c6fd2807SJeff Garzik if (ata_sg_setup(qc)) 4893c6fd2807SJeff Garzik goto sg_err; 4894c6fd2807SJeff Garzik } else if (qc->flags & ATA_QCFLAG_SINGLE) { 4895c6fd2807SJeff Garzik if (ata_sg_setup_one(qc)) 4896c6fd2807SJeff Garzik goto sg_err; 4897c6fd2807SJeff Garzik } 4898c6fd2807SJeff Garzik } else { 4899c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_DMAMAP; 4900c6fd2807SJeff Garzik } 4901c6fd2807SJeff Garzik 4902c6fd2807SJeff Garzik ap->ops->qc_prep(qc); 4903c6fd2807SJeff Garzik 4904c6fd2807SJeff Garzik qc->err_mask |= ap->ops->qc_issue(qc); 4905c6fd2807SJeff Garzik if (unlikely(qc->err_mask)) 4906c6fd2807SJeff Garzik goto err; 4907c6fd2807SJeff Garzik return; 4908c6fd2807SJeff Garzik 4909c6fd2807SJeff Garzik sg_err: 4910c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_DMAMAP; 4911c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_SYSTEM; 4912c6fd2807SJeff Garzik err: 4913c6fd2807SJeff Garzik ata_qc_complete(qc); 4914c6fd2807SJeff Garzik } 4915c6fd2807SJeff Garzik 4916c6fd2807SJeff Garzik /** 4917c6fd2807SJeff Garzik * ata_qc_issue_prot - issue taskfile to device in proto-dependent manner 4918c6fd2807SJeff Garzik * @qc: command to issue to device 4919c6fd2807SJeff Garzik * 4920c6fd2807SJeff Garzik * Using various libata functions and hooks, this function 4921c6fd2807SJeff Garzik * starts an ATA command. ATA commands are grouped into 4922c6fd2807SJeff Garzik * classes called "protocols", and issuing each type of protocol 4923c6fd2807SJeff Garzik * is slightly different. 4924c6fd2807SJeff Garzik * 4925c6fd2807SJeff Garzik * May be used as the qc_issue() entry in ata_port_operations. 4926c6fd2807SJeff Garzik * 4927c6fd2807SJeff Garzik * LOCKING: 4928cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4929c6fd2807SJeff Garzik * 4930c6fd2807SJeff Garzik * RETURNS: 4931c6fd2807SJeff Garzik * Zero on success, AC_ERR_* mask on failure 4932c6fd2807SJeff Garzik */ 4933c6fd2807SJeff Garzik 4934c6fd2807SJeff Garzik unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc) 4935c6fd2807SJeff Garzik { 4936c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4937c6fd2807SJeff Garzik 4938c6fd2807SJeff Garzik /* Use polling pio if the LLD doesn't handle 4939c6fd2807SJeff Garzik * interrupt driven pio and atapi CDB interrupt. 4940c6fd2807SJeff Garzik */ 4941c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_PIO_POLLING) { 4942c6fd2807SJeff Garzik switch (qc->tf.protocol) { 4943c6fd2807SJeff Garzik case ATA_PROT_PIO: 4944e3472cbeSAlbert Lee case ATA_PROT_NODATA: 4945c6fd2807SJeff Garzik case ATA_PROT_ATAPI: 4946c6fd2807SJeff Garzik case ATA_PROT_ATAPI_NODATA: 4947c6fd2807SJeff Garzik qc->tf.flags |= ATA_TFLAG_POLLING; 4948c6fd2807SJeff Garzik break; 4949c6fd2807SJeff Garzik case ATA_PROT_ATAPI_DMA: 4950c6fd2807SJeff Garzik if (qc->dev->flags & ATA_DFLAG_CDB_INTR) 4951c6fd2807SJeff Garzik /* see ata_dma_blacklisted() */ 4952c6fd2807SJeff Garzik BUG(); 4953c6fd2807SJeff Garzik break; 4954c6fd2807SJeff Garzik default: 4955c6fd2807SJeff Garzik break; 4956c6fd2807SJeff Garzik } 4957c6fd2807SJeff Garzik } 4958c6fd2807SJeff Garzik 49593d3cca37STejun Heo /* Some controllers show flaky interrupt behavior after 49603d3cca37STejun Heo * setting xfer mode. Use polling instead. 49613d3cca37STejun Heo */ 49623d3cca37STejun Heo if (unlikely(qc->tf.command == ATA_CMD_SET_FEATURES && 49633d3cca37STejun Heo qc->tf.feature == SETFEATURES_XFER) && 49643d3cca37STejun Heo (ap->flags & ATA_FLAG_SETXFER_POLLING)) 49653d3cca37STejun Heo qc->tf.flags |= ATA_TFLAG_POLLING; 49663d3cca37STejun Heo 4967c6fd2807SJeff Garzik /* select the device */ 4968c6fd2807SJeff Garzik ata_dev_select(ap, qc->dev->devno, 1, 0); 4969c6fd2807SJeff Garzik 4970c6fd2807SJeff Garzik /* start the command */ 4971c6fd2807SJeff Garzik switch (qc->tf.protocol) { 4972c6fd2807SJeff Garzik case ATA_PROT_NODATA: 4973c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 4974c6fd2807SJeff Garzik ata_qc_set_polling(qc); 4975c6fd2807SJeff Garzik 4976c6fd2807SJeff Garzik ata_tf_to_host(ap, &qc->tf); 4977c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4978c6fd2807SJeff Garzik 4979c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 4980c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, 0); 4981c6fd2807SJeff Garzik 4982c6fd2807SJeff Garzik break; 4983c6fd2807SJeff Garzik 4984c6fd2807SJeff Garzik case ATA_PROT_DMA: 4985c6fd2807SJeff Garzik WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING); 4986c6fd2807SJeff Garzik 4987c6fd2807SJeff Garzik ap->ops->tf_load(ap, &qc->tf); /* load tf registers */ 4988c6fd2807SJeff Garzik ap->ops->bmdma_setup(qc); /* set up bmdma */ 4989c6fd2807SJeff Garzik ap->ops->bmdma_start(qc); /* initiate bmdma */ 4990c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4991c6fd2807SJeff Garzik break; 4992c6fd2807SJeff Garzik 4993c6fd2807SJeff Garzik case ATA_PROT_PIO: 4994c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 4995c6fd2807SJeff Garzik ata_qc_set_polling(qc); 4996c6fd2807SJeff Garzik 4997c6fd2807SJeff Garzik ata_tf_to_host(ap, &qc->tf); 4998c6fd2807SJeff Garzik 4999c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_WRITE) { 5000c6fd2807SJeff Garzik /* PIO data out protocol */ 5001c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_FIRST; 5002c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, 0); 5003c6fd2807SJeff Garzik 5004c6fd2807SJeff Garzik /* always send first data block using 5005c6fd2807SJeff Garzik * the ata_pio_task() codepath. 5006c6fd2807SJeff Garzik */ 5007c6fd2807SJeff Garzik } else { 5008c6fd2807SJeff Garzik /* PIO data in protocol */ 5009c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST; 5010c6fd2807SJeff Garzik 5011c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 5012c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, 0); 5013c6fd2807SJeff Garzik 5014c6fd2807SJeff Garzik /* if polling, ata_pio_task() handles the rest. 5015c6fd2807SJeff Garzik * otherwise, interrupt handler takes over from here. 5016c6fd2807SJeff Garzik */ 5017c6fd2807SJeff Garzik } 5018c6fd2807SJeff Garzik 5019c6fd2807SJeff Garzik break; 5020c6fd2807SJeff Garzik 5021c6fd2807SJeff Garzik case ATA_PROT_ATAPI: 5022c6fd2807SJeff Garzik case ATA_PROT_ATAPI_NODATA: 5023c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 5024c6fd2807SJeff Garzik ata_qc_set_polling(qc); 5025c6fd2807SJeff Garzik 5026c6fd2807SJeff Garzik ata_tf_to_host(ap, &qc->tf); 5027c6fd2807SJeff Garzik 5028c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_FIRST; 5029c6fd2807SJeff Garzik 5030c6fd2807SJeff Garzik /* send cdb by polling if no cdb interrupt */ 5031c6fd2807SJeff Garzik if ((!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) || 5032c6fd2807SJeff Garzik (qc->tf.flags & ATA_TFLAG_POLLING)) 5033c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, 0); 5034c6fd2807SJeff Garzik break; 5035c6fd2807SJeff Garzik 5036c6fd2807SJeff Garzik case ATA_PROT_ATAPI_DMA: 5037c6fd2807SJeff Garzik WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING); 5038c6fd2807SJeff Garzik 5039c6fd2807SJeff Garzik ap->ops->tf_load(ap, &qc->tf); /* load tf registers */ 5040c6fd2807SJeff Garzik ap->ops->bmdma_setup(qc); /* set up bmdma */ 5041c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_FIRST; 5042c6fd2807SJeff Garzik 5043c6fd2807SJeff Garzik /* send cdb by polling if no cdb interrupt */ 5044c6fd2807SJeff Garzik if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) 5045c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, 0); 5046c6fd2807SJeff Garzik break; 5047c6fd2807SJeff Garzik 5048c6fd2807SJeff Garzik default: 5049c6fd2807SJeff Garzik WARN_ON(1); 5050c6fd2807SJeff Garzik return AC_ERR_SYSTEM; 5051c6fd2807SJeff Garzik } 5052c6fd2807SJeff Garzik 5053c6fd2807SJeff Garzik return 0; 5054c6fd2807SJeff Garzik } 5055c6fd2807SJeff Garzik 5056c6fd2807SJeff Garzik /** 5057c6fd2807SJeff Garzik * ata_host_intr - Handle host interrupt for given (port, task) 5058c6fd2807SJeff Garzik * @ap: Port on which interrupt arrived (possibly...) 5059c6fd2807SJeff Garzik * @qc: Taskfile currently active in engine 5060c6fd2807SJeff Garzik * 5061c6fd2807SJeff Garzik * Handle host interrupt for given queued command. Currently, 5062c6fd2807SJeff Garzik * only DMA interrupts are handled. All other commands are 5063c6fd2807SJeff Garzik * handled via polling with interrupts disabled (nIEN bit). 5064c6fd2807SJeff Garzik * 5065c6fd2807SJeff Garzik * LOCKING: 5066cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 5067c6fd2807SJeff Garzik * 5068c6fd2807SJeff Garzik * RETURNS: 5069c6fd2807SJeff Garzik * One if interrupt was handled, zero if not (shared irq). 5070c6fd2807SJeff Garzik */ 5071c6fd2807SJeff Garzik 5072c6fd2807SJeff Garzik inline unsigned int ata_host_intr (struct ata_port *ap, 5073c6fd2807SJeff Garzik struct ata_queued_cmd *qc) 5074c6fd2807SJeff Garzik { 5075ea54763fSTejun Heo struct ata_eh_info *ehi = &ap->eh_info; 5076c6fd2807SJeff Garzik u8 status, host_stat = 0; 5077c6fd2807SJeff Garzik 5078c6fd2807SJeff Garzik VPRINTK("ata%u: protocol %d task_state %d\n", 5079c6fd2807SJeff Garzik ap->id, qc->tf.protocol, ap->hsm_task_state); 5080c6fd2807SJeff Garzik 5081c6fd2807SJeff Garzik /* Check whether we are expecting interrupt in this state */ 5082c6fd2807SJeff Garzik switch (ap->hsm_task_state) { 5083c6fd2807SJeff Garzik case HSM_ST_FIRST: 5084c6fd2807SJeff Garzik /* Some pre-ATAPI-4 devices assert INTRQ 5085c6fd2807SJeff Garzik * at this state when ready to receive CDB. 5086c6fd2807SJeff Garzik */ 5087c6fd2807SJeff Garzik 5088c6fd2807SJeff Garzik /* Check the ATA_DFLAG_CDB_INTR flag is enough here. 5089c6fd2807SJeff Garzik * The flag was turned on only for atapi devices. 5090c6fd2807SJeff Garzik * No need to check is_atapi_taskfile(&qc->tf) again. 5091c6fd2807SJeff Garzik */ 5092c6fd2807SJeff Garzik if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) 5093c6fd2807SJeff Garzik goto idle_irq; 5094c6fd2807SJeff Garzik break; 5095c6fd2807SJeff Garzik case HSM_ST_LAST: 5096c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_DMA || 5097c6fd2807SJeff Garzik qc->tf.protocol == ATA_PROT_ATAPI_DMA) { 5098c6fd2807SJeff Garzik /* check status of DMA engine */ 5099c6fd2807SJeff Garzik host_stat = ap->ops->bmdma_status(ap); 5100c6fd2807SJeff Garzik VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat); 5101c6fd2807SJeff Garzik 5102c6fd2807SJeff Garzik /* if it's not our irq... */ 5103c6fd2807SJeff Garzik if (!(host_stat & ATA_DMA_INTR)) 5104c6fd2807SJeff Garzik goto idle_irq; 5105c6fd2807SJeff Garzik 5106c6fd2807SJeff Garzik /* before we do anything else, clear DMA-Start bit */ 5107c6fd2807SJeff Garzik ap->ops->bmdma_stop(qc); 5108c6fd2807SJeff Garzik 5109c6fd2807SJeff Garzik if (unlikely(host_stat & ATA_DMA_ERR)) { 5110c6fd2807SJeff Garzik /* error when transfering data to/from memory */ 5111c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HOST_BUS; 5112c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 5113c6fd2807SJeff Garzik } 5114c6fd2807SJeff Garzik } 5115c6fd2807SJeff Garzik break; 5116c6fd2807SJeff Garzik case HSM_ST: 5117c6fd2807SJeff Garzik break; 5118c6fd2807SJeff Garzik default: 5119c6fd2807SJeff Garzik goto idle_irq; 5120c6fd2807SJeff Garzik } 5121c6fd2807SJeff Garzik 5122c6fd2807SJeff Garzik /* check altstatus */ 5123c6fd2807SJeff Garzik status = ata_altstatus(ap); 5124c6fd2807SJeff Garzik if (status & ATA_BUSY) 5125c6fd2807SJeff Garzik goto idle_irq; 5126c6fd2807SJeff Garzik 5127c6fd2807SJeff Garzik /* check main status, clearing INTRQ */ 5128c6fd2807SJeff Garzik status = ata_chk_status(ap); 5129c6fd2807SJeff Garzik if (unlikely(status & ATA_BUSY)) 5130c6fd2807SJeff Garzik goto idle_irq; 5131c6fd2807SJeff Garzik 5132c6fd2807SJeff Garzik /* ack bmdma irq events */ 5133c6fd2807SJeff Garzik ap->ops->irq_clear(ap); 5134c6fd2807SJeff Garzik 5135c6fd2807SJeff Garzik ata_hsm_move(ap, qc, status, 0); 5136ea54763fSTejun Heo 5137ea54763fSTejun Heo if (unlikely(qc->err_mask) && (qc->tf.protocol == ATA_PROT_DMA || 5138ea54763fSTejun Heo qc->tf.protocol == ATA_PROT_ATAPI_DMA)) 5139ea54763fSTejun Heo ata_ehi_push_desc(ehi, "BMDMA stat 0x%x", host_stat); 5140ea54763fSTejun Heo 5141c6fd2807SJeff Garzik return 1; /* irq handled */ 5142c6fd2807SJeff Garzik 5143c6fd2807SJeff Garzik idle_irq: 5144c6fd2807SJeff Garzik ap->stats.idle_irq++; 5145c6fd2807SJeff Garzik 5146c6fd2807SJeff Garzik #ifdef ATA_IRQ_TRAP 5147c6fd2807SJeff Garzik if ((ap->stats.idle_irq % 1000) == 0) { 5148c6fd2807SJeff Garzik ata_irq_ack(ap, 0); /* debug trap */ 5149c6fd2807SJeff Garzik ata_port_printk(ap, KERN_WARNING, "irq trap\n"); 5150c6fd2807SJeff Garzik return 1; 5151c6fd2807SJeff Garzik } 5152c6fd2807SJeff Garzik #endif 5153c6fd2807SJeff Garzik return 0; /* irq not handled */ 5154c6fd2807SJeff Garzik } 5155c6fd2807SJeff Garzik 5156c6fd2807SJeff Garzik /** 5157c6fd2807SJeff Garzik * ata_interrupt - Default ATA host interrupt handler 5158c6fd2807SJeff Garzik * @irq: irq line (unused) 5159cca3974eSJeff Garzik * @dev_instance: pointer to our ata_host information structure 5160c6fd2807SJeff Garzik * 5161c6fd2807SJeff Garzik * Default interrupt handler for PCI IDE devices. Calls 5162c6fd2807SJeff Garzik * ata_host_intr() for each port that is not disabled. 5163c6fd2807SJeff Garzik * 5164c6fd2807SJeff Garzik * LOCKING: 5165cca3974eSJeff Garzik * Obtains host lock during operation. 5166c6fd2807SJeff Garzik * 5167c6fd2807SJeff Garzik * RETURNS: 5168c6fd2807SJeff Garzik * IRQ_NONE or IRQ_HANDLED. 5169c6fd2807SJeff Garzik */ 5170c6fd2807SJeff Garzik 51717d12e780SDavid Howells irqreturn_t ata_interrupt (int irq, void *dev_instance) 5172c6fd2807SJeff Garzik { 5173cca3974eSJeff Garzik struct ata_host *host = dev_instance; 5174c6fd2807SJeff Garzik unsigned int i; 5175c6fd2807SJeff Garzik unsigned int handled = 0; 5176c6fd2807SJeff Garzik unsigned long flags; 5177c6fd2807SJeff Garzik 5178c6fd2807SJeff Garzik /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */ 5179cca3974eSJeff Garzik spin_lock_irqsave(&host->lock, flags); 5180c6fd2807SJeff Garzik 5181cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 5182c6fd2807SJeff Garzik struct ata_port *ap; 5183c6fd2807SJeff Garzik 5184cca3974eSJeff Garzik ap = host->ports[i]; 5185c6fd2807SJeff Garzik if (ap && 5186c6fd2807SJeff Garzik !(ap->flags & ATA_FLAG_DISABLED)) { 5187c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 5188c6fd2807SJeff Garzik 5189c6fd2807SJeff Garzik qc = ata_qc_from_tag(ap, ap->active_tag); 5190c6fd2807SJeff Garzik if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) && 5191c6fd2807SJeff Garzik (qc->flags & ATA_QCFLAG_ACTIVE)) 5192c6fd2807SJeff Garzik handled |= ata_host_intr(ap, qc); 5193c6fd2807SJeff Garzik } 5194c6fd2807SJeff Garzik } 5195c6fd2807SJeff Garzik 5196cca3974eSJeff Garzik spin_unlock_irqrestore(&host->lock, flags); 5197c6fd2807SJeff Garzik 5198c6fd2807SJeff Garzik return IRQ_RETVAL(handled); 5199c6fd2807SJeff Garzik } 5200c6fd2807SJeff Garzik 5201c6fd2807SJeff Garzik /** 5202c6fd2807SJeff Garzik * sata_scr_valid - test whether SCRs are accessible 5203c6fd2807SJeff Garzik * @ap: ATA port to test SCR accessibility for 5204c6fd2807SJeff Garzik * 5205c6fd2807SJeff Garzik * Test whether SCRs are accessible for @ap. 5206c6fd2807SJeff Garzik * 5207c6fd2807SJeff Garzik * LOCKING: 5208c6fd2807SJeff Garzik * None. 5209c6fd2807SJeff Garzik * 5210c6fd2807SJeff Garzik * RETURNS: 5211c6fd2807SJeff Garzik * 1 if SCRs are accessible, 0 otherwise. 5212c6fd2807SJeff Garzik */ 5213c6fd2807SJeff Garzik int sata_scr_valid(struct ata_port *ap) 5214c6fd2807SJeff Garzik { 5215c6fd2807SJeff Garzik return ap->cbl == ATA_CBL_SATA && ap->ops->scr_read; 5216c6fd2807SJeff Garzik } 5217c6fd2807SJeff Garzik 5218c6fd2807SJeff Garzik /** 5219c6fd2807SJeff Garzik * sata_scr_read - read SCR register of the specified port 5220c6fd2807SJeff Garzik * @ap: ATA port to read SCR for 5221c6fd2807SJeff Garzik * @reg: SCR to read 5222c6fd2807SJeff Garzik * @val: Place to store read value 5223c6fd2807SJeff Garzik * 5224c6fd2807SJeff Garzik * Read SCR register @reg of @ap into *@val. This function is 5225c6fd2807SJeff Garzik * guaranteed to succeed if the cable type of the port is SATA 5226c6fd2807SJeff Garzik * and the port implements ->scr_read. 5227c6fd2807SJeff Garzik * 5228c6fd2807SJeff Garzik * LOCKING: 5229c6fd2807SJeff Garzik * None. 5230c6fd2807SJeff Garzik * 5231c6fd2807SJeff Garzik * RETURNS: 5232c6fd2807SJeff Garzik * 0 on success, negative errno on failure. 5233c6fd2807SJeff Garzik */ 5234c6fd2807SJeff Garzik int sata_scr_read(struct ata_port *ap, int reg, u32 *val) 5235c6fd2807SJeff Garzik { 5236c6fd2807SJeff Garzik if (sata_scr_valid(ap)) { 5237c6fd2807SJeff Garzik *val = ap->ops->scr_read(ap, reg); 5238c6fd2807SJeff Garzik return 0; 5239c6fd2807SJeff Garzik } 5240c6fd2807SJeff Garzik return -EOPNOTSUPP; 5241c6fd2807SJeff Garzik } 5242c6fd2807SJeff Garzik 5243c6fd2807SJeff Garzik /** 5244c6fd2807SJeff Garzik * sata_scr_write - write SCR register of the specified port 5245c6fd2807SJeff Garzik * @ap: ATA port to write SCR for 5246c6fd2807SJeff Garzik * @reg: SCR to write 5247c6fd2807SJeff Garzik * @val: value to write 5248c6fd2807SJeff Garzik * 5249c6fd2807SJeff Garzik * Write @val to SCR register @reg of @ap. This function is 5250c6fd2807SJeff Garzik * guaranteed to succeed if the cable type of the port is SATA 5251c6fd2807SJeff Garzik * and the port implements ->scr_read. 5252c6fd2807SJeff Garzik * 5253c6fd2807SJeff Garzik * LOCKING: 5254c6fd2807SJeff Garzik * None. 5255c6fd2807SJeff Garzik * 5256c6fd2807SJeff Garzik * RETURNS: 5257c6fd2807SJeff Garzik * 0 on success, negative errno on failure. 5258c6fd2807SJeff Garzik */ 5259c6fd2807SJeff Garzik int sata_scr_write(struct ata_port *ap, int reg, u32 val) 5260c6fd2807SJeff Garzik { 5261c6fd2807SJeff Garzik if (sata_scr_valid(ap)) { 5262c6fd2807SJeff Garzik ap->ops->scr_write(ap, reg, val); 5263c6fd2807SJeff Garzik return 0; 5264c6fd2807SJeff Garzik } 5265c6fd2807SJeff Garzik return -EOPNOTSUPP; 5266c6fd2807SJeff Garzik } 5267c6fd2807SJeff Garzik 5268c6fd2807SJeff Garzik /** 5269c6fd2807SJeff Garzik * sata_scr_write_flush - write SCR register of the specified port and flush 5270c6fd2807SJeff Garzik * @ap: ATA port to write SCR for 5271c6fd2807SJeff Garzik * @reg: SCR to write 5272c6fd2807SJeff Garzik * @val: value to write 5273c6fd2807SJeff Garzik * 5274c6fd2807SJeff Garzik * This function is identical to sata_scr_write() except that this 5275c6fd2807SJeff Garzik * function performs flush after writing to the register. 5276c6fd2807SJeff Garzik * 5277c6fd2807SJeff Garzik * LOCKING: 5278c6fd2807SJeff Garzik * None. 5279c6fd2807SJeff Garzik * 5280c6fd2807SJeff Garzik * RETURNS: 5281c6fd2807SJeff Garzik * 0 on success, negative errno on failure. 5282c6fd2807SJeff Garzik */ 5283c6fd2807SJeff Garzik int sata_scr_write_flush(struct ata_port *ap, int reg, u32 val) 5284c6fd2807SJeff Garzik { 5285c6fd2807SJeff Garzik if (sata_scr_valid(ap)) { 5286c6fd2807SJeff Garzik ap->ops->scr_write(ap, reg, val); 5287c6fd2807SJeff Garzik ap->ops->scr_read(ap, reg); 5288c6fd2807SJeff Garzik return 0; 5289c6fd2807SJeff Garzik } 5290c6fd2807SJeff Garzik return -EOPNOTSUPP; 5291c6fd2807SJeff Garzik } 5292c6fd2807SJeff Garzik 5293c6fd2807SJeff Garzik /** 5294c6fd2807SJeff Garzik * ata_port_online - test whether the given port is online 5295c6fd2807SJeff Garzik * @ap: ATA port to test 5296c6fd2807SJeff Garzik * 5297c6fd2807SJeff Garzik * Test whether @ap is online. Note that this function returns 0 5298c6fd2807SJeff Garzik * if online status of @ap cannot be obtained, so 5299c6fd2807SJeff Garzik * ata_port_online(ap) != !ata_port_offline(ap). 5300c6fd2807SJeff Garzik * 5301c6fd2807SJeff Garzik * LOCKING: 5302c6fd2807SJeff Garzik * None. 5303c6fd2807SJeff Garzik * 5304c6fd2807SJeff Garzik * RETURNS: 5305c6fd2807SJeff Garzik * 1 if the port online status is available and online. 5306c6fd2807SJeff Garzik */ 5307c6fd2807SJeff Garzik int ata_port_online(struct ata_port *ap) 5308c6fd2807SJeff Garzik { 5309c6fd2807SJeff Garzik u32 sstatus; 5310c6fd2807SJeff Garzik 5311c6fd2807SJeff Garzik if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) == 0x3) 5312c6fd2807SJeff Garzik return 1; 5313c6fd2807SJeff Garzik return 0; 5314c6fd2807SJeff Garzik } 5315c6fd2807SJeff Garzik 5316c6fd2807SJeff Garzik /** 5317c6fd2807SJeff Garzik * ata_port_offline - test whether the given port is offline 5318c6fd2807SJeff Garzik * @ap: ATA port to test 5319c6fd2807SJeff Garzik * 5320c6fd2807SJeff Garzik * Test whether @ap is offline. Note that this function returns 5321c6fd2807SJeff Garzik * 0 if offline status of @ap cannot be obtained, so 5322c6fd2807SJeff Garzik * ata_port_online(ap) != !ata_port_offline(ap). 5323c6fd2807SJeff Garzik * 5324c6fd2807SJeff Garzik * LOCKING: 5325c6fd2807SJeff Garzik * None. 5326c6fd2807SJeff Garzik * 5327c6fd2807SJeff Garzik * RETURNS: 5328c6fd2807SJeff Garzik * 1 if the port offline status is available and offline. 5329c6fd2807SJeff Garzik */ 5330c6fd2807SJeff Garzik int ata_port_offline(struct ata_port *ap) 5331c6fd2807SJeff Garzik { 5332c6fd2807SJeff Garzik u32 sstatus; 5333c6fd2807SJeff Garzik 5334c6fd2807SJeff Garzik if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) != 0x3) 5335c6fd2807SJeff Garzik return 1; 5336c6fd2807SJeff Garzik return 0; 5337c6fd2807SJeff Garzik } 5338c6fd2807SJeff Garzik 5339c6fd2807SJeff Garzik int ata_flush_cache(struct ata_device *dev) 5340c6fd2807SJeff Garzik { 5341c6fd2807SJeff Garzik unsigned int err_mask; 5342c6fd2807SJeff Garzik u8 cmd; 5343c6fd2807SJeff Garzik 5344c6fd2807SJeff Garzik if (!ata_try_flush_cache(dev)) 5345c6fd2807SJeff Garzik return 0; 5346c6fd2807SJeff Garzik 53476fc49adbSTejun Heo if (dev->flags & ATA_DFLAG_FLUSH_EXT) 5348c6fd2807SJeff Garzik cmd = ATA_CMD_FLUSH_EXT; 5349c6fd2807SJeff Garzik else 5350c6fd2807SJeff Garzik cmd = ATA_CMD_FLUSH; 5351c6fd2807SJeff Garzik 5352c6fd2807SJeff Garzik err_mask = ata_do_simple_cmd(dev, cmd); 5353c6fd2807SJeff Garzik if (err_mask) { 5354c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_ERR, "failed to flush cache\n"); 5355c6fd2807SJeff Garzik return -EIO; 5356c6fd2807SJeff Garzik } 5357c6fd2807SJeff Garzik 5358c6fd2807SJeff Garzik return 0; 5359c6fd2807SJeff Garzik } 5360c6fd2807SJeff Garzik 5361cca3974eSJeff Garzik static int ata_host_request_pm(struct ata_host *host, pm_message_t mesg, 5362cca3974eSJeff Garzik unsigned int action, unsigned int ehi_flags, 5363cca3974eSJeff Garzik int wait) 5364c6fd2807SJeff Garzik { 5365c6fd2807SJeff Garzik unsigned long flags; 5366c6fd2807SJeff Garzik int i, rc; 5367c6fd2807SJeff Garzik 5368cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 5369cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 5370c6fd2807SJeff Garzik 5371c6fd2807SJeff Garzik /* Previous resume operation might still be in 5372c6fd2807SJeff Garzik * progress. Wait for PM_PENDING to clear. 5373c6fd2807SJeff Garzik */ 5374c6fd2807SJeff Garzik if (ap->pflags & ATA_PFLAG_PM_PENDING) { 5375c6fd2807SJeff Garzik ata_port_wait_eh(ap); 5376c6fd2807SJeff Garzik WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING); 5377c6fd2807SJeff Garzik } 5378c6fd2807SJeff Garzik 5379c6fd2807SJeff Garzik /* request PM ops to EH */ 5380c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 5381c6fd2807SJeff Garzik 5382c6fd2807SJeff Garzik ap->pm_mesg = mesg; 5383c6fd2807SJeff Garzik if (wait) { 5384c6fd2807SJeff Garzik rc = 0; 5385c6fd2807SJeff Garzik ap->pm_result = &rc; 5386c6fd2807SJeff Garzik } 5387c6fd2807SJeff Garzik 5388c6fd2807SJeff Garzik ap->pflags |= ATA_PFLAG_PM_PENDING; 5389c6fd2807SJeff Garzik ap->eh_info.action |= action; 5390c6fd2807SJeff Garzik ap->eh_info.flags |= ehi_flags; 5391c6fd2807SJeff Garzik 5392c6fd2807SJeff Garzik ata_port_schedule_eh(ap); 5393c6fd2807SJeff Garzik 5394c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5395c6fd2807SJeff Garzik 5396c6fd2807SJeff Garzik /* wait and check result */ 5397c6fd2807SJeff Garzik if (wait) { 5398c6fd2807SJeff Garzik ata_port_wait_eh(ap); 5399c6fd2807SJeff Garzik WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING); 5400c6fd2807SJeff Garzik if (rc) 5401c6fd2807SJeff Garzik return rc; 5402c6fd2807SJeff Garzik } 5403c6fd2807SJeff Garzik } 5404c6fd2807SJeff Garzik 5405c6fd2807SJeff Garzik return 0; 5406c6fd2807SJeff Garzik } 5407c6fd2807SJeff Garzik 5408c6fd2807SJeff Garzik /** 5409cca3974eSJeff Garzik * ata_host_suspend - suspend host 5410cca3974eSJeff Garzik * @host: host to suspend 5411c6fd2807SJeff Garzik * @mesg: PM message 5412c6fd2807SJeff Garzik * 5413cca3974eSJeff Garzik * Suspend @host. Actual operation is performed by EH. This 5414c6fd2807SJeff Garzik * function requests EH to perform PM operations and waits for EH 5415c6fd2807SJeff Garzik * to finish. 5416c6fd2807SJeff Garzik * 5417c6fd2807SJeff Garzik * LOCKING: 5418c6fd2807SJeff Garzik * Kernel thread context (may sleep). 5419c6fd2807SJeff Garzik * 5420c6fd2807SJeff Garzik * RETURNS: 5421c6fd2807SJeff Garzik * 0 on success, -errno on failure. 5422c6fd2807SJeff Garzik */ 5423cca3974eSJeff Garzik int ata_host_suspend(struct ata_host *host, pm_message_t mesg) 5424c6fd2807SJeff Garzik { 5425c6fd2807SJeff Garzik int i, j, rc; 5426c6fd2807SJeff Garzik 5427cca3974eSJeff Garzik rc = ata_host_request_pm(host, mesg, 0, ATA_EHI_QUIET, 1); 5428c6fd2807SJeff Garzik if (rc) 5429c6fd2807SJeff Garzik goto fail; 5430c6fd2807SJeff Garzik 5431c6fd2807SJeff Garzik /* EH is quiescent now. Fail if we have any ready device. 5432c6fd2807SJeff Garzik * This happens if hotplug occurs between completion of device 5433c6fd2807SJeff Garzik * suspension and here. 5434c6fd2807SJeff Garzik */ 5435cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 5436cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 5437c6fd2807SJeff Garzik 5438c6fd2807SJeff Garzik for (j = 0; j < ATA_MAX_DEVICES; j++) { 5439c6fd2807SJeff Garzik struct ata_device *dev = &ap->device[j]; 5440c6fd2807SJeff Garzik 5441c6fd2807SJeff Garzik if (ata_dev_ready(dev)) { 5442c6fd2807SJeff Garzik ata_port_printk(ap, KERN_WARNING, 5443c6fd2807SJeff Garzik "suspend failed, device %d " 5444c6fd2807SJeff Garzik "still active\n", dev->devno); 5445c6fd2807SJeff Garzik rc = -EBUSY; 5446c6fd2807SJeff Garzik goto fail; 5447c6fd2807SJeff Garzik } 5448c6fd2807SJeff Garzik } 5449c6fd2807SJeff Garzik } 5450c6fd2807SJeff Garzik 5451cca3974eSJeff Garzik host->dev->power.power_state = mesg; 5452c6fd2807SJeff Garzik return 0; 5453c6fd2807SJeff Garzik 5454c6fd2807SJeff Garzik fail: 5455cca3974eSJeff Garzik ata_host_resume(host); 5456c6fd2807SJeff Garzik return rc; 5457c6fd2807SJeff Garzik } 5458c6fd2807SJeff Garzik 5459c6fd2807SJeff Garzik /** 5460cca3974eSJeff Garzik * ata_host_resume - resume host 5461cca3974eSJeff Garzik * @host: host to resume 5462c6fd2807SJeff Garzik * 5463cca3974eSJeff Garzik * Resume @host. Actual operation is performed by EH. This 5464c6fd2807SJeff Garzik * function requests EH to perform PM operations and returns. 5465c6fd2807SJeff Garzik * Note that all resume operations are performed parallely. 5466c6fd2807SJeff Garzik * 5467c6fd2807SJeff Garzik * LOCKING: 5468c6fd2807SJeff Garzik * Kernel thread context (may sleep). 5469c6fd2807SJeff Garzik */ 5470cca3974eSJeff Garzik void ata_host_resume(struct ata_host *host) 5471c6fd2807SJeff Garzik { 5472cca3974eSJeff Garzik ata_host_request_pm(host, PMSG_ON, ATA_EH_SOFTRESET, 5473c6fd2807SJeff Garzik ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET, 0); 5474cca3974eSJeff Garzik host->dev->power.power_state = PMSG_ON; 5475c6fd2807SJeff Garzik } 5476c6fd2807SJeff Garzik 5477c6fd2807SJeff Garzik /** 5478c6fd2807SJeff Garzik * ata_port_start - Set port up for dma. 5479c6fd2807SJeff Garzik * @ap: Port to initialize 5480c6fd2807SJeff Garzik * 5481c6fd2807SJeff Garzik * Called just after data structures for each port are 5482c6fd2807SJeff Garzik * initialized. Allocates space for PRD table. 5483c6fd2807SJeff Garzik * 5484c6fd2807SJeff Garzik * May be used as the port_start() entry in ata_port_operations. 5485c6fd2807SJeff Garzik * 5486c6fd2807SJeff Garzik * LOCKING: 5487c6fd2807SJeff Garzik * Inherited from caller. 5488c6fd2807SJeff Garzik */ 5489c6fd2807SJeff Garzik 5490c6fd2807SJeff Garzik int ata_port_start (struct ata_port *ap) 5491c6fd2807SJeff Garzik { 5492c6fd2807SJeff Garzik struct device *dev = ap->dev; 5493c6fd2807SJeff Garzik int rc; 5494c6fd2807SJeff Garzik 5495c6fd2807SJeff Garzik ap->prd = dma_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, GFP_KERNEL); 5496c6fd2807SJeff Garzik if (!ap->prd) 5497c6fd2807SJeff Garzik return -ENOMEM; 5498c6fd2807SJeff Garzik 5499c6fd2807SJeff Garzik rc = ata_pad_alloc(ap, dev); 5500c6fd2807SJeff Garzik if (rc) { 5501c6fd2807SJeff Garzik dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma); 5502c6fd2807SJeff Garzik return rc; 5503c6fd2807SJeff Garzik } 5504c6fd2807SJeff Garzik 5505c6fd2807SJeff Garzik DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, (unsigned long long) ap->prd_dma); 5506c6fd2807SJeff Garzik 5507c6fd2807SJeff Garzik return 0; 5508c6fd2807SJeff Garzik } 5509c6fd2807SJeff Garzik 5510c6fd2807SJeff Garzik 5511c6fd2807SJeff Garzik /** 5512c6fd2807SJeff Garzik * ata_port_stop - Undo ata_port_start() 5513c6fd2807SJeff Garzik * @ap: Port to shut down 5514c6fd2807SJeff Garzik * 5515c6fd2807SJeff Garzik * Frees the PRD table. 5516c6fd2807SJeff Garzik * 5517c6fd2807SJeff Garzik * May be used as the port_stop() entry in ata_port_operations. 5518c6fd2807SJeff Garzik * 5519c6fd2807SJeff Garzik * LOCKING: 5520c6fd2807SJeff Garzik * Inherited from caller. 5521c6fd2807SJeff Garzik */ 5522c6fd2807SJeff Garzik 5523c6fd2807SJeff Garzik void ata_port_stop (struct ata_port *ap) 5524c6fd2807SJeff Garzik { 5525c6fd2807SJeff Garzik struct device *dev = ap->dev; 5526c6fd2807SJeff Garzik 5527c6fd2807SJeff Garzik dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma); 5528c6fd2807SJeff Garzik ata_pad_free(ap, dev); 5529c6fd2807SJeff Garzik } 5530c6fd2807SJeff Garzik 5531cca3974eSJeff Garzik void ata_host_stop (struct ata_host *host) 5532c6fd2807SJeff Garzik { 5533cca3974eSJeff Garzik if (host->mmio_base) 5534cca3974eSJeff Garzik iounmap(host->mmio_base); 5535c6fd2807SJeff Garzik } 5536c6fd2807SJeff Garzik 5537c6fd2807SJeff Garzik /** 5538c6fd2807SJeff Garzik * ata_dev_init - Initialize an ata_device structure 5539c6fd2807SJeff Garzik * @dev: Device structure to initialize 5540c6fd2807SJeff Garzik * 5541c6fd2807SJeff Garzik * Initialize @dev in preparation for probing. 5542c6fd2807SJeff Garzik * 5543c6fd2807SJeff Garzik * LOCKING: 5544c6fd2807SJeff Garzik * Inherited from caller. 5545c6fd2807SJeff Garzik */ 5546c6fd2807SJeff Garzik void ata_dev_init(struct ata_device *dev) 5547c6fd2807SJeff Garzik { 5548c6fd2807SJeff Garzik struct ata_port *ap = dev->ap; 5549c6fd2807SJeff Garzik unsigned long flags; 5550c6fd2807SJeff Garzik 5551c6fd2807SJeff Garzik /* SATA spd limit is bound to the first device */ 5552c6fd2807SJeff Garzik ap->sata_spd_limit = ap->hw_sata_spd_limit; 5553c6fd2807SJeff Garzik 5554c6fd2807SJeff Garzik /* High bits of dev->flags are used to record warm plug 5555c6fd2807SJeff Garzik * requests which occur asynchronously. Synchronize using 5556cca3974eSJeff Garzik * host lock. 5557c6fd2807SJeff Garzik */ 5558c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 5559c6fd2807SJeff Garzik dev->flags &= ~ATA_DFLAG_INIT_MASK; 5560c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5561c6fd2807SJeff Garzik 5562c6fd2807SJeff Garzik memset((void *)dev + ATA_DEVICE_CLEAR_OFFSET, 0, 5563c6fd2807SJeff Garzik sizeof(*dev) - ATA_DEVICE_CLEAR_OFFSET); 5564c6fd2807SJeff Garzik dev->pio_mask = UINT_MAX; 5565c6fd2807SJeff Garzik dev->mwdma_mask = UINT_MAX; 5566c6fd2807SJeff Garzik dev->udma_mask = UINT_MAX; 5567c6fd2807SJeff Garzik } 5568c6fd2807SJeff Garzik 5569c6fd2807SJeff Garzik /** 5570c6fd2807SJeff Garzik * ata_port_init - Initialize an ata_port structure 5571c6fd2807SJeff Garzik * @ap: Structure to initialize 5572cca3974eSJeff Garzik * @host: Collection of hosts to which @ap belongs 5573c6fd2807SJeff Garzik * @ent: Probe information provided by low-level driver 5574c6fd2807SJeff Garzik * @port_no: Port number associated with this ata_port 5575c6fd2807SJeff Garzik * 5576c6fd2807SJeff Garzik * Initialize a new ata_port structure. 5577c6fd2807SJeff Garzik * 5578c6fd2807SJeff Garzik * LOCKING: 5579c6fd2807SJeff Garzik * Inherited from caller. 5580c6fd2807SJeff Garzik */ 5581cca3974eSJeff Garzik void ata_port_init(struct ata_port *ap, struct ata_host *host, 5582c6fd2807SJeff Garzik const struct ata_probe_ent *ent, unsigned int port_no) 5583c6fd2807SJeff Garzik { 5584c6fd2807SJeff Garzik unsigned int i; 5585c6fd2807SJeff Garzik 5586cca3974eSJeff Garzik ap->lock = &host->lock; 5587c6fd2807SJeff Garzik ap->flags = ATA_FLAG_DISABLED; 5588c6fd2807SJeff Garzik ap->id = ata_unique_id++; 5589c6fd2807SJeff Garzik ap->ctl = ATA_DEVCTL_OBS; 5590cca3974eSJeff Garzik ap->host = host; 5591c6fd2807SJeff Garzik ap->dev = ent->dev; 5592c6fd2807SJeff Garzik ap->port_no = port_no; 5593fea63e38STejun Heo if (port_no == 1 && ent->pinfo2) { 5594fea63e38STejun Heo ap->pio_mask = ent->pinfo2->pio_mask; 5595fea63e38STejun Heo ap->mwdma_mask = ent->pinfo2->mwdma_mask; 5596fea63e38STejun Heo ap->udma_mask = ent->pinfo2->udma_mask; 5597fea63e38STejun Heo ap->flags |= ent->pinfo2->flags; 5598fea63e38STejun Heo ap->ops = ent->pinfo2->port_ops; 5599fea63e38STejun Heo } else { 5600c6fd2807SJeff Garzik ap->pio_mask = ent->pio_mask; 5601c6fd2807SJeff Garzik ap->mwdma_mask = ent->mwdma_mask; 5602c6fd2807SJeff Garzik ap->udma_mask = ent->udma_mask; 5603cca3974eSJeff Garzik ap->flags |= ent->port_flags; 5604c6fd2807SJeff Garzik ap->ops = ent->port_ops; 5605fea63e38STejun Heo } 5606c6fd2807SJeff Garzik ap->hw_sata_spd_limit = UINT_MAX; 5607c6fd2807SJeff Garzik ap->active_tag = ATA_TAG_POISON; 5608c6fd2807SJeff Garzik ap->last_ctl = 0xFF; 5609c6fd2807SJeff Garzik 5610c6fd2807SJeff Garzik #if defined(ATA_VERBOSE_DEBUG) 5611c6fd2807SJeff Garzik /* turn on all debugging levels */ 5612c6fd2807SJeff Garzik ap->msg_enable = 0x00FF; 5613c6fd2807SJeff Garzik #elif defined(ATA_DEBUG) 5614c6fd2807SJeff Garzik ap->msg_enable = ATA_MSG_DRV | ATA_MSG_INFO | ATA_MSG_CTL | ATA_MSG_WARN | ATA_MSG_ERR; 5615c6fd2807SJeff Garzik #else 5616c6fd2807SJeff Garzik ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR | ATA_MSG_WARN; 5617c6fd2807SJeff Garzik #endif 5618c6fd2807SJeff Garzik 561965f27f38SDavid Howells INIT_DELAYED_WORK(&ap->port_task, NULL); 562065f27f38SDavid Howells INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug); 562165f27f38SDavid Howells INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan); 5622c6fd2807SJeff Garzik INIT_LIST_HEAD(&ap->eh_done_q); 5623c6fd2807SJeff Garzik init_waitqueue_head(&ap->eh_wait_q); 5624c6fd2807SJeff Garzik 5625c6fd2807SJeff Garzik /* set cable type */ 5626c6fd2807SJeff Garzik ap->cbl = ATA_CBL_NONE; 5627c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_SATA) 5628c6fd2807SJeff Garzik ap->cbl = ATA_CBL_SATA; 5629c6fd2807SJeff Garzik 5630c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_DEVICES; i++) { 5631c6fd2807SJeff Garzik struct ata_device *dev = &ap->device[i]; 5632c6fd2807SJeff Garzik dev->ap = ap; 5633c6fd2807SJeff Garzik dev->devno = i; 5634c6fd2807SJeff Garzik ata_dev_init(dev); 5635c6fd2807SJeff Garzik } 5636c6fd2807SJeff Garzik 5637c6fd2807SJeff Garzik #ifdef ATA_IRQ_TRAP 5638c6fd2807SJeff Garzik ap->stats.unhandled_irq = 1; 5639c6fd2807SJeff Garzik ap->stats.idle_irq = 1; 5640c6fd2807SJeff Garzik #endif 5641c6fd2807SJeff Garzik 5642c6fd2807SJeff Garzik memcpy(&ap->ioaddr, &ent->port[port_no], sizeof(struct ata_ioports)); 5643c6fd2807SJeff Garzik } 5644c6fd2807SJeff Garzik 5645c6fd2807SJeff Garzik /** 5646c6fd2807SJeff Garzik * ata_port_init_shost - Initialize SCSI host associated with ATA port 5647c6fd2807SJeff Garzik * @ap: ATA port to initialize SCSI host for 5648c6fd2807SJeff Garzik * @shost: SCSI host associated with @ap 5649c6fd2807SJeff Garzik * 5650c6fd2807SJeff Garzik * Initialize SCSI host @shost associated with ATA port @ap. 5651c6fd2807SJeff Garzik * 5652c6fd2807SJeff Garzik * LOCKING: 5653c6fd2807SJeff Garzik * Inherited from caller. 5654c6fd2807SJeff Garzik */ 5655c6fd2807SJeff Garzik static void ata_port_init_shost(struct ata_port *ap, struct Scsi_Host *shost) 5656c6fd2807SJeff Garzik { 5657cca3974eSJeff Garzik ap->scsi_host = shost; 5658c6fd2807SJeff Garzik 5659c6fd2807SJeff Garzik shost->unique_id = ap->id; 5660c6fd2807SJeff Garzik shost->max_id = 16; 5661c6fd2807SJeff Garzik shost->max_lun = 1; 5662c6fd2807SJeff Garzik shost->max_channel = 1; 5663c6fd2807SJeff Garzik shost->max_cmd_len = 12; 5664c6fd2807SJeff Garzik } 5665c6fd2807SJeff Garzik 5666c6fd2807SJeff Garzik /** 5667c6fd2807SJeff Garzik * ata_port_add - Attach low-level ATA driver to system 5668c6fd2807SJeff Garzik * @ent: Information provided by low-level driver 5669cca3974eSJeff Garzik * @host: Collections of ports to which we add 5670c6fd2807SJeff Garzik * @port_no: Port number associated with this host 5671c6fd2807SJeff Garzik * 5672c6fd2807SJeff Garzik * Attach low-level ATA driver to system. 5673c6fd2807SJeff Garzik * 5674c6fd2807SJeff Garzik * LOCKING: 5675c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 5676c6fd2807SJeff Garzik * 5677c6fd2807SJeff Garzik * RETURNS: 5678c6fd2807SJeff Garzik * New ata_port on success, for NULL on error. 5679c6fd2807SJeff Garzik */ 5680c6fd2807SJeff Garzik static struct ata_port * ata_port_add(const struct ata_probe_ent *ent, 5681cca3974eSJeff Garzik struct ata_host *host, 5682c6fd2807SJeff Garzik unsigned int port_no) 5683c6fd2807SJeff Garzik { 5684c6fd2807SJeff Garzik struct Scsi_Host *shost; 5685c6fd2807SJeff Garzik struct ata_port *ap; 5686c6fd2807SJeff Garzik 5687c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 5688c6fd2807SJeff Garzik 5689c6fd2807SJeff Garzik if (!ent->port_ops->error_handler && 5690cca3974eSJeff Garzik !(ent->port_flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST))) { 5691c6fd2807SJeff Garzik printk(KERN_ERR "ata%u: no reset mechanism available\n", 5692c6fd2807SJeff Garzik port_no); 5693c6fd2807SJeff Garzik return NULL; 5694c6fd2807SJeff Garzik } 5695c6fd2807SJeff Garzik 5696c6fd2807SJeff Garzik shost = scsi_host_alloc(ent->sht, sizeof(struct ata_port)); 5697c6fd2807SJeff Garzik if (!shost) 5698c6fd2807SJeff Garzik return NULL; 5699c6fd2807SJeff Garzik 5700c6fd2807SJeff Garzik shost->transportt = &ata_scsi_transport_template; 5701c6fd2807SJeff Garzik 5702c6fd2807SJeff Garzik ap = ata_shost_to_port(shost); 5703c6fd2807SJeff Garzik 5704cca3974eSJeff Garzik ata_port_init(ap, host, ent, port_no); 5705c6fd2807SJeff Garzik ata_port_init_shost(ap, shost); 5706c6fd2807SJeff Garzik 5707c6fd2807SJeff Garzik return ap; 5708c6fd2807SJeff Garzik } 5709c6fd2807SJeff Garzik 5710c6fd2807SJeff Garzik /** 5711cca3974eSJeff Garzik * ata_sas_host_init - Initialize a host struct 5712cca3974eSJeff Garzik * @host: host to initialize 5713cca3974eSJeff Garzik * @dev: device host is attached to 5714cca3974eSJeff Garzik * @flags: host flags 5715c6fd2807SJeff Garzik * @ops: port_ops 5716c6fd2807SJeff Garzik * 5717c6fd2807SJeff Garzik * LOCKING: 5718c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 5719c6fd2807SJeff Garzik * 5720c6fd2807SJeff Garzik */ 5721c6fd2807SJeff Garzik 5722cca3974eSJeff Garzik void ata_host_init(struct ata_host *host, struct device *dev, 5723cca3974eSJeff Garzik unsigned long flags, const struct ata_port_operations *ops) 5724c6fd2807SJeff Garzik { 5725cca3974eSJeff Garzik spin_lock_init(&host->lock); 5726cca3974eSJeff Garzik host->dev = dev; 5727cca3974eSJeff Garzik host->flags = flags; 5728cca3974eSJeff Garzik host->ops = ops; 5729c6fd2807SJeff Garzik } 5730c6fd2807SJeff Garzik 5731c6fd2807SJeff Garzik /** 5732c6fd2807SJeff Garzik * ata_device_add - Register hardware device with ATA and SCSI layers 5733c6fd2807SJeff Garzik * @ent: Probe information describing hardware device to be registered 5734c6fd2807SJeff Garzik * 5735c6fd2807SJeff Garzik * This function processes the information provided in the probe 5736c6fd2807SJeff Garzik * information struct @ent, allocates the necessary ATA and SCSI 5737c6fd2807SJeff Garzik * host information structures, initializes them, and registers 5738c6fd2807SJeff Garzik * everything with requisite kernel subsystems. 5739c6fd2807SJeff Garzik * 5740c6fd2807SJeff Garzik * This function requests irqs, probes the ATA bus, and probes 5741c6fd2807SJeff Garzik * the SCSI bus. 5742c6fd2807SJeff Garzik * 5743c6fd2807SJeff Garzik * LOCKING: 5744c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 5745c6fd2807SJeff Garzik * 5746c6fd2807SJeff Garzik * RETURNS: 5747c6fd2807SJeff Garzik * Number of ports registered. Zero on error (no ports registered). 5748c6fd2807SJeff Garzik */ 5749c6fd2807SJeff Garzik int ata_device_add(const struct ata_probe_ent *ent) 5750c6fd2807SJeff Garzik { 5751c6fd2807SJeff Garzik unsigned int i; 5752c6fd2807SJeff Garzik struct device *dev = ent->dev; 5753cca3974eSJeff Garzik struct ata_host *host; 5754c6fd2807SJeff Garzik int rc; 5755c6fd2807SJeff Garzik 5756c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 575702f076aaSAlan Cox 575802f076aaSAlan Cox if (ent->irq == 0) { 575902f076aaSAlan Cox dev_printk(KERN_ERR, dev, "is not available: No interrupt assigned.\n"); 576002f076aaSAlan Cox return 0; 576102f076aaSAlan Cox } 5762c6fd2807SJeff Garzik /* alloc a container for our list of ATA ports (buses) */ 5763cca3974eSJeff Garzik host = kzalloc(sizeof(struct ata_host) + 5764c6fd2807SJeff Garzik (ent->n_ports * sizeof(void *)), GFP_KERNEL); 5765cca3974eSJeff Garzik if (!host) 5766c6fd2807SJeff Garzik return 0; 5767c6fd2807SJeff Garzik 5768cca3974eSJeff Garzik ata_host_init(host, dev, ent->_host_flags, ent->port_ops); 5769cca3974eSJeff Garzik host->n_ports = ent->n_ports; 5770cca3974eSJeff Garzik host->irq = ent->irq; 5771cca3974eSJeff Garzik host->irq2 = ent->irq2; 5772cca3974eSJeff Garzik host->mmio_base = ent->mmio_base; 5773cca3974eSJeff Garzik host->private_data = ent->private_data; 5774c6fd2807SJeff Garzik 5775c6fd2807SJeff Garzik /* register each port bound to this device */ 5776cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 5777c6fd2807SJeff Garzik struct ata_port *ap; 5778c6fd2807SJeff Garzik unsigned long xfer_mode_mask; 5779c6fd2807SJeff Garzik int irq_line = ent->irq; 5780c6fd2807SJeff Garzik 5781cca3974eSJeff Garzik ap = ata_port_add(ent, host, i); 5782c38778c3SDave Jones host->ports[i] = ap; 5783c6fd2807SJeff Garzik if (!ap) 5784c6fd2807SJeff Garzik goto err_out; 5785c6fd2807SJeff Garzik 5786c6fd2807SJeff Garzik /* dummy? */ 5787c6fd2807SJeff Garzik if (ent->dummy_port_mask & (1 << i)) { 5788c6fd2807SJeff Garzik ata_port_printk(ap, KERN_INFO, "DUMMY\n"); 5789c6fd2807SJeff Garzik ap->ops = &ata_dummy_port_ops; 5790c6fd2807SJeff Garzik continue; 5791c6fd2807SJeff Garzik } 5792c6fd2807SJeff Garzik 5793c6fd2807SJeff Garzik /* start port */ 5794c6fd2807SJeff Garzik rc = ap->ops->port_start(ap); 5795c6fd2807SJeff Garzik if (rc) { 5796cca3974eSJeff Garzik host->ports[i] = NULL; 5797cca3974eSJeff Garzik scsi_host_put(ap->scsi_host); 5798c6fd2807SJeff Garzik goto err_out; 5799c6fd2807SJeff Garzik } 5800c6fd2807SJeff Garzik 5801c6fd2807SJeff Garzik /* Report the secondary IRQ for second channel legacy */ 5802c6fd2807SJeff Garzik if (i == 1 && ent->irq2) 5803c6fd2807SJeff Garzik irq_line = ent->irq2; 5804c6fd2807SJeff Garzik 5805c6fd2807SJeff Garzik xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) | 5806c6fd2807SJeff Garzik (ap->mwdma_mask << ATA_SHIFT_MWDMA) | 5807c6fd2807SJeff Garzik (ap->pio_mask << ATA_SHIFT_PIO); 5808c6fd2807SJeff Garzik 5809c6fd2807SJeff Garzik /* print per-port info to dmesg */ 5810c6fd2807SJeff Garzik ata_port_printk(ap, KERN_INFO, "%cATA max %s cmd 0x%lX " 5811c6fd2807SJeff Garzik "ctl 0x%lX bmdma 0x%lX irq %d\n", 5812c6fd2807SJeff Garzik ap->flags & ATA_FLAG_SATA ? 'S' : 'P', 5813c6fd2807SJeff Garzik ata_mode_string(xfer_mode_mask), 5814c6fd2807SJeff Garzik ap->ioaddr.cmd_addr, 5815c6fd2807SJeff Garzik ap->ioaddr.ctl_addr, 5816c6fd2807SJeff Garzik ap->ioaddr.bmdma_addr, 5817c6fd2807SJeff Garzik irq_line); 5818c6fd2807SJeff Garzik 58190f0a3ad3STejun Heo /* freeze port before requesting IRQ */ 58200f0a3ad3STejun Heo ata_eh_freeze_port(ap); 5821c6fd2807SJeff Garzik } 5822c6fd2807SJeff Garzik 5823c6fd2807SJeff Garzik /* obtain irq, that may be shared between channels */ 5824c6fd2807SJeff Garzik rc = request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags, 5825cca3974eSJeff Garzik DRV_NAME, host); 5826c6fd2807SJeff Garzik if (rc) { 5827c6fd2807SJeff Garzik dev_printk(KERN_ERR, dev, "irq %lu request failed: %d\n", 5828c6fd2807SJeff Garzik ent->irq, rc); 5829c6fd2807SJeff Garzik goto err_out; 5830c6fd2807SJeff Garzik } 5831c6fd2807SJeff Garzik 5832c6fd2807SJeff Garzik /* do we have a second IRQ for the other channel, eg legacy mode */ 5833c6fd2807SJeff Garzik if (ent->irq2) { 5834c6fd2807SJeff Garzik /* We will get weird core code crashes later if this is true 5835c6fd2807SJeff Garzik so trap it now */ 5836c6fd2807SJeff Garzik BUG_ON(ent->irq == ent->irq2); 5837c6fd2807SJeff Garzik 5838c6fd2807SJeff Garzik rc = request_irq(ent->irq2, ent->port_ops->irq_handler, ent->irq_flags, 5839cca3974eSJeff Garzik DRV_NAME, host); 5840c6fd2807SJeff Garzik if (rc) { 5841c6fd2807SJeff Garzik dev_printk(KERN_ERR, dev, "irq %lu request failed: %d\n", 5842c6fd2807SJeff Garzik ent->irq2, rc); 5843c6fd2807SJeff Garzik goto err_out_free_irq; 5844c6fd2807SJeff Garzik } 5845c6fd2807SJeff Garzik } 5846c6fd2807SJeff Garzik 5847c6fd2807SJeff Garzik /* perform each probe synchronously */ 5848c6fd2807SJeff Garzik DPRINTK("probe begin\n"); 5849cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 5850cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 5851c6fd2807SJeff Garzik u32 scontrol; 5852c6fd2807SJeff Garzik int rc; 5853c6fd2807SJeff Garzik 5854c6fd2807SJeff Garzik /* init sata_spd_limit to the current value */ 5855c6fd2807SJeff Garzik if (sata_scr_read(ap, SCR_CONTROL, &scontrol) == 0) { 5856c6fd2807SJeff Garzik int spd = (scontrol >> 4) & 0xf; 5857c6fd2807SJeff Garzik ap->hw_sata_spd_limit &= (1 << spd) - 1; 5858c6fd2807SJeff Garzik } 5859c6fd2807SJeff Garzik ap->sata_spd_limit = ap->hw_sata_spd_limit; 5860c6fd2807SJeff Garzik 5861cca3974eSJeff Garzik rc = scsi_add_host(ap->scsi_host, dev); 5862c6fd2807SJeff Garzik if (rc) { 5863c6fd2807SJeff Garzik ata_port_printk(ap, KERN_ERR, "scsi_add_host failed\n"); 5864c6fd2807SJeff Garzik /* FIXME: do something useful here */ 5865c6fd2807SJeff Garzik /* FIXME: handle unconditional calls to 5866c6fd2807SJeff Garzik * scsi_scan_host and ata_host_remove, below, 5867c6fd2807SJeff Garzik * at the very least 5868c6fd2807SJeff Garzik */ 5869c6fd2807SJeff Garzik } 5870c6fd2807SJeff Garzik 5871c6fd2807SJeff Garzik if (ap->ops->error_handler) { 5872c6fd2807SJeff Garzik struct ata_eh_info *ehi = &ap->eh_info; 5873c6fd2807SJeff Garzik unsigned long flags; 5874c6fd2807SJeff Garzik 5875c6fd2807SJeff Garzik ata_port_probe(ap); 5876c6fd2807SJeff Garzik 5877c6fd2807SJeff Garzik /* kick EH for boot probing */ 5878c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 5879c6fd2807SJeff Garzik 5880c6fd2807SJeff Garzik ehi->probe_mask = (1 << ATA_MAX_DEVICES) - 1; 5881c6fd2807SJeff Garzik ehi->action |= ATA_EH_SOFTRESET; 5882c6fd2807SJeff Garzik ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET; 5883c6fd2807SJeff Garzik 5884c6fd2807SJeff Garzik ap->pflags |= ATA_PFLAG_LOADING; 5885c6fd2807SJeff Garzik ata_port_schedule_eh(ap); 5886c6fd2807SJeff Garzik 5887c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5888c6fd2807SJeff Garzik 5889c6fd2807SJeff Garzik /* wait for EH to finish */ 5890c6fd2807SJeff Garzik ata_port_wait_eh(ap); 5891c6fd2807SJeff Garzik } else { 5892c6fd2807SJeff Garzik DPRINTK("ata%u: bus probe begin\n", ap->id); 5893c6fd2807SJeff Garzik rc = ata_bus_probe(ap); 5894c6fd2807SJeff Garzik DPRINTK("ata%u: bus probe end\n", ap->id); 5895c6fd2807SJeff Garzik 5896c6fd2807SJeff Garzik if (rc) { 5897c6fd2807SJeff Garzik /* FIXME: do something useful here? 5898c6fd2807SJeff Garzik * Current libata behavior will 5899c6fd2807SJeff Garzik * tear down everything when 5900c6fd2807SJeff Garzik * the module is removed 5901c6fd2807SJeff Garzik * or the h/w is unplugged. 5902c6fd2807SJeff Garzik */ 5903c6fd2807SJeff Garzik } 5904c6fd2807SJeff Garzik } 5905c6fd2807SJeff Garzik } 5906c6fd2807SJeff Garzik 5907c6fd2807SJeff Garzik /* probes are done, now scan each port's disk(s) */ 5908c6fd2807SJeff Garzik DPRINTK("host probe begin\n"); 5909cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 5910cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 5911c6fd2807SJeff Garzik 5912c6fd2807SJeff Garzik ata_scsi_scan_host(ap); 5913c6fd2807SJeff Garzik } 5914c6fd2807SJeff Garzik 5915cca3974eSJeff Garzik dev_set_drvdata(dev, host); 5916c6fd2807SJeff Garzik 5917c6fd2807SJeff Garzik VPRINTK("EXIT, returning %u\n", ent->n_ports); 5918c6fd2807SJeff Garzik return ent->n_ports; /* success */ 5919c6fd2807SJeff Garzik 5920c6fd2807SJeff Garzik err_out_free_irq: 5921cca3974eSJeff Garzik free_irq(ent->irq, host); 5922c6fd2807SJeff Garzik err_out: 5923cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 5924cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 5925c6fd2807SJeff Garzik if (ap) { 5926c6fd2807SJeff Garzik ap->ops->port_stop(ap); 5927cca3974eSJeff Garzik scsi_host_put(ap->scsi_host); 5928c6fd2807SJeff Garzik } 5929c6fd2807SJeff Garzik } 5930c6fd2807SJeff Garzik 5931cca3974eSJeff Garzik kfree(host); 5932c6fd2807SJeff Garzik VPRINTK("EXIT, returning 0\n"); 5933c6fd2807SJeff Garzik return 0; 5934c6fd2807SJeff Garzik } 5935c6fd2807SJeff Garzik 5936c6fd2807SJeff Garzik /** 5937c6fd2807SJeff Garzik * ata_port_detach - Detach ATA port in prepration of device removal 5938c6fd2807SJeff Garzik * @ap: ATA port to be detached 5939c6fd2807SJeff Garzik * 5940c6fd2807SJeff Garzik * Detach all ATA devices and the associated SCSI devices of @ap; 5941c6fd2807SJeff Garzik * then, remove the associated SCSI host. @ap is guaranteed to 5942c6fd2807SJeff Garzik * be quiescent on return from this function. 5943c6fd2807SJeff Garzik * 5944c6fd2807SJeff Garzik * LOCKING: 5945c6fd2807SJeff Garzik * Kernel thread context (may sleep). 5946c6fd2807SJeff Garzik */ 5947c6fd2807SJeff Garzik void ata_port_detach(struct ata_port *ap) 5948c6fd2807SJeff Garzik { 5949c6fd2807SJeff Garzik unsigned long flags; 5950c6fd2807SJeff Garzik int i; 5951c6fd2807SJeff Garzik 5952c6fd2807SJeff Garzik if (!ap->ops->error_handler) 5953c6fd2807SJeff Garzik goto skip_eh; 5954c6fd2807SJeff Garzik 5955c6fd2807SJeff Garzik /* tell EH we're leaving & flush EH */ 5956c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 5957c6fd2807SJeff Garzik ap->pflags |= ATA_PFLAG_UNLOADING; 5958c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5959c6fd2807SJeff Garzik 5960c6fd2807SJeff Garzik ata_port_wait_eh(ap); 5961c6fd2807SJeff Garzik 5962c6fd2807SJeff Garzik /* EH is now guaranteed to see UNLOADING, so no new device 5963c6fd2807SJeff Garzik * will be attached. Disable all existing devices. 5964c6fd2807SJeff Garzik */ 5965c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 5966c6fd2807SJeff Garzik 5967c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_DEVICES; i++) 5968c6fd2807SJeff Garzik ata_dev_disable(&ap->device[i]); 5969c6fd2807SJeff Garzik 5970c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5971c6fd2807SJeff Garzik 5972c6fd2807SJeff Garzik /* Final freeze & EH. All in-flight commands are aborted. EH 5973c6fd2807SJeff Garzik * will be skipped and retrials will be terminated with bad 5974c6fd2807SJeff Garzik * target. 5975c6fd2807SJeff Garzik */ 5976c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 5977c6fd2807SJeff Garzik ata_port_freeze(ap); /* won't be thawed */ 5978c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5979c6fd2807SJeff Garzik 5980c6fd2807SJeff Garzik ata_port_wait_eh(ap); 5981c6fd2807SJeff Garzik 5982c6fd2807SJeff Garzik /* Flush hotplug task. The sequence is similar to 5983c6fd2807SJeff Garzik * ata_port_flush_task(). 5984c6fd2807SJeff Garzik */ 5985c6fd2807SJeff Garzik flush_workqueue(ata_aux_wq); 5986c6fd2807SJeff Garzik cancel_delayed_work(&ap->hotplug_task); 5987c6fd2807SJeff Garzik flush_workqueue(ata_aux_wq); 5988c6fd2807SJeff Garzik 5989c6fd2807SJeff Garzik skip_eh: 5990c6fd2807SJeff Garzik /* remove the associated SCSI host */ 5991cca3974eSJeff Garzik scsi_remove_host(ap->scsi_host); 5992c6fd2807SJeff Garzik } 5993c6fd2807SJeff Garzik 5994c6fd2807SJeff Garzik /** 5995cca3974eSJeff Garzik * ata_host_remove - PCI layer callback for device removal 5996cca3974eSJeff Garzik * @host: ATA host set that was removed 5997c6fd2807SJeff Garzik * 5998c6fd2807SJeff Garzik * Unregister all objects associated with this host set. Free those 5999c6fd2807SJeff Garzik * objects. 6000c6fd2807SJeff Garzik * 6001c6fd2807SJeff Garzik * LOCKING: 6002c6fd2807SJeff Garzik * Inherited from calling layer (may sleep). 6003c6fd2807SJeff Garzik */ 6004c6fd2807SJeff Garzik 6005cca3974eSJeff Garzik void ata_host_remove(struct ata_host *host) 6006c6fd2807SJeff Garzik { 6007c6fd2807SJeff Garzik unsigned int i; 6008c6fd2807SJeff Garzik 6009cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) 6010cca3974eSJeff Garzik ata_port_detach(host->ports[i]); 6011c6fd2807SJeff Garzik 6012cca3974eSJeff Garzik free_irq(host->irq, host); 6013cca3974eSJeff Garzik if (host->irq2) 6014cca3974eSJeff Garzik free_irq(host->irq2, host); 6015c6fd2807SJeff Garzik 6016cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 6017cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 6018c6fd2807SJeff Garzik 6019cca3974eSJeff Garzik ata_scsi_release(ap->scsi_host); 6020c6fd2807SJeff Garzik 6021c6fd2807SJeff Garzik if ((ap->flags & ATA_FLAG_NO_LEGACY) == 0) { 6022c6fd2807SJeff Garzik struct ata_ioports *ioaddr = &ap->ioaddr; 6023c6fd2807SJeff Garzik 6024c6fd2807SJeff Garzik /* FIXME: Add -ac IDE pci mods to remove these special cases */ 6025c6fd2807SJeff Garzik if (ioaddr->cmd_addr == ATA_PRIMARY_CMD) 6026c6fd2807SJeff Garzik release_region(ATA_PRIMARY_CMD, 8); 6027c6fd2807SJeff Garzik else if (ioaddr->cmd_addr == ATA_SECONDARY_CMD) 6028c6fd2807SJeff Garzik release_region(ATA_SECONDARY_CMD, 8); 6029c6fd2807SJeff Garzik } 6030c6fd2807SJeff Garzik 6031cca3974eSJeff Garzik scsi_host_put(ap->scsi_host); 6032c6fd2807SJeff Garzik } 6033c6fd2807SJeff Garzik 6034cca3974eSJeff Garzik if (host->ops->host_stop) 6035cca3974eSJeff Garzik host->ops->host_stop(host); 6036c6fd2807SJeff Garzik 6037cca3974eSJeff Garzik kfree(host); 6038c6fd2807SJeff Garzik } 6039c6fd2807SJeff Garzik 6040c6fd2807SJeff Garzik /** 6041c6fd2807SJeff Garzik * ata_scsi_release - SCSI layer callback hook for host unload 60424f931374SJeff Garzik * @shost: libata host to be unloaded 6043c6fd2807SJeff Garzik * 6044c6fd2807SJeff Garzik * Performs all duties necessary to shut down a libata port... 6045c6fd2807SJeff Garzik * Kill port kthread, disable port, and release resources. 6046c6fd2807SJeff Garzik * 6047c6fd2807SJeff Garzik * LOCKING: 6048c6fd2807SJeff Garzik * Inherited from SCSI layer. 6049c6fd2807SJeff Garzik * 6050c6fd2807SJeff Garzik * RETURNS: 6051c6fd2807SJeff Garzik * One. 6052c6fd2807SJeff Garzik */ 6053c6fd2807SJeff Garzik 6054cca3974eSJeff Garzik int ata_scsi_release(struct Scsi_Host *shost) 6055c6fd2807SJeff Garzik { 6056cca3974eSJeff Garzik struct ata_port *ap = ata_shost_to_port(shost); 6057c6fd2807SJeff Garzik 6058c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 6059c6fd2807SJeff Garzik 6060c6fd2807SJeff Garzik ap->ops->port_disable(ap); 6061c6fd2807SJeff Garzik ap->ops->port_stop(ap); 6062c6fd2807SJeff Garzik 6063c6fd2807SJeff Garzik DPRINTK("EXIT\n"); 6064c6fd2807SJeff Garzik return 1; 6065c6fd2807SJeff Garzik } 6066c6fd2807SJeff Garzik 6067c6fd2807SJeff Garzik struct ata_probe_ent * 6068c6fd2807SJeff Garzik ata_probe_ent_alloc(struct device *dev, const struct ata_port_info *port) 6069c6fd2807SJeff Garzik { 6070c6fd2807SJeff Garzik struct ata_probe_ent *probe_ent; 6071c6fd2807SJeff Garzik 6072c6fd2807SJeff Garzik probe_ent = kzalloc(sizeof(*probe_ent), GFP_KERNEL); 6073c6fd2807SJeff Garzik if (!probe_ent) { 6074c6fd2807SJeff Garzik printk(KERN_ERR DRV_NAME "(%s): out of memory\n", 6075c6fd2807SJeff Garzik kobject_name(&(dev->kobj))); 6076c6fd2807SJeff Garzik return NULL; 6077c6fd2807SJeff Garzik } 6078c6fd2807SJeff Garzik 6079c6fd2807SJeff Garzik INIT_LIST_HEAD(&probe_ent->node); 6080c6fd2807SJeff Garzik probe_ent->dev = dev; 6081c6fd2807SJeff Garzik 6082c6fd2807SJeff Garzik probe_ent->sht = port->sht; 6083cca3974eSJeff Garzik probe_ent->port_flags = port->flags; 6084c6fd2807SJeff Garzik probe_ent->pio_mask = port->pio_mask; 6085c6fd2807SJeff Garzik probe_ent->mwdma_mask = port->mwdma_mask; 6086c6fd2807SJeff Garzik probe_ent->udma_mask = port->udma_mask; 6087c6fd2807SJeff Garzik probe_ent->port_ops = port->port_ops; 6088d639ca94SJeff Garzik probe_ent->private_data = port->private_data; 6089c6fd2807SJeff Garzik 6090c6fd2807SJeff Garzik return probe_ent; 6091c6fd2807SJeff Garzik } 6092c6fd2807SJeff Garzik 6093c6fd2807SJeff Garzik /** 6094c6fd2807SJeff Garzik * ata_std_ports - initialize ioaddr with standard port offsets. 6095c6fd2807SJeff Garzik * @ioaddr: IO address structure to be initialized 6096c6fd2807SJeff Garzik * 6097c6fd2807SJeff Garzik * Utility function which initializes data_addr, error_addr, 6098c6fd2807SJeff Garzik * feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr, 6099c6fd2807SJeff Garzik * device_addr, status_addr, and command_addr to standard offsets 6100c6fd2807SJeff Garzik * relative to cmd_addr. 6101c6fd2807SJeff Garzik * 6102c6fd2807SJeff Garzik * Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr. 6103c6fd2807SJeff Garzik */ 6104c6fd2807SJeff Garzik 6105c6fd2807SJeff Garzik void ata_std_ports(struct ata_ioports *ioaddr) 6106c6fd2807SJeff Garzik { 6107c6fd2807SJeff Garzik ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA; 6108c6fd2807SJeff Garzik ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR; 6109c6fd2807SJeff Garzik ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE; 6110c6fd2807SJeff Garzik ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT; 6111c6fd2807SJeff Garzik ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL; 6112c6fd2807SJeff Garzik ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM; 6113c6fd2807SJeff Garzik ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH; 6114c6fd2807SJeff Garzik ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE; 6115c6fd2807SJeff Garzik ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS; 6116c6fd2807SJeff Garzik ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD; 6117c6fd2807SJeff Garzik } 6118c6fd2807SJeff Garzik 6119c6fd2807SJeff Garzik 6120c6fd2807SJeff Garzik #ifdef CONFIG_PCI 6121c6fd2807SJeff Garzik 6122cca3974eSJeff Garzik void ata_pci_host_stop (struct ata_host *host) 6123c6fd2807SJeff Garzik { 6124cca3974eSJeff Garzik struct pci_dev *pdev = to_pci_dev(host->dev); 6125c6fd2807SJeff Garzik 6126cca3974eSJeff Garzik pci_iounmap(pdev, host->mmio_base); 6127c6fd2807SJeff Garzik } 6128c6fd2807SJeff Garzik 6129c6fd2807SJeff Garzik /** 6130c6fd2807SJeff Garzik * ata_pci_remove_one - PCI layer callback for device removal 6131c6fd2807SJeff Garzik * @pdev: PCI device that was removed 6132c6fd2807SJeff Garzik * 6133c6fd2807SJeff Garzik * PCI layer indicates to libata via this hook that 6134c6fd2807SJeff Garzik * hot-unplug or module unload event has occurred. 6135c6fd2807SJeff Garzik * Handle this by unregistering all objects associated 6136c6fd2807SJeff Garzik * with this PCI device. Free those objects. Then finally 6137c6fd2807SJeff Garzik * release PCI resources and disable device. 6138c6fd2807SJeff Garzik * 6139c6fd2807SJeff Garzik * LOCKING: 6140c6fd2807SJeff Garzik * Inherited from PCI layer (may sleep). 6141c6fd2807SJeff Garzik */ 6142c6fd2807SJeff Garzik 6143c6fd2807SJeff Garzik void ata_pci_remove_one (struct pci_dev *pdev) 6144c6fd2807SJeff Garzik { 6145c6fd2807SJeff Garzik struct device *dev = pci_dev_to_dev(pdev); 6146cca3974eSJeff Garzik struct ata_host *host = dev_get_drvdata(dev); 6147c6fd2807SJeff Garzik 6148cca3974eSJeff Garzik ata_host_remove(host); 6149c6fd2807SJeff Garzik 6150c6fd2807SJeff Garzik pci_release_regions(pdev); 6151c6fd2807SJeff Garzik pci_disable_device(pdev); 6152c6fd2807SJeff Garzik dev_set_drvdata(dev, NULL); 6153c6fd2807SJeff Garzik } 6154c6fd2807SJeff Garzik 6155c6fd2807SJeff Garzik /* move to PCI subsystem */ 6156c6fd2807SJeff Garzik int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits) 6157c6fd2807SJeff Garzik { 6158c6fd2807SJeff Garzik unsigned long tmp = 0; 6159c6fd2807SJeff Garzik 6160c6fd2807SJeff Garzik switch (bits->width) { 6161c6fd2807SJeff Garzik case 1: { 6162c6fd2807SJeff Garzik u8 tmp8 = 0; 6163c6fd2807SJeff Garzik pci_read_config_byte(pdev, bits->reg, &tmp8); 6164c6fd2807SJeff Garzik tmp = tmp8; 6165c6fd2807SJeff Garzik break; 6166c6fd2807SJeff Garzik } 6167c6fd2807SJeff Garzik case 2: { 6168c6fd2807SJeff Garzik u16 tmp16 = 0; 6169c6fd2807SJeff Garzik pci_read_config_word(pdev, bits->reg, &tmp16); 6170c6fd2807SJeff Garzik tmp = tmp16; 6171c6fd2807SJeff Garzik break; 6172c6fd2807SJeff Garzik } 6173c6fd2807SJeff Garzik case 4: { 6174c6fd2807SJeff Garzik u32 tmp32 = 0; 6175c6fd2807SJeff Garzik pci_read_config_dword(pdev, bits->reg, &tmp32); 6176c6fd2807SJeff Garzik tmp = tmp32; 6177c6fd2807SJeff Garzik break; 6178c6fd2807SJeff Garzik } 6179c6fd2807SJeff Garzik 6180c6fd2807SJeff Garzik default: 6181c6fd2807SJeff Garzik return -EINVAL; 6182c6fd2807SJeff Garzik } 6183c6fd2807SJeff Garzik 6184c6fd2807SJeff Garzik tmp &= bits->mask; 6185c6fd2807SJeff Garzik 6186c6fd2807SJeff Garzik return (tmp == bits->val) ? 1 : 0; 6187c6fd2807SJeff Garzik } 6188c6fd2807SJeff Garzik 6189c6fd2807SJeff Garzik void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg) 6190c6fd2807SJeff Garzik { 6191c6fd2807SJeff Garzik pci_save_state(pdev); 6192c6fd2807SJeff Garzik 6193c6fd2807SJeff Garzik if (mesg.event == PM_EVENT_SUSPEND) { 6194c6fd2807SJeff Garzik pci_disable_device(pdev); 6195c6fd2807SJeff Garzik pci_set_power_state(pdev, PCI_D3hot); 6196c6fd2807SJeff Garzik } 6197c6fd2807SJeff Garzik } 6198c6fd2807SJeff Garzik 6199c6fd2807SJeff Garzik void ata_pci_device_do_resume(struct pci_dev *pdev) 6200c6fd2807SJeff Garzik { 6201c6fd2807SJeff Garzik pci_set_power_state(pdev, PCI_D0); 6202c6fd2807SJeff Garzik pci_restore_state(pdev); 6203c6fd2807SJeff Garzik pci_enable_device(pdev); 6204c6fd2807SJeff Garzik pci_set_master(pdev); 6205c6fd2807SJeff Garzik } 6206c6fd2807SJeff Garzik 6207c6fd2807SJeff Garzik int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg) 6208c6fd2807SJeff Garzik { 6209cca3974eSJeff Garzik struct ata_host *host = dev_get_drvdata(&pdev->dev); 6210c6fd2807SJeff Garzik int rc = 0; 6211c6fd2807SJeff Garzik 6212cca3974eSJeff Garzik rc = ata_host_suspend(host, mesg); 6213c6fd2807SJeff Garzik if (rc) 6214c6fd2807SJeff Garzik return rc; 6215c6fd2807SJeff Garzik 6216c6fd2807SJeff Garzik ata_pci_device_do_suspend(pdev, mesg); 6217c6fd2807SJeff Garzik 6218c6fd2807SJeff Garzik return 0; 6219c6fd2807SJeff Garzik } 6220c6fd2807SJeff Garzik 6221c6fd2807SJeff Garzik int ata_pci_device_resume(struct pci_dev *pdev) 6222c6fd2807SJeff Garzik { 6223cca3974eSJeff Garzik struct ata_host *host = dev_get_drvdata(&pdev->dev); 6224c6fd2807SJeff Garzik 6225c6fd2807SJeff Garzik ata_pci_device_do_resume(pdev); 6226cca3974eSJeff Garzik ata_host_resume(host); 6227c6fd2807SJeff Garzik return 0; 6228c6fd2807SJeff Garzik } 6229c6fd2807SJeff Garzik #endif /* CONFIG_PCI */ 6230c6fd2807SJeff Garzik 6231c6fd2807SJeff Garzik 6232c6fd2807SJeff Garzik static int __init ata_init(void) 6233c6fd2807SJeff Garzik { 6234c6fd2807SJeff Garzik ata_probe_timeout *= HZ; 6235c6fd2807SJeff Garzik ata_wq = create_workqueue("ata"); 6236c6fd2807SJeff Garzik if (!ata_wq) 6237c6fd2807SJeff Garzik return -ENOMEM; 6238c6fd2807SJeff Garzik 6239c6fd2807SJeff Garzik ata_aux_wq = create_singlethread_workqueue("ata_aux"); 6240c6fd2807SJeff Garzik if (!ata_aux_wq) { 6241c6fd2807SJeff Garzik destroy_workqueue(ata_wq); 6242c6fd2807SJeff Garzik return -ENOMEM; 6243c6fd2807SJeff Garzik } 6244c6fd2807SJeff Garzik 6245c6fd2807SJeff Garzik printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n"); 6246c6fd2807SJeff Garzik return 0; 6247c6fd2807SJeff Garzik } 6248c6fd2807SJeff Garzik 6249c6fd2807SJeff Garzik static void __exit ata_exit(void) 6250c6fd2807SJeff Garzik { 6251c6fd2807SJeff Garzik destroy_workqueue(ata_wq); 6252c6fd2807SJeff Garzik destroy_workqueue(ata_aux_wq); 6253c6fd2807SJeff Garzik } 6254c6fd2807SJeff Garzik 6255a4625085SBrian King subsys_initcall(ata_init); 6256c6fd2807SJeff Garzik module_exit(ata_exit); 6257c6fd2807SJeff Garzik 6258c6fd2807SJeff Garzik static unsigned long ratelimit_time; 6259c6fd2807SJeff Garzik static DEFINE_SPINLOCK(ata_ratelimit_lock); 6260c6fd2807SJeff Garzik 6261c6fd2807SJeff Garzik int ata_ratelimit(void) 6262c6fd2807SJeff Garzik { 6263c6fd2807SJeff Garzik int rc; 6264c6fd2807SJeff Garzik unsigned long flags; 6265c6fd2807SJeff Garzik 6266c6fd2807SJeff Garzik spin_lock_irqsave(&ata_ratelimit_lock, flags); 6267c6fd2807SJeff Garzik 6268c6fd2807SJeff Garzik if (time_after(jiffies, ratelimit_time)) { 6269c6fd2807SJeff Garzik rc = 1; 6270c6fd2807SJeff Garzik ratelimit_time = jiffies + (HZ/5); 6271c6fd2807SJeff Garzik } else 6272c6fd2807SJeff Garzik rc = 0; 6273c6fd2807SJeff Garzik 6274c6fd2807SJeff Garzik spin_unlock_irqrestore(&ata_ratelimit_lock, flags); 6275c6fd2807SJeff Garzik 6276c6fd2807SJeff Garzik return rc; 6277c6fd2807SJeff Garzik } 6278c6fd2807SJeff Garzik 6279c6fd2807SJeff Garzik /** 6280c6fd2807SJeff Garzik * ata_wait_register - wait until register value changes 6281c6fd2807SJeff Garzik * @reg: IO-mapped register 6282c6fd2807SJeff Garzik * @mask: Mask to apply to read register value 6283c6fd2807SJeff Garzik * @val: Wait condition 6284c6fd2807SJeff Garzik * @interval_msec: polling interval in milliseconds 6285c6fd2807SJeff Garzik * @timeout_msec: timeout in milliseconds 6286c6fd2807SJeff Garzik * 6287c6fd2807SJeff Garzik * Waiting for some bits of register to change is a common 6288c6fd2807SJeff Garzik * operation for ATA controllers. This function reads 32bit LE 6289c6fd2807SJeff Garzik * IO-mapped register @reg and tests for the following condition. 6290c6fd2807SJeff Garzik * 6291c6fd2807SJeff Garzik * (*@reg & mask) != val 6292c6fd2807SJeff Garzik * 6293c6fd2807SJeff Garzik * If the condition is met, it returns; otherwise, the process is 6294c6fd2807SJeff Garzik * repeated after @interval_msec until timeout. 6295c6fd2807SJeff Garzik * 6296c6fd2807SJeff Garzik * LOCKING: 6297c6fd2807SJeff Garzik * Kernel thread context (may sleep) 6298c6fd2807SJeff Garzik * 6299c6fd2807SJeff Garzik * RETURNS: 6300c6fd2807SJeff Garzik * The final register value. 6301c6fd2807SJeff Garzik */ 6302c6fd2807SJeff Garzik u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val, 6303c6fd2807SJeff Garzik unsigned long interval_msec, 6304c6fd2807SJeff Garzik unsigned long timeout_msec) 6305c6fd2807SJeff Garzik { 6306c6fd2807SJeff Garzik unsigned long timeout; 6307c6fd2807SJeff Garzik u32 tmp; 6308c6fd2807SJeff Garzik 6309c6fd2807SJeff Garzik tmp = ioread32(reg); 6310c6fd2807SJeff Garzik 6311c6fd2807SJeff Garzik /* Calculate timeout _after_ the first read to make sure 6312c6fd2807SJeff Garzik * preceding writes reach the controller before starting to 6313c6fd2807SJeff Garzik * eat away the timeout. 6314c6fd2807SJeff Garzik */ 6315c6fd2807SJeff Garzik timeout = jiffies + (timeout_msec * HZ) / 1000; 6316c6fd2807SJeff Garzik 6317c6fd2807SJeff Garzik while ((tmp & mask) == val && time_before(jiffies, timeout)) { 6318c6fd2807SJeff Garzik msleep(interval_msec); 6319c6fd2807SJeff Garzik tmp = ioread32(reg); 6320c6fd2807SJeff Garzik } 6321c6fd2807SJeff Garzik 6322c6fd2807SJeff Garzik return tmp; 6323c6fd2807SJeff Garzik } 6324c6fd2807SJeff Garzik 6325c6fd2807SJeff Garzik /* 6326c6fd2807SJeff Garzik * Dummy port_ops 6327c6fd2807SJeff Garzik */ 6328c6fd2807SJeff Garzik static void ata_dummy_noret(struct ata_port *ap) { } 6329c6fd2807SJeff Garzik static int ata_dummy_ret0(struct ata_port *ap) { return 0; } 6330c6fd2807SJeff Garzik static void ata_dummy_qc_noret(struct ata_queued_cmd *qc) { } 6331c6fd2807SJeff Garzik 6332c6fd2807SJeff Garzik static u8 ata_dummy_check_status(struct ata_port *ap) 6333c6fd2807SJeff Garzik { 6334c6fd2807SJeff Garzik return ATA_DRDY; 6335c6fd2807SJeff Garzik } 6336c6fd2807SJeff Garzik 6337c6fd2807SJeff Garzik static unsigned int ata_dummy_qc_issue(struct ata_queued_cmd *qc) 6338c6fd2807SJeff Garzik { 6339c6fd2807SJeff Garzik return AC_ERR_SYSTEM; 6340c6fd2807SJeff Garzik } 6341c6fd2807SJeff Garzik 6342c6fd2807SJeff Garzik const struct ata_port_operations ata_dummy_port_ops = { 6343c6fd2807SJeff Garzik .port_disable = ata_port_disable, 6344c6fd2807SJeff Garzik .check_status = ata_dummy_check_status, 6345c6fd2807SJeff Garzik .check_altstatus = ata_dummy_check_status, 6346c6fd2807SJeff Garzik .dev_select = ata_noop_dev_select, 6347c6fd2807SJeff Garzik .qc_prep = ata_noop_qc_prep, 6348c6fd2807SJeff Garzik .qc_issue = ata_dummy_qc_issue, 6349c6fd2807SJeff Garzik .freeze = ata_dummy_noret, 6350c6fd2807SJeff Garzik .thaw = ata_dummy_noret, 6351c6fd2807SJeff Garzik .error_handler = ata_dummy_noret, 6352c6fd2807SJeff Garzik .post_internal_cmd = ata_dummy_qc_noret, 6353c6fd2807SJeff Garzik .irq_clear = ata_dummy_noret, 6354c6fd2807SJeff Garzik .port_start = ata_dummy_ret0, 6355c6fd2807SJeff Garzik .port_stop = ata_dummy_noret, 6356c6fd2807SJeff Garzik }; 6357c6fd2807SJeff Garzik 6358c6fd2807SJeff Garzik /* 6359c6fd2807SJeff Garzik * libata is essentially a library of internal helper functions for 6360c6fd2807SJeff Garzik * low-level ATA host controller drivers. As such, the API/ABI is 6361c6fd2807SJeff Garzik * likely to change as new drivers are added and updated. 6362c6fd2807SJeff Garzik * Do not depend on ABI/API stability. 6363c6fd2807SJeff Garzik */ 6364c6fd2807SJeff Garzik 6365c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_deb_timing_normal); 6366c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_deb_timing_hotplug); 6367c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_deb_timing_long); 6368c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_dummy_port_ops); 6369c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_bios_param); 6370c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_ports); 6371cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_init); 6372c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_device_add); 6373c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_detach); 6374cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_remove); 6375c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_sg_init); 6376c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_sg_init_one); 6377c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_hsm_move); 6378c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_complete); 6379c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_complete_multiple); 6380c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_issue_prot); 6381c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_load); 6382c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_read); 6383c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_noop_dev_select); 6384c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_dev_select); 6385c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_to_fis); 6386c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_from_fis); 6387c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_check_status); 6388c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_altstatus); 6389c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_exec_command); 6390c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_start); 6391c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_stop); 6392c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_host_stop); 6393c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_interrupt); 6394c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_mmio_data_xfer); 6395c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pio_data_xfer); 6396c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pio_data_xfer_noirq); 6397c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_prep); 6398c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_noop_qc_prep); 6399c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_setup); 6400c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_start); 6401c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear); 6402c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_status); 6403c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_stop); 6404c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_freeze); 6405c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_thaw); 6406c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_drive_eh); 6407c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_error_handler); 6408c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_post_internal_cmd); 6409c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_probe); 6410c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_set_spd); 6411c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_phy_debounce); 6412c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_phy_resume); 6413c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_phy_reset); 6414c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(__sata_phy_reset); 6415c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bus_reset); 6416c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_prereset); 6417c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_softreset); 6418b6103f6dSTejun Heo EXPORT_SYMBOL_GPL(sata_port_hardreset); 6419c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_std_hardreset); 6420c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_postreset); 6421c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_dev_classify); 6422c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_dev_pair); 6423c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_disable); 6424c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_ratelimit); 6425c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_wait_register); 6426c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_busy_sleep); 6427c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_queue_task); 6428c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_ioctl); 6429c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_queuecmd); 6430c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_slave_config); 6431c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_slave_destroy); 6432c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth); 6433c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_release); 6434c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_host_intr); 6435c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_valid); 6436c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_read); 6437c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_write); 6438c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_write_flush); 6439c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_online); 6440c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_offline); 6441cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_suspend); 6442cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_resume); 6443c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_id_string); 6444c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_id_c_string); 64456919a0a6SAlan Cox EXPORT_SYMBOL_GPL(ata_device_blacklisted); 6446c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_simulate); 6447c6fd2807SJeff Garzik 6448c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pio_need_iordy); 6449c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_timing_compute); 6450c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_timing_merge); 6451c6fd2807SJeff Garzik 6452c6fd2807SJeff Garzik #ifdef CONFIG_PCI 6453c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(pci_test_config_bits); 6454c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_host_stop); 6455c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_init_native_mode); 6456c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_init_one); 6457c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_remove_one); 6458c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_do_suspend); 6459c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_do_resume); 6460c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_suspend); 6461c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_resume); 6462c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_default_filter); 6463c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_clear_simplex); 6464c6fd2807SJeff Garzik #endif /* CONFIG_PCI */ 6465c6fd2807SJeff Garzik 6466c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_device_suspend); 6467c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_device_resume); 6468c6fd2807SJeff Garzik 6469c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eng_timeout); 6470c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_schedule_eh); 6471c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_abort); 6472c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_freeze); 6473c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_freeze_port); 6474c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_thaw_port); 6475c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_qc_complete); 6476c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_qc_retry); 6477c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_do_eh); 6478