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 62fda0efc5SJeff Garzik 63c6fd2807SJeff Garzik /* debounce timing parameters in msecs { interval, duration, timeout } */ 64c6fd2807SJeff Garzik const unsigned long sata_deb_timing_normal[] = { 5, 100, 2000 }; 65c6fd2807SJeff Garzik const unsigned long sata_deb_timing_hotplug[] = { 25, 500, 2000 }; 66c6fd2807SJeff Garzik const unsigned long sata_deb_timing_long[] = { 100, 2000, 5000 }; 67c6fd2807SJeff Garzik 68c6fd2807SJeff Garzik static unsigned int ata_dev_init_params(struct ata_device *dev, 69c6fd2807SJeff Garzik u16 heads, u16 sectors); 70c6fd2807SJeff Garzik static unsigned int ata_dev_set_xfermode(struct ata_device *dev); 719f45cbd3SKristen Carlson Accardi static unsigned int ata_dev_set_AN(struct ata_device *dev, u8 enable); 72c6fd2807SJeff Garzik static void ata_dev_xfermask(struct ata_device *dev); 7375683fe7STejun Heo static unsigned long ata_dev_blacklisted(const struct ata_device *dev); 74c6fd2807SJeff Garzik 75f3187195STejun Heo unsigned int ata_print_id = 1; 76c6fd2807SJeff Garzik static struct workqueue_struct *ata_wq; 77c6fd2807SJeff Garzik 78c6fd2807SJeff Garzik struct workqueue_struct *ata_aux_wq; 79c6fd2807SJeff Garzik 80c6fd2807SJeff Garzik int atapi_enabled = 1; 81c6fd2807SJeff Garzik module_param(atapi_enabled, int, 0444); 82c6fd2807SJeff Garzik MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)"); 83c6fd2807SJeff Garzik 84c6fd2807SJeff Garzik int atapi_dmadir = 0; 85c6fd2807SJeff Garzik module_param(atapi_dmadir, int, 0444); 86c6fd2807SJeff Garzik MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)"); 87c6fd2807SJeff Garzik 88baf4fdfaSMark Lord int atapi_passthru16 = 1; 89baf4fdfaSMark Lord module_param(atapi_passthru16, int, 0444); 90baf4fdfaSMark Lord MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices; on by default (0=off, 1=on)"); 91baf4fdfaSMark Lord 92c6fd2807SJeff Garzik int libata_fua = 0; 93c6fd2807SJeff Garzik module_param_named(fua, libata_fua, int, 0444); 94c6fd2807SJeff Garzik MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)"); 95c6fd2807SJeff Garzik 961e999736SAlan Cox static int ata_ignore_hpa = 0; 971e999736SAlan Cox module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644); 981e999736SAlan Cox MODULE_PARM_DESC(ignore_hpa, "Ignore HPA limit (0=keep BIOS limits, 1=ignore limits, using full disk)"); 991e999736SAlan Cox 100b3a70601SAlan Cox static int libata_dma_mask = ATA_DMA_MASK_ATA|ATA_DMA_MASK_ATAPI|ATA_DMA_MASK_CFA; 101b3a70601SAlan Cox module_param_named(dma, libata_dma_mask, int, 0444); 102b3a70601SAlan Cox MODULE_PARM_DESC(dma, "DMA enable/disable (0x1==ATA, 0x2==ATAPI, 0x4==CF)"); 103b3a70601SAlan Cox 104c6fd2807SJeff Garzik static int ata_probe_timeout = ATA_TMOUT_INTERNAL / HZ; 105c6fd2807SJeff Garzik module_param(ata_probe_timeout, int, 0444); 106c6fd2807SJeff Garzik MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)"); 107c6fd2807SJeff Garzik 1086ebe9d86SJeff Garzik int libata_noacpi = 0; 109d7d0dad6SJeff Garzik module_param_named(noacpi, libata_noacpi, int, 0444); 1106ebe9d86SJeff Garzik MODULE_PARM_DESC(noacpi, "Disables the use of ACPI in probe/suspend/resume when set"); 11111ef697bSKristen Carlson Accardi 112c6fd2807SJeff Garzik MODULE_AUTHOR("Jeff Garzik"); 113c6fd2807SJeff Garzik MODULE_DESCRIPTION("Library module for ATA devices"); 114c6fd2807SJeff Garzik MODULE_LICENSE("GPL"); 115c6fd2807SJeff Garzik MODULE_VERSION(DRV_VERSION); 116c6fd2807SJeff Garzik 117c6fd2807SJeff Garzik 118c6fd2807SJeff Garzik /** 119c6fd2807SJeff Garzik * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure 120c6fd2807SJeff Garzik * @tf: Taskfile to convert 121c6fd2807SJeff Garzik * @pmp: Port multiplier port 1229977126cSTejun Heo * @is_cmd: This FIS is for command 1239977126cSTejun Heo * @fis: Buffer into which data will output 124c6fd2807SJeff Garzik * 125c6fd2807SJeff Garzik * Converts a standard ATA taskfile to a Serial ATA 126c6fd2807SJeff Garzik * FIS structure (Register - Host to Device). 127c6fd2807SJeff Garzik * 128c6fd2807SJeff Garzik * LOCKING: 129c6fd2807SJeff Garzik * Inherited from caller. 130c6fd2807SJeff Garzik */ 1319977126cSTejun Heo void ata_tf_to_fis(const struct ata_taskfile *tf, u8 pmp, int is_cmd, u8 *fis) 132c6fd2807SJeff Garzik { 133c6fd2807SJeff Garzik fis[0] = 0x27; /* Register - Host to Device FIS */ 1349977126cSTejun Heo fis[1] = pmp & 0xf; /* Port multiplier number*/ 1359977126cSTejun Heo if (is_cmd) 1369977126cSTejun Heo fis[1] |= (1 << 7); /* bit 7 indicates Command FIS */ 1379977126cSTejun Heo 138c6fd2807SJeff Garzik fis[2] = tf->command; 139c6fd2807SJeff Garzik fis[3] = tf->feature; 140c6fd2807SJeff Garzik 141c6fd2807SJeff Garzik fis[4] = tf->lbal; 142c6fd2807SJeff Garzik fis[5] = tf->lbam; 143c6fd2807SJeff Garzik fis[6] = tf->lbah; 144c6fd2807SJeff Garzik fis[7] = tf->device; 145c6fd2807SJeff Garzik 146c6fd2807SJeff Garzik fis[8] = tf->hob_lbal; 147c6fd2807SJeff Garzik fis[9] = tf->hob_lbam; 148c6fd2807SJeff Garzik fis[10] = tf->hob_lbah; 149c6fd2807SJeff Garzik fis[11] = tf->hob_feature; 150c6fd2807SJeff Garzik 151c6fd2807SJeff Garzik fis[12] = tf->nsect; 152c6fd2807SJeff Garzik fis[13] = tf->hob_nsect; 153c6fd2807SJeff Garzik fis[14] = 0; 154c6fd2807SJeff Garzik fis[15] = tf->ctl; 155c6fd2807SJeff Garzik 156c6fd2807SJeff Garzik fis[16] = 0; 157c6fd2807SJeff Garzik fis[17] = 0; 158c6fd2807SJeff Garzik fis[18] = 0; 159c6fd2807SJeff Garzik fis[19] = 0; 160c6fd2807SJeff Garzik } 161c6fd2807SJeff Garzik 162c6fd2807SJeff Garzik /** 163c6fd2807SJeff Garzik * ata_tf_from_fis - Convert SATA FIS to ATA taskfile 164c6fd2807SJeff Garzik * @fis: Buffer from which data will be input 165c6fd2807SJeff Garzik * @tf: Taskfile to output 166c6fd2807SJeff Garzik * 167c6fd2807SJeff Garzik * Converts a serial ATA FIS structure to a standard ATA taskfile. 168c6fd2807SJeff Garzik * 169c6fd2807SJeff Garzik * LOCKING: 170c6fd2807SJeff Garzik * Inherited from caller. 171c6fd2807SJeff Garzik */ 172c6fd2807SJeff Garzik 173c6fd2807SJeff Garzik void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf) 174c6fd2807SJeff Garzik { 175c6fd2807SJeff Garzik tf->command = fis[2]; /* status */ 176c6fd2807SJeff Garzik tf->feature = fis[3]; /* error */ 177c6fd2807SJeff Garzik 178c6fd2807SJeff Garzik tf->lbal = fis[4]; 179c6fd2807SJeff Garzik tf->lbam = fis[5]; 180c6fd2807SJeff Garzik tf->lbah = fis[6]; 181c6fd2807SJeff Garzik tf->device = fis[7]; 182c6fd2807SJeff Garzik 183c6fd2807SJeff Garzik tf->hob_lbal = fis[8]; 184c6fd2807SJeff Garzik tf->hob_lbam = fis[9]; 185c6fd2807SJeff Garzik tf->hob_lbah = fis[10]; 186c6fd2807SJeff Garzik 187c6fd2807SJeff Garzik tf->nsect = fis[12]; 188c6fd2807SJeff Garzik tf->hob_nsect = fis[13]; 189c6fd2807SJeff Garzik } 190c6fd2807SJeff Garzik 191c6fd2807SJeff Garzik static const u8 ata_rw_cmds[] = { 192c6fd2807SJeff Garzik /* pio multi */ 193c6fd2807SJeff Garzik ATA_CMD_READ_MULTI, 194c6fd2807SJeff Garzik ATA_CMD_WRITE_MULTI, 195c6fd2807SJeff Garzik ATA_CMD_READ_MULTI_EXT, 196c6fd2807SJeff Garzik ATA_CMD_WRITE_MULTI_EXT, 197c6fd2807SJeff Garzik 0, 198c6fd2807SJeff Garzik 0, 199c6fd2807SJeff Garzik 0, 200c6fd2807SJeff Garzik ATA_CMD_WRITE_MULTI_FUA_EXT, 201c6fd2807SJeff Garzik /* pio */ 202c6fd2807SJeff Garzik ATA_CMD_PIO_READ, 203c6fd2807SJeff Garzik ATA_CMD_PIO_WRITE, 204c6fd2807SJeff Garzik ATA_CMD_PIO_READ_EXT, 205c6fd2807SJeff Garzik ATA_CMD_PIO_WRITE_EXT, 206c6fd2807SJeff Garzik 0, 207c6fd2807SJeff Garzik 0, 208c6fd2807SJeff Garzik 0, 209c6fd2807SJeff Garzik 0, 210c6fd2807SJeff Garzik /* dma */ 211c6fd2807SJeff Garzik ATA_CMD_READ, 212c6fd2807SJeff Garzik ATA_CMD_WRITE, 213c6fd2807SJeff Garzik ATA_CMD_READ_EXT, 214c6fd2807SJeff Garzik ATA_CMD_WRITE_EXT, 215c6fd2807SJeff Garzik 0, 216c6fd2807SJeff Garzik 0, 217c6fd2807SJeff Garzik 0, 218c6fd2807SJeff Garzik ATA_CMD_WRITE_FUA_EXT 219c6fd2807SJeff Garzik }; 220c6fd2807SJeff Garzik 221c6fd2807SJeff Garzik /** 222c6fd2807SJeff Garzik * ata_rwcmd_protocol - set taskfile r/w commands and protocol 223bd056d7eSTejun Heo * @tf: command to examine and configure 224bd056d7eSTejun Heo * @dev: device tf belongs to 225c6fd2807SJeff Garzik * 226c6fd2807SJeff Garzik * Examine the device configuration and tf->flags to calculate 227c6fd2807SJeff Garzik * the proper read/write commands and protocol to use. 228c6fd2807SJeff Garzik * 229c6fd2807SJeff Garzik * LOCKING: 230c6fd2807SJeff Garzik * caller. 231c6fd2807SJeff Garzik */ 232bd056d7eSTejun Heo static int ata_rwcmd_protocol(struct ata_taskfile *tf, struct ata_device *dev) 233c6fd2807SJeff Garzik { 234c6fd2807SJeff Garzik u8 cmd; 235c6fd2807SJeff Garzik 236c6fd2807SJeff Garzik int index, fua, lba48, write; 237c6fd2807SJeff Garzik 238c6fd2807SJeff Garzik fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0; 239c6fd2807SJeff Garzik lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0; 240c6fd2807SJeff Garzik write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0; 241c6fd2807SJeff Garzik 242c6fd2807SJeff Garzik if (dev->flags & ATA_DFLAG_PIO) { 243c6fd2807SJeff Garzik tf->protocol = ATA_PROT_PIO; 244c6fd2807SJeff Garzik index = dev->multi_count ? 0 : 8; 2459af5c9c9STejun Heo } else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) { 246c6fd2807SJeff Garzik /* Unable to use DMA due to host limitation */ 247c6fd2807SJeff Garzik tf->protocol = ATA_PROT_PIO; 248c6fd2807SJeff Garzik index = dev->multi_count ? 0 : 8; 249c6fd2807SJeff Garzik } else { 250c6fd2807SJeff Garzik tf->protocol = ATA_PROT_DMA; 251c6fd2807SJeff Garzik index = 16; 252c6fd2807SJeff Garzik } 253c6fd2807SJeff Garzik 254c6fd2807SJeff Garzik cmd = ata_rw_cmds[index + fua + lba48 + write]; 255c6fd2807SJeff Garzik if (cmd) { 256c6fd2807SJeff Garzik tf->command = cmd; 257c6fd2807SJeff Garzik return 0; 258c6fd2807SJeff Garzik } 259c6fd2807SJeff Garzik return -1; 260c6fd2807SJeff Garzik } 261c6fd2807SJeff Garzik 262c6fd2807SJeff Garzik /** 26335b649feSTejun Heo * ata_tf_read_block - Read block address from ATA taskfile 26435b649feSTejun Heo * @tf: ATA taskfile of interest 26535b649feSTejun Heo * @dev: ATA device @tf belongs to 26635b649feSTejun Heo * 26735b649feSTejun Heo * LOCKING: 26835b649feSTejun Heo * None. 26935b649feSTejun Heo * 27035b649feSTejun Heo * Read block address from @tf. This function can handle all 27135b649feSTejun Heo * three address formats - LBA, LBA48 and CHS. tf->protocol and 27235b649feSTejun Heo * flags select the address format to use. 27335b649feSTejun Heo * 27435b649feSTejun Heo * RETURNS: 27535b649feSTejun Heo * Block address read from @tf. 27635b649feSTejun Heo */ 27735b649feSTejun Heo u64 ata_tf_read_block(struct ata_taskfile *tf, struct ata_device *dev) 27835b649feSTejun Heo { 27935b649feSTejun Heo u64 block = 0; 28035b649feSTejun Heo 28135b649feSTejun Heo if (tf->flags & ATA_TFLAG_LBA) { 28235b649feSTejun Heo if (tf->flags & ATA_TFLAG_LBA48) { 28335b649feSTejun Heo block |= (u64)tf->hob_lbah << 40; 28435b649feSTejun Heo block |= (u64)tf->hob_lbam << 32; 28535b649feSTejun Heo block |= tf->hob_lbal << 24; 28635b649feSTejun Heo } else 28735b649feSTejun Heo block |= (tf->device & 0xf) << 24; 28835b649feSTejun Heo 28935b649feSTejun Heo block |= tf->lbah << 16; 29035b649feSTejun Heo block |= tf->lbam << 8; 29135b649feSTejun Heo block |= tf->lbal; 29235b649feSTejun Heo } else { 29335b649feSTejun Heo u32 cyl, head, sect; 29435b649feSTejun Heo 29535b649feSTejun Heo cyl = tf->lbam | (tf->lbah << 8); 29635b649feSTejun Heo head = tf->device & 0xf; 29735b649feSTejun Heo sect = tf->lbal; 29835b649feSTejun Heo 29935b649feSTejun Heo block = (cyl * dev->heads + head) * dev->sectors + sect; 30035b649feSTejun Heo } 30135b649feSTejun Heo 30235b649feSTejun Heo return block; 30335b649feSTejun Heo } 30435b649feSTejun Heo 30535b649feSTejun Heo /** 306bd056d7eSTejun Heo * ata_build_rw_tf - Build ATA taskfile for given read/write request 307bd056d7eSTejun Heo * @tf: Target ATA taskfile 308bd056d7eSTejun Heo * @dev: ATA device @tf belongs to 309bd056d7eSTejun Heo * @block: Block address 310bd056d7eSTejun Heo * @n_block: Number of blocks 311bd056d7eSTejun Heo * @tf_flags: RW/FUA etc... 312bd056d7eSTejun Heo * @tag: tag 313bd056d7eSTejun Heo * 314bd056d7eSTejun Heo * LOCKING: 315bd056d7eSTejun Heo * None. 316bd056d7eSTejun Heo * 317bd056d7eSTejun Heo * Build ATA taskfile @tf for read/write request described by 318bd056d7eSTejun Heo * @block, @n_block, @tf_flags and @tag on @dev. 319bd056d7eSTejun Heo * 320bd056d7eSTejun Heo * RETURNS: 321bd056d7eSTejun Heo * 322bd056d7eSTejun Heo * 0 on success, -ERANGE if the request is too large for @dev, 323bd056d7eSTejun Heo * -EINVAL if the request is invalid. 324bd056d7eSTejun Heo */ 325bd056d7eSTejun Heo int ata_build_rw_tf(struct ata_taskfile *tf, struct ata_device *dev, 326bd056d7eSTejun Heo u64 block, u32 n_block, unsigned int tf_flags, 327bd056d7eSTejun Heo unsigned int tag) 328bd056d7eSTejun Heo { 329bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 330bd056d7eSTejun Heo tf->flags |= tf_flags; 331bd056d7eSTejun Heo 3326d1245bfSTejun Heo if (ata_ncq_enabled(dev) && likely(tag != ATA_TAG_INTERNAL)) { 333bd056d7eSTejun Heo /* yay, NCQ */ 334bd056d7eSTejun Heo if (!lba_48_ok(block, n_block)) 335bd056d7eSTejun Heo return -ERANGE; 336bd056d7eSTejun Heo 337bd056d7eSTejun Heo tf->protocol = ATA_PROT_NCQ; 338bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48; 339bd056d7eSTejun Heo 340bd056d7eSTejun Heo if (tf->flags & ATA_TFLAG_WRITE) 341bd056d7eSTejun Heo tf->command = ATA_CMD_FPDMA_WRITE; 342bd056d7eSTejun Heo else 343bd056d7eSTejun Heo tf->command = ATA_CMD_FPDMA_READ; 344bd056d7eSTejun Heo 345bd056d7eSTejun Heo tf->nsect = tag << 3; 346bd056d7eSTejun Heo tf->hob_feature = (n_block >> 8) & 0xff; 347bd056d7eSTejun Heo tf->feature = n_block & 0xff; 348bd056d7eSTejun Heo 349bd056d7eSTejun Heo tf->hob_lbah = (block >> 40) & 0xff; 350bd056d7eSTejun Heo tf->hob_lbam = (block >> 32) & 0xff; 351bd056d7eSTejun Heo tf->hob_lbal = (block >> 24) & 0xff; 352bd056d7eSTejun Heo tf->lbah = (block >> 16) & 0xff; 353bd056d7eSTejun Heo tf->lbam = (block >> 8) & 0xff; 354bd056d7eSTejun Heo tf->lbal = block & 0xff; 355bd056d7eSTejun Heo 356bd056d7eSTejun Heo tf->device = 1 << 6; 357bd056d7eSTejun Heo if (tf->flags & ATA_TFLAG_FUA) 358bd056d7eSTejun Heo tf->device |= 1 << 7; 359bd056d7eSTejun Heo } else if (dev->flags & ATA_DFLAG_LBA) { 360bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_LBA; 361bd056d7eSTejun Heo 362bd056d7eSTejun Heo if (lba_28_ok(block, n_block)) { 363bd056d7eSTejun Heo /* use LBA28 */ 364bd056d7eSTejun Heo tf->device |= (block >> 24) & 0xf; 365bd056d7eSTejun Heo } else if (lba_48_ok(block, n_block)) { 366bd056d7eSTejun Heo if (!(dev->flags & ATA_DFLAG_LBA48)) 367bd056d7eSTejun Heo return -ERANGE; 368bd056d7eSTejun Heo 369bd056d7eSTejun Heo /* use LBA48 */ 370bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_LBA48; 371bd056d7eSTejun Heo 372bd056d7eSTejun Heo tf->hob_nsect = (n_block >> 8) & 0xff; 373bd056d7eSTejun Heo 374bd056d7eSTejun Heo tf->hob_lbah = (block >> 40) & 0xff; 375bd056d7eSTejun Heo tf->hob_lbam = (block >> 32) & 0xff; 376bd056d7eSTejun Heo tf->hob_lbal = (block >> 24) & 0xff; 377bd056d7eSTejun Heo } else 378bd056d7eSTejun Heo /* request too large even for LBA48 */ 379bd056d7eSTejun Heo return -ERANGE; 380bd056d7eSTejun Heo 381bd056d7eSTejun Heo if (unlikely(ata_rwcmd_protocol(tf, dev) < 0)) 382bd056d7eSTejun Heo return -EINVAL; 383bd056d7eSTejun Heo 384bd056d7eSTejun Heo tf->nsect = n_block & 0xff; 385bd056d7eSTejun Heo 386bd056d7eSTejun Heo tf->lbah = (block >> 16) & 0xff; 387bd056d7eSTejun Heo tf->lbam = (block >> 8) & 0xff; 388bd056d7eSTejun Heo tf->lbal = block & 0xff; 389bd056d7eSTejun Heo 390bd056d7eSTejun Heo tf->device |= ATA_LBA; 391bd056d7eSTejun Heo } else { 392bd056d7eSTejun Heo /* CHS */ 393bd056d7eSTejun Heo u32 sect, head, cyl, track; 394bd056d7eSTejun Heo 395bd056d7eSTejun Heo /* The request -may- be too large for CHS addressing. */ 396bd056d7eSTejun Heo if (!lba_28_ok(block, n_block)) 397bd056d7eSTejun Heo return -ERANGE; 398bd056d7eSTejun Heo 399bd056d7eSTejun Heo if (unlikely(ata_rwcmd_protocol(tf, dev) < 0)) 400bd056d7eSTejun Heo return -EINVAL; 401bd056d7eSTejun Heo 402bd056d7eSTejun Heo /* Convert LBA to CHS */ 403bd056d7eSTejun Heo track = (u32)block / dev->sectors; 404bd056d7eSTejun Heo cyl = track / dev->heads; 405bd056d7eSTejun Heo head = track % dev->heads; 406bd056d7eSTejun Heo sect = (u32)block % dev->sectors + 1; 407bd056d7eSTejun Heo 408bd056d7eSTejun Heo DPRINTK("block %u track %u cyl %u head %u sect %u\n", 409bd056d7eSTejun Heo (u32)block, track, cyl, head, sect); 410bd056d7eSTejun Heo 411bd056d7eSTejun Heo /* Check whether the converted CHS can fit. 412bd056d7eSTejun Heo Cylinder: 0-65535 413bd056d7eSTejun Heo Head: 0-15 414bd056d7eSTejun Heo Sector: 1-255*/ 415bd056d7eSTejun Heo if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect)) 416bd056d7eSTejun Heo return -ERANGE; 417bd056d7eSTejun Heo 418bd056d7eSTejun Heo tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */ 419bd056d7eSTejun Heo tf->lbal = sect; 420bd056d7eSTejun Heo tf->lbam = cyl; 421bd056d7eSTejun Heo tf->lbah = cyl >> 8; 422bd056d7eSTejun Heo tf->device |= head; 423bd056d7eSTejun Heo } 424bd056d7eSTejun Heo 425bd056d7eSTejun Heo return 0; 426bd056d7eSTejun Heo } 427bd056d7eSTejun Heo 428bd056d7eSTejun Heo /** 429c6fd2807SJeff Garzik * ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask 430c6fd2807SJeff Garzik * @pio_mask: pio_mask 431c6fd2807SJeff Garzik * @mwdma_mask: mwdma_mask 432c6fd2807SJeff Garzik * @udma_mask: udma_mask 433c6fd2807SJeff Garzik * 434c6fd2807SJeff Garzik * Pack @pio_mask, @mwdma_mask and @udma_mask into a single 435c6fd2807SJeff Garzik * unsigned int xfer_mask. 436c6fd2807SJeff Garzik * 437c6fd2807SJeff Garzik * LOCKING: 438c6fd2807SJeff Garzik * None. 439c6fd2807SJeff Garzik * 440c6fd2807SJeff Garzik * RETURNS: 441c6fd2807SJeff Garzik * Packed xfer_mask. 442c6fd2807SJeff Garzik */ 443c6fd2807SJeff Garzik static unsigned int ata_pack_xfermask(unsigned int pio_mask, 444c6fd2807SJeff Garzik unsigned int mwdma_mask, 445c6fd2807SJeff Garzik unsigned int udma_mask) 446c6fd2807SJeff Garzik { 447c6fd2807SJeff Garzik return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) | 448c6fd2807SJeff Garzik ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) | 449c6fd2807SJeff Garzik ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA); 450c6fd2807SJeff Garzik } 451c6fd2807SJeff Garzik 452c6fd2807SJeff Garzik /** 453c6fd2807SJeff Garzik * ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks 454c6fd2807SJeff Garzik * @xfer_mask: xfer_mask to unpack 455c6fd2807SJeff Garzik * @pio_mask: resulting pio_mask 456c6fd2807SJeff Garzik * @mwdma_mask: resulting mwdma_mask 457c6fd2807SJeff Garzik * @udma_mask: resulting udma_mask 458c6fd2807SJeff Garzik * 459c6fd2807SJeff Garzik * Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask. 460c6fd2807SJeff Garzik * Any NULL distination masks will be ignored. 461c6fd2807SJeff Garzik */ 462c6fd2807SJeff Garzik static void ata_unpack_xfermask(unsigned int xfer_mask, 463c6fd2807SJeff Garzik unsigned int *pio_mask, 464c6fd2807SJeff Garzik unsigned int *mwdma_mask, 465c6fd2807SJeff Garzik unsigned int *udma_mask) 466c6fd2807SJeff Garzik { 467c6fd2807SJeff Garzik if (pio_mask) 468c6fd2807SJeff Garzik *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO; 469c6fd2807SJeff Garzik if (mwdma_mask) 470c6fd2807SJeff Garzik *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA; 471c6fd2807SJeff Garzik if (udma_mask) 472c6fd2807SJeff Garzik *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA; 473c6fd2807SJeff Garzik } 474c6fd2807SJeff Garzik 475c6fd2807SJeff Garzik static const struct ata_xfer_ent { 476c6fd2807SJeff Garzik int shift, bits; 477c6fd2807SJeff Garzik u8 base; 478c6fd2807SJeff Garzik } ata_xfer_tbl[] = { 479c6fd2807SJeff Garzik { ATA_SHIFT_PIO, ATA_BITS_PIO, XFER_PIO_0 }, 480c6fd2807SJeff Garzik { ATA_SHIFT_MWDMA, ATA_BITS_MWDMA, XFER_MW_DMA_0 }, 481c6fd2807SJeff Garzik { ATA_SHIFT_UDMA, ATA_BITS_UDMA, XFER_UDMA_0 }, 482c6fd2807SJeff Garzik { -1, }, 483c6fd2807SJeff Garzik }; 484c6fd2807SJeff Garzik 485c6fd2807SJeff Garzik /** 486c6fd2807SJeff Garzik * ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask 487c6fd2807SJeff Garzik * @xfer_mask: xfer_mask of interest 488c6fd2807SJeff Garzik * 489c6fd2807SJeff Garzik * Return matching XFER_* value for @xfer_mask. Only the highest 490c6fd2807SJeff Garzik * bit of @xfer_mask is considered. 491c6fd2807SJeff Garzik * 492c6fd2807SJeff Garzik * LOCKING: 493c6fd2807SJeff Garzik * None. 494c6fd2807SJeff Garzik * 495c6fd2807SJeff Garzik * RETURNS: 496c6fd2807SJeff Garzik * Matching XFER_* value, 0 if no match found. 497c6fd2807SJeff Garzik */ 498c6fd2807SJeff Garzik static u8 ata_xfer_mask2mode(unsigned int xfer_mask) 499c6fd2807SJeff Garzik { 500c6fd2807SJeff Garzik int highbit = fls(xfer_mask) - 1; 501c6fd2807SJeff Garzik const struct ata_xfer_ent *ent; 502c6fd2807SJeff Garzik 503c6fd2807SJeff Garzik for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 504c6fd2807SJeff Garzik if (highbit >= ent->shift && highbit < ent->shift + ent->bits) 505c6fd2807SJeff Garzik return ent->base + highbit - ent->shift; 506c6fd2807SJeff Garzik return 0; 507c6fd2807SJeff Garzik } 508c6fd2807SJeff Garzik 509c6fd2807SJeff Garzik /** 510c6fd2807SJeff Garzik * ata_xfer_mode2mask - Find matching xfer_mask for XFER_* 511c6fd2807SJeff Garzik * @xfer_mode: XFER_* of interest 512c6fd2807SJeff Garzik * 513c6fd2807SJeff Garzik * Return matching xfer_mask for @xfer_mode. 514c6fd2807SJeff Garzik * 515c6fd2807SJeff Garzik * LOCKING: 516c6fd2807SJeff Garzik * None. 517c6fd2807SJeff Garzik * 518c6fd2807SJeff Garzik * RETURNS: 519c6fd2807SJeff Garzik * Matching xfer_mask, 0 if no match found. 520c6fd2807SJeff Garzik */ 521c6fd2807SJeff Garzik static unsigned int ata_xfer_mode2mask(u8 xfer_mode) 522c6fd2807SJeff Garzik { 523c6fd2807SJeff Garzik const struct ata_xfer_ent *ent; 524c6fd2807SJeff Garzik 525c6fd2807SJeff Garzik for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 526c6fd2807SJeff Garzik if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits) 527c6fd2807SJeff Garzik return 1 << (ent->shift + xfer_mode - ent->base); 528c6fd2807SJeff Garzik return 0; 529c6fd2807SJeff Garzik } 530c6fd2807SJeff Garzik 531c6fd2807SJeff Garzik /** 532c6fd2807SJeff Garzik * ata_xfer_mode2shift - Find matching xfer_shift for XFER_* 533c6fd2807SJeff Garzik * @xfer_mode: XFER_* of interest 534c6fd2807SJeff Garzik * 535c6fd2807SJeff Garzik * Return matching xfer_shift for @xfer_mode. 536c6fd2807SJeff Garzik * 537c6fd2807SJeff Garzik * LOCKING: 538c6fd2807SJeff Garzik * None. 539c6fd2807SJeff Garzik * 540c6fd2807SJeff Garzik * RETURNS: 541c6fd2807SJeff Garzik * Matching xfer_shift, -1 if no match found. 542c6fd2807SJeff Garzik */ 543c6fd2807SJeff Garzik static int ata_xfer_mode2shift(unsigned int xfer_mode) 544c6fd2807SJeff Garzik { 545c6fd2807SJeff Garzik const struct ata_xfer_ent *ent; 546c6fd2807SJeff Garzik 547c6fd2807SJeff Garzik for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 548c6fd2807SJeff Garzik if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits) 549c6fd2807SJeff Garzik return ent->shift; 550c6fd2807SJeff Garzik return -1; 551c6fd2807SJeff Garzik } 552c6fd2807SJeff Garzik 553c6fd2807SJeff Garzik /** 554c6fd2807SJeff Garzik * ata_mode_string - convert xfer_mask to string 555c6fd2807SJeff Garzik * @xfer_mask: mask of bits supported; only highest bit counts. 556c6fd2807SJeff Garzik * 557c6fd2807SJeff Garzik * Determine string which represents the highest speed 558c6fd2807SJeff Garzik * (highest bit in @modemask). 559c6fd2807SJeff Garzik * 560c6fd2807SJeff Garzik * LOCKING: 561c6fd2807SJeff Garzik * None. 562c6fd2807SJeff Garzik * 563c6fd2807SJeff Garzik * RETURNS: 564c6fd2807SJeff Garzik * Constant C string representing highest speed listed in 565c6fd2807SJeff Garzik * @mode_mask, or the constant C string "<n/a>". 566c6fd2807SJeff Garzik */ 567c6fd2807SJeff Garzik static const char *ata_mode_string(unsigned int xfer_mask) 568c6fd2807SJeff Garzik { 569c6fd2807SJeff Garzik static const char * const xfer_mode_str[] = { 570c6fd2807SJeff Garzik "PIO0", 571c6fd2807SJeff Garzik "PIO1", 572c6fd2807SJeff Garzik "PIO2", 573c6fd2807SJeff Garzik "PIO3", 574c6fd2807SJeff Garzik "PIO4", 575b352e57dSAlan Cox "PIO5", 576b352e57dSAlan Cox "PIO6", 577c6fd2807SJeff Garzik "MWDMA0", 578c6fd2807SJeff Garzik "MWDMA1", 579c6fd2807SJeff Garzik "MWDMA2", 580b352e57dSAlan Cox "MWDMA3", 581b352e57dSAlan Cox "MWDMA4", 582c6fd2807SJeff Garzik "UDMA/16", 583c6fd2807SJeff Garzik "UDMA/25", 584c6fd2807SJeff Garzik "UDMA/33", 585c6fd2807SJeff Garzik "UDMA/44", 586c6fd2807SJeff Garzik "UDMA/66", 587c6fd2807SJeff Garzik "UDMA/100", 588c6fd2807SJeff Garzik "UDMA/133", 589c6fd2807SJeff Garzik "UDMA7", 590c6fd2807SJeff Garzik }; 591c6fd2807SJeff Garzik int highbit; 592c6fd2807SJeff Garzik 593c6fd2807SJeff Garzik highbit = fls(xfer_mask) - 1; 594c6fd2807SJeff Garzik if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str)) 595c6fd2807SJeff Garzik return xfer_mode_str[highbit]; 596c6fd2807SJeff Garzik return "<n/a>"; 597c6fd2807SJeff Garzik } 598c6fd2807SJeff Garzik 599c6fd2807SJeff Garzik static const char *sata_spd_string(unsigned int spd) 600c6fd2807SJeff Garzik { 601c6fd2807SJeff Garzik static const char * const spd_str[] = { 602c6fd2807SJeff Garzik "1.5 Gbps", 603c6fd2807SJeff Garzik "3.0 Gbps", 604c6fd2807SJeff Garzik }; 605c6fd2807SJeff Garzik 606c6fd2807SJeff Garzik if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str)) 607c6fd2807SJeff Garzik return "<unknown>"; 608c6fd2807SJeff Garzik return spd_str[spd - 1]; 609c6fd2807SJeff Garzik } 610c6fd2807SJeff Garzik 611c6fd2807SJeff Garzik void ata_dev_disable(struct ata_device *dev) 612c6fd2807SJeff Garzik { 61309d7f9b0STejun Heo if (ata_dev_enabled(dev)) { 6149af5c9c9STejun Heo if (ata_msg_drv(dev->link->ap)) 615c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "disabled\n"); 6164ae72a1eSTejun Heo ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | 6174ae72a1eSTejun Heo ATA_DNXFER_QUIET); 618c6fd2807SJeff Garzik dev->class++; 619c6fd2807SJeff Garzik } 620c6fd2807SJeff Garzik } 621c6fd2807SJeff Garzik 622c6fd2807SJeff Garzik /** 623c6fd2807SJeff Garzik * ata_devchk - PATA device presence detection 624c6fd2807SJeff Garzik * @ap: ATA channel to examine 625c6fd2807SJeff Garzik * @device: Device to examine (starting at zero) 626c6fd2807SJeff Garzik * 6270d5ff566STejun Heo * This technique was originally described in 6280d5ff566STejun Heo * Hale Landis's ATADRVR (www.ata-atapi.com), and 6290d5ff566STejun Heo * later found its way into the ATA/ATAPI spec. 6300d5ff566STejun Heo * 6310d5ff566STejun Heo * Write a pattern to the ATA shadow registers, 6320d5ff566STejun Heo * and if a device is present, it will respond by 6330d5ff566STejun Heo * correctly storing and echoing back the 6340d5ff566STejun Heo * ATA shadow register contents. 635c6fd2807SJeff Garzik * 636c6fd2807SJeff Garzik * LOCKING: 637c6fd2807SJeff Garzik * caller. 638c6fd2807SJeff Garzik */ 639c6fd2807SJeff Garzik 6400d5ff566STejun Heo static unsigned int ata_devchk(struct ata_port *ap, unsigned int device) 641c6fd2807SJeff Garzik { 6420d5ff566STejun Heo struct ata_ioports *ioaddr = &ap->ioaddr; 6430d5ff566STejun Heo u8 nsect, lbal; 6440d5ff566STejun Heo 6450d5ff566STejun Heo ap->ops->dev_select(ap, device); 6460d5ff566STejun Heo 6470d5ff566STejun Heo iowrite8(0x55, ioaddr->nsect_addr); 6480d5ff566STejun Heo iowrite8(0xaa, ioaddr->lbal_addr); 6490d5ff566STejun Heo 6500d5ff566STejun Heo iowrite8(0xaa, ioaddr->nsect_addr); 6510d5ff566STejun Heo iowrite8(0x55, ioaddr->lbal_addr); 6520d5ff566STejun Heo 6530d5ff566STejun Heo iowrite8(0x55, ioaddr->nsect_addr); 6540d5ff566STejun Heo iowrite8(0xaa, ioaddr->lbal_addr); 6550d5ff566STejun Heo 6560d5ff566STejun Heo nsect = ioread8(ioaddr->nsect_addr); 6570d5ff566STejun Heo lbal = ioread8(ioaddr->lbal_addr); 6580d5ff566STejun Heo 6590d5ff566STejun Heo if ((nsect == 0x55) && (lbal == 0xaa)) 6600d5ff566STejun Heo return 1; /* we found a device */ 6610d5ff566STejun Heo 6620d5ff566STejun Heo return 0; /* nothing found */ 663c6fd2807SJeff Garzik } 664c6fd2807SJeff Garzik 665c6fd2807SJeff Garzik /** 666c6fd2807SJeff Garzik * ata_dev_classify - determine device type based on ATA-spec signature 667c6fd2807SJeff Garzik * @tf: ATA taskfile register set for device to be identified 668c6fd2807SJeff Garzik * 669c6fd2807SJeff Garzik * Determine from taskfile register contents whether a device is 670c6fd2807SJeff Garzik * ATA or ATAPI, as per "Signature and persistence" section 671c6fd2807SJeff Garzik * of ATA/PI spec (volume 1, sect 5.14). 672c6fd2807SJeff Garzik * 673c6fd2807SJeff Garzik * LOCKING: 674c6fd2807SJeff Garzik * None. 675c6fd2807SJeff Garzik * 676c6fd2807SJeff Garzik * RETURNS: 677633273a3STejun Heo * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, %ATA_DEV_PMP or 678633273a3STejun Heo * %ATA_DEV_UNKNOWN the event of failure. 679c6fd2807SJeff Garzik */ 680c6fd2807SJeff Garzik unsigned int ata_dev_classify(const struct ata_taskfile *tf) 681c6fd2807SJeff Garzik { 682c6fd2807SJeff Garzik /* Apple's open source Darwin code hints that some devices only 683c6fd2807SJeff Garzik * put a proper signature into the LBA mid/high registers, 684c6fd2807SJeff Garzik * So, we only check those. It's sufficient for uniqueness. 685633273a3STejun Heo * 686633273a3STejun Heo * ATA/ATAPI-7 (d1532v1r1: Feb. 19, 2003) specified separate 687633273a3STejun Heo * signatures for ATA and ATAPI devices attached on SerialATA, 688633273a3STejun Heo * 0x3c/0xc3 and 0x69/0x96 respectively. However, SerialATA 689633273a3STejun Heo * spec has never mentioned about using different signatures 690633273a3STejun Heo * for ATA/ATAPI devices. Then, Serial ATA II: Port 691633273a3STejun Heo * Multiplier specification began to use 0x69/0x96 to identify 692633273a3STejun Heo * port multpliers and 0x3c/0xc3 to identify SEMB device. 693633273a3STejun Heo * ATA/ATAPI-7 dropped descriptions about 0x3c/0xc3 and 694633273a3STejun Heo * 0x69/0x96 shortly and described them as reserved for 695633273a3STejun Heo * SerialATA. 696633273a3STejun Heo * 697633273a3STejun Heo * We follow the current spec and consider that 0x69/0x96 698633273a3STejun Heo * identifies a port multiplier and 0x3c/0xc3 a SEMB device. 699c6fd2807SJeff Garzik */ 700633273a3STejun Heo if ((tf->lbam == 0) && (tf->lbah == 0)) { 701c6fd2807SJeff Garzik DPRINTK("found ATA device by sig\n"); 702c6fd2807SJeff Garzik return ATA_DEV_ATA; 703c6fd2807SJeff Garzik } 704c6fd2807SJeff Garzik 705633273a3STejun Heo if ((tf->lbam == 0x14) && (tf->lbah == 0xeb)) { 706c6fd2807SJeff Garzik DPRINTK("found ATAPI device by sig\n"); 707c6fd2807SJeff Garzik return ATA_DEV_ATAPI; 708c6fd2807SJeff Garzik } 709c6fd2807SJeff Garzik 710633273a3STejun Heo if ((tf->lbam == 0x69) && (tf->lbah == 0x96)) { 711633273a3STejun Heo DPRINTK("found PMP device by sig\n"); 712633273a3STejun Heo return ATA_DEV_PMP; 713633273a3STejun Heo } 714633273a3STejun Heo 715633273a3STejun Heo if ((tf->lbam == 0x3c) && (tf->lbah == 0xc3)) { 716633273a3STejun Heo printk("ata: SEMB device ignored\n"); 717633273a3STejun Heo return ATA_DEV_SEMB_UNSUP; /* not yet */ 718633273a3STejun Heo } 719633273a3STejun Heo 720c6fd2807SJeff Garzik DPRINTK("unknown device\n"); 721c6fd2807SJeff Garzik return ATA_DEV_UNKNOWN; 722c6fd2807SJeff Garzik } 723c6fd2807SJeff Garzik 724c6fd2807SJeff Garzik /** 725c6fd2807SJeff Garzik * ata_dev_try_classify - Parse returned ATA device signature 7263f19859eSTejun Heo * @dev: ATA device to classify (starting at zero) 7273f19859eSTejun Heo * @present: device seems present 728c6fd2807SJeff Garzik * @r_err: Value of error register on completion 729c6fd2807SJeff Garzik * 730c6fd2807SJeff Garzik * After an event -- SRST, E.D.D., or SATA COMRESET -- occurs, 731c6fd2807SJeff Garzik * an ATA/ATAPI-defined set of values is placed in the ATA 732c6fd2807SJeff Garzik * shadow registers, indicating the results of device detection 733c6fd2807SJeff Garzik * and diagnostics. 734c6fd2807SJeff Garzik * 735c6fd2807SJeff Garzik * Select the ATA device, and read the values from the ATA shadow 736c6fd2807SJeff Garzik * registers. Then parse according to the Error register value, 737c6fd2807SJeff Garzik * and the spec-defined values examined by ata_dev_classify(). 738c6fd2807SJeff Garzik * 739c6fd2807SJeff Garzik * LOCKING: 740c6fd2807SJeff Garzik * caller. 741c6fd2807SJeff Garzik * 742c6fd2807SJeff Garzik * RETURNS: 743c6fd2807SJeff Garzik * Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE. 744c6fd2807SJeff Garzik */ 7453f19859eSTejun Heo unsigned int ata_dev_try_classify(struct ata_device *dev, int present, 7463f19859eSTejun Heo u8 *r_err) 747c6fd2807SJeff Garzik { 7483f19859eSTejun Heo struct ata_port *ap = dev->link->ap; 749c6fd2807SJeff Garzik struct ata_taskfile tf; 750c6fd2807SJeff Garzik unsigned int class; 751c6fd2807SJeff Garzik u8 err; 752c6fd2807SJeff Garzik 7533f19859eSTejun Heo ap->ops->dev_select(ap, dev->devno); 754c6fd2807SJeff Garzik 755c6fd2807SJeff Garzik memset(&tf, 0, sizeof(tf)); 756c6fd2807SJeff Garzik 757c6fd2807SJeff Garzik ap->ops->tf_read(ap, &tf); 758c6fd2807SJeff Garzik err = tf.feature; 759c6fd2807SJeff Garzik if (r_err) 760c6fd2807SJeff Garzik *r_err = err; 761c6fd2807SJeff Garzik 76293590859SAlan Cox /* see if device passed diags: if master then continue and warn later */ 7633f19859eSTejun Heo if (err == 0 && dev->devno == 0) 76493590859SAlan Cox /* diagnostic fail : do nothing _YET_ */ 7653f19859eSTejun Heo dev->horkage |= ATA_HORKAGE_DIAGNOSTIC; 76693590859SAlan Cox else if (err == 1) 767c6fd2807SJeff Garzik /* do nothing */ ; 7683f19859eSTejun Heo else if ((dev->devno == 0) && (err == 0x81)) 769c6fd2807SJeff Garzik /* do nothing */ ; 770c6fd2807SJeff Garzik else 771c6fd2807SJeff Garzik return ATA_DEV_NONE; 772c6fd2807SJeff Garzik 773c6fd2807SJeff Garzik /* determine if device is ATA or ATAPI */ 774c6fd2807SJeff Garzik class = ata_dev_classify(&tf); 775c6fd2807SJeff Garzik 776d7fbee05STejun Heo if (class == ATA_DEV_UNKNOWN) { 777d7fbee05STejun Heo /* If the device failed diagnostic, it's likely to 778d7fbee05STejun Heo * have reported incorrect device signature too. 779d7fbee05STejun Heo * Assume ATA device if the device seems present but 780d7fbee05STejun Heo * device signature is invalid with diagnostic 781d7fbee05STejun Heo * failure. 782d7fbee05STejun Heo */ 783d7fbee05STejun Heo if (present && (dev->horkage & ATA_HORKAGE_DIAGNOSTIC)) 784d7fbee05STejun Heo class = ATA_DEV_ATA; 785d7fbee05STejun Heo else 786d7fbee05STejun Heo class = ATA_DEV_NONE; 787d7fbee05STejun Heo } else if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0)) 788d7fbee05STejun Heo class = ATA_DEV_NONE; 789d7fbee05STejun Heo 790c6fd2807SJeff Garzik return class; 791c6fd2807SJeff Garzik } 792c6fd2807SJeff Garzik 793c6fd2807SJeff Garzik /** 794c6fd2807SJeff Garzik * ata_id_string - Convert IDENTIFY DEVICE page into string 795c6fd2807SJeff Garzik * @id: IDENTIFY DEVICE results we will examine 796c6fd2807SJeff Garzik * @s: string into which data is output 797c6fd2807SJeff Garzik * @ofs: offset into identify device page 798c6fd2807SJeff Garzik * @len: length of string to return. must be an even number. 799c6fd2807SJeff Garzik * 800c6fd2807SJeff Garzik * The strings in the IDENTIFY DEVICE page are broken up into 801c6fd2807SJeff Garzik * 16-bit chunks. Run through the string, and output each 802c6fd2807SJeff Garzik * 8-bit chunk linearly, regardless of platform. 803c6fd2807SJeff Garzik * 804c6fd2807SJeff Garzik * LOCKING: 805c6fd2807SJeff Garzik * caller. 806c6fd2807SJeff Garzik */ 807c6fd2807SJeff Garzik 808c6fd2807SJeff Garzik void ata_id_string(const u16 *id, unsigned char *s, 809c6fd2807SJeff Garzik unsigned int ofs, unsigned int len) 810c6fd2807SJeff Garzik { 811c6fd2807SJeff Garzik unsigned int c; 812c6fd2807SJeff Garzik 813c6fd2807SJeff Garzik while (len > 0) { 814c6fd2807SJeff Garzik c = id[ofs] >> 8; 815c6fd2807SJeff Garzik *s = c; 816c6fd2807SJeff Garzik s++; 817c6fd2807SJeff Garzik 818c6fd2807SJeff Garzik c = id[ofs] & 0xff; 819c6fd2807SJeff Garzik *s = c; 820c6fd2807SJeff Garzik s++; 821c6fd2807SJeff Garzik 822c6fd2807SJeff Garzik ofs++; 823c6fd2807SJeff Garzik len -= 2; 824c6fd2807SJeff Garzik } 825c6fd2807SJeff Garzik } 826c6fd2807SJeff Garzik 827c6fd2807SJeff Garzik /** 828c6fd2807SJeff Garzik * ata_id_c_string - Convert IDENTIFY DEVICE page into C string 829c6fd2807SJeff Garzik * @id: IDENTIFY DEVICE results we will examine 830c6fd2807SJeff Garzik * @s: string into which data is output 831c6fd2807SJeff Garzik * @ofs: offset into identify device page 832c6fd2807SJeff Garzik * @len: length of string to return. must be an odd number. 833c6fd2807SJeff Garzik * 834c6fd2807SJeff Garzik * This function is identical to ata_id_string except that it 835c6fd2807SJeff Garzik * trims trailing spaces and terminates the resulting string with 836c6fd2807SJeff Garzik * null. @len must be actual maximum length (even number) + 1. 837c6fd2807SJeff Garzik * 838c6fd2807SJeff Garzik * LOCKING: 839c6fd2807SJeff Garzik * caller. 840c6fd2807SJeff Garzik */ 841c6fd2807SJeff Garzik void ata_id_c_string(const u16 *id, unsigned char *s, 842c6fd2807SJeff Garzik unsigned int ofs, unsigned int len) 843c6fd2807SJeff Garzik { 844c6fd2807SJeff Garzik unsigned char *p; 845c6fd2807SJeff Garzik 846c6fd2807SJeff Garzik WARN_ON(!(len & 1)); 847c6fd2807SJeff Garzik 848c6fd2807SJeff Garzik ata_id_string(id, s, ofs, len - 1); 849c6fd2807SJeff Garzik 850c6fd2807SJeff Garzik p = s + strnlen(s, len - 1); 851c6fd2807SJeff Garzik while (p > s && p[-1] == ' ') 852c6fd2807SJeff Garzik p--; 853c6fd2807SJeff Garzik *p = '\0'; 854c6fd2807SJeff Garzik } 855c6fd2807SJeff Garzik 856db6f8759STejun Heo static u64 ata_id_n_sectors(const u16 *id) 857db6f8759STejun Heo { 858db6f8759STejun Heo if (ata_id_has_lba(id)) { 859db6f8759STejun Heo if (ata_id_has_lba48(id)) 860db6f8759STejun Heo return ata_id_u64(id, 100); 861db6f8759STejun Heo else 862db6f8759STejun Heo return ata_id_u32(id, 60); 863db6f8759STejun Heo } else { 864db6f8759STejun Heo if (ata_id_current_chs_valid(id)) 865db6f8759STejun Heo return ata_id_u32(id, 57); 866db6f8759STejun Heo else 867db6f8759STejun Heo return id[1] * id[3] * id[6]; 868db6f8759STejun Heo } 869db6f8759STejun Heo } 870db6f8759STejun Heo 8711e999736SAlan Cox static u64 ata_tf_to_lba48(struct ata_taskfile *tf) 8721e999736SAlan Cox { 8731e999736SAlan Cox u64 sectors = 0; 8741e999736SAlan Cox 8751e999736SAlan Cox sectors |= ((u64)(tf->hob_lbah & 0xff)) << 40; 8761e999736SAlan Cox sectors |= ((u64)(tf->hob_lbam & 0xff)) << 32; 8771e999736SAlan Cox sectors |= (tf->hob_lbal & 0xff) << 24; 8781e999736SAlan Cox sectors |= (tf->lbah & 0xff) << 16; 8791e999736SAlan Cox sectors |= (tf->lbam & 0xff) << 8; 8801e999736SAlan Cox sectors |= (tf->lbal & 0xff); 8811e999736SAlan Cox 8821e999736SAlan Cox return ++sectors; 8831e999736SAlan Cox } 8841e999736SAlan Cox 8851e999736SAlan Cox static u64 ata_tf_to_lba(struct ata_taskfile *tf) 8861e999736SAlan Cox { 8871e999736SAlan Cox u64 sectors = 0; 8881e999736SAlan Cox 8891e999736SAlan Cox sectors |= (tf->device & 0x0f) << 24; 8901e999736SAlan Cox sectors |= (tf->lbah & 0xff) << 16; 8911e999736SAlan Cox sectors |= (tf->lbam & 0xff) << 8; 8921e999736SAlan Cox sectors |= (tf->lbal & 0xff); 8931e999736SAlan Cox 8941e999736SAlan Cox return ++sectors; 8951e999736SAlan Cox } 8961e999736SAlan Cox 8971e999736SAlan Cox /** 898c728a914STejun Heo * ata_read_native_max_address - Read native max address 899c728a914STejun Heo * @dev: target device 900c728a914STejun Heo * @max_sectors: out parameter for the result native max address 9011e999736SAlan Cox * 902c728a914STejun Heo * Perform an LBA48 or LBA28 native size query upon the device in 903c728a914STejun Heo * question. 904c728a914STejun Heo * 905c728a914STejun Heo * RETURNS: 906c728a914STejun Heo * 0 on success, -EACCES if command is aborted by the drive. 907c728a914STejun Heo * -EIO on other errors. 9081e999736SAlan Cox */ 909c728a914STejun Heo static int ata_read_native_max_address(struct ata_device *dev, u64 *max_sectors) 9101e999736SAlan Cox { 911c728a914STejun Heo unsigned int err_mask; 9121e999736SAlan Cox struct ata_taskfile tf; 913c728a914STejun Heo int lba48 = ata_id_has_lba48(dev->id); 9141e999736SAlan Cox 9151e999736SAlan Cox ata_tf_init(dev, &tf); 9161e999736SAlan Cox 917c728a914STejun Heo /* always clear all address registers */ 9181e999736SAlan Cox tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR; 919c728a914STejun Heo 920c728a914STejun Heo if (lba48) { 921c728a914STejun Heo tf.command = ATA_CMD_READ_NATIVE_MAX_EXT; 922c728a914STejun Heo tf.flags |= ATA_TFLAG_LBA48; 923c728a914STejun Heo } else 924c728a914STejun Heo tf.command = ATA_CMD_READ_NATIVE_MAX; 925c728a914STejun Heo 9261e999736SAlan Cox tf.protocol |= ATA_PROT_NODATA; 927c728a914STejun Heo tf.device |= ATA_LBA; 9281e999736SAlan Cox 9292b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 930c728a914STejun Heo if (err_mask) { 931c728a914STejun Heo ata_dev_printk(dev, KERN_WARNING, "failed to read native " 932c728a914STejun Heo "max address (err_mask=0x%x)\n", err_mask); 933c728a914STejun Heo if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED)) 934c728a914STejun Heo return -EACCES; 935c728a914STejun Heo return -EIO; 936c728a914STejun Heo } 937c728a914STejun Heo 938c728a914STejun Heo if (lba48) 939c728a914STejun Heo *max_sectors = ata_tf_to_lba48(&tf); 940c728a914STejun Heo else 941c728a914STejun Heo *max_sectors = ata_tf_to_lba(&tf); 94293328e11SAlan Cox if (dev->horkage & ATA_HORKAGE_HPA_SIZE) 94393328e11SAlan Cox (*max_sectors)--; 9441e999736SAlan Cox return 0; 9451e999736SAlan Cox } 9461e999736SAlan Cox 9471e999736SAlan Cox /** 948c728a914STejun Heo * ata_set_max_sectors - Set max sectors 949c728a914STejun Heo * @dev: target device 9506b38d1d1SRandy Dunlap * @new_sectors: new max sectors value to set for the device 9511e999736SAlan Cox * 952c728a914STejun Heo * Set max sectors of @dev to @new_sectors. 953c728a914STejun Heo * 954c728a914STejun Heo * RETURNS: 955c728a914STejun Heo * 0 on success, -EACCES if command is aborted or denied (due to 956c728a914STejun Heo * previous non-volatile SET_MAX) by the drive. -EIO on other 957c728a914STejun Heo * errors. 9581e999736SAlan Cox */ 95905027adcSTejun Heo static int ata_set_max_sectors(struct ata_device *dev, u64 new_sectors) 9601e999736SAlan Cox { 961c728a914STejun Heo unsigned int err_mask; 9621e999736SAlan Cox struct ata_taskfile tf; 963c728a914STejun Heo int lba48 = ata_id_has_lba48(dev->id); 9641e999736SAlan Cox 9651e999736SAlan Cox new_sectors--; 9661e999736SAlan Cox 9671e999736SAlan Cox ata_tf_init(dev, &tf); 9681e999736SAlan Cox 969c728a914STejun Heo tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR; 9701e999736SAlan Cox 971c728a914STejun Heo if (lba48) { 972c728a914STejun Heo tf.command = ATA_CMD_SET_MAX_EXT; 973c728a914STejun Heo tf.flags |= ATA_TFLAG_LBA48; 9741e999736SAlan Cox 9751e999736SAlan Cox tf.hob_lbal = (new_sectors >> 24) & 0xff; 9761e999736SAlan Cox tf.hob_lbam = (new_sectors >> 32) & 0xff; 9771e999736SAlan Cox tf.hob_lbah = (new_sectors >> 40) & 0xff; 9781e582ba4STejun Heo } else { 9791e999736SAlan Cox tf.command = ATA_CMD_SET_MAX; 980c728a914STejun Heo 9811e582ba4STejun Heo tf.device |= (new_sectors >> 24) & 0xf; 9821e582ba4STejun Heo } 9831e582ba4STejun Heo 9841e999736SAlan Cox tf.protocol |= ATA_PROT_NODATA; 985c728a914STejun Heo tf.device |= ATA_LBA; 9861e999736SAlan Cox 9871e999736SAlan Cox tf.lbal = (new_sectors >> 0) & 0xff; 9881e999736SAlan Cox tf.lbam = (new_sectors >> 8) & 0xff; 9891e999736SAlan Cox tf.lbah = (new_sectors >> 16) & 0xff; 9901e999736SAlan Cox 9912b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 992c728a914STejun Heo if (err_mask) { 993c728a914STejun Heo ata_dev_printk(dev, KERN_WARNING, "failed to set " 994c728a914STejun Heo "max address (err_mask=0x%x)\n", err_mask); 995c728a914STejun Heo if (err_mask == AC_ERR_DEV && 996c728a914STejun Heo (tf.feature & (ATA_ABORTED | ATA_IDNF))) 997c728a914STejun Heo return -EACCES; 998c728a914STejun Heo return -EIO; 999c728a914STejun Heo } 1000c728a914STejun Heo 10011e999736SAlan Cox return 0; 10021e999736SAlan Cox } 10031e999736SAlan Cox 10041e999736SAlan Cox /** 10051e999736SAlan Cox * ata_hpa_resize - Resize a device with an HPA set 10061e999736SAlan Cox * @dev: Device to resize 10071e999736SAlan Cox * 10081e999736SAlan Cox * Read the size of an LBA28 or LBA48 disk with HPA features and resize 10091e999736SAlan Cox * it if required to the full size of the media. The caller must check 10101e999736SAlan Cox * the drive has the HPA feature set enabled. 101105027adcSTejun Heo * 101205027adcSTejun Heo * RETURNS: 101305027adcSTejun Heo * 0 on success, -errno on failure. 10141e999736SAlan Cox */ 101505027adcSTejun Heo static int ata_hpa_resize(struct ata_device *dev) 10161e999736SAlan Cox { 101705027adcSTejun Heo struct ata_eh_context *ehc = &dev->link->eh_context; 101805027adcSTejun Heo int print_info = ehc->i.flags & ATA_EHI_PRINTINFO; 101905027adcSTejun Heo u64 sectors = ata_id_n_sectors(dev->id); 102005027adcSTejun Heo u64 native_sectors; 1021c728a914STejun Heo int rc; 10221e999736SAlan Cox 102305027adcSTejun Heo /* do we need to do it? */ 102405027adcSTejun Heo if (dev->class != ATA_DEV_ATA || 102505027adcSTejun Heo !ata_id_has_lba(dev->id) || !ata_id_hpa_enabled(dev->id) || 102605027adcSTejun Heo (dev->horkage & ATA_HORKAGE_BROKEN_HPA)) 1027c728a914STejun Heo return 0; 10281e999736SAlan Cox 102905027adcSTejun Heo /* read native max address */ 103005027adcSTejun Heo rc = ata_read_native_max_address(dev, &native_sectors); 103105027adcSTejun Heo if (rc) { 103205027adcSTejun Heo /* If HPA isn't going to be unlocked, skip HPA 103305027adcSTejun Heo * resizing from the next try. 103405027adcSTejun Heo */ 103505027adcSTejun Heo if (!ata_ignore_hpa) { 103605027adcSTejun Heo ata_dev_printk(dev, KERN_WARNING, "HPA support seems " 103705027adcSTejun Heo "broken, will skip HPA handling\n"); 103805027adcSTejun Heo dev->horkage |= ATA_HORKAGE_BROKEN_HPA; 103905027adcSTejun Heo 104005027adcSTejun Heo /* we can continue if device aborted the command */ 104105027adcSTejun Heo if (rc == -EACCES) 104205027adcSTejun Heo rc = 0; 104305027adcSTejun Heo } 104405027adcSTejun Heo 104505027adcSTejun Heo return rc; 104605027adcSTejun Heo } 104705027adcSTejun Heo 104805027adcSTejun Heo /* nothing to do? */ 104905027adcSTejun Heo if (native_sectors <= sectors || !ata_ignore_hpa) { 105005027adcSTejun Heo if (!print_info || native_sectors == sectors) 105105027adcSTejun Heo return 0; 105205027adcSTejun Heo 105305027adcSTejun Heo if (native_sectors > sectors) 10541e999736SAlan Cox ata_dev_printk(dev, KERN_INFO, 105505027adcSTejun Heo "HPA detected: current %llu, native %llu\n", 105605027adcSTejun Heo (unsigned long long)sectors, 105705027adcSTejun Heo (unsigned long long)native_sectors); 105805027adcSTejun Heo else if (native_sectors < sectors) 105905027adcSTejun Heo ata_dev_printk(dev, KERN_WARNING, 106005027adcSTejun Heo "native sectors (%llu) is smaller than " 106105027adcSTejun Heo "sectors (%llu)\n", 106205027adcSTejun Heo (unsigned long long)native_sectors, 106305027adcSTejun Heo (unsigned long long)sectors); 106405027adcSTejun Heo return 0; 10651e999736SAlan Cox } 106637301a55STejun Heo 106705027adcSTejun Heo /* let's unlock HPA */ 106805027adcSTejun Heo rc = ata_set_max_sectors(dev, native_sectors); 106905027adcSTejun Heo if (rc == -EACCES) { 107005027adcSTejun Heo /* if device aborted the command, skip HPA resizing */ 107105027adcSTejun Heo ata_dev_printk(dev, KERN_WARNING, "device aborted resize " 107205027adcSTejun Heo "(%llu -> %llu), skipping HPA handling\n", 107305027adcSTejun Heo (unsigned long long)sectors, 107405027adcSTejun Heo (unsigned long long)native_sectors); 107505027adcSTejun Heo dev->horkage |= ATA_HORKAGE_BROKEN_HPA; 107605027adcSTejun Heo return 0; 107705027adcSTejun Heo } else if (rc) 107805027adcSTejun Heo return rc; 107905027adcSTejun Heo 108005027adcSTejun Heo /* re-read IDENTIFY data */ 108105027adcSTejun Heo rc = ata_dev_reread_id(dev, 0); 108205027adcSTejun Heo if (rc) { 108305027adcSTejun Heo ata_dev_printk(dev, KERN_ERR, "failed to re-read IDENTIFY " 108405027adcSTejun Heo "data after HPA resizing\n"); 108505027adcSTejun Heo return rc; 108605027adcSTejun Heo } 108705027adcSTejun Heo 108805027adcSTejun Heo if (print_info) { 108905027adcSTejun Heo u64 new_sectors = ata_id_n_sectors(dev->id); 109005027adcSTejun Heo ata_dev_printk(dev, KERN_INFO, 109105027adcSTejun Heo "HPA unlocked: %llu -> %llu, native %llu\n", 109205027adcSTejun Heo (unsigned long long)sectors, 109305027adcSTejun Heo (unsigned long long)new_sectors, 109405027adcSTejun Heo (unsigned long long)native_sectors); 109505027adcSTejun Heo } 109605027adcSTejun Heo 109705027adcSTejun Heo return 0; 10981e999736SAlan Cox } 10991e999736SAlan Cox 1100c6fd2807SJeff Garzik /** 110110305f0fSAlan * ata_id_to_dma_mode - Identify DMA mode from id block 110210305f0fSAlan * @dev: device to identify 1103cc261267SRandy Dunlap * @unknown: mode to assume if we cannot tell 110410305f0fSAlan * 110510305f0fSAlan * Set up the timing values for the device based upon the identify 110610305f0fSAlan * reported values for the DMA mode. This function is used by drivers 110710305f0fSAlan * which rely upon firmware configured modes, but wish to report the 110810305f0fSAlan * mode correctly when possible. 110910305f0fSAlan * 111010305f0fSAlan * In addition we emit similarly formatted messages to the default 111110305f0fSAlan * ata_dev_set_mode handler, in order to provide consistency of 111210305f0fSAlan * presentation. 111310305f0fSAlan */ 111410305f0fSAlan 111510305f0fSAlan void ata_id_to_dma_mode(struct ata_device *dev, u8 unknown) 111610305f0fSAlan { 111710305f0fSAlan unsigned int mask; 111810305f0fSAlan u8 mode; 111910305f0fSAlan 112010305f0fSAlan /* Pack the DMA modes */ 112110305f0fSAlan mask = ((dev->id[63] >> 8) << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA; 112210305f0fSAlan if (dev->id[53] & 0x04) 112310305f0fSAlan mask |= ((dev->id[88] >> 8) << ATA_SHIFT_UDMA) & ATA_MASK_UDMA; 112410305f0fSAlan 112510305f0fSAlan /* Select the mode in use */ 112610305f0fSAlan mode = ata_xfer_mask2mode(mask); 112710305f0fSAlan 112810305f0fSAlan if (mode != 0) { 112910305f0fSAlan ata_dev_printk(dev, KERN_INFO, "configured for %s\n", 113010305f0fSAlan ata_mode_string(mask)); 113110305f0fSAlan } else { 113210305f0fSAlan /* SWDMA perhaps ? */ 113310305f0fSAlan mode = unknown; 113410305f0fSAlan ata_dev_printk(dev, KERN_INFO, "configured for DMA\n"); 113510305f0fSAlan } 113610305f0fSAlan 113710305f0fSAlan /* Configure the device reporting */ 113810305f0fSAlan dev->xfer_mode = mode; 113910305f0fSAlan dev->xfer_shift = ata_xfer_mode2shift(mode); 114010305f0fSAlan } 114110305f0fSAlan 114210305f0fSAlan /** 1143c6fd2807SJeff Garzik * ata_noop_dev_select - Select device 0/1 on ATA bus 1144c6fd2807SJeff Garzik * @ap: ATA channel to manipulate 1145c6fd2807SJeff Garzik * @device: ATA device (numbered from zero) to select 1146c6fd2807SJeff Garzik * 1147c6fd2807SJeff Garzik * This function performs no actual function. 1148c6fd2807SJeff Garzik * 1149c6fd2807SJeff Garzik * May be used as the dev_select() entry in ata_port_operations. 1150c6fd2807SJeff Garzik * 1151c6fd2807SJeff Garzik * LOCKING: 1152c6fd2807SJeff Garzik * caller. 1153c6fd2807SJeff Garzik */ 1154c6fd2807SJeff Garzik void ata_noop_dev_select (struct ata_port *ap, unsigned int device) 1155c6fd2807SJeff Garzik { 1156c6fd2807SJeff Garzik } 1157c6fd2807SJeff Garzik 1158c6fd2807SJeff Garzik 1159c6fd2807SJeff Garzik /** 1160c6fd2807SJeff Garzik * ata_std_dev_select - Select device 0/1 on ATA bus 1161c6fd2807SJeff Garzik * @ap: ATA channel to manipulate 1162c6fd2807SJeff Garzik * @device: ATA device (numbered from zero) to select 1163c6fd2807SJeff Garzik * 1164c6fd2807SJeff Garzik * Use the method defined in the ATA specification to 1165c6fd2807SJeff Garzik * make either device 0, or device 1, active on the 1166c6fd2807SJeff Garzik * ATA channel. Works with both PIO and MMIO. 1167c6fd2807SJeff Garzik * 1168c6fd2807SJeff Garzik * May be used as the dev_select() entry in ata_port_operations. 1169c6fd2807SJeff Garzik * 1170c6fd2807SJeff Garzik * LOCKING: 1171c6fd2807SJeff Garzik * caller. 1172c6fd2807SJeff Garzik */ 1173c6fd2807SJeff Garzik 1174c6fd2807SJeff Garzik void ata_std_dev_select (struct ata_port *ap, unsigned int device) 1175c6fd2807SJeff Garzik { 1176c6fd2807SJeff Garzik u8 tmp; 1177c6fd2807SJeff Garzik 1178c6fd2807SJeff Garzik if (device == 0) 1179c6fd2807SJeff Garzik tmp = ATA_DEVICE_OBS; 1180c6fd2807SJeff Garzik else 1181c6fd2807SJeff Garzik tmp = ATA_DEVICE_OBS | ATA_DEV1; 1182c6fd2807SJeff Garzik 11830d5ff566STejun Heo iowrite8(tmp, ap->ioaddr.device_addr); 1184c6fd2807SJeff Garzik ata_pause(ap); /* needed; also flushes, for mmio */ 1185c6fd2807SJeff Garzik } 1186c6fd2807SJeff Garzik 1187c6fd2807SJeff Garzik /** 1188c6fd2807SJeff Garzik * ata_dev_select - Select device 0/1 on ATA bus 1189c6fd2807SJeff Garzik * @ap: ATA channel to manipulate 1190c6fd2807SJeff Garzik * @device: ATA device (numbered from zero) to select 1191c6fd2807SJeff Garzik * @wait: non-zero to wait for Status register BSY bit to clear 1192c6fd2807SJeff Garzik * @can_sleep: non-zero if context allows sleeping 1193c6fd2807SJeff Garzik * 1194c6fd2807SJeff Garzik * Use the method defined in the ATA specification to 1195c6fd2807SJeff Garzik * make either device 0, or device 1, active on the 1196c6fd2807SJeff Garzik * ATA channel. 1197c6fd2807SJeff Garzik * 1198c6fd2807SJeff Garzik * This is a high-level version of ata_std_dev_select(), 1199c6fd2807SJeff Garzik * which additionally provides the services of inserting 1200c6fd2807SJeff Garzik * the proper pauses and status polling, where needed. 1201c6fd2807SJeff Garzik * 1202c6fd2807SJeff Garzik * LOCKING: 1203c6fd2807SJeff Garzik * caller. 1204c6fd2807SJeff Garzik */ 1205c6fd2807SJeff Garzik 1206c6fd2807SJeff Garzik void ata_dev_select(struct ata_port *ap, unsigned int device, 1207c6fd2807SJeff Garzik unsigned int wait, unsigned int can_sleep) 1208c6fd2807SJeff Garzik { 1209c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 121044877b4eSTejun Heo ata_port_printk(ap, KERN_INFO, "ata_dev_select: ENTER, " 121144877b4eSTejun Heo "device %u, wait %u\n", device, wait); 1212c6fd2807SJeff Garzik 1213c6fd2807SJeff Garzik if (wait) 1214c6fd2807SJeff Garzik ata_wait_idle(ap); 1215c6fd2807SJeff Garzik 1216c6fd2807SJeff Garzik ap->ops->dev_select(ap, device); 1217c6fd2807SJeff Garzik 1218c6fd2807SJeff Garzik if (wait) { 12199af5c9c9STejun Heo if (can_sleep && ap->link.device[device].class == ATA_DEV_ATAPI) 1220c6fd2807SJeff Garzik msleep(150); 1221c6fd2807SJeff Garzik ata_wait_idle(ap); 1222c6fd2807SJeff Garzik } 1223c6fd2807SJeff Garzik } 1224c6fd2807SJeff Garzik 1225c6fd2807SJeff Garzik /** 1226c6fd2807SJeff Garzik * ata_dump_id - IDENTIFY DEVICE info debugging output 1227c6fd2807SJeff Garzik * @id: IDENTIFY DEVICE page to dump 1228c6fd2807SJeff Garzik * 1229c6fd2807SJeff Garzik * Dump selected 16-bit words from the given IDENTIFY DEVICE 1230c6fd2807SJeff Garzik * page. 1231c6fd2807SJeff Garzik * 1232c6fd2807SJeff Garzik * LOCKING: 1233c6fd2807SJeff Garzik * caller. 1234c6fd2807SJeff Garzik */ 1235c6fd2807SJeff Garzik 1236c6fd2807SJeff Garzik static inline void ata_dump_id(const u16 *id) 1237c6fd2807SJeff Garzik { 1238c6fd2807SJeff Garzik DPRINTK("49==0x%04x " 1239c6fd2807SJeff Garzik "53==0x%04x " 1240c6fd2807SJeff Garzik "63==0x%04x " 1241c6fd2807SJeff Garzik "64==0x%04x " 1242c6fd2807SJeff Garzik "75==0x%04x \n", 1243c6fd2807SJeff Garzik id[49], 1244c6fd2807SJeff Garzik id[53], 1245c6fd2807SJeff Garzik id[63], 1246c6fd2807SJeff Garzik id[64], 1247c6fd2807SJeff Garzik id[75]); 1248c6fd2807SJeff Garzik DPRINTK("80==0x%04x " 1249c6fd2807SJeff Garzik "81==0x%04x " 1250c6fd2807SJeff Garzik "82==0x%04x " 1251c6fd2807SJeff Garzik "83==0x%04x " 1252c6fd2807SJeff Garzik "84==0x%04x \n", 1253c6fd2807SJeff Garzik id[80], 1254c6fd2807SJeff Garzik id[81], 1255c6fd2807SJeff Garzik id[82], 1256c6fd2807SJeff Garzik id[83], 1257c6fd2807SJeff Garzik id[84]); 1258c6fd2807SJeff Garzik DPRINTK("88==0x%04x " 1259c6fd2807SJeff Garzik "93==0x%04x\n", 1260c6fd2807SJeff Garzik id[88], 1261c6fd2807SJeff Garzik id[93]); 1262c6fd2807SJeff Garzik } 1263c6fd2807SJeff Garzik 1264c6fd2807SJeff Garzik /** 1265c6fd2807SJeff Garzik * ata_id_xfermask - Compute xfermask from the given IDENTIFY data 1266c6fd2807SJeff Garzik * @id: IDENTIFY data to compute xfer mask from 1267c6fd2807SJeff Garzik * 1268c6fd2807SJeff Garzik * Compute the xfermask for this device. This is not as trivial 1269c6fd2807SJeff Garzik * as it seems if we must consider early devices correctly. 1270c6fd2807SJeff Garzik * 1271c6fd2807SJeff Garzik * FIXME: pre IDE drive timing (do we care ?). 1272c6fd2807SJeff Garzik * 1273c6fd2807SJeff Garzik * LOCKING: 1274c6fd2807SJeff Garzik * None. 1275c6fd2807SJeff Garzik * 1276c6fd2807SJeff Garzik * RETURNS: 1277c6fd2807SJeff Garzik * Computed xfermask 1278c6fd2807SJeff Garzik */ 1279c6fd2807SJeff Garzik static unsigned int ata_id_xfermask(const u16 *id) 1280c6fd2807SJeff Garzik { 1281c6fd2807SJeff Garzik unsigned int pio_mask, mwdma_mask, udma_mask; 1282c6fd2807SJeff Garzik 1283c6fd2807SJeff Garzik /* Usual case. Word 53 indicates word 64 is valid */ 1284c6fd2807SJeff Garzik if (id[ATA_ID_FIELD_VALID] & (1 << 1)) { 1285c6fd2807SJeff Garzik pio_mask = id[ATA_ID_PIO_MODES] & 0x03; 1286c6fd2807SJeff Garzik pio_mask <<= 3; 1287c6fd2807SJeff Garzik pio_mask |= 0x7; 1288c6fd2807SJeff Garzik } else { 1289c6fd2807SJeff Garzik /* If word 64 isn't valid then Word 51 high byte holds 1290c6fd2807SJeff Garzik * the PIO timing number for the maximum. Turn it into 1291c6fd2807SJeff Garzik * a mask. 1292c6fd2807SJeff Garzik */ 12937a0f1c8aSLennert Buytenhek u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF; 129446767aebSAlan Cox if (mode < 5) /* Valid PIO range */ 129546767aebSAlan Cox pio_mask = (2 << mode) - 1; 129646767aebSAlan Cox else 129746767aebSAlan Cox pio_mask = 1; 1298c6fd2807SJeff Garzik 1299c6fd2807SJeff Garzik /* But wait.. there's more. Design your standards by 1300c6fd2807SJeff Garzik * committee and you too can get a free iordy field to 1301c6fd2807SJeff Garzik * process. However its the speeds not the modes that 1302c6fd2807SJeff Garzik * are supported... Note drivers using the timing API 1303c6fd2807SJeff Garzik * will get this right anyway 1304c6fd2807SJeff Garzik */ 1305c6fd2807SJeff Garzik } 1306c6fd2807SJeff Garzik 1307c6fd2807SJeff Garzik mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07; 1308c6fd2807SJeff Garzik 1309b352e57dSAlan Cox if (ata_id_is_cfa(id)) { 1310b352e57dSAlan Cox /* 1311b352e57dSAlan Cox * Process compact flash extended modes 1312b352e57dSAlan Cox */ 1313b352e57dSAlan Cox int pio = id[163] & 0x7; 1314b352e57dSAlan Cox int dma = (id[163] >> 3) & 7; 1315b352e57dSAlan Cox 1316b352e57dSAlan Cox if (pio) 1317b352e57dSAlan Cox pio_mask |= (1 << 5); 1318b352e57dSAlan Cox if (pio > 1) 1319b352e57dSAlan Cox pio_mask |= (1 << 6); 1320b352e57dSAlan Cox if (dma) 1321b352e57dSAlan Cox mwdma_mask |= (1 << 3); 1322b352e57dSAlan Cox if (dma > 1) 1323b352e57dSAlan Cox mwdma_mask |= (1 << 4); 1324b352e57dSAlan Cox } 1325b352e57dSAlan Cox 1326c6fd2807SJeff Garzik udma_mask = 0; 1327c6fd2807SJeff Garzik if (id[ATA_ID_FIELD_VALID] & (1 << 2)) 1328c6fd2807SJeff Garzik udma_mask = id[ATA_ID_UDMA_MODES] & 0xff; 1329c6fd2807SJeff Garzik 1330c6fd2807SJeff Garzik return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask); 1331c6fd2807SJeff Garzik } 1332c6fd2807SJeff Garzik 1333c6fd2807SJeff Garzik /** 1334c6fd2807SJeff Garzik * ata_port_queue_task - Queue port_task 1335c6fd2807SJeff Garzik * @ap: The ata_port to queue port_task for 1336c6fd2807SJeff Garzik * @fn: workqueue function to be scheduled 133765f27f38SDavid Howells * @data: data for @fn to use 1338c6fd2807SJeff Garzik * @delay: delay time for workqueue function 1339c6fd2807SJeff Garzik * 1340c6fd2807SJeff Garzik * Schedule @fn(@data) for execution after @delay jiffies using 1341c6fd2807SJeff Garzik * port_task. There is one port_task per port and it's the 1342c6fd2807SJeff Garzik * user(low level driver)'s responsibility to make sure that only 1343c6fd2807SJeff Garzik * one task is active at any given time. 1344c6fd2807SJeff Garzik * 1345c6fd2807SJeff Garzik * libata core layer takes care of synchronization between 1346c6fd2807SJeff Garzik * port_task and EH. ata_port_queue_task() may be ignored for EH 1347c6fd2807SJeff Garzik * synchronization. 1348c6fd2807SJeff Garzik * 1349c6fd2807SJeff Garzik * LOCKING: 1350c6fd2807SJeff Garzik * Inherited from caller. 1351c6fd2807SJeff Garzik */ 135265f27f38SDavid Howells void ata_port_queue_task(struct ata_port *ap, work_func_t fn, void *data, 1353c6fd2807SJeff Garzik unsigned long delay) 1354c6fd2807SJeff Garzik { 135565f27f38SDavid Howells PREPARE_DELAYED_WORK(&ap->port_task, fn); 135665f27f38SDavid Howells ap->port_task_data = data; 1357c6fd2807SJeff Garzik 135845a66c1cSOleg Nesterov /* may fail if ata_port_flush_task() in progress */ 135945a66c1cSOleg Nesterov queue_delayed_work(ata_wq, &ap->port_task, delay); 1360c6fd2807SJeff Garzik } 1361c6fd2807SJeff Garzik 1362c6fd2807SJeff Garzik /** 1363c6fd2807SJeff Garzik * ata_port_flush_task - Flush port_task 1364c6fd2807SJeff Garzik * @ap: The ata_port to flush port_task for 1365c6fd2807SJeff Garzik * 1366c6fd2807SJeff Garzik * After this function completes, port_task is guranteed not to 1367c6fd2807SJeff Garzik * be running or scheduled. 1368c6fd2807SJeff Garzik * 1369c6fd2807SJeff Garzik * LOCKING: 1370c6fd2807SJeff Garzik * Kernel thread context (may sleep) 1371c6fd2807SJeff Garzik */ 1372c6fd2807SJeff Garzik void ata_port_flush_task(struct ata_port *ap) 1373c6fd2807SJeff Garzik { 1374c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 1375c6fd2807SJeff Garzik 137645a66c1cSOleg Nesterov cancel_rearming_delayed_work(&ap->port_task); 1377c6fd2807SJeff Garzik 1378c6fd2807SJeff Garzik if (ata_msg_ctl(ap)) 1379c6fd2807SJeff Garzik ata_port_printk(ap, KERN_DEBUG, "%s: EXIT\n", __FUNCTION__); 1380c6fd2807SJeff Garzik } 1381c6fd2807SJeff Garzik 13827102d230SAdrian Bunk static void ata_qc_complete_internal(struct ata_queued_cmd *qc) 1383c6fd2807SJeff Garzik { 1384c6fd2807SJeff Garzik struct completion *waiting = qc->private_data; 1385c6fd2807SJeff Garzik 1386c6fd2807SJeff Garzik complete(waiting); 1387c6fd2807SJeff Garzik } 1388c6fd2807SJeff Garzik 1389c6fd2807SJeff Garzik /** 13902432697bSTejun Heo * ata_exec_internal_sg - execute libata internal command 1391c6fd2807SJeff Garzik * @dev: Device to which the command is sent 1392c6fd2807SJeff Garzik * @tf: Taskfile registers for the command and the result 1393c6fd2807SJeff Garzik * @cdb: CDB for packet command 1394c6fd2807SJeff Garzik * @dma_dir: Data tranfer direction of the command 13952432697bSTejun Heo * @sg: sg list for the data buffer of the command 13962432697bSTejun Heo * @n_elem: Number of sg entries 13972b789108STejun Heo * @timeout: Timeout in msecs (0 for default) 1398c6fd2807SJeff Garzik * 1399c6fd2807SJeff Garzik * Executes libata internal command with timeout. @tf contains 1400c6fd2807SJeff Garzik * command on entry and result on return. Timeout and error 1401c6fd2807SJeff Garzik * conditions are reported via return value. No recovery action 1402c6fd2807SJeff Garzik * is taken after a command times out. It's caller's duty to 1403c6fd2807SJeff Garzik * clean up after timeout. 1404c6fd2807SJeff Garzik * 1405c6fd2807SJeff Garzik * LOCKING: 1406c6fd2807SJeff Garzik * None. Should be called with kernel context, might sleep. 1407c6fd2807SJeff Garzik * 1408c6fd2807SJeff Garzik * RETURNS: 1409c6fd2807SJeff Garzik * Zero on success, AC_ERR_* mask on failure 1410c6fd2807SJeff Garzik */ 14112432697bSTejun Heo unsigned ata_exec_internal_sg(struct ata_device *dev, 1412c6fd2807SJeff Garzik struct ata_taskfile *tf, const u8 *cdb, 14132432697bSTejun Heo int dma_dir, struct scatterlist *sg, 14142b789108STejun Heo unsigned int n_elem, unsigned long timeout) 1415c6fd2807SJeff Garzik { 14169af5c9c9STejun Heo struct ata_link *link = dev->link; 14179af5c9c9STejun Heo struct ata_port *ap = link->ap; 1418c6fd2807SJeff Garzik u8 command = tf->command; 1419c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 1420c6fd2807SJeff Garzik unsigned int tag, preempted_tag; 1421c6fd2807SJeff Garzik u32 preempted_sactive, preempted_qc_active; 1422da917d69STejun Heo int preempted_nr_active_links; 1423c6fd2807SJeff Garzik DECLARE_COMPLETION_ONSTACK(wait); 1424c6fd2807SJeff Garzik unsigned long flags; 1425c6fd2807SJeff Garzik unsigned int err_mask; 1426c6fd2807SJeff Garzik int rc; 1427c6fd2807SJeff Garzik 1428c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1429c6fd2807SJeff Garzik 1430c6fd2807SJeff Garzik /* no internal command while frozen */ 1431c6fd2807SJeff Garzik if (ap->pflags & ATA_PFLAG_FROZEN) { 1432c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1433c6fd2807SJeff Garzik return AC_ERR_SYSTEM; 1434c6fd2807SJeff Garzik } 1435c6fd2807SJeff Garzik 1436c6fd2807SJeff Garzik /* initialize internal qc */ 1437c6fd2807SJeff Garzik 1438c6fd2807SJeff Garzik /* XXX: Tag 0 is used for drivers with legacy EH as some 1439c6fd2807SJeff Garzik * drivers choke if any other tag is given. This breaks 1440c6fd2807SJeff Garzik * ata_tag_internal() test for those drivers. Don't use new 1441c6fd2807SJeff Garzik * EH stuff without converting to it. 1442c6fd2807SJeff Garzik */ 1443c6fd2807SJeff Garzik if (ap->ops->error_handler) 1444c6fd2807SJeff Garzik tag = ATA_TAG_INTERNAL; 1445c6fd2807SJeff Garzik else 1446c6fd2807SJeff Garzik tag = 0; 1447c6fd2807SJeff Garzik 1448c6fd2807SJeff Garzik if (test_and_set_bit(tag, &ap->qc_allocated)) 1449c6fd2807SJeff Garzik BUG(); 1450c6fd2807SJeff Garzik qc = __ata_qc_from_tag(ap, tag); 1451c6fd2807SJeff Garzik 1452c6fd2807SJeff Garzik qc->tag = tag; 1453c6fd2807SJeff Garzik qc->scsicmd = NULL; 1454c6fd2807SJeff Garzik qc->ap = ap; 1455c6fd2807SJeff Garzik qc->dev = dev; 1456c6fd2807SJeff Garzik ata_qc_reinit(qc); 1457c6fd2807SJeff Garzik 14589af5c9c9STejun Heo preempted_tag = link->active_tag; 14599af5c9c9STejun Heo preempted_sactive = link->sactive; 1460c6fd2807SJeff Garzik preempted_qc_active = ap->qc_active; 1461da917d69STejun Heo preempted_nr_active_links = ap->nr_active_links; 14629af5c9c9STejun Heo link->active_tag = ATA_TAG_POISON; 14639af5c9c9STejun Heo link->sactive = 0; 1464c6fd2807SJeff Garzik ap->qc_active = 0; 1465da917d69STejun Heo ap->nr_active_links = 0; 1466c6fd2807SJeff Garzik 1467c6fd2807SJeff Garzik /* prepare & issue qc */ 1468c6fd2807SJeff Garzik qc->tf = *tf; 1469c6fd2807SJeff Garzik if (cdb) 1470c6fd2807SJeff Garzik memcpy(qc->cdb, cdb, ATAPI_CDB_LEN); 1471c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_RESULT_TF; 1472c6fd2807SJeff Garzik qc->dma_dir = dma_dir; 1473c6fd2807SJeff Garzik if (dma_dir != DMA_NONE) { 14742432697bSTejun Heo unsigned int i, buflen = 0; 14752432697bSTejun Heo 14762432697bSTejun Heo for (i = 0; i < n_elem; i++) 14772432697bSTejun Heo buflen += sg[i].length; 14782432697bSTejun Heo 14792432697bSTejun Heo ata_sg_init(qc, sg, n_elem); 148049c80429SBrian King qc->nbytes = buflen; 1481c6fd2807SJeff Garzik } 1482c6fd2807SJeff Garzik 1483c6fd2807SJeff Garzik qc->private_data = &wait; 1484c6fd2807SJeff Garzik qc->complete_fn = ata_qc_complete_internal; 1485c6fd2807SJeff Garzik 1486c6fd2807SJeff Garzik ata_qc_issue(qc); 1487c6fd2807SJeff Garzik 1488c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1489c6fd2807SJeff Garzik 14902b789108STejun Heo if (!timeout) 14912b789108STejun Heo timeout = ata_probe_timeout * 1000 / HZ; 14922b789108STejun Heo 14932b789108STejun Heo rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout)); 1494c6fd2807SJeff Garzik 1495c6fd2807SJeff Garzik ata_port_flush_task(ap); 1496c6fd2807SJeff Garzik 1497c6fd2807SJeff Garzik if (!rc) { 1498c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1499c6fd2807SJeff Garzik 1500c6fd2807SJeff Garzik /* We're racing with irq here. If we lose, the 1501c6fd2807SJeff Garzik * following test prevents us from completing the qc 1502c6fd2807SJeff Garzik * twice. If we win, the port is frozen and will be 1503c6fd2807SJeff Garzik * cleaned up by ->post_internal_cmd(). 1504c6fd2807SJeff Garzik */ 1505c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_ACTIVE) { 1506c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_TIMEOUT; 1507c6fd2807SJeff Garzik 1508c6fd2807SJeff Garzik if (ap->ops->error_handler) 1509c6fd2807SJeff Garzik ata_port_freeze(ap); 1510c6fd2807SJeff Garzik else 1511c6fd2807SJeff Garzik ata_qc_complete(qc); 1512c6fd2807SJeff Garzik 1513c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 1514c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 1515c6fd2807SJeff Garzik "qc timeout (cmd 0x%x)\n", command); 1516c6fd2807SJeff Garzik } 1517c6fd2807SJeff Garzik 1518c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1519c6fd2807SJeff Garzik } 1520c6fd2807SJeff Garzik 1521c6fd2807SJeff Garzik /* do post_internal_cmd */ 1522c6fd2807SJeff Garzik if (ap->ops->post_internal_cmd) 1523c6fd2807SJeff Garzik ap->ops->post_internal_cmd(qc); 1524c6fd2807SJeff Garzik 1525a51d644aSTejun Heo /* perform minimal error analysis */ 1526a51d644aSTejun Heo if (qc->flags & ATA_QCFLAG_FAILED) { 1527a51d644aSTejun Heo if (qc->result_tf.command & (ATA_ERR | ATA_DF)) 1528a51d644aSTejun Heo qc->err_mask |= AC_ERR_DEV; 1529a51d644aSTejun Heo 1530a51d644aSTejun Heo if (!qc->err_mask) 1531c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_OTHER; 1532a51d644aSTejun Heo 1533a51d644aSTejun Heo if (qc->err_mask & ~AC_ERR_OTHER) 1534a51d644aSTejun Heo qc->err_mask &= ~AC_ERR_OTHER; 1535c6fd2807SJeff Garzik } 1536c6fd2807SJeff Garzik 1537c6fd2807SJeff Garzik /* finish up */ 1538c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1539c6fd2807SJeff Garzik 1540c6fd2807SJeff Garzik *tf = qc->result_tf; 1541c6fd2807SJeff Garzik err_mask = qc->err_mask; 1542c6fd2807SJeff Garzik 1543c6fd2807SJeff Garzik ata_qc_free(qc); 15449af5c9c9STejun Heo link->active_tag = preempted_tag; 15459af5c9c9STejun Heo link->sactive = preempted_sactive; 1546c6fd2807SJeff Garzik ap->qc_active = preempted_qc_active; 1547da917d69STejun Heo ap->nr_active_links = preempted_nr_active_links; 1548c6fd2807SJeff Garzik 1549c6fd2807SJeff Garzik /* XXX - Some LLDDs (sata_mv) disable port on command failure. 1550c6fd2807SJeff Garzik * Until those drivers are fixed, we detect the condition 1551c6fd2807SJeff Garzik * here, fail the command with AC_ERR_SYSTEM and reenable the 1552c6fd2807SJeff Garzik * port. 1553c6fd2807SJeff Garzik * 1554c6fd2807SJeff Garzik * Note that this doesn't change any behavior as internal 1555c6fd2807SJeff Garzik * command failure results in disabling the device in the 1556c6fd2807SJeff Garzik * higher layer for LLDDs without new reset/EH callbacks. 1557c6fd2807SJeff Garzik * 1558c6fd2807SJeff Garzik * Kill the following code as soon as those drivers are fixed. 1559c6fd2807SJeff Garzik */ 1560c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_DISABLED) { 1561c6fd2807SJeff Garzik err_mask |= AC_ERR_SYSTEM; 1562c6fd2807SJeff Garzik ata_port_probe(ap); 1563c6fd2807SJeff Garzik } 1564c6fd2807SJeff Garzik 1565c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1566c6fd2807SJeff Garzik 1567c6fd2807SJeff Garzik return err_mask; 1568c6fd2807SJeff Garzik } 1569c6fd2807SJeff Garzik 1570c6fd2807SJeff Garzik /** 157133480a0eSTejun Heo * ata_exec_internal - execute libata internal command 15722432697bSTejun Heo * @dev: Device to which the command is sent 15732432697bSTejun Heo * @tf: Taskfile registers for the command and the result 15742432697bSTejun Heo * @cdb: CDB for packet command 15752432697bSTejun Heo * @dma_dir: Data tranfer direction of the command 15762432697bSTejun Heo * @buf: Data buffer of the command 15772432697bSTejun Heo * @buflen: Length of data buffer 15782b789108STejun Heo * @timeout: Timeout in msecs (0 for default) 15792432697bSTejun Heo * 15802432697bSTejun Heo * Wrapper around ata_exec_internal_sg() which takes simple 15812432697bSTejun Heo * buffer instead of sg list. 15822432697bSTejun Heo * 15832432697bSTejun Heo * LOCKING: 15842432697bSTejun Heo * None. Should be called with kernel context, might sleep. 15852432697bSTejun Heo * 15862432697bSTejun Heo * RETURNS: 15872432697bSTejun Heo * Zero on success, AC_ERR_* mask on failure 15882432697bSTejun Heo */ 15892432697bSTejun Heo unsigned ata_exec_internal(struct ata_device *dev, 15902432697bSTejun Heo struct ata_taskfile *tf, const u8 *cdb, 15912b789108STejun Heo int dma_dir, void *buf, unsigned int buflen, 15922b789108STejun Heo unsigned long timeout) 15932432697bSTejun Heo { 159433480a0eSTejun Heo struct scatterlist *psg = NULL, sg; 159533480a0eSTejun Heo unsigned int n_elem = 0; 15962432697bSTejun Heo 159733480a0eSTejun Heo if (dma_dir != DMA_NONE) { 159833480a0eSTejun Heo WARN_ON(!buf); 15992432697bSTejun Heo sg_init_one(&sg, buf, buflen); 160033480a0eSTejun Heo psg = &sg; 160133480a0eSTejun Heo n_elem++; 160233480a0eSTejun Heo } 16032432697bSTejun Heo 16042b789108STejun Heo return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem, 16052b789108STejun Heo timeout); 16062432697bSTejun Heo } 16072432697bSTejun Heo 16082432697bSTejun Heo /** 1609c6fd2807SJeff Garzik * ata_do_simple_cmd - execute simple internal command 1610c6fd2807SJeff Garzik * @dev: Device to which the command is sent 1611c6fd2807SJeff Garzik * @cmd: Opcode to execute 1612c6fd2807SJeff Garzik * 1613c6fd2807SJeff Garzik * Execute a 'simple' command, that only consists of the opcode 1614c6fd2807SJeff Garzik * 'cmd' itself, without filling any other registers 1615c6fd2807SJeff Garzik * 1616c6fd2807SJeff Garzik * LOCKING: 1617c6fd2807SJeff Garzik * Kernel thread context (may sleep). 1618c6fd2807SJeff Garzik * 1619c6fd2807SJeff Garzik * RETURNS: 1620c6fd2807SJeff Garzik * Zero on success, AC_ERR_* mask on failure 1621c6fd2807SJeff Garzik */ 1622c6fd2807SJeff Garzik unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd) 1623c6fd2807SJeff Garzik { 1624c6fd2807SJeff Garzik struct ata_taskfile tf; 1625c6fd2807SJeff Garzik 1626c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 1627c6fd2807SJeff Garzik 1628c6fd2807SJeff Garzik tf.command = cmd; 1629c6fd2807SJeff Garzik tf.flags |= ATA_TFLAG_DEVICE; 1630c6fd2807SJeff Garzik tf.protocol = ATA_PROT_NODATA; 1631c6fd2807SJeff Garzik 16322b789108STejun Heo return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 1633c6fd2807SJeff Garzik } 1634c6fd2807SJeff Garzik 1635c6fd2807SJeff Garzik /** 1636c6fd2807SJeff Garzik * ata_pio_need_iordy - check if iordy needed 1637c6fd2807SJeff Garzik * @adev: ATA device 1638c6fd2807SJeff Garzik * 1639c6fd2807SJeff Garzik * Check if the current speed of the device requires IORDY. Used 1640c6fd2807SJeff Garzik * by various controllers for chip configuration. 1641c6fd2807SJeff Garzik */ 1642c6fd2807SJeff Garzik 1643c6fd2807SJeff Garzik unsigned int ata_pio_need_iordy(const struct ata_device *adev) 1644c6fd2807SJeff Garzik { 1645432729f0SAlan Cox /* Controller doesn't support IORDY. Probably a pointless check 1646432729f0SAlan Cox as the caller should know this */ 16479af5c9c9STejun Heo if (adev->link->ap->flags & ATA_FLAG_NO_IORDY) 1648c6fd2807SJeff Garzik return 0; 1649432729f0SAlan Cox /* PIO3 and higher it is mandatory */ 1650432729f0SAlan Cox if (adev->pio_mode > XFER_PIO_2) 1651c6fd2807SJeff Garzik return 1; 1652432729f0SAlan Cox /* We turn it on when possible */ 1653432729f0SAlan Cox if (ata_id_has_iordy(adev->id)) 1654432729f0SAlan Cox return 1; 1655432729f0SAlan Cox return 0; 1656432729f0SAlan Cox } 1657c6fd2807SJeff Garzik 1658432729f0SAlan Cox /** 1659432729f0SAlan Cox * ata_pio_mask_no_iordy - Return the non IORDY mask 1660432729f0SAlan Cox * @adev: ATA device 1661432729f0SAlan Cox * 1662432729f0SAlan Cox * Compute the highest mode possible if we are not using iordy. Return 1663432729f0SAlan Cox * -1 if no iordy mode is available. 1664432729f0SAlan Cox */ 1665432729f0SAlan Cox 1666432729f0SAlan Cox static u32 ata_pio_mask_no_iordy(const struct ata_device *adev) 1667432729f0SAlan Cox { 1668c6fd2807SJeff Garzik /* If we have no drive specific rule, then PIO 2 is non IORDY */ 1669c6fd2807SJeff Garzik if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */ 1670432729f0SAlan Cox u16 pio = adev->id[ATA_ID_EIDE_PIO]; 1671c6fd2807SJeff Garzik /* Is the speed faster than the drive allows non IORDY ? */ 1672c6fd2807SJeff Garzik if (pio) { 1673c6fd2807SJeff Garzik /* This is cycle times not frequency - watch the logic! */ 1674c6fd2807SJeff Garzik if (pio > 240) /* PIO2 is 240nS per cycle */ 1675432729f0SAlan Cox return 3 << ATA_SHIFT_PIO; 1676432729f0SAlan Cox return 7 << ATA_SHIFT_PIO; 1677c6fd2807SJeff Garzik } 1678c6fd2807SJeff Garzik } 1679432729f0SAlan Cox return 3 << ATA_SHIFT_PIO; 1680c6fd2807SJeff Garzik } 1681c6fd2807SJeff Garzik 1682c6fd2807SJeff Garzik /** 1683c6fd2807SJeff Garzik * ata_dev_read_id - Read ID data from the specified device 1684c6fd2807SJeff Garzik * @dev: target device 1685c6fd2807SJeff Garzik * @p_class: pointer to class of the target device (may be changed) 1686bff04647STejun Heo * @flags: ATA_READID_* flags 1687c6fd2807SJeff Garzik * @id: buffer to read IDENTIFY data into 1688c6fd2807SJeff Garzik * 1689c6fd2807SJeff Garzik * Read ID data from the specified device. ATA_CMD_ID_ATA is 1690c6fd2807SJeff Garzik * performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI 1691c6fd2807SJeff Garzik * devices. This function also issues ATA_CMD_INIT_DEV_PARAMS 1692c6fd2807SJeff Garzik * for pre-ATA4 drives. 1693c6fd2807SJeff Garzik * 169450a99018SAlan Cox * FIXME: ATA_CMD_ID_ATA is optional for early drives and right 169550a99018SAlan Cox * now we abort if we hit that case. 169650a99018SAlan Cox * 1697c6fd2807SJeff Garzik * LOCKING: 1698c6fd2807SJeff Garzik * Kernel thread context (may sleep) 1699c6fd2807SJeff Garzik * 1700c6fd2807SJeff Garzik * RETURNS: 1701c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 1702c6fd2807SJeff Garzik */ 1703c6fd2807SJeff Garzik int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class, 1704bff04647STejun Heo unsigned int flags, u16 *id) 1705c6fd2807SJeff Garzik { 17069af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 1707c6fd2807SJeff Garzik unsigned int class = *p_class; 1708c6fd2807SJeff Garzik struct ata_taskfile tf; 1709c6fd2807SJeff Garzik unsigned int err_mask = 0; 1710c6fd2807SJeff Garzik const char *reason; 171154936f8bSTejun Heo int may_fallback = 1, tried_spinup = 0; 1712c6fd2807SJeff Garzik int rc; 1713c6fd2807SJeff Garzik 1714c6fd2807SJeff Garzik if (ata_msg_ctl(ap)) 171544877b4eSTejun Heo ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __FUNCTION__); 1716c6fd2807SJeff Garzik 1717c6fd2807SJeff Garzik ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */ 1718c6fd2807SJeff Garzik retry: 1719c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 1720c6fd2807SJeff Garzik 1721c6fd2807SJeff Garzik switch (class) { 1722c6fd2807SJeff Garzik case ATA_DEV_ATA: 1723c6fd2807SJeff Garzik tf.command = ATA_CMD_ID_ATA; 1724c6fd2807SJeff Garzik break; 1725c6fd2807SJeff Garzik case ATA_DEV_ATAPI: 1726c6fd2807SJeff Garzik tf.command = ATA_CMD_ID_ATAPI; 1727c6fd2807SJeff Garzik break; 1728c6fd2807SJeff Garzik default: 1729c6fd2807SJeff Garzik rc = -ENODEV; 1730c6fd2807SJeff Garzik reason = "unsupported class"; 1731c6fd2807SJeff Garzik goto err_out; 1732c6fd2807SJeff Garzik } 1733c6fd2807SJeff Garzik 1734c6fd2807SJeff Garzik tf.protocol = ATA_PROT_PIO; 173581afe893STejun Heo 173681afe893STejun Heo /* Some devices choke if TF registers contain garbage. Make 173781afe893STejun Heo * sure those are properly initialized. 173881afe893STejun Heo */ 173981afe893STejun Heo tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 174081afe893STejun Heo 174181afe893STejun Heo /* Device presence detection is unreliable on some 174281afe893STejun Heo * controllers. Always poll IDENTIFY if available. 174381afe893STejun Heo */ 174481afe893STejun Heo tf.flags |= ATA_TFLAG_POLLING; 1745c6fd2807SJeff Garzik 1746c6fd2807SJeff Garzik err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE, 17472b789108STejun Heo id, sizeof(id[0]) * ATA_ID_WORDS, 0); 1748c6fd2807SJeff Garzik if (err_mask) { 1749800b3996STejun Heo if (err_mask & AC_ERR_NODEV_HINT) { 175055a8e2c8STejun Heo DPRINTK("ata%u.%d: NODEV after polling detection\n", 175144877b4eSTejun Heo ap->print_id, dev->devno); 175255a8e2c8STejun Heo return -ENOENT; 175355a8e2c8STejun Heo } 175455a8e2c8STejun Heo 175554936f8bSTejun Heo /* Device or controller might have reported the wrong 175654936f8bSTejun Heo * device class. Give a shot at the other IDENTIFY if 175754936f8bSTejun Heo * the current one is aborted by the device. 175854936f8bSTejun Heo */ 175954936f8bSTejun Heo if (may_fallback && 176054936f8bSTejun Heo (err_mask == AC_ERR_DEV) && (tf.feature & ATA_ABORTED)) { 176154936f8bSTejun Heo may_fallback = 0; 176254936f8bSTejun Heo 176354936f8bSTejun Heo if (class == ATA_DEV_ATA) 176454936f8bSTejun Heo class = ATA_DEV_ATAPI; 176554936f8bSTejun Heo else 176654936f8bSTejun Heo class = ATA_DEV_ATA; 176754936f8bSTejun Heo goto retry; 176854936f8bSTejun Heo } 176954936f8bSTejun Heo 1770c6fd2807SJeff Garzik rc = -EIO; 1771c6fd2807SJeff Garzik reason = "I/O error"; 1772c6fd2807SJeff Garzik goto err_out; 1773c6fd2807SJeff Garzik } 1774c6fd2807SJeff Garzik 177554936f8bSTejun Heo /* Falling back doesn't make sense if ID data was read 177654936f8bSTejun Heo * successfully at least once. 177754936f8bSTejun Heo */ 177854936f8bSTejun Heo may_fallback = 0; 177954936f8bSTejun Heo 1780c6fd2807SJeff Garzik swap_buf_le16(id, ATA_ID_WORDS); 1781c6fd2807SJeff Garzik 1782c6fd2807SJeff Garzik /* sanity check */ 1783c6fd2807SJeff Garzik rc = -EINVAL; 17846070068bSAlan Cox reason = "device reports invalid type"; 17854a3381feSJeff Garzik 17864a3381feSJeff Garzik if (class == ATA_DEV_ATA) { 17874a3381feSJeff Garzik if (!ata_id_is_ata(id) && !ata_id_is_cfa(id)) 17884a3381feSJeff Garzik goto err_out; 17894a3381feSJeff Garzik } else { 17904a3381feSJeff Garzik if (ata_id_is_ata(id)) 1791c6fd2807SJeff Garzik goto err_out; 1792c6fd2807SJeff Garzik } 1793c6fd2807SJeff Garzik 1794169439c2SMark Lord if (!tried_spinup && (id[2] == 0x37c8 || id[2] == 0x738c)) { 1795169439c2SMark Lord tried_spinup = 1; 1796169439c2SMark Lord /* 1797169439c2SMark Lord * Drive powered-up in standby mode, and requires a specific 1798169439c2SMark Lord * SET_FEATURES spin-up subcommand before it will accept 1799169439c2SMark Lord * anything other than the original IDENTIFY command. 1800169439c2SMark Lord */ 1801169439c2SMark Lord ata_tf_init(dev, &tf); 1802169439c2SMark Lord tf.command = ATA_CMD_SET_FEATURES; 1803169439c2SMark Lord tf.feature = SETFEATURES_SPINUP; 1804169439c2SMark Lord tf.protocol = ATA_PROT_NODATA; 1805169439c2SMark Lord tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 18062b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, 18072b789108STejun Heo DMA_NONE, NULL, 0, 0); 1808fb0582f9SRyan Power if (err_mask && id[2] != 0x738c) { 1809169439c2SMark Lord rc = -EIO; 1810169439c2SMark Lord reason = "SPINUP failed"; 1811169439c2SMark Lord goto err_out; 1812169439c2SMark Lord } 1813169439c2SMark Lord /* 1814169439c2SMark Lord * If the drive initially returned incomplete IDENTIFY info, 1815169439c2SMark Lord * we now must reissue the IDENTIFY command. 1816169439c2SMark Lord */ 1817169439c2SMark Lord if (id[2] == 0x37c8) 1818169439c2SMark Lord goto retry; 1819169439c2SMark Lord } 1820169439c2SMark Lord 1821bff04647STejun Heo if ((flags & ATA_READID_POSTRESET) && class == ATA_DEV_ATA) { 1822c6fd2807SJeff Garzik /* 1823c6fd2807SJeff Garzik * The exact sequence expected by certain pre-ATA4 drives is: 1824c6fd2807SJeff Garzik * SRST RESET 182550a99018SAlan Cox * IDENTIFY (optional in early ATA) 182650a99018SAlan Cox * INITIALIZE DEVICE PARAMETERS (later IDE and ATA) 1827c6fd2807SJeff Garzik * anything else.. 1828c6fd2807SJeff Garzik * Some drives were very specific about that exact sequence. 182950a99018SAlan Cox * 183050a99018SAlan Cox * Note that ATA4 says lba is mandatory so the second check 183150a99018SAlan Cox * shoud never trigger. 1832c6fd2807SJeff Garzik */ 1833c6fd2807SJeff Garzik if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) { 1834c6fd2807SJeff Garzik err_mask = ata_dev_init_params(dev, id[3], id[6]); 1835c6fd2807SJeff Garzik if (err_mask) { 1836c6fd2807SJeff Garzik rc = -EIO; 1837c6fd2807SJeff Garzik reason = "INIT_DEV_PARAMS failed"; 1838c6fd2807SJeff Garzik goto err_out; 1839c6fd2807SJeff Garzik } 1840c6fd2807SJeff Garzik 1841c6fd2807SJeff Garzik /* current CHS translation info (id[53-58]) might be 1842c6fd2807SJeff Garzik * changed. reread the identify device info. 1843c6fd2807SJeff Garzik */ 1844bff04647STejun Heo flags &= ~ATA_READID_POSTRESET; 1845c6fd2807SJeff Garzik goto retry; 1846c6fd2807SJeff Garzik } 1847c6fd2807SJeff Garzik } 1848c6fd2807SJeff Garzik 1849c6fd2807SJeff Garzik *p_class = class; 1850c6fd2807SJeff Garzik 1851c6fd2807SJeff Garzik return 0; 1852c6fd2807SJeff Garzik 1853c6fd2807SJeff Garzik err_out: 1854c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 1855c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "failed to IDENTIFY " 1856c6fd2807SJeff Garzik "(%s, err_mask=0x%x)\n", reason, err_mask); 1857c6fd2807SJeff Garzik return rc; 1858c6fd2807SJeff Garzik } 1859c6fd2807SJeff Garzik 1860c6fd2807SJeff Garzik static inline u8 ata_dev_knobble(struct ata_device *dev) 1861c6fd2807SJeff Garzik { 18629af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 18639af5c9c9STejun Heo return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id))); 1864c6fd2807SJeff Garzik } 1865c6fd2807SJeff Garzik 1866c6fd2807SJeff Garzik static void ata_dev_config_ncq(struct ata_device *dev, 1867c6fd2807SJeff Garzik char *desc, size_t desc_sz) 1868c6fd2807SJeff Garzik { 18699af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 1870c6fd2807SJeff Garzik int hdepth = 0, ddepth = ata_id_queue_depth(dev->id); 1871c6fd2807SJeff Garzik 1872c6fd2807SJeff Garzik if (!ata_id_has_ncq(dev->id)) { 1873c6fd2807SJeff Garzik desc[0] = '\0'; 1874c6fd2807SJeff Garzik return; 1875c6fd2807SJeff Garzik } 187675683fe7STejun Heo if (dev->horkage & ATA_HORKAGE_NONCQ) { 18776919a0a6SAlan Cox snprintf(desc, desc_sz, "NCQ (not used)"); 18786919a0a6SAlan Cox return; 18796919a0a6SAlan Cox } 1880c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_NCQ) { 1881cca3974eSJeff Garzik hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE - 1); 1882c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_NCQ; 1883c6fd2807SJeff Garzik } 1884c6fd2807SJeff Garzik 1885c6fd2807SJeff Garzik if (hdepth >= ddepth) 1886c6fd2807SJeff Garzik snprintf(desc, desc_sz, "NCQ (depth %d)", ddepth); 1887c6fd2807SJeff Garzik else 1888c6fd2807SJeff Garzik snprintf(desc, desc_sz, "NCQ (depth %d/%d)", hdepth, ddepth); 1889c6fd2807SJeff Garzik } 1890c6fd2807SJeff Garzik 1891c6fd2807SJeff Garzik /** 1892c6fd2807SJeff Garzik * ata_dev_configure - Configure the specified ATA/ATAPI device 1893c6fd2807SJeff Garzik * @dev: Target device to configure 1894c6fd2807SJeff Garzik * 1895c6fd2807SJeff Garzik * Configure @dev according to @dev->id. Generic and low-level 1896c6fd2807SJeff Garzik * driver specific fixups are also applied. 1897c6fd2807SJeff Garzik * 1898c6fd2807SJeff Garzik * LOCKING: 1899c6fd2807SJeff Garzik * Kernel thread context (may sleep) 1900c6fd2807SJeff Garzik * 1901c6fd2807SJeff Garzik * RETURNS: 1902c6fd2807SJeff Garzik * 0 on success, -errno otherwise 1903c6fd2807SJeff Garzik */ 1904efdaedc4STejun Heo int ata_dev_configure(struct ata_device *dev) 1905c6fd2807SJeff Garzik { 19069af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 19079af5c9c9STejun Heo struct ata_eh_context *ehc = &dev->link->eh_context; 19086746544cSTejun Heo int print_info = ehc->i.flags & ATA_EHI_PRINTINFO; 1909c6fd2807SJeff Garzik const u16 *id = dev->id; 1910c6fd2807SJeff Garzik unsigned int xfer_mask; 1911b352e57dSAlan Cox char revbuf[7]; /* XYZ-99\0 */ 19123f64f565SEric D. Mudama char fwrevbuf[ATA_ID_FW_REV_LEN+1]; 19133f64f565SEric D. Mudama char modelbuf[ATA_ID_PROD_LEN+1]; 1914c6fd2807SJeff Garzik int rc; 1915c6fd2807SJeff Garzik 1916c6fd2807SJeff Garzik if (!ata_dev_enabled(dev) && ata_msg_info(ap)) { 191744877b4eSTejun Heo ata_dev_printk(dev, KERN_INFO, "%s: ENTER/EXIT -- nodev\n", 191844877b4eSTejun Heo __FUNCTION__); 1919c6fd2807SJeff Garzik return 0; 1920c6fd2807SJeff Garzik } 1921c6fd2807SJeff Garzik 1922c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 192344877b4eSTejun Heo ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __FUNCTION__); 1924c6fd2807SJeff Garzik 192575683fe7STejun Heo /* set horkage */ 192675683fe7STejun Heo dev->horkage |= ata_dev_blacklisted(dev); 192775683fe7STejun Heo 19286746544cSTejun Heo /* let ACPI work its magic */ 19296746544cSTejun Heo rc = ata_acpi_on_devcfg(dev); 19306746544cSTejun Heo if (rc) 19316746544cSTejun Heo return rc; 193208573a86SKristen Carlson Accardi 193305027adcSTejun Heo /* massage HPA, do it early as it might change IDENTIFY data */ 193405027adcSTejun Heo rc = ata_hpa_resize(dev); 193505027adcSTejun Heo if (rc) 193605027adcSTejun Heo return rc; 193705027adcSTejun Heo 1938c6fd2807SJeff Garzik /* print device capabilities */ 1939c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 1940c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_DEBUG, 1941c6fd2807SJeff Garzik "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x " 1942c6fd2807SJeff Garzik "85:%04x 86:%04x 87:%04x 88:%04x\n", 1943c6fd2807SJeff Garzik __FUNCTION__, 1944c6fd2807SJeff Garzik id[49], id[82], id[83], id[84], 1945c6fd2807SJeff Garzik id[85], id[86], id[87], id[88]); 1946c6fd2807SJeff Garzik 1947c6fd2807SJeff Garzik /* initialize to-be-configured parameters */ 1948c6fd2807SJeff Garzik dev->flags &= ~ATA_DFLAG_CFG_MASK; 1949c6fd2807SJeff Garzik dev->max_sectors = 0; 1950c6fd2807SJeff Garzik dev->cdb_len = 0; 1951c6fd2807SJeff Garzik dev->n_sectors = 0; 1952c6fd2807SJeff Garzik dev->cylinders = 0; 1953c6fd2807SJeff Garzik dev->heads = 0; 1954c6fd2807SJeff Garzik dev->sectors = 0; 1955c6fd2807SJeff Garzik 1956c6fd2807SJeff Garzik /* 1957c6fd2807SJeff Garzik * common ATA, ATAPI feature tests 1958c6fd2807SJeff Garzik */ 1959c6fd2807SJeff Garzik 1960c6fd2807SJeff Garzik /* find max transfer mode; for printk only */ 1961c6fd2807SJeff Garzik xfer_mask = ata_id_xfermask(id); 1962c6fd2807SJeff Garzik 1963c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 1964c6fd2807SJeff Garzik ata_dump_id(id); 1965c6fd2807SJeff Garzik 1966ef143d57SAlbert Lee /* SCSI only uses 4-char revisions, dump full 8 chars from ATA */ 1967ef143d57SAlbert Lee ata_id_c_string(dev->id, fwrevbuf, ATA_ID_FW_REV, 1968ef143d57SAlbert Lee sizeof(fwrevbuf)); 1969ef143d57SAlbert Lee 1970ef143d57SAlbert Lee ata_id_c_string(dev->id, modelbuf, ATA_ID_PROD, 1971ef143d57SAlbert Lee sizeof(modelbuf)); 1972ef143d57SAlbert Lee 1973c6fd2807SJeff Garzik /* ATA-specific feature tests */ 1974c6fd2807SJeff Garzik if (dev->class == ATA_DEV_ATA) { 1975b352e57dSAlan Cox if (ata_id_is_cfa(id)) { 1976b352e57dSAlan Cox if (id[162] & 1) /* CPRM may make this media unusable */ 197744877b4eSTejun Heo ata_dev_printk(dev, KERN_WARNING, 197844877b4eSTejun Heo "supports DRM functions and may " 197944877b4eSTejun Heo "not be fully accessable.\n"); 1980b352e57dSAlan Cox snprintf(revbuf, 7, "CFA"); 1981b352e57dSAlan Cox } 1982b352e57dSAlan Cox else 1983b352e57dSAlan Cox snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id)); 1984b352e57dSAlan Cox 1985c6fd2807SJeff Garzik dev->n_sectors = ata_id_n_sectors(id); 1986c6fd2807SJeff Garzik 19873f64f565SEric D. Mudama if (dev->id[59] & 0x100) 19883f64f565SEric D. Mudama dev->multi_count = dev->id[59] & 0xff; 19893f64f565SEric D. Mudama 1990c6fd2807SJeff Garzik if (ata_id_has_lba(id)) { 1991c6fd2807SJeff Garzik const char *lba_desc; 1992c6fd2807SJeff Garzik char ncq_desc[20]; 1993c6fd2807SJeff Garzik 1994c6fd2807SJeff Garzik lba_desc = "LBA"; 1995c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_LBA; 1996c6fd2807SJeff Garzik if (ata_id_has_lba48(id)) { 1997c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_LBA48; 1998c6fd2807SJeff Garzik lba_desc = "LBA48"; 19996fc49adbSTejun Heo 20006fc49adbSTejun Heo if (dev->n_sectors >= (1UL << 28) && 20016fc49adbSTejun Heo ata_id_has_flush_ext(id)) 20026fc49adbSTejun Heo dev->flags |= ATA_DFLAG_FLUSH_EXT; 2003c6fd2807SJeff Garzik } 2004c6fd2807SJeff Garzik 2005c6fd2807SJeff Garzik /* config NCQ */ 2006c6fd2807SJeff Garzik ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc)); 2007c6fd2807SJeff Garzik 2008c6fd2807SJeff Garzik /* print device info to dmesg */ 20093f64f565SEric D. Mudama if (ata_msg_drv(ap) && print_info) { 20103f64f565SEric D. Mudama ata_dev_printk(dev, KERN_INFO, 20113f64f565SEric D. Mudama "%s: %s, %s, max %s\n", 20123f64f565SEric D. Mudama revbuf, modelbuf, fwrevbuf, 20133f64f565SEric D. Mudama ata_mode_string(xfer_mask)); 20143f64f565SEric D. Mudama ata_dev_printk(dev, KERN_INFO, 20153f64f565SEric D. Mudama "%Lu sectors, multi %u: %s %s\n", 2016c6fd2807SJeff Garzik (unsigned long long)dev->n_sectors, 20173f64f565SEric D. Mudama dev->multi_count, lba_desc, ncq_desc); 20183f64f565SEric D. Mudama } 2019c6fd2807SJeff Garzik } else { 2020c6fd2807SJeff Garzik /* CHS */ 2021c6fd2807SJeff Garzik 2022c6fd2807SJeff Garzik /* Default translation */ 2023c6fd2807SJeff Garzik dev->cylinders = id[1]; 2024c6fd2807SJeff Garzik dev->heads = id[3]; 2025c6fd2807SJeff Garzik dev->sectors = id[6]; 2026c6fd2807SJeff Garzik 2027c6fd2807SJeff Garzik if (ata_id_current_chs_valid(id)) { 2028c6fd2807SJeff Garzik /* Current CHS translation is valid. */ 2029c6fd2807SJeff Garzik dev->cylinders = id[54]; 2030c6fd2807SJeff Garzik dev->heads = id[55]; 2031c6fd2807SJeff Garzik dev->sectors = id[56]; 2032c6fd2807SJeff Garzik } 2033c6fd2807SJeff Garzik 2034c6fd2807SJeff Garzik /* print device info to dmesg */ 20353f64f565SEric D. Mudama if (ata_msg_drv(ap) && print_info) { 2036c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, 20373f64f565SEric D. Mudama "%s: %s, %s, max %s\n", 20383f64f565SEric D. Mudama revbuf, modelbuf, fwrevbuf, 20393f64f565SEric D. Mudama ata_mode_string(xfer_mask)); 20403f64f565SEric D. Mudama ata_dev_printk(dev, KERN_INFO, 20413f64f565SEric D. Mudama "%Lu sectors, multi %u, CHS %u/%u/%u\n", 20423f64f565SEric D. Mudama (unsigned long long)dev->n_sectors, 20433f64f565SEric D. Mudama dev->multi_count, dev->cylinders, 20443f64f565SEric D. Mudama dev->heads, dev->sectors); 20453f64f565SEric D. Mudama } 2046c6fd2807SJeff Garzik } 2047c6fd2807SJeff Garzik 2048c6fd2807SJeff Garzik dev->cdb_len = 16; 2049c6fd2807SJeff Garzik } 2050c6fd2807SJeff Garzik 2051c6fd2807SJeff Garzik /* ATAPI-specific feature tests */ 2052c6fd2807SJeff Garzik else if (dev->class == ATA_DEV_ATAPI) { 2053854c73a2STejun Heo const char *cdb_intr_string = ""; 2054854c73a2STejun Heo const char *atapi_an_string = ""; 20557d77b247STejun Heo u32 sntf; 2056c6fd2807SJeff Garzik 2057c6fd2807SJeff Garzik rc = atapi_cdb_len(id); 2058c6fd2807SJeff Garzik if ((rc < 12) || (rc > ATAPI_CDB_LEN)) { 2059c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 2060c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 2061c6fd2807SJeff Garzik "unsupported CDB len\n"); 2062c6fd2807SJeff Garzik rc = -EINVAL; 2063c6fd2807SJeff Garzik goto err_out_nosup; 2064c6fd2807SJeff Garzik } 2065c6fd2807SJeff Garzik dev->cdb_len = (unsigned int) rc; 2066c6fd2807SJeff Garzik 20677d77b247STejun Heo /* Enable ATAPI AN if both the host and device have 20687d77b247STejun Heo * the support. If PMP is attached, SNTF is required 20697d77b247STejun Heo * to enable ATAPI AN to discern between PHY status 20707d77b247STejun Heo * changed notifications and ATAPI ANs. 20719f45cbd3SKristen Carlson Accardi */ 20727d77b247STejun Heo if ((ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) && 20737d77b247STejun Heo (!ap->nr_pmp_links || 20747d77b247STejun Heo sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) { 2075854c73a2STejun Heo unsigned int err_mask; 2076854c73a2STejun Heo 20779f45cbd3SKristen Carlson Accardi /* issue SET feature command to turn this on */ 2078854c73a2STejun Heo err_mask = ata_dev_set_AN(dev, SETFEATURES_SATA_ENABLE); 2079854c73a2STejun Heo if (err_mask) 20809f45cbd3SKristen Carlson Accardi ata_dev_printk(dev, KERN_ERR, 2081854c73a2STejun Heo "failed to enable ATAPI AN " 2082854c73a2STejun Heo "(err_mask=0x%x)\n", err_mask); 2083854c73a2STejun Heo else { 20849f45cbd3SKristen Carlson Accardi dev->flags |= ATA_DFLAG_AN; 2085854c73a2STejun Heo atapi_an_string = ", ATAPI AN"; 2086854c73a2STejun Heo } 20879f45cbd3SKristen Carlson Accardi } 20889f45cbd3SKristen Carlson Accardi 2089c6fd2807SJeff Garzik if (ata_id_cdb_intr(dev->id)) { 2090c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_CDB_INTR; 2091c6fd2807SJeff Garzik cdb_intr_string = ", CDB intr"; 2092c6fd2807SJeff Garzik } 2093c6fd2807SJeff Garzik 2094c6fd2807SJeff Garzik /* print device info to dmesg */ 2095c6fd2807SJeff Garzik if (ata_msg_drv(ap) && print_info) 2096ef143d57SAlbert Lee ata_dev_printk(dev, KERN_INFO, 2097854c73a2STejun Heo "ATAPI: %s, %s, max %s%s%s\n", 2098ef143d57SAlbert Lee modelbuf, fwrevbuf, 2099c6fd2807SJeff Garzik ata_mode_string(xfer_mask), 2100854c73a2STejun Heo cdb_intr_string, atapi_an_string); 2101c6fd2807SJeff Garzik } 2102c6fd2807SJeff Garzik 2103914ed354STejun Heo /* determine max_sectors */ 2104914ed354STejun Heo dev->max_sectors = ATA_MAX_SECTORS; 2105914ed354STejun Heo if (dev->flags & ATA_DFLAG_LBA48) 2106914ed354STejun Heo dev->max_sectors = ATA_MAX_SECTORS_LBA48; 2107914ed354STejun Heo 210893590859SAlan Cox if (dev->horkage & ATA_HORKAGE_DIAGNOSTIC) { 210993590859SAlan Cox /* Let the user know. We don't want to disallow opens for 211093590859SAlan Cox rescue purposes, or in case the vendor is just a blithering 211193590859SAlan Cox idiot */ 211293590859SAlan Cox if (print_info) { 211393590859SAlan Cox ata_dev_printk(dev, KERN_WARNING, 211493590859SAlan Cox "Drive reports diagnostics failure. This may indicate a drive\n"); 211593590859SAlan Cox ata_dev_printk(dev, KERN_WARNING, 211693590859SAlan Cox "fault or invalid emulation. Contact drive vendor for information.\n"); 211793590859SAlan Cox } 211893590859SAlan Cox } 211993590859SAlan Cox 2120c6fd2807SJeff Garzik /* limit bridge transfers to udma5, 200 sectors */ 2121c6fd2807SJeff Garzik if (ata_dev_knobble(dev)) { 2122c6fd2807SJeff Garzik if (ata_msg_drv(ap) && print_info) 2123c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, 2124c6fd2807SJeff Garzik "applying bridge limits\n"); 2125c6fd2807SJeff Garzik dev->udma_mask &= ATA_UDMA5; 2126c6fd2807SJeff Garzik dev->max_sectors = ATA_MAX_SECTORS; 2127c6fd2807SJeff Garzik } 2128c6fd2807SJeff Garzik 212975683fe7STejun Heo if (dev->horkage & ATA_HORKAGE_MAX_SEC_128) 213003ec52deSTejun Heo dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128, 213103ec52deSTejun Heo dev->max_sectors); 213218d6e9d5SAlbert Lee 2133c6fd2807SJeff Garzik if (ap->ops->dev_config) 2134cd0d3bbcSAlan ap->ops->dev_config(dev); 2135c6fd2807SJeff Garzik 2136c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 2137c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_DEBUG, "%s: EXIT, drv_stat = 0x%x\n", 2138c6fd2807SJeff Garzik __FUNCTION__, ata_chk_status(ap)); 2139c6fd2807SJeff Garzik return 0; 2140c6fd2807SJeff Garzik 2141c6fd2807SJeff Garzik err_out_nosup: 2142c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 2143c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_DEBUG, 2144c6fd2807SJeff Garzik "%s: EXIT, err\n", __FUNCTION__); 2145c6fd2807SJeff Garzik return rc; 2146c6fd2807SJeff Garzik } 2147c6fd2807SJeff Garzik 2148c6fd2807SJeff Garzik /** 21492e41e8e6SAlan Cox * ata_cable_40wire - return 40 wire cable type 2150be0d18dfSAlan Cox * @ap: port 2151be0d18dfSAlan Cox * 21522e41e8e6SAlan Cox * Helper method for drivers which want to hardwire 40 wire cable 2153be0d18dfSAlan Cox * detection. 2154be0d18dfSAlan Cox */ 2155be0d18dfSAlan Cox 2156be0d18dfSAlan Cox int ata_cable_40wire(struct ata_port *ap) 2157be0d18dfSAlan Cox { 2158be0d18dfSAlan Cox return ATA_CBL_PATA40; 2159be0d18dfSAlan Cox } 2160be0d18dfSAlan Cox 2161be0d18dfSAlan Cox /** 21622e41e8e6SAlan Cox * ata_cable_80wire - return 80 wire cable type 2163be0d18dfSAlan Cox * @ap: port 2164be0d18dfSAlan Cox * 21652e41e8e6SAlan Cox * Helper method for drivers which want to hardwire 80 wire cable 2166be0d18dfSAlan Cox * detection. 2167be0d18dfSAlan Cox */ 2168be0d18dfSAlan Cox 2169be0d18dfSAlan Cox int ata_cable_80wire(struct ata_port *ap) 2170be0d18dfSAlan Cox { 2171be0d18dfSAlan Cox return ATA_CBL_PATA80; 2172be0d18dfSAlan Cox } 2173be0d18dfSAlan Cox 2174be0d18dfSAlan Cox /** 2175be0d18dfSAlan Cox * ata_cable_unknown - return unknown PATA cable. 2176be0d18dfSAlan Cox * @ap: port 2177be0d18dfSAlan Cox * 2178be0d18dfSAlan Cox * Helper method for drivers which have no PATA cable detection. 2179be0d18dfSAlan Cox */ 2180be0d18dfSAlan Cox 2181be0d18dfSAlan Cox int ata_cable_unknown(struct ata_port *ap) 2182be0d18dfSAlan Cox { 2183be0d18dfSAlan Cox return ATA_CBL_PATA_UNK; 2184be0d18dfSAlan Cox } 2185be0d18dfSAlan Cox 2186be0d18dfSAlan Cox /** 2187be0d18dfSAlan Cox * ata_cable_sata - return SATA cable type 2188be0d18dfSAlan Cox * @ap: port 2189be0d18dfSAlan Cox * 2190be0d18dfSAlan Cox * Helper method for drivers which have SATA cables 2191be0d18dfSAlan Cox */ 2192be0d18dfSAlan Cox 2193be0d18dfSAlan Cox int ata_cable_sata(struct ata_port *ap) 2194be0d18dfSAlan Cox { 2195be0d18dfSAlan Cox return ATA_CBL_SATA; 2196be0d18dfSAlan Cox } 2197be0d18dfSAlan Cox 2198be0d18dfSAlan Cox /** 2199c6fd2807SJeff Garzik * ata_bus_probe - Reset and probe ATA bus 2200c6fd2807SJeff Garzik * @ap: Bus to probe 2201c6fd2807SJeff Garzik * 2202c6fd2807SJeff Garzik * Master ATA bus probing function. Initiates a hardware-dependent 2203c6fd2807SJeff Garzik * bus reset, then attempts to identify any devices found on 2204c6fd2807SJeff Garzik * the bus. 2205c6fd2807SJeff Garzik * 2206c6fd2807SJeff Garzik * LOCKING: 2207c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 2208c6fd2807SJeff Garzik * 2209c6fd2807SJeff Garzik * RETURNS: 2210c6fd2807SJeff Garzik * Zero on success, negative errno otherwise. 2211c6fd2807SJeff Garzik */ 2212c6fd2807SJeff Garzik 2213c6fd2807SJeff Garzik int ata_bus_probe(struct ata_port *ap) 2214c6fd2807SJeff Garzik { 2215c6fd2807SJeff Garzik unsigned int classes[ATA_MAX_DEVICES]; 2216c6fd2807SJeff Garzik int tries[ATA_MAX_DEVICES]; 2217f58229f8STejun Heo int rc; 2218c6fd2807SJeff Garzik struct ata_device *dev; 2219c6fd2807SJeff Garzik 2220c6fd2807SJeff Garzik ata_port_probe(ap); 2221c6fd2807SJeff Garzik 2222f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) 2223f58229f8STejun Heo tries[dev->devno] = ATA_PROBE_MAX_TRIES; 2224c6fd2807SJeff Garzik 2225c6fd2807SJeff Garzik retry: 2226c6fd2807SJeff Garzik /* reset and determine device classes */ 2227c6fd2807SJeff Garzik ap->ops->phy_reset(ap); 2228c6fd2807SJeff Garzik 2229f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) { 2230c6fd2807SJeff Garzik if (!(ap->flags & ATA_FLAG_DISABLED) && 2231c6fd2807SJeff Garzik dev->class != ATA_DEV_UNKNOWN) 2232c6fd2807SJeff Garzik classes[dev->devno] = dev->class; 2233c6fd2807SJeff Garzik else 2234c6fd2807SJeff Garzik classes[dev->devno] = ATA_DEV_NONE; 2235c6fd2807SJeff Garzik 2236c6fd2807SJeff Garzik dev->class = ATA_DEV_UNKNOWN; 2237c6fd2807SJeff Garzik } 2238c6fd2807SJeff Garzik 2239c6fd2807SJeff Garzik ata_port_probe(ap); 2240c6fd2807SJeff Garzik 2241c6fd2807SJeff Garzik /* after the reset the device state is PIO 0 and the controller 2242c6fd2807SJeff Garzik state is undefined. Record the mode */ 2243c6fd2807SJeff Garzik 2244f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) 2245f58229f8STejun Heo dev->pio_mode = XFER_PIO_0; 2246c6fd2807SJeff Garzik 2247f31f0cc2SJeff Garzik /* read IDENTIFY page and configure devices. We have to do the identify 2248f31f0cc2SJeff Garzik specific sequence bass-ackwards so that PDIAG- is released by 2249f31f0cc2SJeff Garzik the slave device */ 2250f31f0cc2SJeff Garzik 2251f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) { 2252f58229f8STejun Heo if (tries[dev->devno]) 2253f58229f8STejun Heo dev->class = classes[dev->devno]; 2254c6fd2807SJeff Garzik 2255c6fd2807SJeff Garzik if (!ata_dev_enabled(dev)) 2256c6fd2807SJeff Garzik continue; 2257c6fd2807SJeff Garzik 2258bff04647STejun Heo rc = ata_dev_read_id(dev, &dev->class, ATA_READID_POSTRESET, 2259bff04647STejun Heo dev->id); 2260c6fd2807SJeff Garzik if (rc) 2261c6fd2807SJeff Garzik goto fail; 2262f31f0cc2SJeff Garzik } 2263f31f0cc2SJeff Garzik 2264be0d18dfSAlan Cox /* Now ask for the cable type as PDIAG- should have been released */ 2265be0d18dfSAlan Cox if (ap->ops->cable_detect) 2266be0d18dfSAlan Cox ap->cbl = ap->ops->cable_detect(ap); 2267be0d18dfSAlan Cox 2268614fe29bSAlan Cox /* We may have SATA bridge glue hiding here irrespective of the 2269614fe29bSAlan Cox reported cable types and sensed types */ 2270614fe29bSAlan Cox ata_link_for_each_dev(dev, &ap->link) { 2271614fe29bSAlan Cox if (!ata_dev_enabled(dev)) 2272614fe29bSAlan Cox continue; 2273614fe29bSAlan Cox /* SATA drives indicate we have a bridge. We don't know which 2274614fe29bSAlan Cox end of the link the bridge is which is a problem */ 2275614fe29bSAlan Cox if (ata_id_is_sata(dev->id)) 2276614fe29bSAlan Cox ap->cbl = ATA_CBL_SATA; 2277614fe29bSAlan Cox } 2278614fe29bSAlan Cox 2279f31f0cc2SJeff Garzik /* After the identify sequence we can now set up the devices. We do 2280f31f0cc2SJeff Garzik this in the normal order so that the user doesn't get confused */ 2281f31f0cc2SJeff Garzik 2282f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) { 2283f31f0cc2SJeff Garzik if (!ata_dev_enabled(dev)) 2284f31f0cc2SJeff Garzik continue; 2285c6fd2807SJeff Garzik 22869af5c9c9STejun Heo ap->link.eh_context.i.flags |= ATA_EHI_PRINTINFO; 2287efdaedc4STejun Heo rc = ata_dev_configure(dev); 22889af5c9c9STejun Heo ap->link.eh_context.i.flags &= ~ATA_EHI_PRINTINFO; 2289c6fd2807SJeff Garzik if (rc) 2290c6fd2807SJeff Garzik goto fail; 2291c6fd2807SJeff Garzik } 2292c6fd2807SJeff Garzik 2293c6fd2807SJeff Garzik /* configure transfer mode */ 22940260731fSTejun Heo rc = ata_set_mode(&ap->link, &dev); 22954ae72a1eSTejun Heo if (rc) 2296c6fd2807SJeff Garzik goto fail; 2297c6fd2807SJeff Garzik 2298f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) 2299f58229f8STejun Heo if (ata_dev_enabled(dev)) 2300c6fd2807SJeff Garzik return 0; 2301c6fd2807SJeff Garzik 2302c6fd2807SJeff Garzik /* no device present, disable port */ 2303c6fd2807SJeff Garzik ata_port_disable(ap); 2304c6fd2807SJeff Garzik return -ENODEV; 2305c6fd2807SJeff Garzik 2306c6fd2807SJeff Garzik fail: 23074ae72a1eSTejun Heo tries[dev->devno]--; 23084ae72a1eSTejun Heo 2309c6fd2807SJeff Garzik switch (rc) { 2310c6fd2807SJeff Garzik case -EINVAL: 23114ae72a1eSTejun Heo /* eeek, something went very wrong, give up */ 2312c6fd2807SJeff Garzik tries[dev->devno] = 0; 2313c6fd2807SJeff Garzik break; 23144ae72a1eSTejun Heo 23154ae72a1eSTejun Heo case -ENODEV: 23164ae72a1eSTejun Heo /* give it just one more chance */ 23174ae72a1eSTejun Heo tries[dev->devno] = min(tries[dev->devno], 1); 2318c6fd2807SJeff Garzik case -EIO: 23194ae72a1eSTejun Heo if (tries[dev->devno] == 1) { 23204ae72a1eSTejun Heo /* This is the last chance, better to slow 23214ae72a1eSTejun Heo * down than lose it. 23224ae72a1eSTejun Heo */ 2323936fd732STejun Heo sata_down_spd_limit(&ap->link); 23244ae72a1eSTejun Heo ata_down_xfermask_limit(dev, ATA_DNXFER_PIO); 23254ae72a1eSTejun Heo } 2326c6fd2807SJeff Garzik } 2327c6fd2807SJeff Garzik 23284ae72a1eSTejun Heo if (!tries[dev->devno]) 2329c6fd2807SJeff Garzik ata_dev_disable(dev); 2330c6fd2807SJeff Garzik 2331c6fd2807SJeff Garzik goto retry; 2332c6fd2807SJeff Garzik } 2333c6fd2807SJeff Garzik 2334c6fd2807SJeff Garzik /** 2335c6fd2807SJeff Garzik * ata_port_probe - Mark port as enabled 2336c6fd2807SJeff Garzik * @ap: Port for which we indicate enablement 2337c6fd2807SJeff Garzik * 2338c6fd2807SJeff Garzik * Modify @ap data structure such that the system 2339c6fd2807SJeff Garzik * thinks that the entire port is enabled. 2340c6fd2807SJeff Garzik * 2341cca3974eSJeff Garzik * LOCKING: host lock, or some other form of 2342c6fd2807SJeff Garzik * serialization. 2343c6fd2807SJeff Garzik */ 2344c6fd2807SJeff Garzik 2345c6fd2807SJeff Garzik void ata_port_probe(struct ata_port *ap) 2346c6fd2807SJeff Garzik { 2347c6fd2807SJeff Garzik ap->flags &= ~ATA_FLAG_DISABLED; 2348c6fd2807SJeff Garzik } 2349c6fd2807SJeff Garzik 2350c6fd2807SJeff Garzik /** 2351c6fd2807SJeff Garzik * sata_print_link_status - Print SATA link status 2352936fd732STejun Heo * @link: SATA link to printk link status about 2353c6fd2807SJeff Garzik * 2354c6fd2807SJeff Garzik * This function prints link speed and status of a SATA link. 2355c6fd2807SJeff Garzik * 2356c6fd2807SJeff Garzik * LOCKING: 2357c6fd2807SJeff Garzik * None. 2358c6fd2807SJeff Garzik */ 2359936fd732STejun Heo void sata_print_link_status(struct ata_link *link) 2360c6fd2807SJeff Garzik { 2361c6fd2807SJeff Garzik u32 sstatus, scontrol, tmp; 2362c6fd2807SJeff Garzik 2363936fd732STejun Heo if (sata_scr_read(link, SCR_STATUS, &sstatus)) 2364c6fd2807SJeff Garzik return; 2365936fd732STejun Heo sata_scr_read(link, SCR_CONTROL, &scontrol); 2366c6fd2807SJeff Garzik 2367936fd732STejun Heo if (ata_link_online(link)) { 2368c6fd2807SJeff Garzik tmp = (sstatus >> 4) & 0xf; 2369936fd732STejun Heo ata_link_printk(link, KERN_INFO, 2370c6fd2807SJeff Garzik "SATA link up %s (SStatus %X SControl %X)\n", 2371c6fd2807SJeff Garzik sata_spd_string(tmp), sstatus, scontrol); 2372c6fd2807SJeff Garzik } else { 2373936fd732STejun Heo ata_link_printk(link, KERN_INFO, 2374c6fd2807SJeff Garzik "SATA link down (SStatus %X SControl %X)\n", 2375c6fd2807SJeff Garzik sstatus, scontrol); 2376c6fd2807SJeff Garzik } 2377c6fd2807SJeff Garzik } 2378c6fd2807SJeff Garzik 2379c6fd2807SJeff Garzik /** 2380c6fd2807SJeff Garzik * __sata_phy_reset - Wake/reset a low-level SATA PHY 2381c6fd2807SJeff Garzik * @ap: SATA port associated with target SATA PHY. 2382c6fd2807SJeff Garzik * 2383c6fd2807SJeff Garzik * This function issues commands to standard SATA Sxxx 2384c6fd2807SJeff Garzik * PHY registers, to wake up the phy (and device), and 2385c6fd2807SJeff Garzik * clear any reset condition. 2386c6fd2807SJeff Garzik * 2387c6fd2807SJeff Garzik * LOCKING: 2388c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 2389c6fd2807SJeff Garzik * 2390c6fd2807SJeff Garzik */ 2391c6fd2807SJeff Garzik void __sata_phy_reset(struct ata_port *ap) 2392c6fd2807SJeff Garzik { 2393936fd732STejun Heo struct ata_link *link = &ap->link; 2394c6fd2807SJeff Garzik unsigned long timeout = jiffies + (HZ * 5); 2395936fd732STejun Heo u32 sstatus; 2396c6fd2807SJeff Garzik 2397c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_SATA_RESET) { 2398c6fd2807SJeff Garzik /* issue phy wake/reset */ 2399936fd732STejun Heo sata_scr_write_flush(link, SCR_CONTROL, 0x301); 2400c6fd2807SJeff Garzik /* Couldn't find anything in SATA I/II specs, but 2401c6fd2807SJeff Garzik * AHCI-1.1 10.4.2 says at least 1 ms. */ 2402c6fd2807SJeff Garzik mdelay(1); 2403c6fd2807SJeff Garzik } 2404c6fd2807SJeff Garzik /* phy wake/clear reset */ 2405936fd732STejun Heo sata_scr_write_flush(link, SCR_CONTROL, 0x300); 2406c6fd2807SJeff Garzik 2407c6fd2807SJeff Garzik /* wait for phy to become ready, if necessary */ 2408c6fd2807SJeff Garzik do { 2409c6fd2807SJeff Garzik msleep(200); 2410936fd732STejun Heo sata_scr_read(link, SCR_STATUS, &sstatus); 2411c6fd2807SJeff Garzik if ((sstatus & 0xf) != 1) 2412c6fd2807SJeff Garzik break; 2413c6fd2807SJeff Garzik } while (time_before(jiffies, timeout)); 2414c6fd2807SJeff Garzik 2415c6fd2807SJeff Garzik /* print link status */ 2416936fd732STejun Heo sata_print_link_status(link); 2417c6fd2807SJeff Garzik 2418c6fd2807SJeff Garzik /* TODO: phy layer with polling, timeouts, etc. */ 2419936fd732STejun Heo if (!ata_link_offline(link)) 2420c6fd2807SJeff Garzik ata_port_probe(ap); 2421c6fd2807SJeff Garzik else 2422c6fd2807SJeff Garzik ata_port_disable(ap); 2423c6fd2807SJeff Garzik 2424c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_DISABLED) 2425c6fd2807SJeff Garzik return; 2426c6fd2807SJeff Garzik 2427c6fd2807SJeff Garzik if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) { 2428c6fd2807SJeff Garzik ata_port_disable(ap); 2429c6fd2807SJeff Garzik return; 2430c6fd2807SJeff Garzik } 2431c6fd2807SJeff Garzik 2432c6fd2807SJeff Garzik ap->cbl = ATA_CBL_SATA; 2433c6fd2807SJeff Garzik } 2434c6fd2807SJeff Garzik 2435c6fd2807SJeff Garzik /** 2436c6fd2807SJeff Garzik * sata_phy_reset - Reset SATA bus. 2437c6fd2807SJeff Garzik * @ap: SATA port associated with target SATA PHY. 2438c6fd2807SJeff Garzik * 2439c6fd2807SJeff Garzik * This function resets the SATA bus, and then probes 2440c6fd2807SJeff Garzik * the bus for devices. 2441c6fd2807SJeff Garzik * 2442c6fd2807SJeff Garzik * LOCKING: 2443c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 2444c6fd2807SJeff Garzik * 2445c6fd2807SJeff Garzik */ 2446c6fd2807SJeff Garzik void sata_phy_reset(struct ata_port *ap) 2447c6fd2807SJeff Garzik { 2448c6fd2807SJeff Garzik __sata_phy_reset(ap); 2449c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_DISABLED) 2450c6fd2807SJeff Garzik return; 2451c6fd2807SJeff Garzik ata_bus_reset(ap); 2452c6fd2807SJeff Garzik } 2453c6fd2807SJeff Garzik 2454c6fd2807SJeff Garzik /** 2455c6fd2807SJeff Garzik * ata_dev_pair - return other device on cable 2456c6fd2807SJeff Garzik * @adev: device 2457c6fd2807SJeff Garzik * 2458c6fd2807SJeff Garzik * Obtain the other device on the same cable, or if none is 2459c6fd2807SJeff Garzik * present NULL is returned 2460c6fd2807SJeff Garzik */ 2461c6fd2807SJeff Garzik 2462c6fd2807SJeff Garzik struct ata_device *ata_dev_pair(struct ata_device *adev) 2463c6fd2807SJeff Garzik { 24649af5c9c9STejun Heo struct ata_link *link = adev->link; 24659af5c9c9STejun Heo struct ata_device *pair = &link->device[1 - adev->devno]; 2466c6fd2807SJeff Garzik if (!ata_dev_enabled(pair)) 2467c6fd2807SJeff Garzik return NULL; 2468c6fd2807SJeff Garzik return pair; 2469c6fd2807SJeff Garzik } 2470c6fd2807SJeff Garzik 2471c6fd2807SJeff Garzik /** 2472c6fd2807SJeff Garzik * ata_port_disable - Disable port. 2473c6fd2807SJeff Garzik * @ap: Port to be disabled. 2474c6fd2807SJeff Garzik * 2475c6fd2807SJeff Garzik * Modify @ap data structure such that the system 2476c6fd2807SJeff Garzik * thinks that the entire port is disabled, and should 2477c6fd2807SJeff Garzik * never attempt to probe or communicate with devices 2478c6fd2807SJeff Garzik * on this port. 2479c6fd2807SJeff Garzik * 2480cca3974eSJeff Garzik * LOCKING: host lock, or some other form of 2481c6fd2807SJeff Garzik * serialization. 2482c6fd2807SJeff Garzik */ 2483c6fd2807SJeff Garzik 2484c6fd2807SJeff Garzik void ata_port_disable(struct ata_port *ap) 2485c6fd2807SJeff Garzik { 24869af5c9c9STejun Heo ap->link.device[0].class = ATA_DEV_NONE; 24879af5c9c9STejun Heo ap->link.device[1].class = ATA_DEV_NONE; 2488c6fd2807SJeff Garzik ap->flags |= ATA_FLAG_DISABLED; 2489c6fd2807SJeff Garzik } 2490c6fd2807SJeff Garzik 2491c6fd2807SJeff Garzik /** 2492c6fd2807SJeff Garzik * sata_down_spd_limit - adjust SATA spd limit downward 2493936fd732STejun Heo * @link: Link to adjust SATA spd limit for 2494c6fd2807SJeff Garzik * 2495936fd732STejun Heo * Adjust SATA spd limit of @link downward. Note that this 2496c6fd2807SJeff Garzik * function only adjusts the limit. The change must be applied 2497c6fd2807SJeff Garzik * using sata_set_spd(). 2498c6fd2807SJeff Garzik * 2499c6fd2807SJeff Garzik * LOCKING: 2500c6fd2807SJeff Garzik * Inherited from caller. 2501c6fd2807SJeff Garzik * 2502c6fd2807SJeff Garzik * RETURNS: 2503c6fd2807SJeff Garzik * 0 on success, negative errno on failure 2504c6fd2807SJeff Garzik */ 2505936fd732STejun Heo int sata_down_spd_limit(struct ata_link *link) 2506c6fd2807SJeff Garzik { 2507c6fd2807SJeff Garzik u32 sstatus, spd, mask; 2508c6fd2807SJeff Garzik int rc, highbit; 2509c6fd2807SJeff Garzik 2510936fd732STejun Heo if (!sata_scr_valid(link)) 2511008a7896STejun Heo return -EOPNOTSUPP; 2512008a7896STejun Heo 2513008a7896STejun Heo /* If SCR can be read, use it to determine the current SPD. 2514936fd732STejun Heo * If not, use cached value in link->sata_spd. 2515008a7896STejun Heo */ 2516936fd732STejun Heo rc = sata_scr_read(link, SCR_STATUS, &sstatus); 2517008a7896STejun Heo if (rc == 0) 2518008a7896STejun Heo spd = (sstatus >> 4) & 0xf; 2519008a7896STejun Heo else 2520936fd732STejun Heo spd = link->sata_spd; 2521c6fd2807SJeff Garzik 2522936fd732STejun Heo mask = link->sata_spd_limit; 2523c6fd2807SJeff Garzik if (mask <= 1) 2524c6fd2807SJeff Garzik return -EINVAL; 2525008a7896STejun Heo 2526008a7896STejun Heo /* unconditionally mask off the highest bit */ 2527c6fd2807SJeff Garzik highbit = fls(mask) - 1; 2528c6fd2807SJeff Garzik mask &= ~(1 << highbit); 2529c6fd2807SJeff Garzik 2530008a7896STejun Heo /* Mask off all speeds higher than or equal to the current 2531008a7896STejun Heo * one. Force 1.5Gbps if current SPD is not available. 2532008a7896STejun Heo */ 2533008a7896STejun Heo if (spd > 1) 2534008a7896STejun Heo mask &= (1 << (spd - 1)) - 1; 2535008a7896STejun Heo else 2536008a7896STejun Heo mask &= 1; 2537008a7896STejun Heo 2538008a7896STejun Heo /* were we already at the bottom? */ 2539c6fd2807SJeff Garzik if (!mask) 2540c6fd2807SJeff Garzik return -EINVAL; 2541c6fd2807SJeff Garzik 2542936fd732STejun Heo link->sata_spd_limit = mask; 2543c6fd2807SJeff Garzik 2544936fd732STejun Heo ata_link_printk(link, KERN_WARNING, "limiting SATA link speed to %s\n", 2545c6fd2807SJeff Garzik sata_spd_string(fls(mask))); 2546c6fd2807SJeff Garzik 2547c6fd2807SJeff Garzik return 0; 2548c6fd2807SJeff Garzik } 2549c6fd2807SJeff Garzik 2550936fd732STejun Heo static int __sata_set_spd_needed(struct ata_link *link, u32 *scontrol) 2551c6fd2807SJeff Garzik { 2552c6fd2807SJeff Garzik u32 spd, limit; 2553c6fd2807SJeff Garzik 2554936fd732STejun Heo if (link->sata_spd_limit == UINT_MAX) 2555c6fd2807SJeff Garzik limit = 0; 2556c6fd2807SJeff Garzik else 2557936fd732STejun Heo limit = fls(link->sata_spd_limit); 2558c6fd2807SJeff Garzik 2559c6fd2807SJeff Garzik spd = (*scontrol >> 4) & 0xf; 2560c6fd2807SJeff Garzik *scontrol = (*scontrol & ~0xf0) | ((limit & 0xf) << 4); 2561c6fd2807SJeff Garzik 2562c6fd2807SJeff Garzik return spd != limit; 2563c6fd2807SJeff Garzik } 2564c6fd2807SJeff Garzik 2565c6fd2807SJeff Garzik /** 2566c6fd2807SJeff Garzik * sata_set_spd_needed - is SATA spd configuration needed 2567936fd732STejun Heo * @link: Link in question 2568c6fd2807SJeff Garzik * 2569c6fd2807SJeff Garzik * Test whether the spd limit in SControl matches 2570936fd732STejun Heo * @link->sata_spd_limit. This function is used to determine 2571c6fd2807SJeff Garzik * whether hardreset is necessary to apply SATA spd 2572c6fd2807SJeff Garzik * configuration. 2573c6fd2807SJeff Garzik * 2574c6fd2807SJeff Garzik * LOCKING: 2575c6fd2807SJeff Garzik * Inherited from caller. 2576c6fd2807SJeff Garzik * 2577c6fd2807SJeff Garzik * RETURNS: 2578c6fd2807SJeff Garzik * 1 if SATA spd configuration is needed, 0 otherwise. 2579c6fd2807SJeff Garzik */ 2580936fd732STejun Heo int sata_set_spd_needed(struct ata_link *link) 2581c6fd2807SJeff Garzik { 2582c6fd2807SJeff Garzik u32 scontrol; 2583c6fd2807SJeff Garzik 2584936fd732STejun Heo if (sata_scr_read(link, SCR_CONTROL, &scontrol)) 2585c6fd2807SJeff Garzik return 0; 2586c6fd2807SJeff Garzik 2587936fd732STejun Heo return __sata_set_spd_needed(link, &scontrol); 2588c6fd2807SJeff Garzik } 2589c6fd2807SJeff Garzik 2590c6fd2807SJeff Garzik /** 2591c6fd2807SJeff Garzik * sata_set_spd - set SATA spd according to spd limit 2592936fd732STejun Heo * @link: Link to set SATA spd for 2593c6fd2807SJeff Garzik * 2594936fd732STejun Heo * Set SATA spd of @link according to sata_spd_limit. 2595c6fd2807SJeff Garzik * 2596c6fd2807SJeff Garzik * LOCKING: 2597c6fd2807SJeff Garzik * Inherited from caller. 2598c6fd2807SJeff Garzik * 2599c6fd2807SJeff Garzik * RETURNS: 2600c6fd2807SJeff Garzik * 0 if spd doesn't need to be changed, 1 if spd has been 2601c6fd2807SJeff Garzik * changed. Negative errno if SCR registers are inaccessible. 2602c6fd2807SJeff Garzik */ 2603936fd732STejun Heo int sata_set_spd(struct ata_link *link) 2604c6fd2807SJeff Garzik { 2605c6fd2807SJeff Garzik u32 scontrol; 2606c6fd2807SJeff Garzik int rc; 2607c6fd2807SJeff Garzik 2608936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 2609c6fd2807SJeff Garzik return rc; 2610c6fd2807SJeff Garzik 2611936fd732STejun Heo if (!__sata_set_spd_needed(link, &scontrol)) 2612c6fd2807SJeff Garzik return 0; 2613c6fd2807SJeff Garzik 2614936fd732STejun Heo if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol))) 2615c6fd2807SJeff Garzik return rc; 2616c6fd2807SJeff Garzik 2617c6fd2807SJeff Garzik return 1; 2618c6fd2807SJeff Garzik } 2619c6fd2807SJeff Garzik 2620c6fd2807SJeff Garzik /* 2621c6fd2807SJeff Garzik * This mode timing computation functionality is ported over from 2622c6fd2807SJeff Garzik * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik 2623c6fd2807SJeff Garzik */ 2624c6fd2807SJeff Garzik /* 2625b352e57dSAlan Cox * PIO 0-4, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds). 2626c6fd2807SJeff Garzik * These were taken from ATA/ATAPI-6 standard, rev 0a, except 2627b352e57dSAlan Cox * for UDMA6, which is currently supported only by Maxtor drives. 2628b352e57dSAlan Cox * 2629b352e57dSAlan Cox * For PIO 5/6 MWDMA 3/4 see the CFA specification 3.0. 2630c6fd2807SJeff Garzik */ 2631c6fd2807SJeff Garzik 2632c6fd2807SJeff Garzik static const struct ata_timing ata_timing[] = { 2633c6fd2807SJeff Garzik 2634c6fd2807SJeff Garzik { XFER_UDMA_6, 0, 0, 0, 0, 0, 0, 0, 15 }, 2635c6fd2807SJeff Garzik { XFER_UDMA_5, 0, 0, 0, 0, 0, 0, 0, 20 }, 2636c6fd2807SJeff Garzik { XFER_UDMA_4, 0, 0, 0, 0, 0, 0, 0, 30 }, 2637c6fd2807SJeff Garzik { XFER_UDMA_3, 0, 0, 0, 0, 0, 0, 0, 45 }, 2638c6fd2807SJeff Garzik 2639b352e57dSAlan Cox { XFER_MW_DMA_4, 25, 0, 0, 0, 55, 20, 80, 0 }, 2640b352e57dSAlan Cox { XFER_MW_DMA_3, 25, 0, 0, 0, 65, 25, 100, 0 }, 2641c6fd2807SJeff Garzik { XFER_UDMA_2, 0, 0, 0, 0, 0, 0, 0, 60 }, 2642c6fd2807SJeff Garzik { XFER_UDMA_1, 0, 0, 0, 0, 0, 0, 0, 80 }, 2643c6fd2807SJeff Garzik { XFER_UDMA_0, 0, 0, 0, 0, 0, 0, 0, 120 }, 2644c6fd2807SJeff Garzik 2645c6fd2807SJeff Garzik /* { XFER_UDMA_SLOW, 0, 0, 0, 0, 0, 0, 0, 150 }, */ 2646c6fd2807SJeff Garzik 2647c6fd2807SJeff Garzik { XFER_MW_DMA_2, 25, 0, 0, 0, 70, 25, 120, 0 }, 2648c6fd2807SJeff Garzik { XFER_MW_DMA_1, 45, 0, 0, 0, 80, 50, 150, 0 }, 2649c6fd2807SJeff Garzik { XFER_MW_DMA_0, 60, 0, 0, 0, 215, 215, 480, 0 }, 2650c6fd2807SJeff Garzik 2651c6fd2807SJeff Garzik { XFER_SW_DMA_2, 60, 0, 0, 0, 120, 120, 240, 0 }, 2652c6fd2807SJeff Garzik { XFER_SW_DMA_1, 90, 0, 0, 0, 240, 240, 480, 0 }, 2653c6fd2807SJeff Garzik { XFER_SW_DMA_0, 120, 0, 0, 0, 480, 480, 960, 0 }, 2654c6fd2807SJeff Garzik 2655b352e57dSAlan Cox { XFER_PIO_6, 10, 55, 20, 80, 55, 20, 80, 0 }, 2656b352e57dSAlan Cox { XFER_PIO_5, 15, 65, 25, 100, 65, 25, 100, 0 }, 2657c6fd2807SJeff Garzik { XFER_PIO_4, 25, 70, 25, 120, 70, 25, 120, 0 }, 2658c6fd2807SJeff Garzik { XFER_PIO_3, 30, 80, 70, 180, 80, 70, 180, 0 }, 2659c6fd2807SJeff Garzik 2660c6fd2807SJeff Garzik { XFER_PIO_2, 30, 290, 40, 330, 100, 90, 240, 0 }, 2661c6fd2807SJeff Garzik { XFER_PIO_1, 50, 290, 93, 383, 125, 100, 383, 0 }, 2662c6fd2807SJeff Garzik { XFER_PIO_0, 70, 290, 240, 600, 165, 150, 600, 0 }, 2663c6fd2807SJeff Garzik 2664c6fd2807SJeff Garzik /* { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960, 0 }, */ 2665c6fd2807SJeff Garzik 2666c6fd2807SJeff Garzik { 0xFF } 2667c6fd2807SJeff Garzik }; 2668c6fd2807SJeff Garzik 2669c6fd2807SJeff Garzik #define ENOUGH(v,unit) (((v)-1)/(unit)+1) 2670c6fd2807SJeff Garzik #define EZ(v,unit) ((v)?ENOUGH(v,unit):0) 2671c6fd2807SJeff Garzik 2672c6fd2807SJeff Garzik static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT) 2673c6fd2807SJeff Garzik { 2674c6fd2807SJeff Garzik q->setup = EZ(t->setup * 1000, T); 2675c6fd2807SJeff Garzik q->act8b = EZ(t->act8b * 1000, T); 2676c6fd2807SJeff Garzik q->rec8b = EZ(t->rec8b * 1000, T); 2677c6fd2807SJeff Garzik q->cyc8b = EZ(t->cyc8b * 1000, T); 2678c6fd2807SJeff Garzik q->active = EZ(t->active * 1000, T); 2679c6fd2807SJeff Garzik q->recover = EZ(t->recover * 1000, T); 2680c6fd2807SJeff Garzik q->cycle = EZ(t->cycle * 1000, T); 2681c6fd2807SJeff Garzik q->udma = EZ(t->udma * 1000, UT); 2682c6fd2807SJeff Garzik } 2683c6fd2807SJeff Garzik 2684c6fd2807SJeff Garzik void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b, 2685c6fd2807SJeff Garzik struct ata_timing *m, unsigned int what) 2686c6fd2807SJeff Garzik { 2687c6fd2807SJeff Garzik if (what & ATA_TIMING_SETUP ) m->setup = max(a->setup, b->setup); 2688c6fd2807SJeff Garzik if (what & ATA_TIMING_ACT8B ) m->act8b = max(a->act8b, b->act8b); 2689c6fd2807SJeff Garzik if (what & ATA_TIMING_REC8B ) m->rec8b = max(a->rec8b, b->rec8b); 2690c6fd2807SJeff Garzik if (what & ATA_TIMING_CYC8B ) m->cyc8b = max(a->cyc8b, b->cyc8b); 2691c6fd2807SJeff Garzik if (what & ATA_TIMING_ACTIVE ) m->active = max(a->active, b->active); 2692c6fd2807SJeff Garzik if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover); 2693c6fd2807SJeff Garzik if (what & ATA_TIMING_CYCLE ) m->cycle = max(a->cycle, b->cycle); 2694c6fd2807SJeff Garzik if (what & ATA_TIMING_UDMA ) m->udma = max(a->udma, b->udma); 2695c6fd2807SJeff Garzik } 2696c6fd2807SJeff Garzik 2697c6fd2807SJeff Garzik static const struct ata_timing* ata_timing_find_mode(unsigned short speed) 2698c6fd2807SJeff Garzik { 2699c6fd2807SJeff Garzik const struct ata_timing *t; 2700c6fd2807SJeff Garzik 2701c6fd2807SJeff Garzik for (t = ata_timing; t->mode != speed; t++) 2702c6fd2807SJeff Garzik if (t->mode == 0xFF) 2703c6fd2807SJeff Garzik return NULL; 2704c6fd2807SJeff Garzik return t; 2705c6fd2807SJeff Garzik } 2706c6fd2807SJeff Garzik 2707c6fd2807SJeff Garzik int ata_timing_compute(struct ata_device *adev, unsigned short speed, 2708c6fd2807SJeff Garzik struct ata_timing *t, int T, int UT) 2709c6fd2807SJeff Garzik { 2710c6fd2807SJeff Garzik const struct ata_timing *s; 2711c6fd2807SJeff Garzik struct ata_timing p; 2712c6fd2807SJeff Garzik 2713c6fd2807SJeff Garzik /* 2714c6fd2807SJeff Garzik * Find the mode. 2715c6fd2807SJeff Garzik */ 2716c6fd2807SJeff Garzik 2717c6fd2807SJeff Garzik if (!(s = ata_timing_find_mode(speed))) 2718c6fd2807SJeff Garzik return -EINVAL; 2719c6fd2807SJeff Garzik 2720c6fd2807SJeff Garzik memcpy(t, s, sizeof(*s)); 2721c6fd2807SJeff Garzik 2722c6fd2807SJeff Garzik /* 2723c6fd2807SJeff Garzik * If the drive is an EIDE drive, it can tell us it needs extended 2724c6fd2807SJeff Garzik * PIO/MW_DMA cycle timing. 2725c6fd2807SJeff Garzik */ 2726c6fd2807SJeff Garzik 2727c6fd2807SJeff Garzik if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */ 2728c6fd2807SJeff Garzik memset(&p, 0, sizeof(p)); 2729c6fd2807SJeff Garzik if(speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) { 2730c6fd2807SJeff Garzik if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO]; 2731c6fd2807SJeff Garzik else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY]; 2732c6fd2807SJeff Garzik } else if(speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) { 2733c6fd2807SJeff Garzik p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN]; 2734c6fd2807SJeff Garzik } 2735c6fd2807SJeff Garzik ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B); 2736c6fd2807SJeff Garzik } 2737c6fd2807SJeff Garzik 2738c6fd2807SJeff Garzik /* 2739c6fd2807SJeff Garzik * Convert the timing to bus clock counts. 2740c6fd2807SJeff Garzik */ 2741c6fd2807SJeff Garzik 2742c6fd2807SJeff Garzik ata_timing_quantize(t, t, T, UT); 2743c6fd2807SJeff Garzik 2744c6fd2807SJeff Garzik /* 2745c6fd2807SJeff Garzik * Even in DMA/UDMA modes we still use PIO access for IDENTIFY, 2746c6fd2807SJeff Garzik * S.M.A.R.T * and some other commands. We have to ensure that the 2747c6fd2807SJeff Garzik * DMA cycle timing is slower/equal than the fastest PIO timing. 2748c6fd2807SJeff Garzik */ 2749c6fd2807SJeff Garzik 2750fd3367afSAlan if (speed > XFER_PIO_6) { 2751c6fd2807SJeff Garzik ata_timing_compute(adev, adev->pio_mode, &p, T, UT); 2752c6fd2807SJeff Garzik ata_timing_merge(&p, t, t, ATA_TIMING_ALL); 2753c6fd2807SJeff Garzik } 2754c6fd2807SJeff Garzik 2755c6fd2807SJeff Garzik /* 2756c6fd2807SJeff Garzik * Lengthen active & recovery time so that cycle time is correct. 2757c6fd2807SJeff Garzik */ 2758c6fd2807SJeff Garzik 2759c6fd2807SJeff Garzik if (t->act8b + t->rec8b < t->cyc8b) { 2760c6fd2807SJeff Garzik t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2; 2761c6fd2807SJeff Garzik t->rec8b = t->cyc8b - t->act8b; 2762c6fd2807SJeff Garzik } 2763c6fd2807SJeff Garzik 2764c6fd2807SJeff Garzik if (t->active + t->recover < t->cycle) { 2765c6fd2807SJeff Garzik t->active += (t->cycle - (t->active + t->recover)) / 2; 2766c6fd2807SJeff Garzik t->recover = t->cycle - t->active; 2767c6fd2807SJeff Garzik } 27684f701d1eSAlan Cox 27694f701d1eSAlan Cox /* In a few cases quantisation may produce enough errors to 27704f701d1eSAlan Cox leave t->cycle too low for the sum of active and recovery 27714f701d1eSAlan Cox if so we must correct this */ 27724f701d1eSAlan Cox if (t->active + t->recover > t->cycle) 27734f701d1eSAlan Cox t->cycle = t->active + t->recover; 2774c6fd2807SJeff Garzik 2775c6fd2807SJeff Garzik return 0; 2776c6fd2807SJeff Garzik } 2777c6fd2807SJeff Garzik 2778c6fd2807SJeff Garzik /** 2779c6fd2807SJeff Garzik * ata_down_xfermask_limit - adjust dev xfer masks downward 2780c6fd2807SJeff Garzik * @dev: Device to adjust xfer masks 2781458337dbSTejun Heo * @sel: ATA_DNXFER_* selector 2782c6fd2807SJeff Garzik * 2783c6fd2807SJeff Garzik * Adjust xfer masks of @dev downward. Note that this function 2784c6fd2807SJeff Garzik * does not apply the change. Invoking ata_set_mode() afterwards 2785c6fd2807SJeff Garzik * will apply the limit. 2786c6fd2807SJeff Garzik * 2787c6fd2807SJeff Garzik * LOCKING: 2788c6fd2807SJeff Garzik * Inherited from caller. 2789c6fd2807SJeff Garzik * 2790c6fd2807SJeff Garzik * RETURNS: 2791c6fd2807SJeff Garzik * 0 on success, negative errno on failure 2792c6fd2807SJeff Garzik */ 2793458337dbSTejun Heo int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel) 2794c6fd2807SJeff Garzik { 2795458337dbSTejun Heo char buf[32]; 2796458337dbSTejun Heo unsigned int orig_mask, xfer_mask; 2797458337dbSTejun Heo unsigned int pio_mask, mwdma_mask, udma_mask; 2798458337dbSTejun Heo int quiet, highbit; 2799c6fd2807SJeff Garzik 2800458337dbSTejun Heo quiet = !!(sel & ATA_DNXFER_QUIET); 2801458337dbSTejun Heo sel &= ~ATA_DNXFER_QUIET; 2802458337dbSTejun Heo 2803458337dbSTejun Heo xfer_mask = orig_mask = ata_pack_xfermask(dev->pio_mask, 2804458337dbSTejun Heo dev->mwdma_mask, 2805c6fd2807SJeff Garzik dev->udma_mask); 2806458337dbSTejun Heo ata_unpack_xfermask(xfer_mask, &pio_mask, &mwdma_mask, &udma_mask); 2807c6fd2807SJeff Garzik 2808458337dbSTejun Heo switch (sel) { 2809458337dbSTejun Heo case ATA_DNXFER_PIO: 2810458337dbSTejun Heo highbit = fls(pio_mask) - 1; 2811458337dbSTejun Heo pio_mask &= ~(1 << highbit); 2812458337dbSTejun Heo break; 2813458337dbSTejun Heo 2814458337dbSTejun Heo case ATA_DNXFER_DMA: 2815458337dbSTejun Heo if (udma_mask) { 2816458337dbSTejun Heo highbit = fls(udma_mask) - 1; 2817458337dbSTejun Heo udma_mask &= ~(1 << highbit); 2818458337dbSTejun Heo if (!udma_mask) 2819458337dbSTejun Heo return -ENOENT; 2820458337dbSTejun Heo } else if (mwdma_mask) { 2821458337dbSTejun Heo highbit = fls(mwdma_mask) - 1; 2822458337dbSTejun Heo mwdma_mask &= ~(1 << highbit); 2823458337dbSTejun Heo if (!mwdma_mask) 2824458337dbSTejun Heo return -ENOENT; 2825458337dbSTejun Heo } 2826458337dbSTejun Heo break; 2827458337dbSTejun Heo 2828458337dbSTejun Heo case ATA_DNXFER_40C: 2829458337dbSTejun Heo udma_mask &= ATA_UDMA_MASK_40C; 2830458337dbSTejun Heo break; 2831458337dbSTejun Heo 2832458337dbSTejun Heo case ATA_DNXFER_FORCE_PIO0: 2833458337dbSTejun Heo pio_mask &= 1; 2834458337dbSTejun Heo case ATA_DNXFER_FORCE_PIO: 2835458337dbSTejun Heo mwdma_mask = 0; 2836458337dbSTejun Heo udma_mask = 0; 2837458337dbSTejun Heo break; 2838458337dbSTejun Heo 2839458337dbSTejun Heo default: 2840458337dbSTejun Heo BUG(); 2841458337dbSTejun Heo } 2842458337dbSTejun Heo 2843458337dbSTejun Heo xfer_mask &= ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask); 2844458337dbSTejun Heo 2845458337dbSTejun Heo if (!(xfer_mask & ATA_MASK_PIO) || xfer_mask == orig_mask) 2846458337dbSTejun Heo return -ENOENT; 2847458337dbSTejun Heo 2848458337dbSTejun Heo if (!quiet) { 2849458337dbSTejun Heo if (xfer_mask & (ATA_MASK_MWDMA | ATA_MASK_UDMA)) 2850458337dbSTejun Heo snprintf(buf, sizeof(buf), "%s:%s", 2851458337dbSTejun Heo ata_mode_string(xfer_mask), 2852458337dbSTejun Heo ata_mode_string(xfer_mask & ATA_MASK_PIO)); 2853458337dbSTejun Heo else 2854458337dbSTejun Heo snprintf(buf, sizeof(buf), "%s", 2855458337dbSTejun Heo ata_mode_string(xfer_mask)); 2856458337dbSTejun Heo 2857458337dbSTejun Heo ata_dev_printk(dev, KERN_WARNING, 2858458337dbSTejun Heo "limiting speed to %s\n", buf); 2859458337dbSTejun Heo } 2860c6fd2807SJeff Garzik 2861c6fd2807SJeff Garzik ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask, 2862c6fd2807SJeff Garzik &dev->udma_mask); 2863c6fd2807SJeff Garzik 2864c6fd2807SJeff Garzik return 0; 2865c6fd2807SJeff Garzik } 2866c6fd2807SJeff Garzik 2867c6fd2807SJeff Garzik static int ata_dev_set_mode(struct ata_device *dev) 2868c6fd2807SJeff Garzik { 28699af5c9c9STejun Heo struct ata_eh_context *ehc = &dev->link->eh_context; 2870c6fd2807SJeff Garzik unsigned int err_mask; 2871c6fd2807SJeff Garzik int rc; 2872c6fd2807SJeff Garzik 2873c6fd2807SJeff Garzik dev->flags &= ~ATA_DFLAG_PIO; 2874c6fd2807SJeff Garzik if (dev->xfer_shift == ATA_SHIFT_PIO) 2875c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_PIO; 2876c6fd2807SJeff Garzik 2877c6fd2807SJeff Garzik err_mask = ata_dev_set_xfermode(dev); 287811750a40SAlan /* Old CFA may refuse this command, which is just fine */ 287911750a40SAlan if (dev->xfer_shift == ATA_SHIFT_PIO && ata_id_is_cfa(dev->id)) 288011750a40SAlan err_mask &= ~AC_ERR_DEV; 28810bc2a79aSAlan Cox /* Some very old devices and some bad newer ones fail any kind of 28820bc2a79aSAlan Cox SET_XFERMODE request but support PIO0-2 timings and no IORDY */ 28830bc2a79aSAlan Cox if (dev->xfer_shift == ATA_SHIFT_PIO && !ata_id_has_iordy(dev->id) && 28840bc2a79aSAlan Cox dev->pio_mode <= XFER_PIO_2) 28850bc2a79aSAlan Cox err_mask &= ~AC_ERR_DEV; 2886c6fd2807SJeff Garzik if (err_mask) { 2887c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_ERR, "failed to set xfermode " 2888c6fd2807SJeff Garzik "(err_mask=0x%x)\n", err_mask); 2889c6fd2807SJeff Garzik return -EIO; 2890c6fd2807SJeff Garzik } 2891c6fd2807SJeff Garzik 2892baa1e78aSTejun Heo ehc->i.flags |= ATA_EHI_POST_SETMODE; 2893422c9daaSTejun Heo rc = ata_dev_revalidate(dev, ATA_DEV_UNKNOWN, 0); 2894baa1e78aSTejun Heo ehc->i.flags &= ~ATA_EHI_POST_SETMODE; 2895c6fd2807SJeff Garzik if (rc) 2896c6fd2807SJeff Garzik return rc; 2897c6fd2807SJeff Garzik 2898c6fd2807SJeff Garzik DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n", 2899c6fd2807SJeff Garzik dev->xfer_shift, (int)dev->xfer_mode); 2900c6fd2807SJeff Garzik 2901c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "configured for %s\n", 2902c6fd2807SJeff Garzik ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode))); 2903c6fd2807SJeff Garzik return 0; 2904c6fd2807SJeff Garzik } 2905c6fd2807SJeff Garzik 2906c6fd2807SJeff Garzik /** 290704351821SAlan * ata_do_set_mode - Program timings and issue SET FEATURES - XFER 29080260731fSTejun Heo * @link: link on which timings will be programmed 2909c6fd2807SJeff Garzik * @r_failed_dev: out paramter for failed device 2910c6fd2807SJeff Garzik * 291104351821SAlan * Standard implementation of the function used to tune and set 291204351821SAlan * ATA device disk transfer mode (PIO3, UDMA6, etc.). If 291304351821SAlan * ata_dev_set_mode() fails, pointer to the failing device is 2914c6fd2807SJeff Garzik * returned in @r_failed_dev. 2915c6fd2807SJeff Garzik * 2916c6fd2807SJeff Garzik * LOCKING: 2917c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 2918c6fd2807SJeff Garzik * 2919c6fd2807SJeff Garzik * RETURNS: 2920c6fd2807SJeff Garzik * 0 on success, negative errno otherwise 2921c6fd2807SJeff Garzik */ 292204351821SAlan 29230260731fSTejun Heo int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev) 2924c6fd2807SJeff Garzik { 29250260731fSTejun Heo struct ata_port *ap = link->ap; 2926c6fd2807SJeff Garzik struct ata_device *dev; 2927f58229f8STejun Heo int rc = 0, used_dma = 0, found = 0; 2928c6fd2807SJeff Garzik 2929c6fd2807SJeff Garzik /* step 1: calculate xfer_mask */ 2930f58229f8STejun Heo ata_link_for_each_dev(dev, link) { 2931c6fd2807SJeff Garzik unsigned int pio_mask, dma_mask; 2932b3a70601SAlan Cox unsigned int mode_mask; 2933c6fd2807SJeff Garzik 2934c6fd2807SJeff Garzik if (!ata_dev_enabled(dev)) 2935c6fd2807SJeff Garzik continue; 2936c6fd2807SJeff Garzik 2937b3a70601SAlan Cox mode_mask = ATA_DMA_MASK_ATA; 2938b3a70601SAlan Cox if (dev->class == ATA_DEV_ATAPI) 2939b3a70601SAlan Cox mode_mask = ATA_DMA_MASK_ATAPI; 2940b3a70601SAlan Cox else if (ata_id_is_cfa(dev->id)) 2941b3a70601SAlan Cox mode_mask = ATA_DMA_MASK_CFA; 2942b3a70601SAlan Cox 2943c6fd2807SJeff Garzik ata_dev_xfermask(dev); 2944c6fd2807SJeff Garzik 2945c6fd2807SJeff Garzik pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0); 2946c6fd2807SJeff Garzik dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask); 2947b3a70601SAlan Cox 2948b3a70601SAlan Cox if (libata_dma_mask & mode_mask) 2949b3a70601SAlan Cox dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask); 2950b3a70601SAlan Cox else 2951b3a70601SAlan Cox dma_mask = 0; 2952b3a70601SAlan Cox 2953c6fd2807SJeff Garzik dev->pio_mode = ata_xfer_mask2mode(pio_mask); 2954c6fd2807SJeff Garzik dev->dma_mode = ata_xfer_mask2mode(dma_mask); 2955c6fd2807SJeff Garzik 2956c6fd2807SJeff Garzik found = 1; 2957c6fd2807SJeff Garzik if (dev->dma_mode) 2958c6fd2807SJeff Garzik used_dma = 1; 2959c6fd2807SJeff Garzik } 2960c6fd2807SJeff Garzik if (!found) 2961c6fd2807SJeff Garzik goto out; 2962c6fd2807SJeff Garzik 2963c6fd2807SJeff Garzik /* step 2: always set host PIO timings */ 2964f58229f8STejun Heo ata_link_for_each_dev(dev, link) { 2965c6fd2807SJeff Garzik if (!ata_dev_enabled(dev)) 2966c6fd2807SJeff Garzik continue; 2967c6fd2807SJeff Garzik 2968c6fd2807SJeff Garzik if (!dev->pio_mode) { 2969c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "no PIO support\n"); 2970c6fd2807SJeff Garzik rc = -EINVAL; 2971c6fd2807SJeff Garzik goto out; 2972c6fd2807SJeff Garzik } 2973c6fd2807SJeff Garzik 2974c6fd2807SJeff Garzik dev->xfer_mode = dev->pio_mode; 2975c6fd2807SJeff Garzik dev->xfer_shift = ATA_SHIFT_PIO; 2976c6fd2807SJeff Garzik if (ap->ops->set_piomode) 2977c6fd2807SJeff Garzik ap->ops->set_piomode(ap, dev); 2978c6fd2807SJeff Garzik } 2979c6fd2807SJeff Garzik 2980c6fd2807SJeff Garzik /* step 3: set host DMA timings */ 2981f58229f8STejun Heo ata_link_for_each_dev(dev, link) { 2982c6fd2807SJeff Garzik if (!ata_dev_enabled(dev) || !dev->dma_mode) 2983c6fd2807SJeff Garzik continue; 2984c6fd2807SJeff Garzik 2985c6fd2807SJeff Garzik dev->xfer_mode = dev->dma_mode; 2986c6fd2807SJeff Garzik dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode); 2987c6fd2807SJeff Garzik if (ap->ops->set_dmamode) 2988c6fd2807SJeff Garzik ap->ops->set_dmamode(ap, dev); 2989c6fd2807SJeff Garzik } 2990c6fd2807SJeff Garzik 2991c6fd2807SJeff Garzik /* step 4: update devices' xfer mode */ 2992f58229f8STejun Heo ata_link_for_each_dev(dev, link) { 299318d90debSAlan /* don't update suspended devices' xfer mode */ 29949666f400STejun Heo if (!ata_dev_enabled(dev)) 2995c6fd2807SJeff Garzik continue; 2996c6fd2807SJeff Garzik 2997c6fd2807SJeff Garzik rc = ata_dev_set_mode(dev); 2998c6fd2807SJeff Garzik if (rc) 2999c6fd2807SJeff Garzik goto out; 3000c6fd2807SJeff Garzik } 3001c6fd2807SJeff Garzik 3002c6fd2807SJeff Garzik /* Record simplex status. If we selected DMA then the other 3003c6fd2807SJeff Garzik * host channels are not permitted to do so. 3004c6fd2807SJeff Garzik */ 3005cca3974eSJeff Garzik if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX)) 3006032af1ceSAlan ap->host->simplex_claimed = ap; 3007c6fd2807SJeff Garzik 3008c6fd2807SJeff Garzik out: 3009c6fd2807SJeff Garzik if (rc) 3010c6fd2807SJeff Garzik *r_failed_dev = dev; 3011c6fd2807SJeff Garzik return rc; 3012c6fd2807SJeff Garzik } 3013c6fd2807SJeff Garzik 3014c6fd2807SJeff Garzik /** 301504351821SAlan * ata_set_mode - Program timings and issue SET FEATURES - XFER 30160260731fSTejun Heo * @link: link on which timings will be programmed 301704351821SAlan * @r_failed_dev: out paramter for failed device 301804351821SAlan * 301904351821SAlan * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If 302004351821SAlan * ata_set_mode() fails, pointer to the failing device is 302104351821SAlan * returned in @r_failed_dev. 302204351821SAlan * 302304351821SAlan * LOCKING: 302404351821SAlan * PCI/etc. bus probe sem. 302504351821SAlan * 302604351821SAlan * RETURNS: 302704351821SAlan * 0 on success, negative errno otherwise 302804351821SAlan */ 30290260731fSTejun Heo int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev) 303004351821SAlan { 30310260731fSTejun Heo struct ata_port *ap = link->ap; 30320260731fSTejun Heo 303304351821SAlan /* has private set_mode? */ 303404351821SAlan if (ap->ops->set_mode) 30350260731fSTejun Heo return ap->ops->set_mode(link, r_failed_dev); 30360260731fSTejun Heo return ata_do_set_mode(link, r_failed_dev); 303704351821SAlan } 303804351821SAlan 303904351821SAlan /** 3040c6fd2807SJeff Garzik * ata_tf_to_host - issue ATA taskfile to host controller 3041c6fd2807SJeff Garzik * @ap: port to which command is being issued 3042c6fd2807SJeff Garzik * @tf: ATA taskfile register set 3043c6fd2807SJeff Garzik * 3044c6fd2807SJeff Garzik * Issues ATA taskfile register set to ATA host controller, 3045c6fd2807SJeff Garzik * with proper synchronization with interrupt handler and 3046c6fd2807SJeff Garzik * other threads. 3047c6fd2807SJeff Garzik * 3048c6fd2807SJeff Garzik * LOCKING: 3049cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 3050c6fd2807SJeff Garzik */ 3051c6fd2807SJeff Garzik 3052c6fd2807SJeff Garzik static inline void ata_tf_to_host(struct ata_port *ap, 3053c6fd2807SJeff Garzik const struct ata_taskfile *tf) 3054c6fd2807SJeff Garzik { 3055c6fd2807SJeff Garzik ap->ops->tf_load(ap, tf); 3056c6fd2807SJeff Garzik ap->ops->exec_command(ap, tf); 3057c6fd2807SJeff Garzik } 3058c6fd2807SJeff Garzik 3059c6fd2807SJeff Garzik /** 3060c6fd2807SJeff Garzik * ata_busy_sleep - sleep until BSY clears, or timeout 3061c6fd2807SJeff Garzik * @ap: port containing status register to be polled 3062c6fd2807SJeff Garzik * @tmout_pat: impatience timeout 3063c6fd2807SJeff Garzik * @tmout: overall timeout 3064c6fd2807SJeff Garzik * 3065c6fd2807SJeff Garzik * Sleep until ATA Status register bit BSY clears, 3066c6fd2807SJeff Garzik * or a timeout occurs. 3067c6fd2807SJeff Garzik * 3068d1adc1bbSTejun Heo * LOCKING: 3069d1adc1bbSTejun Heo * Kernel thread context (may sleep). 3070d1adc1bbSTejun Heo * 3071d1adc1bbSTejun Heo * RETURNS: 3072d1adc1bbSTejun Heo * 0 on success, -errno otherwise. 3073c6fd2807SJeff Garzik */ 3074d1adc1bbSTejun Heo int ata_busy_sleep(struct ata_port *ap, 3075c6fd2807SJeff Garzik unsigned long tmout_pat, unsigned long tmout) 3076c6fd2807SJeff Garzik { 3077c6fd2807SJeff Garzik unsigned long timer_start, timeout; 3078c6fd2807SJeff Garzik u8 status; 3079c6fd2807SJeff Garzik 3080c6fd2807SJeff Garzik status = ata_busy_wait(ap, ATA_BUSY, 300); 3081c6fd2807SJeff Garzik timer_start = jiffies; 3082c6fd2807SJeff Garzik timeout = timer_start + tmout_pat; 3083d1adc1bbSTejun Heo while (status != 0xff && (status & ATA_BUSY) && 3084d1adc1bbSTejun Heo time_before(jiffies, timeout)) { 3085c6fd2807SJeff Garzik msleep(50); 3086c6fd2807SJeff Garzik status = ata_busy_wait(ap, ATA_BUSY, 3); 3087c6fd2807SJeff Garzik } 3088c6fd2807SJeff Garzik 3089d1adc1bbSTejun Heo if (status != 0xff && (status & ATA_BUSY)) 3090c6fd2807SJeff Garzik ata_port_printk(ap, KERN_WARNING, 309135aa7a43SJeff Garzik "port is slow to respond, please be patient " 309235aa7a43SJeff Garzik "(Status 0x%x)\n", status); 3093c6fd2807SJeff Garzik 3094c6fd2807SJeff Garzik timeout = timer_start + tmout; 3095d1adc1bbSTejun Heo while (status != 0xff && (status & ATA_BUSY) && 3096d1adc1bbSTejun Heo time_before(jiffies, timeout)) { 3097c6fd2807SJeff Garzik msleep(50); 3098c6fd2807SJeff Garzik status = ata_chk_status(ap); 3099c6fd2807SJeff Garzik } 3100c6fd2807SJeff Garzik 3101d1adc1bbSTejun Heo if (status == 0xff) 3102d1adc1bbSTejun Heo return -ENODEV; 3103d1adc1bbSTejun Heo 3104c6fd2807SJeff Garzik if (status & ATA_BUSY) { 3105c6fd2807SJeff Garzik ata_port_printk(ap, KERN_ERR, "port failed to respond " 310635aa7a43SJeff Garzik "(%lu secs, Status 0x%x)\n", 310735aa7a43SJeff Garzik tmout / HZ, status); 3108d1adc1bbSTejun Heo return -EBUSY; 3109c6fd2807SJeff Garzik } 3110c6fd2807SJeff Garzik 3111c6fd2807SJeff Garzik return 0; 3112c6fd2807SJeff Garzik } 3113c6fd2807SJeff Garzik 3114d4b2bab4STejun Heo /** 3115d4b2bab4STejun Heo * ata_wait_ready - sleep until BSY clears, or timeout 3116d4b2bab4STejun Heo * @ap: port containing status register to be polled 3117d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3118d4b2bab4STejun Heo * 3119d4b2bab4STejun Heo * Sleep until ATA Status register bit BSY clears, or timeout 3120d4b2bab4STejun Heo * occurs. 3121d4b2bab4STejun Heo * 3122d4b2bab4STejun Heo * LOCKING: 3123d4b2bab4STejun Heo * Kernel thread context (may sleep). 3124d4b2bab4STejun Heo * 3125d4b2bab4STejun Heo * RETURNS: 3126d4b2bab4STejun Heo * 0 on success, -errno otherwise. 3127d4b2bab4STejun Heo */ 3128d4b2bab4STejun Heo int ata_wait_ready(struct ata_port *ap, unsigned long deadline) 3129d4b2bab4STejun Heo { 3130d4b2bab4STejun Heo unsigned long start = jiffies; 3131d4b2bab4STejun Heo int warned = 0; 3132d4b2bab4STejun Heo 3133d4b2bab4STejun Heo while (1) { 3134d4b2bab4STejun Heo u8 status = ata_chk_status(ap); 3135d4b2bab4STejun Heo unsigned long now = jiffies; 3136d4b2bab4STejun Heo 3137d4b2bab4STejun Heo if (!(status & ATA_BUSY)) 3138d4b2bab4STejun Heo return 0; 3139936fd732STejun Heo if (!ata_link_online(&ap->link) && status == 0xff) 3140d4b2bab4STejun Heo return -ENODEV; 3141d4b2bab4STejun Heo if (time_after(now, deadline)) 3142d4b2bab4STejun Heo return -EBUSY; 3143d4b2bab4STejun Heo 3144d4b2bab4STejun Heo if (!warned && time_after(now, start + 5 * HZ) && 3145d4b2bab4STejun Heo (deadline - now > 3 * HZ)) { 3146d4b2bab4STejun Heo ata_port_printk(ap, KERN_WARNING, 3147d4b2bab4STejun Heo "port is slow to respond, please be patient " 3148d4b2bab4STejun Heo "(Status 0x%x)\n", status); 3149d4b2bab4STejun Heo warned = 1; 3150d4b2bab4STejun Heo } 3151d4b2bab4STejun Heo 3152d4b2bab4STejun Heo msleep(50); 3153d4b2bab4STejun Heo } 3154d4b2bab4STejun Heo } 3155d4b2bab4STejun Heo 3156d4b2bab4STejun Heo static int ata_bus_post_reset(struct ata_port *ap, unsigned int devmask, 3157d4b2bab4STejun Heo unsigned long deadline) 3158c6fd2807SJeff Garzik { 3159c6fd2807SJeff Garzik struct ata_ioports *ioaddr = &ap->ioaddr; 3160c6fd2807SJeff Garzik unsigned int dev0 = devmask & (1 << 0); 3161c6fd2807SJeff Garzik unsigned int dev1 = devmask & (1 << 1); 31629b89391cSTejun Heo int rc, ret = 0; 3163c6fd2807SJeff Garzik 3164c6fd2807SJeff Garzik /* if device 0 was found in ata_devchk, wait for its 3165c6fd2807SJeff Garzik * BSY bit to clear 3166c6fd2807SJeff Garzik */ 3167d4b2bab4STejun Heo if (dev0) { 3168d4b2bab4STejun Heo rc = ata_wait_ready(ap, deadline); 31699b89391cSTejun Heo if (rc) { 31709b89391cSTejun Heo if (rc != -ENODEV) 3171d4b2bab4STejun Heo return rc; 31729b89391cSTejun Heo ret = rc; 31739b89391cSTejun Heo } 3174d4b2bab4STejun Heo } 3175c6fd2807SJeff Garzik 3176e141d999STejun Heo /* if device 1 was found in ata_devchk, wait for register 3177e141d999STejun Heo * access briefly, then wait for BSY to clear. 3178c6fd2807SJeff Garzik */ 3179e141d999STejun Heo if (dev1) { 3180e141d999STejun Heo int i; 3181c6fd2807SJeff Garzik 3182c6fd2807SJeff Garzik ap->ops->dev_select(ap, 1); 3183e141d999STejun Heo 3184e141d999STejun Heo /* Wait for register access. Some ATAPI devices fail 3185e141d999STejun Heo * to set nsect/lbal after reset, so don't waste too 3186e141d999STejun Heo * much time on it. We're gonna wait for !BSY anyway. 3187e141d999STejun Heo */ 3188e141d999STejun Heo for (i = 0; i < 2; i++) { 3189e141d999STejun Heo u8 nsect, lbal; 3190e141d999STejun Heo 31910d5ff566STejun Heo nsect = ioread8(ioaddr->nsect_addr); 31920d5ff566STejun Heo lbal = ioread8(ioaddr->lbal_addr); 3193c6fd2807SJeff Garzik if ((nsect == 1) && (lbal == 1)) 3194c6fd2807SJeff Garzik break; 3195c6fd2807SJeff Garzik msleep(50); /* give drive a breather */ 3196c6fd2807SJeff Garzik } 3197e141d999STejun Heo 3198d4b2bab4STejun Heo rc = ata_wait_ready(ap, deadline); 31999b89391cSTejun Heo if (rc) { 32009b89391cSTejun Heo if (rc != -ENODEV) 3201d4b2bab4STejun Heo return rc; 32029b89391cSTejun Heo ret = rc; 32039b89391cSTejun Heo } 3204d4b2bab4STejun Heo } 3205c6fd2807SJeff Garzik 3206c6fd2807SJeff Garzik /* is all this really necessary? */ 3207c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 3208c6fd2807SJeff Garzik if (dev1) 3209c6fd2807SJeff Garzik ap->ops->dev_select(ap, 1); 3210c6fd2807SJeff Garzik if (dev0) 3211c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 3212d4b2bab4STejun Heo 32139b89391cSTejun Heo return ret; 3214c6fd2807SJeff Garzik } 3215c6fd2807SJeff Garzik 3216d4b2bab4STejun Heo static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask, 3217d4b2bab4STejun Heo unsigned long deadline) 3218c6fd2807SJeff Garzik { 3219c6fd2807SJeff Garzik struct ata_ioports *ioaddr = &ap->ioaddr; 3220681c80b5SAlan Cox struct ata_device *dev; 3221681c80b5SAlan Cox int i = 0; 3222c6fd2807SJeff Garzik 322344877b4eSTejun Heo DPRINTK("ata%u: bus reset via SRST\n", ap->print_id); 3224c6fd2807SJeff Garzik 3225c6fd2807SJeff Garzik /* software reset. causes dev0 to be selected */ 32260d5ff566STejun Heo iowrite8(ap->ctl, ioaddr->ctl_addr); 3227c6fd2807SJeff Garzik udelay(20); /* FIXME: flush */ 32280d5ff566STejun Heo iowrite8(ap->ctl | ATA_SRST, ioaddr->ctl_addr); 3229c6fd2807SJeff Garzik udelay(20); /* FIXME: flush */ 32300d5ff566STejun Heo iowrite8(ap->ctl, ioaddr->ctl_addr); 3231c6fd2807SJeff Garzik 3232681c80b5SAlan Cox /* If we issued an SRST then an ATA drive (not ATAPI) 3233681c80b5SAlan Cox * may have changed configuration and be in PIO0 timing. If 3234681c80b5SAlan Cox * we did a hard reset (or are coming from power on) this is 3235681c80b5SAlan Cox * true for ATA or ATAPI. Until we've set a suitable controller 3236681c80b5SAlan Cox * mode we should not touch the bus as we may be talking too fast. 3237681c80b5SAlan Cox */ 3238681c80b5SAlan Cox 3239681c80b5SAlan Cox ata_link_for_each_dev(dev, &ap->link) 3240681c80b5SAlan Cox dev->pio_mode = XFER_PIO_0; 3241681c80b5SAlan Cox 3242681c80b5SAlan Cox /* If the controller has a pio mode setup function then use 3243681c80b5SAlan Cox it to set the chipset to rights. Don't touch the DMA setup 3244681c80b5SAlan Cox as that will be dealt with when revalidating */ 3245681c80b5SAlan Cox if (ap->ops->set_piomode) { 3246681c80b5SAlan Cox ata_link_for_each_dev(dev, &ap->link) 3247681c80b5SAlan Cox if (devmask & (1 << i++)) 3248681c80b5SAlan Cox ap->ops->set_piomode(ap, dev); 3249681c80b5SAlan Cox } 3250681c80b5SAlan Cox 3251c6fd2807SJeff Garzik /* spec mandates ">= 2ms" before checking status. 3252c6fd2807SJeff Garzik * We wait 150ms, because that was the magic delay used for 3253c6fd2807SJeff Garzik * ATAPI devices in Hale Landis's ATADRVR, for the period of time 3254c6fd2807SJeff Garzik * between when the ATA command register is written, and then 3255c6fd2807SJeff Garzik * status is checked. Because waiting for "a while" before 3256c6fd2807SJeff Garzik * checking status is fine, post SRST, we perform this magic 3257c6fd2807SJeff Garzik * delay here as well. 3258c6fd2807SJeff Garzik * 3259c6fd2807SJeff Garzik * Old drivers/ide uses the 2mS rule and then waits for ready 3260c6fd2807SJeff Garzik */ 3261c6fd2807SJeff Garzik msleep(150); 3262c6fd2807SJeff Garzik 3263c6fd2807SJeff Garzik /* Before we perform post reset processing we want to see if 3264c6fd2807SJeff Garzik * the bus shows 0xFF because the odd clown forgets the D7 3265c6fd2807SJeff Garzik * pulldown resistor. 3266c6fd2807SJeff Garzik */ 3267d1adc1bbSTejun Heo if (ata_check_status(ap) == 0xFF) 32689b89391cSTejun Heo return -ENODEV; 3269c6fd2807SJeff Garzik 3270d4b2bab4STejun Heo return ata_bus_post_reset(ap, devmask, deadline); 3271c6fd2807SJeff Garzik } 3272c6fd2807SJeff Garzik 3273c6fd2807SJeff Garzik /** 3274c6fd2807SJeff Garzik * ata_bus_reset - reset host port and associated ATA channel 3275c6fd2807SJeff Garzik * @ap: port to reset 3276c6fd2807SJeff Garzik * 3277c6fd2807SJeff Garzik * This is typically the first time we actually start issuing 3278c6fd2807SJeff Garzik * commands to the ATA channel. We wait for BSY to clear, then 3279c6fd2807SJeff Garzik * issue EXECUTE DEVICE DIAGNOSTIC command, polling for its 3280c6fd2807SJeff Garzik * result. Determine what devices, if any, are on the channel 3281c6fd2807SJeff Garzik * by looking at the device 0/1 error register. Look at the signature 3282c6fd2807SJeff Garzik * stored in each device's taskfile registers, to determine if 3283c6fd2807SJeff Garzik * the device is ATA or ATAPI. 3284c6fd2807SJeff Garzik * 3285c6fd2807SJeff Garzik * LOCKING: 3286c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 3287cca3974eSJeff Garzik * Obtains host lock. 3288c6fd2807SJeff Garzik * 3289c6fd2807SJeff Garzik * SIDE EFFECTS: 3290c6fd2807SJeff Garzik * Sets ATA_FLAG_DISABLED if bus reset fails. 3291c6fd2807SJeff Garzik */ 3292c6fd2807SJeff Garzik 3293c6fd2807SJeff Garzik void ata_bus_reset(struct ata_port *ap) 3294c6fd2807SJeff Garzik { 32959af5c9c9STejun Heo struct ata_device *device = ap->link.device; 3296c6fd2807SJeff Garzik struct ata_ioports *ioaddr = &ap->ioaddr; 3297c6fd2807SJeff Garzik unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS; 3298c6fd2807SJeff Garzik u8 err; 3299c6fd2807SJeff Garzik unsigned int dev0, dev1 = 0, devmask = 0; 33009b89391cSTejun Heo int rc; 3301c6fd2807SJeff Garzik 330244877b4eSTejun Heo DPRINTK("ENTER, host %u, port %u\n", ap->print_id, ap->port_no); 3303c6fd2807SJeff Garzik 3304c6fd2807SJeff Garzik /* determine if device 0/1 are present */ 3305c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_SATA_RESET) 3306c6fd2807SJeff Garzik dev0 = 1; 3307c6fd2807SJeff Garzik else { 3308c6fd2807SJeff Garzik dev0 = ata_devchk(ap, 0); 3309c6fd2807SJeff Garzik if (slave_possible) 3310c6fd2807SJeff Garzik dev1 = ata_devchk(ap, 1); 3311c6fd2807SJeff Garzik } 3312c6fd2807SJeff Garzik 3313c6fd2807SJeff Garzik if (dev0) 3314c6fd2807SJeff Garzik devmask |= (1 << 0); 3315c6fd2807SJeff Garzik if (dev1) 3316c6fd2807SJeff Garzik devmask |= (1 << 1); 3317c6fd2807SJeff Garzik 3318c6fd2807SJeff Garzik /* select device 0 again */ 3319c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 3320c6fd2807SJeff Garzik 3321c6fd2807SJeff Garzik /* issue bus reset */ 33229b89391cSTejun Heo if (ap->flags & ATA_FLAG_SRST) { 33239b89391cSTejun Heo rc = ata_bus_softreset(ap, devmask, jiffies + 40 * HZ); 33249b89391cSTejun Heo if (rc && rc != -ENODEV) 3325c6fd2807SJeff Garzik goto err_out; 33269b89391cSTejun Heo } 3327c6fd2807SJeff Garzik 3328c6fd2807SJeff Garzik /* 3329c6fd2807SJeff Garzik * determine by signature whether we have ATA or ATAPI devices 3330c6fd2807SJeff Garzik */ 33313f19859eSTejun Heo device[0].class = ata_dev_try_classify(&device[0], dev0, &err); 3332c6fd2807SJeff Garzik if ((slave_possible) && (err != 0x81)) 33333f19859eSTejun Heo device[1].class = ata_dev_try_classify(&device[1], dev1, &err); 3334c6fd2807SJeff Garzik 3335c6fd2807SJeff Garzik /* is double-select really necessary? */ 33369af5c9c9STejun Heo if (device[1].class != ATA_DEV_NONE) 3337c6fd2807SJeff Garzik ap->ops->dev_select(ap, 1); 33389af5c9c9STejun Heo if (device[0].class != ATA_DEV_NONE) 3339c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 3340c6fd2807SJeff Garzik 3341c6fd2807SJeff Garzik /* if no devices were detected, disable this port */ 33429af5c9c9STejun Heo if ((device[0].class == ATA_DEV_NONE) && 33439af5c9c9STejun Heo (device[1].class == ATA_DEV_NONE)) 3344c6fd2807SJeff Garzik goto err_out; 3345c6fd2807SJeff Garzik 3346c6fd2807SJeff Garzik if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) { 3347c6fd2807SJeff Garzik /* set up device control for ATA_FLAG_SATA_RESET */ 33480d5ff566STejun Heo iowrite8(ap->ctl, ioaddr->ctl_addr); 3349c6fd2807SJeff Garzik } 3350c6fd2807SJeff Garzik 3351c6fd2807SJeff Garzik DPRINTK("EXIT\n"); 3352c6fd2807SJeff Garzik return; 3353c6fd2807SJeff Garzik 3354c6fd2807SJeff Garzik err_out: 3355c6fd2807SJeff Garzik ata_port_printk(ap, KERN_ERR, "disabling port\n"); 3356ac8869d5SJeff Garzik ata_port_disable(ap); 3357c6fd2807SJeff Garzik 3358c6fd2807SJeff Garzik DPRINTK("EXIT\n"); 3359c6fd2807SJeff Garzik } 3360c6fd2807SJeff Garzik 3361c6fd2807SJeff Garzik /** 3362936fd732STejun Heo * sata_link_debounce - debounce SATA phy status 3363936fd732STejun Heo * @link: ATA link to debounce SATA phy status for 3364c6fd2807SJeff Garzik * @params: timing parameters { interval, duratinon, timeout } in msec 3365d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3366c6fd2807SJeff Garzik * 3367936fd732STejun Heo * Make sure SStatus of @link reaches stable state, determined by 3368c6fd2807SJeff Garzik * holding the same value where DET is not 1 for @duration polled 3369c6fd2807SJeff Garzik * every @interval, before @timeout. Timeout constraints the 3370d4b2bab4STejun Heo * beginning of the stable state. Because DET gets stuck at 1 on 3371d4b2bab4STejun Heo * some controllers after hot unplugging, this functions waits 3372c6fd2807SJeff Garzik * until timeout then returns 0 if DET is stable at 1. 3373c6fd2807SJeff Garzik * 3374d4b2bab4STejun Heo * @timeout is further limited by @deadline. The sooner of the 3375d4b2bab4STejun Heo * two is used. 3376d4b2bab4STejun Heo * 3377c6fd2807SJeff Garzik * LOCKING: 3378c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3379c6fd2807SJeff Garzik * 3380c6fd2807SJeff Garzik * RETURNS: 3381c6fd2807SJeff Garzik * 0 on success, -errno on failure. 3382c6fd2807SJeff Garzik */ 3383936fd732STejun Heo int sata_link_debounce(struct ata_link *link, const unsigned long *params, 3384d4b2bab4STejun Heo unsigned long deadline) 3385c6fd2807SJeff Garzik { 3386c6fd2807SJeff Garzik unsigned long interval_msec = params[0]; 3387d4b2bab4STejun Heo unsigned long duration = msecs_to_jiffies(params[1]); 3388d4b2bab4STejun Heo unsigned long last_jiffies, t; 3389c6fd2807SJeff Garzik u32 last, cur; 3390c6fd2807SJeff Garzik int rc; 3391c6fd2807SJeff Garzik 3392d4b2bab4STejun Heo t = jiffies + msecs_to_jiffies(params[2]); 3393d4b2bab4STejun Heo if (time_before(t, deadline)) 3394d4b2bab4STejun Heo deadline = t; 3395d4b2bab4STejun Heo 3396936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_STATUS, &cur))) 3397c6fd2807SJeff Garzik return rc; 3398c6fd2807SJeff Garzik cur &= 0xf; 3399c6fd2807SJeff Garzik 3400c6fd2807SJeff Garzik last = cur; 3401c6fd2807SJeff Garzik last_jiffies = jiffies; 3402c6fd2807SJeff Garzik 3403c6fd2807SJeff Garzik while (1) { 3404c6fd2807SJeff Garzik msleep(interval_msec); 3405936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_STATUS, &cur))) 3406c6fd2807SJeff Garzik return rc; 3407c6fd2807SJeff Garzik cur &= 0xf; 3408c6fd2807SJeff Garzik 3409c6fd2807SJeff Garzik /* DET stable? */ 3410c6fd2807SJeff Garzik if (cur == last) { 3411d4b2bab4STejun Heo if (cur == 1 && time_before(jiffies, deadline)) 3412c6fd2807SJeff Garzik continue; 3413c6fd2807SJeff Garzik if (time_after(jiffies, last_jiffies + duration)) 3414c6fd2807SJeff Garzik return 0; 3415c6fd2807SJeff Garzik continue; 3416c6fd2807SJeff Garzik } 3417c6fd2807SJeff Garzik 3418c6fd2807SJeff Garzik /* unstable, start over */ 3419c6fd2807SJeff Garzik last = cur; 3420c6fd2807SJeff Garzik last_jiffies = jiffies; 3421c6fd2807SJeff Garzik 3422f1545154STejun Heo /* Check deadline. If debouncing failed, return 3423f1545154STejun Heo * -EPIPE to tell upper layer to lower link speed. 3424f1545154STejun Heo */ 3425d4b2bab4STejun Heo if (time_after(jiffies, deadline)) 3426f1545154STejun Heo return -EPIPE; 3427c6fd2807SJeff Garzik } 3428c6fd2807SJeff Garzik } 3429c6fd2807SJeff Garzik 3430c6fd2807SJeff Garzik /** 3431936fd732STejun Heo * sata_link_resume - resume SATA link 3432936fd732STejun Heo * @link: ATA link to resume SATA 3433c6fd2807SJeff Garzik * @params: timing parameters { interval, duratinon, timeout } in msec 3434d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3435c6fd2807SJeff Garzik * 3436936fd732STejun Heo * Resume SATA phy @link and debounce it. 3437c6fd2807SJeff Garzik * 3438c6fd2807SJeff Garzik * LOCKING: 3439c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3440c6fd2807SJeff Garzik * 3441c6fd2807SJeff Garzik * RETURNS: 3442c6fd2807SJeff Garzik * 0 on success, -errno on failure. 3443c6fd2807SJeff Garzik */ 3444936fd732STejun Heo int sata_link_resume(struct ata_link *link, const unsigned long *params, 3445d4b2bab4STejun Heo unsigned long deadline) 3446c6fd2807SJeff Garzik { 3447c6fd2807SJeff Garzik u32 scontrol; 3448c6fd2807SJeff Garzik int rc; 3449c6fd2807SJeff Garzik 3450936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 3451c6fd2807SJeff Garzik return rc; 3452c6fd2807SJeff Garzik 3453c6fd2807SJeff Garzik scontrol = (scontrol & 0x0f0) | 0x300; 3454c6fd2807SJeff Garzik 3455936fd732STejun Heo if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol))) 3456c6fd2807SJeff Garzik return rc; 3457c6fd2807SJeff Garzik 3458c6fd2807SJeff Garzik /* Some PHYs react badly if SStatus is pounded immediately 3459c6fd2807SJeff Garzik * after resuming. Delay 200ms before debouncing. 3460c6fd2807SJeff Garzik */ 3461c6fd2807SJeff Garzik msleep(200); 3462c6fd2807SJeff Garzik 3463936fd732STejun Heo return sata_link_debounce(link, params, deadline); 3464c6fd2807SJeff Garzik } 3465c6fd2807SJeff Garzik 3466c6fd2807SJeff Garzik /** 3467c6fd2807SJeff Garzik * ata_std_prereset - prepare for reset 3468cc0680a5STejun Heo * @link: ATA link to be reset 3469d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3470c6fd2807SJeff Garzik * 3471cc0680a5STejun Heo * @link is about to be reset. Initialize it. Failure from 3472b8cffc6aSTejun Heo * prereset makes libata abort whole reset sequence and give up 3473b8cffc6aSTejun Heo * that port, so prereset should be best-effort. It does its 3474b8cffc6aSTejun Heo * best to prepare for reset sequence but if things go wrong, it 3475b8cffc6aSTejun Heo * should just whine, not fail. 3476c6fd2807SJeff Garzik * 3477c6fd2807SJeff Garzik * LOCKING: 3478c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3479c6fd2807SJeff Garzik * 3480c6fd2807SJeff Garzik * RETURNS: 3481c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 3482c6fd2807SJeff Garzik */ 3483cc0680a5STejun Heo int ata_std_prereset(struct ata_link *link, unsigned long deadline) 3484c6fd2807SJeff Garzik { 3485cc0680a5STejun Heo struct ata_port *ap = link->ap; 3486936fd732STejun Heo struct ata_eh_context *ehc = &link->eh_context; 3487c6fd2807SJeff Garzik const unsigned long *timing = sata_ehc_deb_timing(ehc); 3488c6fd2807SJeff Garzik int rc; 3489c6fd2807SJeff Garzik 349031daabdaSTejun Heo /* handle link resume */ 3491c6fd2807SJeff Garzik if ((ehc->i.flags & ATA_EHI_RESUME_LINK) && 34920c88758bSTejun Heo (link->flags & ATA_LFLAG_HRST_TO_RESUME)) 3493c6fd2807SJeff Garzik ehc->i.action |= ATA_EH_HARDRESET; 3494c6fd2807SJeff Garzik 3495633273a3STejun Heo /* Some PMPs don't work with only SRST, force hardreset if PMP 3496633273a3STejun Heo * is supported. 3497633273a3STejun Heo */ 3498633273a3STejun Heo if (ap->flags & ATA_FLAG_PMP) 3499633273a3STejun Heo ehc->i.action |= ATA_EH_HARDRESET; 3500633273a3STejun Heo 3501c6fd2807SJeff Garzik /* if we're about to do hardreset, nothing more to do */ 3502c6fd2807SJeff Garzik if (ehc->i.action & ATA_EH_HARDRESET) 3503c6fd2807SJeff Garzik return 0; 3504c6fd2807SJeff Garzik 3505936fd732STejun Heo /* if SATA, resume link */ 3506a16abc0bSTejun Heo if (ap->flags & ATA_FLAG_SATA) { 3507936fd732STejun Heo rc = sata_link_resume(link, timing, deadline); 3508b8cffc6aSTejun Heo /* whine about phy resume failure but proceed */ 3509b8cffc6aSTejun Heo if (rc && rc != -EOPNOTSUPP) 3510cc0680a5STejun Heo ata_link_printk(link, KERN_WARNING, "failed to resume " 3511c6fd2807SJeff Garzik "link for reset (errno=%d)\n", rc); 3512c6fd2807SJeff Garzik } 3513c6fd2807SJeff Garzik 3514c6fd2807SJeff Garzik /* Wait for !BSY if the controller can wait for the first D2H 3515c6fd2807SJeff Garzik * Reg FIS and we don't know that no device is attached. 3516c6fd2807SJeff Garzik */ 35170c88758bSTejun Heo if (!(link->flags & ATA_LFLAG_SKIP_D2H_BSY) && !ata_link_offline(link)) { 3518b8cffc6aSTejun Heo rc = ata_wait_ready(ap, deadline); 35196dffaf61STejun Heo if (rc && rc != -ENODEV) { 3520cc0680a5STejun Heo ata_link_printk(link, KERN_WARNING, "device not ready " 3521b8cffc6aSTejun Heo "(errno=%d), forcing hardreset\n", rc); 3522b8cffc6aSTejun Heo ehc->i.action |= ATA_EH_HARDRESET; 3523b8cffc6aSTejun Heo } 3524b8cffc6aSTejun Heo } 3525c6fd2807SJeff Garzik 3526c6fd2807SJeff Garzik return 0; 3527c6fd2807SJeff Garzik } 3528c6fd2807SJeff Garzik 3529c6fd2807SJeff Garzik /** 3530c6fd2807SJeff Garzik * ata_std_softreset - reset host port via ATA SRST 3531cc0680a5STejun Heo * @link: ATA link to reset 3532c6fd2807SJeff Garzik * @classes: resulting classes of attached devices 3533d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3534c6fd2807SJeff Garzik * 3535c6fd2807SJeff Garzik * Reset host port using ATA SRST. 3536c6fd2807SJeff Garzik * 3537c6fd2807SJeff Garzik * LOCKING: 3538c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3539c6fd2807SJeff Garzik * 3540c6fd2807SJeff Garzik * RETURNS: 3541c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 3542c6fd2807SJeff Garzik */ 3543cc0680a5STejun Heo int ata_std_softreset(struct ata_link *link, unsigned int *classes, 3544d4b2bab4STejun Heo unsigned long deadline) 3545c6fd2807SJeff Garzik { 3546cc0680a5STejun Heo struct ata_port *ap = link->ap; 3547c6fd2807SJeff Garzik unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS; 3548d4b2bab4STejun Heo unsigned int devmask = 0; 3549d4b2bab4STejun Heo int rc; 3550c6fd2807SJeff Garzik u8 err; 3551c6fd2807SJeff Garzik 3552c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 3553c6fd2807SJeff Garzik 3554936fd732STejun Heo if (ata_link_offline(link)) { 3555c6fd2807SJeff Garzik classes[0] = ATA_DEV_NONE; 3556c6fd2807SJeff Garzik goto out; 3557c6fd2807SJeff Garzik } 3558c6fd2807SJeff Garzik 3559c6fd2807SJeff Garzik /* determine if device 0/1 are present */ 3560c6fd2807SJeff Garzik if (ata_devchk(ap, 0)) 3561c6fd2807SJeff Garzik devmask |= (1 << 0); 3562c6fd2807SJeff Garzik if (slave_possible && ata_devchk(ap, 1)) 3563c6fd2807SJeff Garzik devmask |= (1 << 1); 3564c6fd2807SJeff Garzik 3565c6fd2807SJeff Garzik /* select device 0 again */ 3566c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 3567c6fd2807SJeff Garzik 3568c6fd2807SJeff Garzik /* issue bus reset */ 3569c6fd2807SJeff Garzik DPRINTK("about to softreset, devmask=%x\n", devmask); 3570d4b2bab4STejun Heo rc = ata_bus_softreset(ap, devmask, deadline); 35719b89391cSTejun Heo /* if link is occupied, -ENODEV too is an error */ 3572936fd732STejun Heo if (rc && (rc != -ENODEV || sata_scr_valid(link))) { 3573cc0680a5STejun Heo ata_link_printk(link, KERN_ERR, "SRST failed (errno=%d)\n", rc); 3574d4b2bab4STejun Heo return rc; 3575c6fd2807SJeff Garzik } 3576c6fd2807SJeff Garzik 3577c6fd2807SJeff Garzik /* determine by signature whether we have ATA or ATAPI devices */ 35783f19859eSTejun Heo classes[0] = ata_dev_try_classify(&link->device[0], 35793f19859eSTejun Heo devmask & (1 << 0), &err); 3580c6fd2807SJeff Garzik if (slave_possible && err != 0x81) 35813f19859eSTejun Heo classes[1] = ata_dev_try_classify(&link->device[1], 35823f19859eSTejun Heo devmask & (1 << 1), &err); 3583c6fd2807SJeff Garzik 3584c6fd2807SJeff Garzik out: 3585c6fd2807SJeff Garzik DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]); 3586c6fd2807SJeff Garzik return 0; 3587c6fd2807SJeff Garzik } 3588c6fd2807SJeff Garzik 3589c6fd2807SJeff Garzik /** 3590cc0680a5STejun Heo * sata_link_hardreset - reset link via SATA phy reset 3591cc0680a5STejun Heo * @link: link to reset 3592b6103f6dSTejun Heo * @timing: timing parameters { interval, duratinon, timeout } in msec 3593d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3594c6fd2807SJeff Garzik * 3595cc0680a5STejun Heo * SATA phy-reset @link using DET bits of SControl register. 3596c6fd2807SJeff Garzik * 3597c6fd2807SJeff Garzik * LOCKING: 3598c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3599c6fd2807SJeff Garzik * 3600c6fd2807SJeff Garzik * RETURNS: 3601c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 3602c6fd2807SJeff Garzik */ 3603cc0680a5STejun Heo int sata_link_hardreset(struct ata_link *link, const unsigned long *timing, 3604d4b2bab4STejun Heo unsigned long deadline) 3605c6fd2807SJeff Garzik { 3606c6fd2807SJeff Garzik u32 scontrol; 3607c6fd2807SJeff Garzik int rc; 3608c6fd2807SJeff Garzik 3609c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 3610c6fd2807SJeff Garzik 3611936fd732STejun Heo if (sata_set_spd_needed(link)) { 3612c6fd2807SJeff Garzik /* SATA spec says nothing about how to reconfigure 3613c6fd2807SJeff Garzik * spd. To be on the safe side, turn off phy during 3614c6fd2807SJeff Garzik * reconfiguration. This works for at least ICH7 AHCI 3615c6fd2807SJeff Garzik * and Sil3124. 3616c6fd2807SJeff Garzik */ 3617936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 3618b6103f6dSTejun Heo goto out; 3619c6fd2807SJeff Garzik 3620cea0d336SJeff Garzik scontrol = (scontrol & 0x0f0) | 0x304; 3621c6fd2807SJeff Garzik 3622936fd732STejun Heo if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol))) 3623b6103f6dSTejun Heo goto out; 3624c6fd2807SJeff Garzik 3625936fd732STejun Heo sata_set_spd(link); 3626c6fd2807SJeff Garzik } 3627c6fd2807SJeff Garzik 3628c6fd2807SJeff Garzik /* issue phy wake/reset */ 3629936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 3630b6103f6dSTejun Heo goto out; 3631c6fd2807SJeff Garzik 3632c6fd2807SJeff Garzik scontrol = (scontrol & 0x0f0) | 0x301; 3633c6fd2807SJeff Garzik 3634936fd732STejun Heo if ((rc = sata_scr_write_flush(link, SCR_CONTROL, scontrol))) 3635b6103f6dSTejun Heo goto out; 3636c6fd2807SJeff Garzik 3637c6fd2807SJeff Garzik /* Couldn't find anything in SATA I/II specs, but AHCI-1.1 3638c6fd2807SJeff Garzik * 10.4.2 says at least 1 ms. 3639c6fd2807SJeff Garzik */ 3640c6fd2807SJeff Garzik msleep(1); 3641c6fd2807SJeff Garzik 3642936fd732STejun Heo /* bring link back */ 3643936fd732STejun Heo rc = sata_link_resume(link, timing, deadline); 3644b6103f6dSTejun Heo out: 3645b6103f6dSTejun Heo DPRINTK("EXIT, rc=%d\n", rc); 3646b6103f6dSTejun Heo return rc; 3647b6103f6dSTejun Heo } 3648b6103f6dSTejun Heo 3649b6103f6dSTejun Heo /** 3650b6103f6dSTejun Heo * sata_std_hardreset - reset host port via SATA phy reset 3651cc0680a5STejun Heo * @link: link to reset 3652b6103f6dSTejun Heo * @class: resulting class of attached device 3653d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3654b6103f6dSTejun Heo * 3655b6103f6dSTejun Heo * SATA phy-reset host port using DET bits of SControl register, 3656b6103f6dSTejun Heo * wait for !BSY and classify the attached device. 3657b6103f6dSTejun Heo * 3658b6103f6dSTejun Heo * LOCKING: 3659b6103f6dSTejun Heo * Kernel thread context (may sleep) 3660b6103f6dSTejun Heo * 3661b6103f6dSTejun Heo * RETURNS: 3662b6103f6dSTejun Heo * 0 on success, -errno otherwise. 3663b6103f6dSTejun Heo */ 3664cc0680a5STejun Heo int sata_std_hardreset(struct ata_link *link, unsigned int *class, 3665d4b2bab4STejun Heo unsigned long deadline) 3666b6103f6dSTejun Heo { 3667cc0680a5STejun Heo struct ata_port *ap = link->ap; 3668936fd732STejun Heo const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context); 3669b6103f6dSTejun Heo int rc; 3670b6103f6dSTejun Heo 3671b6103f6dSTejun Heo DPRINTK("ENTER\n"); 3672b6103f6dSTejun Heo 3673b6103f6dSTejun Heo /* do hardreset */ 3674cc0680a5STejun Heo rc = sata_link_hardreset(link, timing, deadline); 3675b6103f6dSTejun Heo if (rc) { 3676cc0680a5STejun Heo ata_link_printk(link, KERN_ERR, 3677b6103f6dSTejun Heo "COMRESET failed (errno=%d)\n", rc); 3678b6103f6dSTejun Heo return rc; 3679b6103f6dSTejun Heo } 3680c6fd2807SJeff Garzik 3681c6fd2807SJeff Garzik /* TODO: phy layer with polling, timeouts, etc. */ 3682936fd732STejun Heo if (ata_link_offline(link)) { 3683c6fd2807SJeff Garzik *class = ATA_DEV_NONE; 3684c6fd2807SJeff Garzik DPRINTK("EXIT, link offline\n"); 3685c6fd2807SJeff Garzik return 0; 3686c6fd2807SJeff Garzik } 3687c6fd2807SJeff Garzik 368834fee227STejun Heo /* wait a while before checking status, see SRST for more info */ 368934fee227STejun Heo msleep(150); 369034fee227STejun Heo 3691633273a3STejun Heo /* If PMP is supported, we have to do follow-up SRST. Note 3692633273a3STejun Heo * that some PMPs don't send D2H Reg FIS after hardreset at 3693633273a3STejun Heo * all if the first port is empty. Wait for it just for a 3694633273a3STejun Heo * second and request follow-up SRST. 3695633273a3STejun Heo */ 3696633273a3STejun Heo if (ap->flags & ATA_FLAG_PMP) { 3697633273a3STejun Heo ata_wait_ready(ap, jiffies + HZ); 3698633273a3STejun Heo return -EAGAIN; 3699633273a3STejun Heo } 3700633273a3STejun Heo 3701d4b2bab4STejun Heo rc = ata_wait_ready(ap, deadline); 37029b89391cSTejun Heo /* link occupied, -ENODEV too is an error */ 37039b89391cSTejun Heo if (rc) { 3704cc0680a5STejun Heo ata_link_printk(link, KERN_ERR, 3705d4b2bab4STejun Heo "COMRESET failed (errno=%d)\n", rc); 3706d4b2bab4STejun Heo return rc; 3707c6fd2807SJeff Garzik } 3708c6fd2807SJeff Garzik 3709c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); /* probably unnecessary */ 3710c6fd2807SJeff Garzik 37113f19859eSTejun Heo *class = ata_dev_try_classify(link->device, 1, NULL); 3712c6fd2807SJeff Garzik 3713c6fd2807SJeff Garzik DPRINTK("EXIT, class=%u\n", *class); 3714c6fd2807SJeff Garzik return 0; 3715c6fd2807SJeff Garzik } 3716c6fd2807SJeff Garzik 3717c6fd2807SJeff Garzik /** 3718c6fd2807SJeff Garzik * ata_std_postreset - standard postreset callback 3719cc0680a5STejun Heo * @link: the target ata_link 3720c6fd2807SJeff Garzik * @classes: classes of attached devices 3721c6fd2807SJeff Garzik * 3722c6fd2807SJeff Garzik * This function is invoked after a successful reset. Note that 3723c6fd2807SJeff Garzik * the device might have been reset more than once using 3724c6fd2807SJeff Garzik * different reset methods before postreset is invoked. 3725c6fd2807SJeff Garzik * 3726c6fd2807SJeff Garzik * LOCKING: 3727c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3728c6fd2807SJeff Garzik */ 3729cc0680a5STejun Heo void ata_std_postreset(struct ata_link *link, unsigned int *classes) 3730c6fd2807SJeff Garzik { 3731cc0680a5STejun Heo struct ata_port *ap = link->ap; 3732c6fd2807SJeff Garzik u32 serror; 3733c6fd2807SJeff Garzik 3734c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 3735c6fd2807SJeff Garzik 3736c6fd2807SJeff Garzik /* print link status */ 3737936fd732STejun Heo sata_print_link_status(link); 3738c6fd2807SJeff Garzik 3739c6fd2807SJeff Garzik /* clear SError */ 3740936fd732STejun Heo if (sata_scr_read(link, SCR_ERROR, &serror) == 0) 3741936fd732STejun Heo sata_scr_write(link, SCR_ERROR, serror); 3742c6fd2807SJeff Garzik 3743c6fd2807SJeff Garzik /* is double-select really necessary? */ 3744c6fd2807SJeff Garzik if (classes[0] != ATA_DEV_NONE) 3745c6fd2807SJeff Garzik ap->ops->dev_select(ap, 1); 3746c6fd2807SJeff Garzik if (classes[1] != ATA_DEV_NONE) 3747c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 3748c6fd2807SJeff Garzik 3749c6fd2807SJeff Garzik /* bail out if no device is present */ 3750c6fd2807SJeff Garzik if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) { 3751c6fd2807SJeff Garzik DPRINTK("EXIT, no device\n"); 3752c6fd2807SJeff Garzik return; 3753c6fd2807SJeff Garzik } 3754c6fd2807SJeff Garzik 3755c6fd2807SJeff Garzik /* set up device control */ 37560d5ff566STejun Heo if (ap->ioaddr.ctl_addr) 37570d5ff566STejun Heo iowrite8(ap->ctl, ap->ioaddr.ctl_addr); 3758c6fd2807SJeff Garzik 3759c6fd2807SJeff Garzik DPRINTK("EXIT\n"); 3760c6fd2807SJeff Garzik } 3761c6fd2807SJeff Garzik 3762c6fd2807SJeff Garzik /** 3763c6fd2807SJeff Garzik * ata_dev_same_device - Determine whether new ID matches configured device 3764c6fd2807SJeff Garzik * @dev: device to compare against 3765c6fd2807SJeff Garzik * @new_class: class of the new device 3766c6fd2807SJeff Garzik * @new_id: IDENTIFY page of the new device 3767c6fd2807SJeff Garzik * 3768c6fd2807SJeff Garzik * Compare @new_class and @new_id against @dev and determine 3769c6fd2807SJeff Garzik * whether @dev is the device indicated by @new_class and 3770c6fd2807SJeff Garzik * @new_id. 3771c6fd2807SJeff Garzik * 3772c6fd2807SJeff Garzik * LOCKING: 3773c6fd2807SJeff Garzik * None. 3774c6fd2807SJeff Garzik * 3775c6fd2807SJeff Garzik * RETURNS: 3776c6fd2807SJeff Garzik * 1 if @dev matches @new_class and @new_id, 0 otherwise. 3777c6fd2807SJeff Garzik */ 3778c6fd2807SJeff Garzik static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class, 3779c6fd2807SJeff Garzik const u16 *new_id) 3780c6fd2807SJeff Garzik { 3781c6fd2807SJeff Garzik const u16 *old_id = dev->id; 3782a0cf733bSTejun Heo unsigned char model[2][ATA_ID_PROD_LEN + 1]; 3783a0cf733bSTejun Heo unsigned char serial[2][ATA_ID_SERNO_LEN + 1]; 3784c6fd2807SJeff Garzik 3785c6fd2807SJeff Garzik if (dev->class != new_class) { 3786c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "class mismatch %d != %d\n", 3787c6fd2807SJeff Garzik dev->class, new_class); 3788c6fd2807SJeff Garzik return 0; 3789c6fd2807SJeff Garzik } 3790c6fd2807SJeff Garzik 3791a0cf733bSTejun Heo ata_id_c_string(old_id, model[0], ATA_ID_PROD, sizeof(model[0])); 3792a0cf733bSTejun Heo ata_id_c_string(new_id, model[1], ATA_ID_PROD, sizeof(model[1])); 3793a0cf733bSTejun Heo ata_id_c_string(old_id, serial[0], ATA_ID_SERNO, sizeof(serial[0])); 3794a0cf733bSTejun Heo ata_id_c_string(new_id, serial[1], ATA_ID_SERNO, sizeof(serial[1])); 3795c6fd2807SJeff Garzik 3796c6fd2807SJeff Garzik if (strcmp(model[0], model[1])) { 3797c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "model number mismatch " 3798c6fd2807SJeff Garzik "'%s' != '%s'\n", model[0], model[1]); 3799c6fd2807SJeff Garzik return 0; 3800c6fd2807SJeff Garzik } 3801c6fd2807SJeff Garzik 3802c6fd2807SJeff Garzik if (strcmp(serial[0], serial[1])) { 3803c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "serial number mismatch " 3804c6fd2807SJeff Garzik "'%s' != '%s'\n", serial[0], serial[1]); 3805c6fd2807SJeff Garzik return 0; 3806c6fd2807SJeff Garzik } 3807c6fd2807SJeff Garzik 3808c6fd2807SJeff Garzik return 1; 3809c6fd2807SJeff Garzik } 3810c6fd2807SJeff Garzik 3811c6fd2807SJeff Garzik /** 3812fe30911bSTejun Heo * ata_dev_reread_id - Re-read IDENTIFY data 38133fae450cSHenrik Kretzschmar * @dev: target ATA device 3814bff04647STejun Heo * @readid_flags: read ID flags 3815c6fd2807SJeff Garzik * 3816c6fd2807SJeff Garzik * Re-read IDENTIFY page and make sure @dev is still attached to 3817c6fd2807SJeff Garzik * the port. 3818c6fd2807SJeff Garzik * 3819c6fd2807SJeff Garzik * LOCKING: 3820c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3821c6fd2807SJeff Garzik * 3822c6fd2807SJeff Garzik * RETURNS: 3823c6fd2807SJeff Garzik * 0 on success, negative errno otherwise 3824c6fd2807SJeff Garzik */ 3825fe30911bSTejun Heo int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags) 3826c6fd2807SJeff Garzik { 3827c6fd2807SJeff Garzik unsigned int class = dev->class; 38289af5c9c9STejun Heo u16 *id = (void *)dev->link->ap->sector_buf; 3829c6fd2807SJeff Garzik int rc; 3830c6fd2807SJeff Garzik 3831c6fd2807SJeff Garzik /* read ID data */ 3832bff04647STejun Heo rc = ata_dev_read_id(dev, &class, readid_flags, id); 3833c6fd2807SJeff Garzik if (rc) 3834fe30911bSTejun Heo return rc; 3835c6fd2807SJeff Garzik 3836c6fd2807SJeff Garzik /* is the device still there? */ 3837fe30911bSTejun Heo if (!ata_dev_same_device(dev, class, id)) 3838fe30911bSTejun Heo return -ENODEV; 3839c6fd2807SJeff Garzik 3840c6fd2807SJeff Garzik memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS); 3841fe30911bSTejun Heo return 0; 3842fe30911bSTejun Heo } 3843fe30911bSTejun Heo 3844fe30911bSTejun Heo /** 3845fe30911bSTejun Heo * ata_dev_revalidate - Revalidate ATA device 3846fe30911bSTejun Heo * @dev: device to revalidate 3847422c9daaSTejun Heo * @new_class: new class code 3848fe30911bSTejun Heo * @readid_flags: read ID flags 3849fe30911bSTejun Heo * 3850fe30911bSTejun Heo * Re-read IDENTIFY page, make sure @dev is still attached to the 3851fe30911bSTejun Heo * port and reconfigure it according to the new IDENTIFY page. 3852fe30911bSTejun Heo * 3853fe30911bSTejun Heo * LOCKING: 3854fe30911bSTejun Heo * Kernel thread context (may sleep) 3855fe30911bSTejun Heo * 3856fe30911bSTejun Heo * RETURNS: 3857fe30911bSTejun Heo * 0 on success, negative errno otherwise 3858fe30911bSTejun Heo */ 3859422c9daaSTejun Heo int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class, 3860422c9daaSTejun Heo unsigned int readid_flags) 3861fe30911bSTejun Heo { 38626ddcd3b0STejun Heo u64 n_sectors = dev->n_sectors; 3863fe30911bSTejun Heo int rc; 3864fe30911bSTejun Heo 3865fe30911bSTejun Heo if (!ata_dev_enabled(dev)) 3866fe30911bSTejun Heo return -ENODEV; 3867fe30911bSTejun Heo 3868422c9daaSTejun Heo /* fail early if !ATA && !ATAPI to avoid issuing [P]IDENTIFY to PMP */ 3869422c9daaSTejun Heo if (ata_class_enabled(new_class) && 3870422c9daaSTejun Heo new_class != ATA_DEV_ATA && new_class != ATA_DEV_ATAPI) { 3871422c9daaSTejun Heo ata_dev_printk(dev, KERN_INFO, "class mismatch %u != %u\n", 3872422c9daaSTejun Heo dev->class, new_class); 3873422c9daaSTejun Heo rc = -ENODEV; 3874422c9daaSTejun Heo goto fail; 3875422c9daaSTejun Heo } 3876422c9daaSTejun Heo 3877fe30911bSTejun Heo /* re-read ID */ 3878fe30911bSTejun Heo rc = ata_dev_reread_id(dev, readid_flags); 3879fe30911bSTejun Heo if (rc) 3880fe30911bSTejun Heo goto fail; 3881c6fd2807SJeff Garzik 3882c6fd2807SJeff Garzik /* configure device according to the new ID */ 3883efdaedc4STejun Heo rc = ata_dev_configure(dev); 38846ddcd3b0STejun Heo if (rc) 38856ddcd3b0STejun Heo goto fail; 38866ddcd3b0STejun Heo 38876ddcd3b0STejun Heo /* verify n_sectors hasn't changed */ 3888b54eebd6STejun Heo if (dev->class == ATA_DEV_ATA && n_sectors && 3889b54eebd6STejun Heo dev->n_sectors != n_sectors) { 38906ddcd3b0STejun Heo ata_dev_printk(dev, KERN_INFO, "n_sectors mismatch " 38916ddcd3b0STejun Heo "%llu != %llu\n", 38926ddcd3b0STejun Heo (unsigned long long)n_sectors, 38936ddcd3b0STejun Heo (unsigned long long)dev->n_sectors); 38948270bec4STejun Heo 38958270bec4STejun Heo /* restore original n_sectors */ 38968270bec4STejun Heo dev->n_sectors = n_sectors; 38978270bec4STejun Heo 38986ddcd3b0STejun Heo rc = -ENODEV; 38996ddcd3b0STejun Heo goto fail; 39006ddcd3b0STejun Heo } 39016ddcd3b0STejun Heo 3902c6fd2807SJeff Garzik return 0; 3903c6fd2807SJeff Garzik 3904c6fd2807SJeff Garzik fail: 3905c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_ERR, "revalidation failed (errno=%d)\n", rc); 3906c6fd2807SJeff Garzik return rc; 3907c6fd2807SJeff Garzik } 3908c6fd2807SJeff Garzik 39096919a0a6SAlan Cox struct ata_blacklist_entry { 39106919a0a6SAlan Cox const char *model_num; 39116919a0a6SAlan Cox const char *model_rev; 39126919a0a6SAlan Cox unsigned long horkage; 39136919a0a6SAlan Cox }; 39146919a0a6SAlan Cox 39156919a0a6SAlan Cox static const struct ata_blacklist_entry ata_device_blacklist [] = { 39166919a0a6SAlan Cox /* Devices with DMA related problems under Linux */ 39176919a0a6SAlan Cox { "WDC AC11000H", NULL, ATA_HORKAGE_NODMA }, 39186919a0a6SAlan Cox { "WDC AC22100H", NULL, ATA_HORKAGE_NODMA }, 39196919a0a6SAlan Cox { "WDC AC32500H", NULL, ATA_HORKAGE_NODMA }, 39206919a0a6SAlan Cox { "WDC AC33100H", NULL, ATA_HORKAGE_NODMA }, 39216919a0a6SAlan Cox { "WDC AC31600H", NULL, ATA_HORKAGE_NODMA }, 39226919a0a6SAlan Cox { "WDC AC32100H", "24.09P07", ATA_HORKAGE_NODMA }, 39236919a0a6SAlan Cox { "WDC AC23200L", "21.10N21", ATA_HORKAGE_NODMA }, 39246919a0a6SAlan Cox { "Compaq CRD-8241B", NULL, ATA_HORKAGE_NODMA }, 39256919a0a6SAlan Cox { "CRD-8400B", NULL, ATA_HORKAGE_NODMA }, 39266919a0a6SAlan Cox { "CRD-8480B", NULL, ATA_HORKAGE_NODMA }, 39276919a0a6SAlan Cox { "CRD-8482B", NULL, ATA_HORKAGE_NODMA }, 39286919a0a6SAlan Cox { "CRD-84", NULL, ATA_HORKAGE_NODMA }, 39296919a0a6SAlan Cox { "SanDisk SDP3B", NULL, ATA_HORKAGE_NODMA }, 39306919a0a6SAlan Cox { "SanDisk SDP3B-64", NULL, ATA_HORKAGE_NODMA }, 39316919a0a6SAlan Cox { "SANYO CD-ROM CRD", NULL, ATA_HORKAGE_NODMA }, 39326919a0a6SAlan Cox { "HITACHI CDR-8", NULL, ATA_HORKAGE_NODMA }, 39336919a0a6SAlan Cox { "HITACHI CDR-8335", NULL, ATA_HORKAGE_NODMA }, 39346919a0a6SAlan Cox { "HITACHI CDR-8435", NULL, ATA_HORKAGE_NODMA }, 39356919a0a6SAlan Cox { "Toshiba CD-ROM XM-6202B", NULL, ATA_HORKAGE_NODMA }, 39366919a0a6SAlan Cox { "TOSHIBA CD-ROM XM-1702BC", NULL, ATA_HORKAGE_NODMA }, 39376919a0a6SAlan Cox { "CD-532E-A", NULL, ATA_HORKAGE_NODMA }, 39386919a0a6SAlan Cox { "E-IDE CD-ROM CR-840",NULL, ATA_HORKAGE_NODMA }, 39396919a0a6SAlan Cox { "CD-ROM Drive/F5A", NULL, ATA_HORKAGE_NODMA }, 39406919a0a6SAlan Cox { "WPI CDD-820", NULL, ATA_HORKAGE_NODMA }, 39416919a0a6SAlan Cox { "SAMSUNG CD-ROM SC-148C", NULL, ATA_HORKAGE_NODMA }, 39426919a0a6SAlan Cox { "SAMSUNG CD-ROM SC", NULL, ATA_HORKAGE_NODMA }, 39436919a0a6SAlan Cox { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA }, 39446919a0a6SAlan Cox { "_NEC DV5800A", NULL, ATA_HORKAGE_NODMA }, 39456919a0a6SAlan Cox { "SAMSUNG CD-ROM SN-124","N001", ATA_HORKAGE_NODMA }, 394639f19886SDave Jones { "Seagate STT20000A", NULL, ATA_HORKAGE_NODMA }, 39475acd50f6STejun Heo { "IOMEGA ZIP 250 ATAPI", NULL, ATA_HORKAGE_NODMA }, /* temporary fix */ 394839ce7128STejun Heo { "IOMEGA ZIP 250 ATAPI Floppy", 394939ce7128STejun Heo NULL, ATA_HORKAGE_NODMA }, 39503af9a77aSTejun Heo /* Odd clown on sil3726/4726 PMPs */ 39513af9a77aSTejun Heo { "Config Disk", NULL, ATA_HORKAGE_NODMA | 39523af9a77aSTejun Heo ATA_HORKAGE_SKIP_PM }, 39536919a0a6SAlan Cox 395418d6e9d5SAlbert Lee /* Weird ATAPI devices */ 395540a1d531STejun Heo { "TORiSAN DVD-ROM DRD-N216", NULL, ATA_HORKAGE_MAX_SEC_128 }, 395618d6e9d5SAlbert Lee 39576919a0a6SAlan Cox /* Devices we expect to fail diagnostics */ 39586919a0a6SAlan Cox 39596919a0a6SAlan Cox /* Devices where NCQ should be avoided */ 39606919a0a6SAlan Cox /* NCQ is slow */ 39616919a0a6SAlan Cox { "WDC WD740ADFD-00", NULL, ATA_HORKAGE_NONCQ }, 396209125ea6STejun Heo /* http://thread.gmane.org/gmane.linux.ide/14907 */ 396309125ea6STejun Heo { "FUJITSU MHT2060BH", NULL, ATA_HORKAGE_NONCQ }, 39647acfaf30SPaul Rolland /* NCQ is broken */ 3965539cc7c7SJeff Garzik { "Maxtor *", "BANC*", ATA_HORKAGE_NONCQ }, 39660e3dbc01SAlan Cox { "Maxtor 7V300F0", "VA111630", ATA_HORKAGE_NONCQ }, 39670b0a43e0SDavid Milburn { "HITACHI HDS7250SASUN500G*", NULL, ATA_HORKAGE_NONCQ }, 39680b0a43e0SDavid Milburn { "HITACHI HDS7225SBSUN250G*", NULL, ATA_HORKAGE_NONCQ }, 3969da6f0ec2SPaolo Ornati { "ST380817AS", "3.42", ATA_HORKAGE_NONCQ }, 3970539cc7c7SJeff Garzik 397136e337d0SRobert Hancock /* Blacklist entries taken from Silicon Image 3124/3132 397236e337d0SRobert Hancock Windows driver .inf file - also several Linux problem reports */ 397336e337d0SRobert Hancock { "HTS541060G9SA00", "MB3OC60D", ATA_HORKAGE_NONCQ, }, 397436e337d0SRobert Hancock { "HTS541080G9SA00", "MB4OC60D", ATA_HORKAGE_NONCQ, }, 397536e337d0SRobert Hancock { "HTS541010G9SA00", "MBZOC60D", ATA_HORKAGE_NONCQ, }, 3976bd9c5a39STejun Heo /* Drives which do spurious command completion */ 3977bd9c5a39STejun Heo { "HTS541680J9SA00", "SB2IC7EP", ATA_HORKAGE_NONCQ, }, 39782f8fcebbSTejun Heo { "HTS541612J9SA00", "SBDIC7JP", ATA_HORKAGE_NONCQ, }, 397970edb185STejun Heo { "HDT722516DLA380", "V43OA96A", ATA_HORKAGE_NONCQ, }, 3980e14cbfa6STejun Heo { "Hitachi HTS541616J9SA00", "SB4OC70P", ATA_HORKAGE_NONCQ, }, 39812f8fcebbSTejun Heo { "WDC WD740ADFD-00NLR1", NULL, ATA_HORKAGE_NONCQ, }, 39827f567620STejun Heo { "WDC WD3200AAJS-00RYA0", "12.01B01", ATA_HORKAGE_NONCQ, }, 3983a520f261STejun Heo { "FUJITSU MHV2080BH", "00840028", ATA_HORKAGE_NONCQ, }, 39847f567620STejun Heo { "ST9120822AS", "3.CLF", ATA_HORKAGE_NONCQ, }, 39853fb6589cSTejun Heo { "ST9160821AS", "3.CLF", ATA_HORKAGE_NONCQ, }, 3986954bb005STejun Heo { "ST9160821AS", "3.ALD", ATA_HORKAGE_NONCQ, }, 39877f567620STejun Heo { "ST3160812AS", "3.ADJ", ATA_HORKAGE_NONCQ, }, 39887f567620STejun Heo { "ST980813AS", "3.ADB", ATA_HORKAGE_NONCQ, }, 39895d6aca8dSTejun Heo { "SAMSUNG HD401LJ", "ZZ100-15", ATA_HORKAGE_NONCQ, }, 39906919a0a6SAlan Cox 399116c55b03STejun Heo /* devices which puke on READ_NATIVE_MAX */ 399216c55b03STejun Heo { "HDS724040KLSA80", "KFAOA20N", ATA_HORKAGE_BROKEN_HPA, }, 399316c55b03STejun Heo { "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_HORKAGE_BROKEN_HPA }, 399416c55b03STejun Heo { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA }, 399516c55b03STejun Heo { "MAXTOR 6L080L4", "A93.0500", ATA_HORKAGE_BROKEN_HPA }, 39966919a0a6SAlan Cox 399793328e11SAlan Cox /* Devices which report 1 sector over size HPA */ 399893328e11SAlan Cox { "ST340823A", NULL, ATA_HORKAGE_HPA_SIZE, }, 399993328e11SAlan Cox { "ST320413A", NULL, ATA_HORKAGE_HPA_SIZE, }, 400093328e11SAlan Cox 40016919a0a6SAlan Cox /* End Marker */ 40026919a0a6SAlan Cox { } 4003c6fd2807SJeff Garzik }; 4004c6fd2807SJeff Garzik 4005539cc7c7SJeff Garzik int strn_pattern_cmp(const char *patt, const char *name, int wildchar) 4006539cc7c7SJeff Garzik { 4007539cc7c7SJeff Garzik const char *p; 4008539cc7c7SJeff Garzik int len; 4009539cc7c7SJeff Garzik 4010539cc7c7SJeff Garzik /* 4011539cc7c7SJeff Garzik * check for trailing wildcard: *\0 4012539cc7c7SJeff Garzik */ 4013539cc7c7SJeff Garzik p = strchr(patt, wildchar); 4014539cc7c7SJeff Garzik if (p && ((*(p + 1)) == 0)) 4015539cc7c7SJeff Garzik len = p - patt; 4016539cc7c7SJeff Garzik else 4017539cc7c7SJeff Garzik len = strlen(name); 4018539cc7c7SJeff Garzik 4019539cc7c7SJeff Garzik return strncmp(patt, name, len); 4020539cc7c7SJeff Garzik } 4021539cc7c7SJeff Garzik 402275683fe7STejun Heo static unsigned long ata_dev_blacklisted(const struct ata_device *dev) 4023c6fd2807SJeff Garzik { 40248bfa79fcSTejun Heo unsigned char model_num[ATA_ID_PROD_LEN + 1]; 40258bfa79fcSTejun Heo unsigned char model_rev[ATA_ID_FW_REV_LEN + 1]; 40266919a0a6SAlan Cox const struct ata_blacklist_entry *ad = ata_device_blacklist; 4027c6fd2807SJeff Garzik 40288bfa79fcSTejun Heo ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num)); 40298bfa79fcSTejun Heo ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev)); 4030c6fd2807SJeff Garzik 40316919a0a6SAlan Cox while (ad->model_num) { 4032539cc7c7SJeff Garzik if (!strn_pattern_cmp(ad->model_num, model_num, '*')) { 40336919a0a6SAlan Cox if (ad->model_rev == NULL) 40346919a0a6SAlan Cox return ad->horkage; 4035539cc7c7SJeff Garzik if (!strn_pattern_cmp(ad->model_rev, model_rev, '*')) 40366919a0a6SAlan Cox return ad->horkage; 4037c6fd2807SJeff Garzik } 40386919a0a6SAlan Cox ad++; 4039c6fd2807SJeff Garzik } 4040c6fd2807SJeff Garzik return 0; 4041c6fd2807SJeff Garzik } 4042c6fd2807SJeff Garzik 40436919a0a6SAlan Cox static int ata_dma_blacklisted(const struct ata_device *dev) 40446919a0a6SAlan Cox { 40456919a0a6SAlan Cox /* We don't support polling DMA. 40466919a0a6SAlan Cox * DMA blacklist those ATAPI devices with CDB-intr (and use PIO) 40476919a0a6SAlan Cox * if the LLDD handles only interrupts in the HSM_ST_LAST state. 40486919a0a6SAlan Cox */ 40499af5c9c9STejun Heo if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) && 40506919a0a6SAlan Cox (dev->flags & ATA_DFLAG_CDB_INTR)) 40516919a0a6SAlan Cox return 1; 405275683fe7STejun Heo return (dev->horkage & ATA_HORKAGE_NODMA) ? 1 : 0; 40536919a0a6SAlan Cox } 40546919a0a6SAlan Cox 4055c6fd2807SJeff Garzik /** 4056c6fd2807SJeff Garzik * ata_dev_xfermask - Compute supported xfermask of the given device 4057c6fd2807SJeff Garzik * @dev: Device to compute xfermask for 4058c6fd2807SJeff Garzik * 4059c6fd2807SJeff Garzik * Compute supported xfermask of @dev and store it in 4060c6fd2807SJeff Garzik * dev->*_mask. This function is responsible for applying all 4061c6fd2807SJeff Garzik * known limits including host controller limits, device 4062c6fd2807SJeff Garzik * blacklist, etc... 4063c6fd2807SJeff Garzik * 4064c6fd2807SJeff Garzik * LOCKING: 4065c6fd2807SJeff Garzik * None. 4066c6fd2807SJeff Garzik */ 4067c6fd2807SJeff Garzik static void ata_dev_xfermask(struct ata_device *dev) 4068c6fd2807SJeff Garzik { 40699af5c9c9STejun Heo struct ata_link *link = dev->link; 40709af5c9c9STejun Heo struct ata_port *ap = link->ap; 4071cca3974eSJeff Garzik struct ata_host *host = ap->host; 4072c6fd2807SJeff Garzik unsigned long xfer_mask; 4073c6fd2807SJeff Garzik 4074c6fd2807SJeff Garzik /* controller modes available */ 4075c6fd2807SJeff Garzik xfer_mask = ata_pack_xfermask(ap->pio_mask, 4076c6fd2807SJeff Garzik ap->mwdma_mask, ap->udma_mask); 4077c6fd2807SJeff Garzik 40788343f889SRobert Hancock /* drive modes available */ 4079c6fd2807SJeff Garzik xfer_mask &= ata_pack_xfermask(dev->pio_mask, 4080c6fd2807SJeff Garzik dev->mwdma_mask, dev->udma_mask); 4081c6fd2807SJeff Garzik xfer_mask &= ata_id_xfermask(dev->id); 4082c6fd2807SJeff Garzik 4083b352e57dSAlan Cox /* 4084b352e57dSAlan Cox * CFA Advanced TrueIDE timings are not allowed on a shared 4085b352e57dSAlan Cox * cable 4086b352e57dSAlan Cox */ 4087b352e57dSAlan Cox if (ata_dev_pair(dev)) { 4088b352e57dSAlan Cox /* No PIO5 or PIO6 */ 4089b352e57dSAlan Cox xfer_mask &= ~(0x03 << (ATA_SHIFT_PIO + 5)); 4090b352e57dSAlan Cox /* No MWDMA3 or MWDMA 4 */ 4091b352e57dSAlan Cox xfer_mask &= ~(0x03 << (ATA_SHIFT_MWDMA + 3)); 4092b352e57dSAlan Cox } 4093b352e57dSAlan Cox 4094c6fd2807SJeff Garzik if (ata_dma_blacklisted(dev)) { 4095c6fd2807SJeff Garzik xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA); 4096c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 4097c6fd2807SJeff Garzik "device is on DMA blacklist, disabling DMA\n"); 4098c6fd2807SJeff Garzik } 4099c6fd2807SJeff Garzik 410014d66ab7SPetr Vandrovec if ((host->flags & ATA_HOST_SIMPLEX) && 410114d66ab7SPetr Vandrovec host->simplex_claimed && host->simplex_claimed != ap) { 4102c6fd2807SJeff Garzik xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA); 4103c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "simplex DMA is claimed by " 4104c6fd2807SJeff Garzik "other device, disabling DMA\n"); 4105c6fd2807SJeff Garzik } 4106c6fd2807SJeff Garzik 4107e424675fSJeff Garzik if (ap->flags & ATA_FLAG_NO_IORDY) 4108e424675fSJeff Garzik xfer_mask &= ata_pio_mask_no_iordy(dev); 4109e424675fSJeff Garzik 4110c6fd2807SJeff Garzik if (ap->ops->mode_filter) 4111a76b62caSAlan Cox xfer_mask = ap->ops->mode_filter(dev, xfer_mask); 4112c6fd2807SJeff Garzik 41138343f889SRobert Hancock /* Apply cable rule here. Don't apply it early because when 41148343f889SRobert Hancock * we handle hot plug the cable type can itself change. 41158343f889SRobert Hancock * Check this last so that we know if the transfer rate was 41168343f889SRobert Hancock * solely limited by the cable. 41178343f889SRobert Hancock * Unknown or 80 wire cables reported host side are checked 41188343f889SRobert Hancock * drive side as well. Cases where we know a 40wire cable 41198343f889SRobert Hancock * is used safely for 80 are not checked here. 41208343f889SRobert Hancock */ 41218343f889SRobert Hancock if (xfer_mask & (0xF8 << ATA_SHIFT_UDMA)) 41228343f889SRobert Hancock /* UDMA/44 or higher would be available */ 41238343f889SRobert Hancock if((ap->cbl == ATA_CBL_PATA40) || 41248343f889SRobert Hancock (ata_drive_40wire(dev->id) && 41258343f889SRobert Hancock (ap->cbl == ATA_CBL_PATA_UNK || 41268343f889SRobert Hancock ap->cbl == ATA_CBL_PATA80))) { 41278343f889SRobert Hancock ata_dev_printk(dev, KERN_WARNING, 41288343f889SRobert Hancock "limited to UDMA/33 due to 40-wire cable\n"); 41298343f889SRobert Hancock xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA); 41308343f889SRobert Hancock } 41318343f889SRobert Hancock 4132c6fd2807SJeff Garzik ata_unpack_xfermask(xfer_mask, &dev->pio_mask, 4133c6fd2807SJeff Garzik &dev->mwdma_mask, &dev->udma_mask); 4134c6fd2807SJeff Garzik } 4135c6fd2807SJeff Garzik 4136c6fd2807SJeff Garzik /** 4137c6fd2807SJeff Garzik * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command 4138c6fd2807SJeff Garzik * @dev: Device to which command will be sent 4139c6fd2807SJeff Garzik * 4140c6fd2807SJeff Garzik * Issue SET FEATURES - XFER MODE command to device @dev 4141c6fd2807SJeff Garzik * on port @ap. 4142c6fd2807SJeff Garzik * 4143c6fd2807SJeff Garzik * LOCKING: 4144c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 4145c6fd2807SJeff Garzik * 4146c6fd2807SJeff Garzik * RETURNS: 4147c6fd2807SJeff Garzik * 0 on success, AC_ERR_* mask otherwise. 4148c6fd2807SJeff Garzik */ 4149c6fd2807SJeff Garzik 4150c6fd2807SJeff Garzik static unsigned int ata_dev_set_xfermode(struct ata_device *dev) 4151c6fd2807SJeff Garzik { 4152c6fd2807SJeff Garzik struct ata_taskfile tf; 4153c6fd2807SJeff Garzik unsigned int err_mask; 4154c6fd2807SJeff Garzik 4155c6fd2807SJeff Garzik /* set up set-features taskfile */ 4156c6fd2807SJeff Garzik DPRINTK("set features - xfer mode\n"); 4157c6fd2807SJeff Garzik 4158464cf177STejun Heo /* Some controllers and ATAPI devices show flaky interrupt 4159464cf177STejun Heo * behavior after setting xfer mode. Use polling instead. 4160464cf177STejun Heo */ 4161c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 4162c6fd2807SJeff Garzik tf.command = ATA_CMD_SET_FEATURES; 4163c6fd2807SJeff Garzik tf.feature = SETFEATURES_XFER; 4164464cf177STejun Heo tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_POLLING; 4165c6fd2807SJeff Garzik tf.protocol = ATA_PROT_NODATA; 4166c6fd2807SJeff Garzik tf.nsect = dev->xfer_mode; 4167c6fd2807SJeff Garzik 41682b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 4169c6fd2807SJeff Garzik 4170c6fd2807SJeff Garzik DPRINTK("EXIT, err_mask=%x\n", err_mask); 4171c6fd2807SJeff Garzik return err_mask; 4172c6fd2807SJeff Garzik } 4173c6fd2807SJeff Garzik 4174c6fd2807SJeff Garzik /** 41759f45cbd3SKristen Carlson Accardi * ata_dev_set_AN - Issue SET FEATURES - SATA FEATURES 41769f45cbd3SKristen Carlson Accardi * @dev: Device to which command will be sent 41779f45cbd3SKristen Carlson Accardi * @enable: Whether to enable or disable the feature 41789f45cbd3SKristen Carlson Accardi * 41799f45cbd3SKristen Carlson Accardi * Issue SET FEATURES - SATA FEATURES command to device @dev 41809f45cbd3SKristen Carlson Accardi * on port @ap with sector count set to indicate Asynchronous 41819f45cbd3SKristen Carlson Accardi * Notification feature 41829f45cbd3SKristen Carlson Accardi * 41839f45cbd3SKristen Carlson Accardi * LOCKING: 41849f45cbd3SKristen Carlson Accardi * PCI/etc. bus probe sem. 41859f45cbd3SKristen Carlson Accardi * 41869f45cbd3SKristen Carlson Accardi * RETURNS: 41879f45cbd3SKristen Carlson Accardi * 0 on success, AC_ERR_* mask otherwise. 41889f45cbd3SKristen Carlson Accardi */ 41899f45cbd3SKristen Carlson Accardi static unsigned int ata_dev_set_AN(struct ata_device *dev, u8 enable) 41909f45cbd3SKristen Carlson Accardi { 41919f45cbd3SKristen Carlson Accardi struct ata_taskfile tf; 41929f45cbd3SKristen Carlson Accardi unsigned int err_mask; 41939f45cbd3SKristen Carlson Accardi 41949f45cbd3SKristen Carlson Accardi /* set up set-features taskfile */ 41959f45cbd3SKristen Carlson Accardi DPRINTK("set features - SATA features\n"); 41969f45cbd3SKristen Carlson Accardi 41979f45cbd3SKristen Carlson Accardi ata_tf_init(dev, &tf); 41989f45cbd3SKristen Carlson Accardi tf.command = ATA_CMD_SET_FEATURES; 41999f45cbd3SKristen Carlson Accardi tf.feature = enable; 42009f45cbd3SKristen Carlson Accardi tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 42019f45cbd3SKristen Carlson Accardi tf.protocol = ATA_PROT_NODATA; 42029f45cbd3SKristen Carlson Accardi tf.nsect = SATA_AN; 42039f45cbd3SKristen Carlson Accardi 42042b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 42059f45cbd3SKristen Carlson Accardi 42069f45cbd3SKristen Carlson Accardi DPRINTK("EXIT, err_mask=%x\n", err_mask); 42079f45cbd3SKristen Carlson Accardi return err_mask; 42089f45cbd3SKristen Carlson Accardi } 42099f45cbd3SKristen Carlson Accardi 42109f45cbd3SKristen Carlson Accardi /** 4211c6fd2807SJeff Garzik * ata_dev_init_params - Issue INIT DEV PARAMS command 4212c6fd2807SJeff Garzik * @dev: Device to which command will be sent 4213c6fd2807SJeff Garzik * @heads: Number of heads (taskfile parameter) 4214c6fd2807SJeff Garzik * @sectors: Number of sectors (taskfile parameter) 4215c6fd2807SJeff Garzik * 4216c6fd2807SJeff Garzik * LOCKING: 4217c6fd2807SJeff Garzik * Kernel thread context (may sleep) 4218c6fd2807SJeff Garzik * 4219c6fd2807SJeff Garzik * RETURNS: 4220c6fd2807SJeff Garzik * 0 on success, AC_ERR_* mask otherwise. 4221c6fd2807SJeff Garzik */ 4222c6fd2807SJeff Garzik static unsigned int ata_dev_init_params(struct ata_device *dev, 4223c6fd2807SJeff Garzik u16 heads, u16 sectors) 4224c6fd2807SJeff Garzik { 4225c6fd2807SJeff Garzik struct ata_taskfile tf; 4226c6fd2807SJeff Garzik unsigned int err_mask; 4227c6fd2807SJeff Garzik 4228c6fd2807SJeff Garzik /* Number of sectors per track 1-255. Number of heads 1-16 */ 4229c6fd2807SJeff Garzik if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16) 4230c6fd2807SJeff Garzik return AC_ERR_INVALID; 4231c6fd2807SJeff Garzik 4232c6fd2807SJeff Garzik /* set up init dev params taskfile */ 4233c6fd2807SJeff Garzik DPRINTK("init dev params \n"); 4234c6fd2807SJeff Garzik 4235c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 4236c6fd2807SJeff Garzik tf.command = ATA_CMD_INIT_DEV_PARAMS; 4237c6fd2807SJeff Garzik tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 4238c6fd2807SJeff Garzik tf.protocol = ATA_PROT_NODATA; 4239c6fd2807SJeff Garzik tf.nsect = sectors; 4240c6fd2807SJeff Garzik tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */ 4241c6fd2807SJeff Garzik 42422b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 424318b2466cSAlan Cox /* A clean abort indicates an original or just out of spec drive 424418b2466cSAlan Cox and we should continue as we issue the setup based on the 424518b2466cSAlan Cox drive reported working geometry */ 424618b2466cSAlan Cox if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED)) 424718b2466cSAlan Cox err_mask = 0; 4248c6fd2807SJeff Garzik 4249c6fd2807SJeff Garzik DPRINTK("EXIT, err_mask=%x\n", err_mask); 4250c6fd2807SJeff Garzik return err_mask; 4251c6fd2807SJeff Garzik } 4252c6fd2807SJeff Garzik 4253c6fd2807SJeff Garzik /** 4254c6fd2807SJeff Garzik * ata_sg_clean - Unmap DMA memory associated with command 4255c6fd2807SJeff Garzik * @qc: Command containing DMA memory to be released 4256c6fd2807SJeff Garzik * 4257c6fd2807SJeff Garzik * Unmap all mapped DMA memory associated with this command. 4258c6fd2807SJeff Garzik * 4259c6fd2807SJeff Garzik * LOCKING: 4260cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4261c6fd2807SJeff Garzik */ 426270e6ad0cSTejun Heo void ata_sg_clean(struct ata_queued_cmd *qc) 4263c6fd2807SJeff Garzik { 4264c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4265c6fd2807SJeff Garzik struct scatterlist *sg = qc->__sg; 4266c6fd2807SJeff Garzik int dir = qc->dma_dir; 4267c6fd2807SJeff Garzik void *pad_buf = NULL; 4268c6fd2807SJeff Garzik 4269c6fd2807SJeff Garzik WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP)); 4270c6fd2807SJeff Garzik WARN_ON(sg == NULL); 4271c6fd2807SJeff Garzik 4272c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_SINGLE) 4273c6fd2807SJeff Garzik WARN_ON(qc->n_elem > 1); 4274c6fd2807SJeff Garzik 4275c6fd2807SJeff Garzik VPRINTK("unmapping %u sg elements\n", qc->n_elem); 4276c6fd2807SJeff Garzik 4277c6fd2807SJeff Garzik /* if we padded the buffer out to 32-bit bound, and data 4278c6fd2807SJeff Garzik * xfer direction is from-device, we must copy from the 4279c6fd2807SJeff Garzik * pad buffer back into the supplied buffer 4280c6fd2807SJeff Garzik */ 4281c6fd2807SJeff Garzik if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE)) 4282c6fd2807SJeff Garzik pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ); 4283c6fd2807SJeff Garzik 4284c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_SG) { 4285c6fd2807SJeff Garzik if (qc->n_elem) 4286c6fd2807SJeff Garzik dma_unmap_sg(ap->dev, sg, qc->n_elem, dir); 4287c6fd2807SJeff Garzik /* restore last sg */ 4288c6fd2807SJeff Garzik sg[qc->orig_n_elem - 1].length += qc->pad_len; 4289c6fd2807SJeff Garzik if (pad_buf) { 4290c6fd2807SJeff Garzik struct scatterlist *psg = &qc->pad_sgent; 4291c6fd2807SJeff Garzik void *addr = kmap_atomic(psg->page, KM_IRQ0); 4292c6fd2807SJeff Garzik memcpy(addr + psg->offset, pad_buf, qc->pad_len); 4293c6fd2807SJeff Garzik kunmap_atomic(addr, KM_IRQ0); 4294c6fd2807SJeff Garzik } 4295c6fd2807SJeff Garzik } else { 4296c6fd2807SJeff Garzik if (qc->n_elem) 4297c6fd2807SJeff Garzik dma_unmap_single(ap->dev, 4298c6fd2807SJeff Garzik sg_dma_address(&sg[0]), sg_dma_len(&sg[0]), 4299c6fd2807SJeff Garzik dir); 4300c6fd2807SJeff Garzik /* restore sg */ 4301c6fd2807SJeff Garzik sg->length += qc->pad_len; 4302c6fd2807SJeff Garzik if (pad_buf) 4303c6fd2807SJeff Garzik memcpy(qc->buf_virt + sg->length - qc->pad_len, 4304c6fd2807SJeff Garzik pad_buf, qc->pad_len); 4305c6fd2807SJeff Garzik } 4306c6fd2807SJeff Garzik 4307c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_DMAMAP; 4308c6fd2807SJeff Garzik qc->__sg = NULL; 4309c6fd2807SJeff Garzik } 4310c6fd2807SJeff Garzik 4311c6fd2807SJeff Garzik /** 4312c6fd2807SJeff Garzik * ata_fill_sg - Fill PCI IDE PRD table 4313c6fd2807SJeff Garzik * @qc: Metadata associated with taskfile to be transferred 4314c6fd2807SJeff Garzik * 4315c6fd2807SJeff Garzik * Fill PCI IDE PRD (scatter-gather) table with segments 4316c6fd2807SJeff Garzik * associated with the current disk command. 4317c6fd2807SJeff Garzik * 4318c6fd2807SJeff Garzik * LOCKING: 4319cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4320c6fd2807SJeff Garzik * 4321c6fd2807SJeff Garzik */ 4322c6fd2807SJeff Garzik static void ata_fill_sg(struct ata_queued_cmd *qc) 4323c6fd2807SJeff Garzik { 4324c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4325c6fd2807SJeff Garzik struct scatterlist *sg; 4326c6fd2807SJeff Garzik unsigned int idx; 4327c6fd2807SJeff Garzik 4328c6fd2807SJeff Garzik WARN_ON(qc->__sg == NULL); 4329c6fd2807SJeff Garzik WARN_ON(qc->n_elem == 0 && qc->pad_len == 0); 4330c6fd2807SJeff Garzik 4331c6fd2807SJeff Garzik idx = 0; 4332c6fd2807SJeff Garzik ata_for_each_sg(sg, qc) { 4333c6fd2807SJeff Garzik u32 addr, offset; 4334c6fd2807SJeff Garzik u32 sg_len, len; 4335c6fd2807SJeff Garzik 4336c6fd2807SJeff Garzik /* determine if physical DMA addr spans 64K boundary. 4337c6fd2807SJeff Garzik * Note h/w doesn't support 64-bit, so we unconditionally 4338c6fd2807SJeff Garzik * truncate dma_addr_t to u32. 4339c6fd2807SJeff Garzik */ 4340c6fd2807SJeff Garzik addr = (u32) sg_dma_address(sg); 4341c6fd2807SJeff Garzik sg_len = sg_dma_len(sg); 4342c6fd2807SJeff Garzik 4343c6fd2807SJeff Garzik while (sg_len) { 4344c6fd2807SJeff Garzik offset = addr & 0xffff; 4345c6fd2807SJeff Garzik len = sg_len; 4346c6fd2807SJeff Garzik if ((offset + sg_len) > 0x10000) 4347c6fd2807SJeff Garzik len = 0x10000 - offset; 4348c6fd2807SJeff Garzik 4349c6fd2807SJeff Garzik ap->prd[idx].addr = cpu_to_le32(addr); 4350c6fd2807SJeff Garzik ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff); 4351c6fd2807SJeff Garzik VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len); 4352c6fd2807SJeff Garzik 4353c6fd2807SJeff Garzik idx++; 4354c6fd2807SJeff Garzik sg_len -= len; 4355c6fd2807SJeff Garzik addr += len; 4356c6fd2807SJeff Garzik } 4357c6fd2807SJeff Garzik } 4358c6fd2807SJeff Garzik 4359c6fd2807SJeff Garzik if (idx) 4360c6fd2807SJeff Garzik ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT); 4361c6fd2807SJeff Garzik } 4362b9a4197eSTejun Heo 4363c6fd2807SJeff Garzik /** 4364d26fc955SAlan Cox * ata_fill_sg_dumb - Fill PCI IDE PRD table 4365d26fc955SAlan Cox * @qc: Metadata associated with taskfile to be transferred 4366d26fc955SAlan Cox * 4367d26fc955SAlan Cox * Fill PCI IDE PRD (scatter-gather) table with segments 4368d26fc955SAlan Cox * associated with the current disk command. Perform the fill 4369d26fc955SAlan Cox * so that we avoid writing any length 64K records for 4370d26fc955SAlan Cox * controllers that don't follow the spec. 4371d26fc955SAlan Cox * 4372d26fc955SAlan Cox * LOCKING: 4373d26fc955SAlan Cox * spin_lock_irqsave(host lock) 4374d26fc955SAlan Cox * 4375d26fc955SAlan Cox */ 4376d26fc955SAlan Cox static void ata_fill_sg_dumb(struct ata_queued_cmd *qc) 4377d26fc955SAlan Cox { 4378d26fc955SAlan Cox struct ata_port *ap = qc->ap; 4379d26fc955SAlan Cox struct scatterlist *sg; 4380d26fc955SAlan Cox unsigned int idx; 4381d26fc955SAlan Cox 4382d26fc955SAlan Cox WARN_ON(qc->__sg == NULL); 4383d26fc955SAlan Cox WARN_ON(qc->n_elem == 0 && qc->pad_len == 0); 4384d26fc955SAlan Cox 4385d26fc955SAlan Cox idx = 0; 4386d26fc955SAlan Cox ata_for_each_sg(sg, qc) { 4387d26fc955SAlan Cox u32 addr, offset; 4388d26fc955SAlan Cox u32 sg_len, len, blen; 4389d26fc955SAlan Cox 4390d26fc955SAlan Cox /* determine if physical DMA addr spans 64K boundary. 4391d26fc955SAlan Cox * Note h/w doesn't support 64-bit, so we unconditionally 4392d26fc955SAlan Cox * truncate dma_addr_t to u32. 4393d26fc955SAlan Cox */ 4394d26fc955SAlan Cox addr = (u32) sg_dma_address(sg); 4395d26fc955SAlan Cox sg_len = sg_dma_len(sg); 4396d26fc955SAlan Cox 4397d26fc955SAlan Cox while (sg_len) { 4398d26fc955SAlan Cox offset = addr & 0xffff; 4399d26fc955SAlan Cox len = sg_len; 4400d26fc955SAlan Cox if ((offset + sg_len) > 0x10000) 4401d26fc955SAlan Cox len = 0x10000 - offset; 4402d26fc955SAlan Cox 4403d26fc955SAlan Cox blen = len & 0xffff; 4404d26fc955SAlan Cox ap->prd[idx].addr = cpu_to_le32(addr); 4405d26fc955SAlan Cox if (blen == 0) { 4406d26fc955SAlan Cox /* Some PATA chipsets like the CS5530 can't 4407d26fc955SAlan Cox cope with 0x0000 meaning 64K as the spec says */ 4408d26fc955SAlan Cox ap->prd[idx].flags_len = cpu_to_le32(0x8000); 4409d26fc955SAlan Cox blen = 0x8000; 4410d26fc955SAlan Cox ap->prd[++idx].addr = cpu_to_le32(addr + 0x8000); 4411d26fc955SAlan Cox } 4412d26fc955SAlan Cox ap->prd[idx].flags_len = cpu_to_le32(blen); 4413d26fc955SAlan Cox VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len); 4414d26fc955SAlan Cox 4415d26fc955SAlan Cox idx++; 4416d26fc955SAlan Cox sg_len -= len; 4417d26fc955SAlan Cox addr += len; 4418d26fc955SAlan Cox } 4419d26fc955SAlan Cox } 4420d26fc955SAlan Cox 4421d26fc955SAlan Cox if (idx) 4422d26fc955SAlan Cox ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT); 4423d26fc955SAlan Cox } 4424d26fc955SAlan Cox 4425d26fc955SAlan Cox /** 4426c6fd2807SJeff Garzik * ata_check_atapi_dma - Check whether ATAPI DMA can be supported 4427c6fd2807SJeff Garzik * @qc: Metadata associated with taskfile to check 4428c6fd2807SJeff Garzik * 4429c6fd2807SJeff Garzik * Allow low-level driver to filter ATA PACKET commands, returning 4430c6fd2807SJeff Garzik * a status indicating whether or not it is OK to use DMA for the 4431c6fd2807SJeff Garzik * supplied PACKET command. 4432c6fd2807SJeff Garzik * 4433c6fd2807SJeff Garzik * LOCKING: 4434cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4435c6fd2807SJeff Garzik * 4436c6fd2807SJeff Garzik * RETURNS: 0 when ATAPI DMA can be used 4437c6fd2807SJeff Garzik * nonzero otherwise 4438c6fd2807SJeff Garzik */ 4439c6fd2807SJeff Garzik int ata_check_atapi_dma(struct ata_queued_cmd *qc) 4440c6fd2807SJeff Garzik { 4441c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4442c6fd2807SJeff Garzik 4443b9a4197eSTejun Heo /* Don't allow DMA if it isn't multiple of 16 bytes. Quite a 4444b9a4197eSTejun Heo * few ATAPI devices choke on such DMA requests. 4445b9a4197eSTejun Heo */ 4446b9a4197eSTejun Heo if (unlikely(qc->nbytes & 15)) 44476f23a31dSAlbert Lee return 1; 44486f23a31dSAlbert Lee 4449c6fd2807SJeff Garzik if (ap->ops->check_atapi_dma) 4450b9a4197eSTejun Heo return ap->ops->check_atapi_dma(qc); 4451c6fd2807SJeff Garzik 4452b9a4197eSTejun Heo return 0; 4453c6fd2807SJeff Garzik } 4454b9a4197eSTejun Heo 4455c6fd2807SJeff Garzik /** 445631cc23b3STejun Heo * ata_std_qc_defer - Check whether a qc needs to be deferred 445731cc23b3STejun Heo * @qc: ATA command in question 445831cc23b3STejun Heo * 445931cc23b3STejun Heo * Non-NCQ commands cannot run with any other command, NCQ or 446031cc23b3STejun Heo * not. As upper layer only knows the queue depth, we are 446131cc23b3STejun Heo * responsible for maintaining exclusion. This function checks 446231cc23b3STejun Heo * whether a new command @qc can be issued. 446331cc23b3STejun Heo * 446431cc23b3STejun Heo * LOCKING: 446531cc23b3STejun Heo * spin_lock_irqsave(host lock) 446631cc23b3STejun Heo * 446731cc23b3STejun Heo * RETURNS: 446831cc23b3STejun Heo * ATA_DEFER_* if deferring is needed, 0 otherwise. 446931cc23b3STejun Heo */ 447031cc23b3STejun Heo int ata_std_qc_defer(struct ata_queued_cmd *qc) 447131cc23b3STejun Heo { 447231cc23b3STejun Heo struct ata_link *link = qc->dev->link; 447331cc23b3STejun Heo 447431cc23b3STejun Heo if (qc->tf.protocol == ATA_PROT_NCQ) { 447531cc23b3STejun Heo if (!ata_tag_valid(link->active_tag)) 447631cc23b3STejun Heo return 0; 447731cc23b3STejun Heo } else { 447831cc23b3STejun Heo if (!ata_tag_valid(link->active_tag) && !link->sactive) 447931cc23b3STejun Heo return 0; 448031cc23b3STejun Heo } 448131cc23b3STejun Heo 448231cc23b3STejun Heo return ATA_DEFER_LINK; 448331cc23b3STejun Heo } 448431cc23b3STejun Heo 448531cc23b3STejun Heo /** 4486c6fd2807SJeff Garzik * ata_qc_prep - Prepare taskfile for submission 4487c6fd2807SJeff Garzik * @qc: Metadata associated with taskfile to be prepared 4488c6fd2807SJeff Garzik * 4489c6fd2807SJeff Garzik * Prepare ATA taskfile for submission. 4490c6fd2807SJeff Garzik * 4491c6fd2807SJeff Garzik * LOCKING: 4492cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4493c6fd2807SJeff Garzik */ 4494c6fd2807SJeff Garzik void ata_qc_prep(struct ata_queued_cmd *qc) 4495c6fd2807SJeff Garzik { 4496c6fd2807SJeff Garzik if (!(qc->flags & ATA_QCFLAG_DMAMAP)) 4497c6fd2807SJeff Garzik return; 4498c6fd2807SJeff Garzik 4499c6fd2807SJeff Garzik ata_fill_sg(qc); 4500c6fd2807SJeff Garzik } 4501c6fd2807SJeff Garzik 4502d26fc955SAlan Cox /** 4503d26fc955SAlan Cox * ata_dumb_qc_prep - Prepare taskfile for submission 4504d26fc955SAlan Cox * @qc: Metadata associated with taskfile to be prepared 4505d26fc955SAlan Cox * 4506d26fc955SAlan Cox * Prepare ATA taskfile for submission. 4507d26fc955SAlan Cox * 4508d26fc955SAlan Cox * LOCKING: 4509d26fc955SAlan Cox * spin_lock_irqsave(host lock) 4510d26fc955SAlan Cox */ 4511d26fc955SAlan Cox void ata_dumb_qc_prep(struct ata_queued_cmd *qc) 4512d26fc955SAlan Cox { 4513d26fc955SAlan Cox if (!(qc->flags & ATA_QCFLAG_DMAMAP)) 4514d26fc955SAlan Cox return; 4515d26fc955SAlan Cox 4516d26fc955SAlan Cox ata_fill_sg_dumb(qc); 4517d26fc955SAlan Cox } 4518d26fc955SAlan Cox 4519c6fd2807SJeff Garzik void ata_noop_qc_prep(struct ata_queued_cmd *qc) { } 4520c6fd2807SJeff Garzik 4521c6fd2807SJeff Garzik /** 4522c6fd2807SJeff Garzik * ata_sg_init_one - Associate command with memory buffer 4523c6fd2807SJeff Garzik * @qc: Command to be associated 4524c6fd2807SJeff Garzik * @buf: Memory buffer 4525c6fd2807SJeff Garzik * @buflen: Length of memory buffer, in bytes. 4526c6fd2807SJeff Garzik * 4527c6fd2807SJeff Garzik * Initialize the data-related elements of queued_cmd @qc 4528c6fd2807SJeff Garzik * to point to a single memory buffer, @buf of byte length @buflen. 4529c6fd2807SJeff Garzik * 4530c6fd2807SJeff Garzik * LOCKING: 4531cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4532c6fd2807SJeff Garzik */ 4533c6fd2807SJeff Garzik 4534c6fd2807SJeff Garzik void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen) 4535c6fd2807SJeff Garzik { 4536c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_SINGLE; 4537c6fd2807SJeff Garzik 4538c6fd2807SJeff Garzik qc->__sg = &qc->sgent; 4539c6fd2807SJeff Garzik qc->n_elem = 1; 4540c6fd2807SJeff Garzik qc->orig_n_elem = 1; 4541c6fd2807SJeff Garzik qc->buf_virt = buf; 4542c6fd2807SJeff Garzik qc->nbytes = buflen; 4543c6fd2807SJeff Garzik 454461c0596cSTejun Heo sg_init_one(&qc->sgent, buf, buflen); 4545c6fd2807SJeff Garzik } 4546c6fd2807SJeff Garzik 4547c6fd2807SJeff Garzik /** 4548c6fd2807SJeff Garzik * ata_sg_init - Associate command with scatter-gather table. 4549c6fd2807SJeff Garzik * @qc: Command to be associated 4550c6fd2807SJeff Garzik * @sg: Scatter-gather table. 4551c6fd2807SJeff Garzik * @n_elem: Number of elements in s/g table. 4552c6fd2807SJeff Garzik * 4553c6fd2807SJeff Garzik * Initialize the data-related elements of queued_cmd @qc 4554c6fd2807SJeff Garzik * to point to a scatter-gather table @sg, containing @n_elem 4555c6fd2807SJeff Garzik * elements. 4556c6fd2807SJeff Garzik * 4557c6fd2807SJeff Garzik * LOCKING: 4558cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4559c6fd2807SJeff Garzik */ 4560c6fd2807SJeff Garzik 4561c6fd2807SJeff Garzik void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg, 4562c6fd2807SJeff Garzik unsigned int n_elem) 4563c6fd2807SJeff Garzik { 4564c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_SG; 4565c6fd2807SJeff Garzik qc->__sg = sg; 4566c6fd2807SJeff Garzik qc->n_elem = n_elem; 4567c6fd2807SJeff Garzik qc->orig_n_elem = n_elem; 4568c6fd2807SJeff Garzik } 4569c6fd2807SJeff Garzik 4570c6fd2807SJeff Garzik /** 4571c6fd2807SJeff Garzik * ata_sg_setup_one - DMA-map the memory buffer associated with a command. 4572c6fd2807SJeff Garzik * @qc: Command with memory buffer to be mapped. 4573c6fd2807SJeff Garzik * 4574c6fd2807SJeff Garzik * DMA-map the memory buffer associated with queued_cmd @qc. 4575c6fd2807SJeff Garzik * 4576c6fd2807SJeff Garzik * LOCKING: 4577cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4578c6fd2807SJeff Garzik * 4579c6fd2807SJeff Garzik * RETURNS: 4580c6fd2807SJeff Garzik * Zero on success, negative on error. 4581c6fd2807SJeff Garzik */ 4582c6fd2807SJeff Garzik 4583c6fd2807SJeff Garzik static int ata_sg_setup_one(struct ata_queued_cmd *qc) 4584c6fd2807SJeff Garzik { 4585c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4586c6fd2807SJeff Garzik int dir = qc->dma_dir; 4587c6fd2807SJeff Garzik struct scatterlist *sg = qc->__sg; 4588c6fd2807SJeff Garzik dma_addr_t dma_address; 4589c6fd2807SJeff Garzik int trim_sg = 0; 4590c6fd2807SJeff Garzik 4591c6fd2807SJeff Garzik /* we must lengthen transfers to end on a 32-bit boundary */ 4592c6fd2807SJeff Garzik qc->pad_len = sg->length & 3; 4593c6fd2807SJeff Garzik if (qc->pad_len) { 4594c6fd2807SJeff Garzik void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ); 4595c6fd2807SJeff Garzik struct scatterlist *psg = &qc->pad_sgent; 4596c6fd2807SJeff Garzik 4597c6fd2807SJeff Garzik WARN_ON(qc->dev->class != ATA_DEV_ATAPI); 4598c6fd2807SJeff Garzik 4599c6fd2807SJeff Garzik memset(pad_buf, 0, ATA_DMA_PAD_SZ); 4600c6fd2807SJeff Garzik 4601c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_WRITE) 4602c6fd2807SJeff Garzik memcpy(pad_buf, qc->buf_virt + sg->length - qc->pad_len, 4603c6fd2807SJeff Garzik qc->pad_len); 4604c6fd2807SJeff Garzik 4605c6fd2807SJeff Garzik sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ); 4606c6fd2807SJeff Garzik sg_dma_len(psg) = ATA_DMA_PAD_SZ; 4607c6fd2807SJeff Garzik /* trim sg */ 4608c6fd2807SJeff Garzik sg->length -= qc->pad_len; 4609c6fd2807SJeff Garzik if (sg->length == 0) 4610c6fd2807SJeff Garzik trim_sg = 1; 4611c6fd2807SJeff Garzik 4612c6fd2807SJeff Garzik DPRINTK("padding done, sg->length=%u pad_len=%u\n", 4613c6fd2807SJeff Garzik sg->length, qc->pad_len); 4614c6fd2807SJeff Garzik } 4615c6fd2807SJeff Garzik 4616c6fd2807SJeff Garzik if (trim_sg) { 4617c6fd2807SJeff Garzik qc->n_elem--; 4618c6fd2807SJeff Garzik goto skip_map; 4619c6fd2807SJeff Garzik } 4620c6fd2807SJeff Garzik 4621c6fd2807SJeff Garzik dma_address = dma_map_single(ap->dev, qc->buf_virt, 4622c6fd2807SJeff Garzik sg->length, dir); 4623c6fd2807SJeff Garzik if (dma_mapping_error(dma_address)) { 4624c6fd2807SJeff Garzik /* restore sg */ 4625c6fd2807SJeff Garzik sg->length += qc->pad_len; 4626c6fd2807SJeff Garzik return -1; 4627c6fd2807SJeff Garzik } 4628c6fd2807SJeff Garzik 4629c6fd2807SJeff Garzik sg_dma_address(sg) = dma_address; 4630c6fd2807SJeff Garzik sg_dma_len(sg) = sg->length; 4631c6fd2807SJeff Garzik 4632c6fd2807SJeff Garzik skip_map: 4633c6fd2807SJeff Garzik DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg), 4634c6fd2807SJeff Garzik qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read"); 4635c6fd2807SJeff Garzik 4636c6fd2807SJeff Garzik return 0; 4637c6fd2807SJeff Garzik } 4638c6fd2807SJeff Garzik 4639c6fd2807SJeff Garzik /** 4640c6fd2807SJeff Garzik * ata_sg_setup - DMA-map the scatter-gather table associated with a command. 4641c6fd2807SJeff Garzik * @qc: Command with scatter-gather table to be mapped. 4642c6fd2807SJeff Garzik * 4643c6fd2807SJeff Garzik * DMA-map the scatter-gather table associated with queued_cmd @qc. 4644c6fd2807SJeff Garzik * 4645c6fd2807SJeff Garzik * LOCKING: 4646cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4647c6fd2807SJeff Garzik * 4648c6fd2807SJeff Garzik * RETURNS: 4649c6fd2807SJeff Garzik * Zero on success, negative on error. 4650c6fd2807SJeff Garzik * 4651c6fd2807SJeff Garzik */ 4652c6fd2807SJeff Garzik 4653c6fd2807SJeff Garzik static int ata_sg_setup(struct ata_queued_cmd *qc) 4654c6fd2807SJeff Garzik { 4655c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4656c6fd2807SJeff Garzik struct scatterlist *sg = qc->__sg; 4657c6fd2807SJeff Garzik struct scatterlist *lsg = &sg[qc->n_elem - 1]; 4658c6fd2807SJeff Garzik int n_elem, pre_n_elem, dir, trim_sg = 0; 4659c6fd2807SJeff Garzik 466044877b4eSTejun Heo VPRINTK("ENTER, ata%u\n", ap->print_id); 4661c6fd2807SJeff Garzik WARN_ON(!(qc->flags & ATA_QCFLAG_SG)); 4662c6fd2807SJeff Garzik 4663c6fd2807SJeff Garzik /* we must lengthen transfers to end on a 32-bit boundary */ 4664c6fd2807SJeff Garzik qc->pad_len = lsg->length & 3; 4665c6fd2807SJeff Garzik if (qc->pad_len) { 4666c6fd2807SJeff Garzik void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ); 4667c6fd2807SJeff Garzik struct scatterlist *psg = &qc->pad_sgent; 4668c6fd2807SJeff Garzik unsigned int offset; 4669c6fd2807SJeff Garzik 4670c6fd2807SJeff Garzik WARN_ON(qc->dev->class != ATA_DEV_ATAPI); 4671c6fd2807SJeff Garzik 4672c6fd2807SJeff Garzik memset(pad_buf, 0, ATA_DMA_PAD_SZ); 4673c6fd2807SJeff Garzik 4674c6fd2807SJeff Garzik /* 4675c6fd2807SJeff Garzik * psg->page/offset are used to copy to-be-written 4676c6fd2807SJeff Garzik * data in this function or read data in ata_sg_clean. 4677c6fd2807SJeff Garzik */ 4678c6fd2807SJeff Garzik offset = lsg->offset + lsg->length - qc->pad_len; 4679c6fd2807SJeff Garzik psg->page = nth_page(lsg->page, offset >> PAGE_SHIFT); 4680c6fd2807SJeff Garzik psg->offset = offset_in_page(offset); 4681c6fd2807SJeff Garzik 4682c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_WRITE) { 4683c6fd2807SJeff Garzik void *addr = kmap_atomic(psg->page, KM_IRQ0); 4684c6fd2807SJeff Garzik memcpy(pad_buf, addr + psg->offset, qc->pad_len); 4685c6fd2807SJeff Garzik kunmap_atomic(addr, KM_IRQ0); 4686c6fd2807SJeff Garzik } 4687c6fd2807SJeff Garzik 4688c6fd2807SJeff Garzik sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ); 4689c6fd2807SJeff Garzik sg_dma_len(psg) = ATA_DMA_PAD_SZ; 4690c6fd2807SJeff Garzik /* trim last sg */ 4691c6fd2807SJeff Garzik lsg->length -= qc->pad_len; 4692c6fd2807SJeff Garzik if (lsg->length == 0) 4693c6fd2807SJeff Garzik trim_sg = 1; 4694c6fd2807SJeff Garzik 4695c6fd2807SJeff Garzik DPRINTK("padding done, sg[%d].length=%u pad_len=%u\n", 4696c6fd2807SJeff Garzik qc->n_elem - 1, lsg->length, qc->pad_len); 4697c6fd2807SJeff Garzik } 4698c6fd2807SJeff Garzik 4699c6fd2807SJeff Garzik pre_n_elem = qc->n_elem; 4700c6fd2807SJeff Garzik if (trim_sg && pre_n_elem) 4701c6fd2807SJeff Garzik pre_n_elem--; 4702c6fd2807SJeff Garzik 4703c6fd2807SJeff Garzik if (!pre_n_elem) { 4704c6fd2807SJeff Garzik n_elem = 0; 4705c6fd2807SJeff Garzik goto skip_map; 4706c6fd2807SJeff Garzik } 4707c6fd2807SJeff Garzik 4708c6fd2807SJeff Garzik dir = qc->dma_dir; 4709c6fd2807SJeff Garzik n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir); 4710c6fd2807SJeff Garzik if (n_elem < 1) { 4711c6fd2807SJeff Garzik /* restore last sg */ 4712c6fd2807SJeff Garzik lsg->length += qc->pad_len; 4713c6fd2807SJeff Garzik return -1; 4714c6fd2807SJeff Garzik } 4715c6fd2807SJeff Garzik 4716c6fd2807SJeff Garzik DPRINTK("%d sg elements mapped\n", n_elem); 4717c6fd2807SJeff Garzik 4718c6fd2807SJeff Garzik skip_map: 4719c6fd2807SJeff Garzik qc->n_elem = n_elem; 4720c6fd2807SJeff Garzik 4721c6fd2807SJeff Garzik return 0; 4722c6fd2807SJeff Garzik } 4723c6fd2807SJeff Garzik 4724c6fd2807SJeff Garzik /** 4725c6fd2807SJeff Garzik * swap_buf_le16 - swap halves of 16-bit words in place 4726c6fd2807SJeff Garzik * @buf: Buffer to swap 4727c6fd2807SJeff Garzik * @buf_words: Number of 16-bit words in buffer. 4728c6fd2807SJeff Garzik * 4729c6fd2807SJeff Garzik * Swap halves of 16-bit words if needed to convert from 4730c6fd2807SJeff Garzik * little-endian byte order to native cpu byte order, or 4731c6fd2807SJeff Garzik * vice-versa. 4732c6fd2807SJeff Garzik * 4733c6fd2807SJeff Garzik * LOCKING: 4734c6fd2807SJeff Garzik * Inherited from caller. 4735c6fd2807SJeff Garzik */ 4736c6fd2807SJeff Garzik void swap_buf_le16(u16 *buf, unsigned int buf_words) 4737c6fd2807SJeff Garzik { 4738c6fd2807SJeff Garzik #ifdef __BIG_ENDIAN 4739c6fd2807SJeff Garzik unsigned int i; 4740c6fd2807SJeff Garzik 4741c6fd2807SJeff Garzik for (i = 0; i < buf_words; i++) 4742c6fd2807SJeff Garzik buf[i] = le16_to_cpu(buf[i]); 4743c6fd2807SJeff Garzik #endif /* __BIG_ENDIAN */ 4744c6fd2807SJeff Garzik } 4745c6fd2807SJeff Garzik 4746c6fd2807SJeff Garzik /** 47470d5ff566STejun Heo * ata_data_xfer - Transfer data by PIO 4748c6fd2807SJeff Garzik * @adev: device to target 4749c6fd2807SJeff Garzik * @buf: data buffer 4750c6fd2807SJeff Garzik * @buflen: buffer length 4751c6fd2807SJeff Garzik * @write_data: read/write 4752c6fd2807SJeff Garzik * 4753c6fd2807SJeff Garzik * Transfer data from/to the device data register by PIO. 4754c6fd2807SJeff Garzik * 4755c6fd2807SJeff Garzik * LOCKING: 4756c6fd2807SJeff Garzik * Inherited from caller. 4757c6fd2807SJeff Garzik */ 47580d5ff566STejun Heo void ata_data_xfer(struct ata_device *adev, unsigned char *buf, 4759c6fd2807SJeff Garzik unsigned int buflen, int write_data) 4760c6fd2807SJeff Garzik { 47619af5c9c9STejun Heo struct ata_port *ap = adev->link->ap; 4762c6fd2807SJeff Garzik unsigned int words = buflen >> 1; 4763c6fd2807SJeff Garzik 4764c6fd2807SJeff Garzik /* Transfer multiple of 2 bytes */ 4765c6fd2807SJeff Garzik if (write_data) 47660d5ff566STejun Heo iowrite16_rep(ap->ioaddr.data_addr, buf, words); 4767c6fd2807SJeff Garzik else 47680d5ff566STejun Heo ioread16_rep(ap->ioaddr.data_addr, buf, words); 4769c6fd2807SJeff Garzik 4770c6fd2807SJeff Garzik /* Transfer trailing 1 byte, if any. */ 4771c6fd2807SJeff Garzik if (unlikely(buflen & 0x01)) { 4772c6fd2807SJeff Garzik u16 align_buf[1] = { 0 }; 4773c6fd2807SJeff Garzik unsigned char *trailing_buf = buf + buflen - 1; 4774c6fd2807SJeff Garzik 4775c6fd2807SJeff Garzik if (write_data) { 4776c6fd2807SJeff Garzik memcpy(align_buf, trailing_buf, 1); 47770d5ff566STejun Heo iowrite16(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr); 4778c6fd2807SJeff Garzik } else { 47790d5ff566STejun Heo align_buf[0] = cpu_to_le16(ioread16(ap->ioaddr.data_addr)); 4780c6fd2807SJeff Garzik memcpy(trailing_buf, align_buf, 1); 4781c6fd2807SJeff Garzik } 4782c6fd2807SJeff Garzik } 4783c6fd2807SJeff Garzik } 4784c6fd2807SJeff Garzik 4785c6fd2807SJeff Garzik /** 47860d5ff566STejun Heo * ata_data_xfer_noirq - Transfer data by PIO 4787c6fd2807SJeff Garzik * @adev: device to target 4788c6fd2807SJeff Garzik * @buf: data buffer 4789c6fd2807SJeff Garzik * @buflen: buffer length 4790c6fd2807SJeff Garzik * @write_data: read/write 4791c6fd2807SJeff Garzik * 4792c6fd2807SJeff Garzik * Transfer data from/to the device data register by PIO. Do the 4793c6fd2807SJeff Garzik * transfer with interrupts disabled. 4794c6fd2807SJeff Garzik * 4795c6fd2807SJeff Garzik * LOCKING: 4796c6fd2807SJeff Garzik * Inherited from caller. 4797c6fd2807SJeff Garzik */ 47980d5ff566STejun Heo void ata_data_xfer_noirq(struct ata_device *adev, unsigned char *buf, 4799c6fd2807SJeff Garzik unsigned int buflen, int write_data) 4800c6fd2807SJeff Garzik { 4801c6fd2807SJeff Garzik unsigned long flags; 4802c6fd2807SJeff Garzik local_irq_save(flags); 48030d5ff566STejun Heo ata_data_xfer(adev, buf, buflen, write_data); 4804c6fd2807SJeff Garzik local_irq_restore(flags); 4805c6fd2807SJeff Garzik } 4806c6fd2807SJeff Garzik 4807c6fd2807SJeff Garzik 4808c6fd2807SJeff Garzik /** 48095a5dbd18SMark Lord * ata_pio_sector - Transfer a sector of data. 4810c6fd2807SJeff Garzik * @qc: Command on going 4811c6fd2807SJeff Garzik * 48125a5dbd18SMark Lord * Transfer qc->sect_size bytes of data from/to the ATA device. 4813c6fd2807SJeff Garzik * 4814c6fd2807SJeff Garzik * LOCKING: 4815c6fd2807SJeff Garzik * Inherited from caller. 4816c6fd2807SJeff Garzik */ 4817c6fd2807SJeff Garzik 4818c6fd2807SJeff Garzik static void ata_pio_sector(struct ata_queued_cmd *qc) 4819c6fd2807SJeff Garzik { 4820c6fd2807SJeff Garzik int do_write = (qc->tf.flags & ATA_TFLAG_WRITE); 4821c6fd2807SJeff Garzik struct scatterlist *sg = qc->__sg; 4822c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4823c6fd2807SJeff Garzik struct page *page; 4824c6fd2807SJeff Garzik unsigned int offset; 4825c6fd2807SJeff Garzik unsigned char *buf; 4826c6fd2807SJeff Garzik 48275a5dbd18SMark Lord if (qc->curbytes == qc->nbytes - qc->sect_size) 4828c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4829c6fd2807SJeff Garzik 4830c6fd2807SJeff Garzik page = sg[qc->cursg].page; 4831726f0785STejun Heo offset = sg[qc->cursg].offset + qc->cursg_ofs; 4832c6fd2807SJeff Garzik 4833c6fd2807SJeff Garzik /* get the current page and offset */ 4834c6fd2807SJeff Garzik page = nth_page(page, (offset >> PAGE_SHIFT)); 4835c6fd2807SJeff Garzik offset %= PAGE_SIZE; 4836c6fd2807SJeff Garzik 4837c6fd2807SJeff Garzik DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read"); 4838c6fd2807SJeff Garzik 4839c6fd2807SJeff Garzik if (PageHighMem(page)) { 4840c6fd2807SJeff Garzik unsigned long flags; 4841c6fd2807SJeff Garzik 4842c6fd2807SJeff Garzik /* FIXME: use a bounce buffer */ 4843c6fd2807SJeff Garzik local_irq_save(flags); 4844c6fd2807SJeff Garzik buf = kmap_atomic(page, KM_IRQ0); 4845c6fd2807SJeff Garzik 4846c6fd2807SJeff Garzik /* do the actual data transfer */ 48475a5dbd18SMark Lord ap->ops->data_xfer(qc->dev, buf + offset, qc->sect_size, do_write); 4848c6fd2807SJeff Garzik 4849c6fd2807SJeff Garzik kunmap_atomic(buf, KM_IRQ0); 4850c6fd2807SJeff Garzik local_irq_restore(flags); 4851c6fd2807SJeff Garzik } else { 4852c6fd2807SJeff Garzik buf = page_address(page); 48535a5dbd18SMark Lord ap->ops->data_xfer(qc->dev, buf + offset, qc->sect_size, do_write); 4854c6fd2807SJeff Garzik } 4855c6fd2807SJeff Garzik 48565a5dbd18SMark Lord qc->curbytes += qc->sect_size; 48575a5dbd18SMark Lord qc->cursg_ofs += qc->sect_size; 4858c6fd2807SJeff Garzik 4859726f0785STejun Heo if (qc->cursg_ofs == (&sg[qc->cursg])->length) { 4860c6fd2807SJeff Garzik qc->cursg++; 4861c6fd2807SJeff Garzik qc->cursg_ofs = 0; 4862c6fd2807SJeff Garzik } 4863c6fd2807SJeff Garzik } 4864c6fd2807SJeff Garzik 4865c6fd2807SJeff Garzik /** 48665a5dbd18SMark Lord * ata_pio_sectors - Transfer one or many sectors. 4867c6fd2807SJeff Garzik * @qc: Command on going 4868c6fd2807SJeff Garzik * 48695a5dbd18SMark Lord * Transfer one or many sectors of data from/to the 4870c6fd2807SJeff Garzik * ATA device for the DRQ request. 4871c6fd2807SJeff Garzik * 4872c6fd2807SJeff Garzik * LOCKING: 4873c6fd2807SJeff Garzik * Inherited from caller. 4874c6fd2807SJeff Garzik */ 4875c6fd2807SJeff Garzik 4876c6fd2807SJeff Garzik static void ata_pio_sectors(struct ata_queued_cmd *qc) 4877c6fd2807SJeff Garzik { 4878c6fd2807SJeff Garzik if (is_multi_taskfile(&qc->tf)) { 4879c6fd2807SJeff Garzik /* READ/WRITE MULTIPLE */ 4880c6fd2807SJeff Garzik unsigned int nsect; 4881c6fd2807SJeff Garzik 4882c6fd2807SJeff Garzik WARN_ON(qc->dev->multi_count == 0); 4883c6fd2807SJeff Garzik 48845a5dbd18SMark Lord nsect = min((qc->nbytes - qc->curbytes) / qc->sect_size, 4885726f0785STejun Heo qc->dev->multi_count); 4886c6fd2807SJeff Garzik while (nsect--) 4887c6fd2807SJeff Garzik ata_pio_sector(qc); 4888c6fd2807SJeff Garzik } else 4889c6fd2807SJeff Garzik ata_pio_sector(qc); 48904cc980b3SAlbert Lee 48914cc980b3SAlbert Lee ata_altstatus(qc->ap); /* flush */ 4892c6fd2807SJeff Garzik } 4893c6fd2807SJeff Garzik 4894c6fd2807SJeff Garzik /** 4895c6fd2807SJeff Garzik * atapi_send_cdb - Write CDB bytes to hardware 4896c6fd2807SJeff Garzik * @ap: Port to which ATAPI device is attached. 4897c6fd2807SJeff Garzik * @qc: Taskfile currently active 4898c6fd2807SJeff Garzik * 4899c6fd2807SJeff Garzik * When device has indicated its readiness to accept 4900c6fd2807SJeff Garzik * a CDB, this function is called. Send the CDB. 4901c6fd2807SJeff Garzik * 4902c6fd2807SJeff Garzik * LOCKING: 4903c6fd2807SJeff Garzik * caller. 4904c6fd2807SJeff Garzik */ 4905c6fd2807SJeff Garzik 4906c6fd2807SJeff Garzik static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc) 4907c6fd2807SJeff Garzik { 4908c6fd2807SJeff Garzik /* send SCSI cdb */ 4909c6fd2807SJeff Garzik DPRINTK("send cdb\n"); 4910c6fd2807SJeff Garzik WARN_ON(qc->dev->cdb_len < 12); 4911c6fd2807SJeff Garzik 4912c6fd2807SJeff Garzik ap->ops->data_xfer(qc->dev, qc->cdb, qc->dev->cdb_len, 1); 4913c6fd2807SJeff Garzik ata_altstatus(ap); /* flush */ 4914c6fd2807SJeff Garzik 4915c6fd2807SJeff Garzik switch (qc->tf.protocol) { 4916c6fd2807SJeff Garzik case ATA_PROT_ATAPI: 4917c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST; 4918c6fd2807SJeff Garzik break; 4919c6fd2807SJeff Garzik case ATA_PROT_ATAPI_NODATA: 4920c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4921c6fd2807SJeff Garzik break; 4922c6fd2807SJeff Garzik case ATA_PROT_ATAPI_DMA: 4923c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4924c6fd2807SJeff Garzik /* initiate bmdma */ 4925c6fd2807SJeff Garzik ap->ops->bmdma_start(qc); 4926c6fd2807SJeff Garzik break; 4927c6fd2807SJeff Garzik } 4928c6fd2807SJeff Garzik } 4929c6fd2807SJeff Garzik 4930c6fd2807SJeff Garzik /** 4931c6fd2807SJeff Garzik * __atapi_pio_bytes - Transfer data from/to the ATAPI device. 4932c6fd2807SJeff Garzik * @qc: Command on going 4933c6fd2807SJeff Garzik * @bytes: number of bytes 4934c6fd2807SJeff Garzik * 4935c6fd2807SJeff Garzik * Transfer Transfer data from/to the ATAPI device. 4936c6fd2807SJeff Garzik * 4937c6fd2807SJeff Garzik * LOCKING: 4938c6fd2807SJeff Garzik * Inherited from caller. 4939c6fd2807SJeff Garzik * 4940c6fd2807SJeff Garzik */ 4941c6fd2807SJeff Garzik 4942c6fd2807SJeff Garzik static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes) 4943c6fd2807SJeff Garzik { 4944c6fd2807SJeff Garzik int do_write = (qc->tf.flags & ATA_TFLAG_WRITE); 4945c6fd2807SJeff Garzik struct scatterlist *sg = qc->__sg; 4946c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4947c6fd2807SJeff Garzik struct page *page; 4948c6fd2807SJeff Garzik unsigned char *buf; 4949c6fd2807SJeff Garzik unsigned int offset, count; 4950c6fd2807SJeff Garzik 4951c6fd2807SJeff Garzik if (qc->curbytes + bytes >= qc->nbytes) 4952c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4953c6fd2807SJeff Garzik 4954c6fd2807SJeff Garzik next_sg: 4955c6fd2807SJeff Garzik if (unlikely(qc->cursg >= qc->n_elem)) { 4956c6fd2807SJeff Garzik /* 4957c6fd2807SJeff Garzik * The end of qc->sg is reached and the device expects 4958c6fd2807SJeff Garzik * more data to transfer. In order not to overrun qc->sg 4959c6fd2807SJeff Garzik * and fulfill length specified in the byte count register, 4960c6fd2807SJeff Garzik * - for read case, discard trailing data from the device 4961c6fd2807SJeff Garzik * - for write case, padding zero data to the device 4962c6fd2807SJeff Garzik */ 4963c6fd2807SJeff Garzik u16 pad_buf[1] = { 0 }; 4964c6fd2807SJeff Garzik unsigned int words = bytes >> 1; 4965c6fd2807SJeff Garzik unsigned int i; 4966c6fd2807SJeff Garzik 4967c6fd2807SJeff Garzik if (words) /* warning if bytes > 1 */ 4968c6fd2807SJeff Garzik ata_dev_printk(qc->dev, KERN_WARNING, 4969c6fd2807SJeff Garzik "%u bytes trailing data\n", bytes); 4970c6fd2807SJeff Garzik 4971c6fd2807SJeff Garzik for (i = 0; i < words; i++) 4972c6fd2807SJeff Garzik ap->ops->data_xfer(qc->dev, (unsigned char*)pad_buf, 2, do_write); 4973c6fd2807SJeff Garzik 4974c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4975c6fd2807SJeff Garzik return; 4976c6fd2807SJeff Garzik } 4977c6fd2807SJeff Garzik 4978c6fd2807SJeff Garzik sg = &qc->__sg[qc->cursg]; 4979c6fd2807SJeff Garzik 4980c6fd2807SJeff Garzik page = sg->page; 4981c6fd2807SJeff Garzik offset = sg->offset + qc->cursg_ofs; 4982c6fd2807SJeff Garzik 4983c6fd2807SJeff Garzik /* get the current page and offset */ 4984c6fd2807SJeff Garzik page = nth_page(page, (offset >> PAGE_SHIFT)); 4985c6fd2807SJeff Garzik offset %= PAGE_SIZE; 4986c6fd2807SJeff Garzik 4987c6fd2807SJeff Garzik /* don't overrun current sg */ 4988c6fd2807SJeff Garzik count = min(sg->length - qc->cursg_ofs, bytes); 4989c6fd2807SJeff Garzik 4990c6fd2807SJeff Garzik /* don't cross page boundaries */ 4991c6fd2807SJeff Garzik count = min(count, (unsigned int)PAGE_SIZE - offset); 4992c6fd2807SJeff Garzik 4993c6fd2807SJeff Garzik DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read"); 4994c6fd2807SJeff Garzik 4995c6fd2807SJeff Garzik if (PageHighMem(page)) { 4996c6fd2807SJeff Garzik unsigned long flags; 4997c6fd2807SJeff Garzik 4998c6fd2807SJeff Garzik /* FIXME: use bounce buffer */ 4999c6fd2807SJeff Garzik local_irq_save(flags); 5000c6fd2807SJeff Garzik buf = kmap_atomic(page, KM_IRQ0); 5001c6fd2807SJeff Garzik 5002c6fd2807SJeff Garzik /* do the actual data transfer */ 5003c6fd2807SJeff Garzik ap->ops->data_xfer(qc->dev, buf + offset, count, do_write); 5004c6fd2807SJeff Garzik 5005c6fd2807SJeff Garzik kunmap_atomic(buf, KM_IRQ0); 5006c6fd2807SJeff Garzik local_irq_restore(flags); 5007c6fd2807SJeff Garzik } else { 5008c6fd2807SJeff Garzik buf = page_address(page); 5009c6fd2807SJeff Garzik ap->ops->data_xfer(qc->dev, buf + offset, count, do_write); 5010c6fd2807SJeff Garzik } 5011c6fd2807SJeff Garzik 5012c6fd2807SJeff Garzik bytes -= count; 5013c6fd2807SJeff Garzik qc->curbytes += count; 5014c6fd2807SJeff Garzik qc->cursg_ofs += count; 5015c6fd2807SJeff Garzik 5016c6fd2807SJeff Garzik if (qc->cursg_ofs == sg->length) { 5017c6fd2807SJeff Garzik qc->cursg++; 5018c6fd2807SJeff Garzik qc->cursg_ofs = 0; 5019c6fd2807SJeff Garzik } 5020c6fd2807SJeff Garzik 5021c6fd2807SJeff Garzik if (bytes) 5022c6fd2807SJeff Garzik goto next_sg; 5023c6fd2807SJeff Garzik } 5024c6fd2807SJeff Garzik 5025c6fd2807SJeff Garzik /** 5026c6fd2807SJeff Garzik * atapi_pio_bytes - Transfer data from/to the ATAPI device. 5027c6fd2807SJeff Garzik * @qc: Command on going 5028c6fd2807SJeff Garzik * 5029c6fd2807SJeff Garzik * Transfer Transfer data from/to the ATAPI device. 5030c6fd2807SJeff Garzik * 5031c6fd2807SJeff Garzik * LOCKING: 5032c6fd2807SJeff Garzik * Inherited from caller. 5033c6fd2807SJeff Garzik */ 5034c6fd2807SJeff Garzik 5035c6fd2807SJeff Garzik static void atapi_pio_bytes(struct ata_queued_cmd *qc) 5036c6fd2807SJeff Garzik { 5037c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 5038c6fd2807SJeff Garzik struct ata_device *dev = qc->dev; 5039c6fd2807SJeff Garzik unsigned int ireason, bc_lo, bc_hi, bytes; 5040c6fd2807SJeff Garzik int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0; 5041c6fd2807SJeff Garzik 5042c6fd2807SJeff Garzik /* Abuse qc->result_tf for temp storage of intermediate TF 5043c6fd2807SJeff Garzik * here to save some kernel stack usage. 5044c6fd2807SJeff Garzik * For normal completion, qc->result_tf is not relevant. For 5045c6fd2807SJeff Garzik * error, qc->result_tf is later overwritten by ata_qc_complete(). 5046c6fd2807SJeff Garzik * So, the correctness of qc->result_tf is not affected. 5047c6fd2807SJeff Garzik */ 5048c6fd2807SJeff Garzik ap->ops->tf_read(ap, &qc->result_tf); 5049c6fd2807SJeff Garzik ireason = qc->result_tf.nsect; 5050c6fd2807SJeff Garzik bc_lo = qc->result_tf.lbam; 5051c6fd2807SJeff Garzik bc_hi = qc->result_tf.lbah; 5052c6fd2807SJeff Garzik bytes = (bc_hi << 8) | bc_lo; 5053c6fd2807SJeff Garzik 5054c6fd2807SJeff Garzik /* shall be cleared to zero, indicating xfer of data */ 5055c6fd2807SJeff Garzik if (ireason & (1 << 0)) 5056c6fd2807SJeff Garzik goto err_out; 5057c6fd2807SJeff Garzik 5058c6fd2807SJeff Garzik /* make sure transfer direction matches expected */ 5059c6fd2807SJeff Garzik i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0; 5060c6fd2807SJeff Garzik if (do_write != i_write) 5061c6fd2807SJeff Garzik goto err_out; 5062c6fd2807SJeff Garzik 506344877b4eSTejun Heo VPRINTK("ata%u: xfering %d bytes\n", ap->print_id, bytes); 5064c6fd2807SJeff Garzik 5065c6fd2807SJeff Garzik __atapi_pio_bytes(qc, bytes); 50664cc980b3SAlbert Lee ata_altstatus(ap); /* flush */ 5067c6fd2807SJeff Garzik 5068c6fd2807SJeff Garzik return; 5069c6fd2807SJeff Garzik 5070c6fd2807SJeff Garzik err_out: 5071c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "ATAPI check failed\n"); 5072c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HSM; 5073c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 5074c6fd2807SJeff Garzik } 5075c6fd2807SJeff Garzik 5076c6fd2807SJeff Garzik /** 5077c6fd2807SJeff Garzik * ata_hsm_ok_in_wq - Check if the qc can be handled in the workqueue. 5078c6fd2807SJeff Garzik * @ap: the target ata_port 5079c6fd2807SJeff Garzik * @qc: qc on going 5080c6fd2807SJeff Garzik * 5081c6fd2807SJeff Garzik * RETURNS: 5082c6fd2807SJeff Garzik * 1 if ok in workqueue, 0 otherwise. 5083c6fd2807SJeff Garzik */ 5084c6fd2807SJeff Garzik 5085c6fd2807SJeff Garzik static inline int ata_hsm_ok_in_wq(struct ata_port *ap, struct ata_queued_cmd *qc) 5086c6fd2807SJeff Garzik { 5087c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 5088c6fd2807SJeff Garzik return 1; 5089c6fd2807SJeff Garzik 5090c6fd2807SJeff Garzik if (ap->hsm_task_state == HSM_ST_FIRST) { 5091c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_PIO && 5092c6fd2807SJeff Garzik (qc->tf.flags & ATA_TFLAG_WRITE)) 5093c6fd2807SJeff Garzik return 1; 5094c6fd2807SJeff Garzik 5095c6fd2807SJeff Garzik if (is_atapi_taskfile(&qc->tf) && 5096c6fd2807SJeff Garzik !(qc->dev->flags & ATA_DFLAG_CDB_INTR)) 5097c6fd2807SJeff Garzik return 1; 5098c6fd2807SJeff Garzik } 5099c6fd2807SJeff Garzik 5100c6fd2807SJeff Garzik return 0; 5101c6fd2807SJeff Garzik } 5102c6fd2807SJeff Garzik 5103c6fd2807SJeff Garzik /** 5104c6fd2807SJeff Garzik * ata_hsm_qc_complete - finish a qc running on standard HSM 5105c6fd2807SJeff Garzik * @qc: Command to complete 5106c6fd2807SJeff Garzik * @in_wq: 1 if called from workqueue, 0 otherwise 5107c6fd2807SJeff Garzik * 5108c6fd2807SJeff Garzik * Finish @qc which is running on standard HSM. 5109c6fd2807SJeff Garzik * 5110c6fd2807SJeff Garzik * LOCKING: 5111cca3974eSJeff Garzik * If @in_wq is zero, spin_lock_irqsave(host lock). 5112c6fd2807SJeff Garzik * Otherwise, none on entry and grabs host lock. 5113c6fd2807SJeff Garzik */ 5114c6fd2807SJeff Garzik static void ata_hsm_qc_complete(struct ata_queued_cmd *qc, int in_wq) 5115c6fd2807SJeff Garzik { 5116c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 5117c6fd2807SJeff Garzik unsigned long flags; 5118c6fd2807SJeff Garzik 5119c6fd2807SJeff Garzik if (ap->ops->error_handler) { 5120c6fd2807SJeff Garzik if (in_wq) { 5121c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 5122c6fd2807SJeff Garzik 5123cca3974eSJeff Garzik /* EH might have kicked in while host lock is 5124cca3974eSJeff Garzik * released. 5125c6fd2807SJeff Garzik */ 5126c6fd2807SJeff Garzik qc = ata_qc_from_tag(ap, qc->tag); 5127c6fd2807SJeff Garzik if (qc) { 5128c6fd2807SJeff Garzik if (likely(!(qc->err_mask & AC_ERR_HSM))) { 512983625006SAkira Iguchi ap->ops->irq_on(ap); 5130c6fd2807SJeff Garzik ata_qc_complete(qc); 5131c6fd2807SJeff Garzik } else 5132c6fd2807SJeff Garzik ata_port_freeze(ap); 5133c6fd2807SJeff Garzik } 5134c6fd2807SJeff Garzik 5135c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5136c6fd2807SJeff Garzik } else { 5137c6fd2807SJeff Garzik if (likely(!(qc->err_mask & AC_ERR_HSM))) 5138c6fd2807SJeff Garzik ata_qc_complete(qc); 5139c6fd2807SJeff Garzik else 5140c6fd2807SJeff Garzik ata_port_freeze(ap); 5141c6fd2807SJeff Garzik } 5142c6fd2807SJeff Garzik } else { 5143c6fd2807SJeff Garzik if (in_wq) { 5144c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 514583625006SAkira Iguchi ap->ops->irq_on(ap); 5146c6fd2807SJeff Garzik ata_qc_complete(qc); 5147c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5148c6fd2807SJeff Garzik } else 5149c6fd2807SJeff Garzik ata_qc_complete(qc); 5150c6fd2807SJeff Garzik } 5151c6fd2807SJeff Garzik } 5152c6fd2807SJeff Garzik 5153c6fd2807SJeff Garzik /** 5154c6fd2807SJeff Garzik * ata_hsm_move - move the HSM to the next state. 5155c6fd2807SJeff Garzik * @ap: the target ata_port 5156c6fd2807SJeff Garzik * @qc: qc on going 5157c6fd2807SJeff Garzik * @status: current device status 5158c6fd2807SJeff Garzik * @in_wq: 1 if called from workqueue, 0 otherwise 5159c6fd2807SJeff Garzik * 5160c6fd2807SJeff Garzik * RETURNS: 5161c6fd2807SJeff Garzik * 1 when poll next status needed, 0 otherwise. 5162c6fd2807SJeff Garzik */ 5163c6fd2807SJeff Garzik int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc, 5164c6fd2807SJeff Garzik u8 status, int in_wq) 5165c6fd2807SJeff Garzik { 5166c6fd2807SJeff Garzik unsigned long flags = 0; 5167c6fd2807SJeff Garzik int poll_next; 5168c6fd2807SJeff Garzik 5169c6fd2807SJeff Garzik WARN_ON((qc->flags & ATA_QCFLAG_ACTIVE) == 0); 5170c6fd2807SJeff Garzik 5171c6fd2807SJeff Garzik /* Make sure ata_qc_issue_prot() does not throw things 5172c6fd2807SJeff Garzik * like DMA polling into the workqueue. Notice that 5173c6fd2807SJeff Garzik * in_wq is not equivalent to (qc->tf.flags & ATA_TFLAG_POLLING). 5174c6fd2807SJeff Garzik */ 5175c6fd2807SJeff Garzik WARN_ON(in_wq != ata_hsm_ok_in_wq(ap, qc)); 5176c6fd2807SJeff Garzik 5177c6fd2807SJeff Garzik fsm_start: 5178c6fd2807SJeff Garzik DPRINTK("ata%u: protocol %d task_state %d (dev_stat 0x%X)\n", 517944877b4eSTejun Heo ap->print_id, qc->tf.protocol, ap->hsm_task_state, status); 5180c6fd2807SJeff Garzik 5181c6fd2807SJeff Garzik switch (ap->hsm_task_state) { 5182c6fd2807SJeff Garzik case HSM_ST_FIRST: 5183c6fd2807SJeff Garzik /* Send first data block or PACKET CDB */ 5184c6fd2807SJeff Garzik 5185c6fd2807SJeff Garzik /* If polling, we will stay in the work queue after 5186c6fd2807SJeff Garzik * sending the data. Otherwise, interrupt handler 5187c6fd2807SJeff Garzik * takes over after sending the data. 5188c6fd2807SJeff Garzik */ 5189c6fd2807SJeff Garzik poll_next = (qc->tf.flags & ATA_TFLAG_POLLING); 5190c6fd2807SJeff Garzik 5191c6fd2807SJeff Garzik /* check device status */ 5192c6fd2807SJeff Garzik if (unlikely((status & ATA_DRQ) == 0)) { 5193c6fd2807SJeff Garzik /* handle BSY=0, DRQ=0 as error */ 5194c6fd2807SJeff Garzik if (likely(status & (ATA_ERR | ATA_DF))) 5195c6fd2807SJeff Garzik /* device stops HSM for abort/error */ 5196c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_DEV; 5197c6fd2807SJeff Garzik else 5198c6fd2807SJeff Garzik /* HSM violation. Let EH handle this */ 5199c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HSM; 5200c6fd2807SJeff Garzik 5201c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 5202c6fd2807SJeff Garzik goto fsm_start; 5203c6fd2807SJeff Garzik } 5204c6fd2807SJeff Garzik 5205c6fd2807SJeff Garzik /* Device should not ask for data transfer (DRQ=1) 5206c6fd2807SJeff Garzik * when it finds something wrong. 5207c6fd2807SJeff Garzik * We ignore DRQ here and stop the HSM by 5208c6fd2807SJeff Garzik * changing hsm_task_state to HSM_ST_ERR and 5209c6fd2807SJeff Garzik * let the EH abort the command or reset the device. 5210c6fd2807SJeff Garzik */ 5211c6fd2807SJeff Garzik if (unlikely(status & (ATA_ERR | ATA_DF))) { 521244877b4eSTejun Heo ata_port_printk(ap, KERN_WARNING, "DRQ=1 with device " 521344877b4eSTejun Heo "error, dev_stat 0x%X\n", status); 5214c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HSM; 5215c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 5216c6fd2807SJeff Garzik goto fsm_start; 5217c6fd2807SJeff Garzik } 5218c6fd2807SJeff Garzik 5219c6fd2807SJeff Garzik /* Send the CDB (atapi) or the first data block (ata pio out). 5220c6fd2807SJeff Garzik * During the state transition, interrupt handler shouldn't 5221c6fd2807SJeff Garzik * be invoked before the data transfer is complete and 5222c6fd2807SJeff Garzik * hsm_task_state is changed. Hence, the following locking. 5223c6fd2807SJeff Garzik */ 5224c6fd2807SJeff Garzik if (in_wq) 5225c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 5226c6fd2807SJeff Garzik 5227c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_PIO) { 5228c6fd2807SJeff Garzik /* PIO data out protocol. 5229c6fd2807SJeff Garzik * send first data block. 5230c6fd2807SJeff Garzik */ 5231c6fd2807SJeff Garzik 5232c6fd2807SJeff Garzik /* ata_pio_sectors() might change the state 5233c6fd2807SJeff Garzik * to HSM_ST_LAST. so, the state is changed here 5234c6fd2807SJeff Garzik * before ata_pio_sectors(). 5235c6fd2807SJeff Garzik */ 5236c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST; 5237c6fd2807SJeff Garzik ata_pio_sectors(qc); 5238c6fd2807SJeff Garzik } else 5239c6fd2807SJeff Garzik /* send CDB */ 5240c6fd2807SJeff Garzik atapi_send_cdb(ap, qc); 5241c6fd2807SJeff Garzik 5242c6fd2807SJeff Garzik if (in_wq) 5243c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5244c6fd2807SJeff Garzik 5245c6fd2807SJeff Garzik /* if polling, ata_pio_task() handles the rest. 5246c6fd2807SJeff Garzik * otherwise, interrupt handler takes over from here. 5247c6fd2807SJeff Garzik */ 5248c6fd2807SJeff Garzik break; 5249c6fd2807SJeff Garzik 5250c6fd2807SJeff Garzik case HSM_ST: 5251c6fd2807SJeff Garzik /* complete command or read/write the data register */ 5252c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_ATAPI) { 5253c6fd2807SJeff Garzik /* ATAPI PIO protocol */ 5254c6fd2807SJeff Garzik if ((status & ATA_DRQ) == 0) { 5255c6fd2807SJeff Garzik /* No more data to transfer or device error. 5256c6fd2807SJeff Garzik * Device error will be tagged in HSM_ST_LAST. 5257c6fd2807SJeff Garzik */ 5258c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 5259c6fd2807SJeff Garzik goto fsm_start; 5260c6fd2807SJeff Garzik } 5261c6fd2807SJeff Garzik 5262c6fd2807SJeff Garzik /* Device should not ask for data transfer (DRQ=1) 5263c6fd2807SJeff Garzik * when it finds something wrong. 5264c6fd2807SJeff Garzik * We ignore DRQ here and stop the HSM by 5265c6fd2807SJeff Garzik * changing hsm_task_state to HSM_ST_ERR and 5266c6fd2807SJeff Garzik * let the EH abort the command or reset the device. 5267c6fd2807SJeff Garzik */ 5268c6fd2807SJeff Garzik if (unlikely(status & (ATA_ERR | ATA_DF))) { 526944877b4eSTejun Heo ata_port_printk(ap, KERN_WARNING, "DRQ=1 with " 527044877b4eSTejun Heo "device error, dev_stat 0x%X\n", 527144877b4eSTejun Heo status); 5272c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HSM; 5273c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 5274c6fd2807SJeff Garzik goto fsm_start; 5275c6fd2807SJeff Garzik } 5276c6fd2807SJeff Garzik 5277c6fd2807SJeff Garzik atapi_pio_bytes(qc); 5278c6fd2807SJeff Garzik 5279c6fd2807SJeff Garzik if (unlikely(ap->hsm_task_state == HSM_ST_ERR)) 5280c6fd2807SJeff Garzik /* bad ireason reported by device */ 5281c6fd2807SJeff Garzik goto fsm_start; 5282c6fd2807SJeff Garzik 5283c6fd2807SJeff Garzik } else { 5284c6fd2807SJeff Garzik /* ATA PIO protocol */ 5285c6fd2807SJeff Garzik if (unlikely((status & ATA_DRQ) == 0)) { 5286c6fd2807SJeff Garzik /* handle BSY=0, DRQ=0 as error */ 5287c6fd2807SJeff Garzik if (likely(status & (ATA_ERR | ATA_DF))) 5288c6fd2807SJeff Garzik /* device stops HSM for abort/error */ 5289c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_DEV; 5290c6fd2807SJeff Garzik else 529155a8e2c8STejun Heo /* HSM violation. Let EH handle this. 529255a8e2c8STejun Heo * Phantom devices also trigger this 529355a8e2c8STejun Heo * condition. Mark hint. 529455a8e2c8STejun Heo */ 529555a8e2c8STejun Heo qc->err_mask |= AC_ERR_HSM | 529655a8e2c8STejun Heo AC_ERR_NODEV_HINT; 5297c6fd2807SJeff Garzik 5298c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 5299c6fd2807SJeff Garzik goto fsm_start; 5300c6fd2807SJeff Garzik } 5301c6fd2807SJeff Garzik 5302c6fd2807SJeff Garzik /* For PIO reads, some devices may ask for 5303c6fd2807SJeff Garzik * data transfer (DRQ=1) alone with ERR=1. 5304c6fd2807SJeff Garzik * We respect DRQ here and transfer one 5305c6fd2807SJeff Garzik * block of junk data before changing the 5306c6fd2807SJeff Garzik * hsm_task_state to HSM_ST_ERR. 5307c6fd2807SJeff Garzik * 5308c6fd2807SJeff Garzik * For PIO writes, ERR=1 DRQ=1 doesn't make 5309c6fd2807SJeff Garzik * sense since the data block has been 5310c6fd2807SJeff Garzik * transferred to the device. 5311c6fd2807SJeff Garzik */ 5312c6fd2807SJeff Garzik if (unlikely(status & (ATA_ERR | ATA_DF))) { 5313c6fd2807SJeff Garzik /* data might be corrputed */ 5314c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_DEV; 5315c6fd2807SJeff Garzik 5316c6fd2807SJeff Garzik if (!(qc->tf.flags & ATA_TFLAG_WRITE)) { 5317c6fd2807SJeff Garzik ata_pio_sectors(qc); 5318c6fd2807SJeff Garzik status = ata_wait_idle(ap); 5319c6fd2807SJeff Garzik } 5320c6fd2807SJeff Garzik 5321c6fd2807SJeff Garzik if (status & (ATA_BUSY | ATA_DRQ)) 5322c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HSM; 5323c6fd2807SJeff Garzik 5324c6fd2807SJeff Garzik /* ata_pio_sectors() might change the 5325c6fd2807SJeff Garzik * state to HSM_ST_LAST. so, the state 5326c6fd2807SJeff Garzik * is changed after ata_pio_sectors(). 5327c6fd2807SJeff Garzik */ 5328c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 5329c6fd2807SJeff Garzik goto fsm_start; 5330c6fd2807SJeff Garzik } 5331c6fd2807SJeff Garzik 5332c6fd2807SJeff Garzik ata_pio_sectors(qc); 5333c6fd2807SJeff Garzik 5334c6fd2807SJeff Garzik if (ap->hsm_task_state == HSM_ST_LAST && 5335c6fd2807SJeff Garzik (!(qc->tf.flags & ATA_TFLAG_WRITE))) { 5336c6fd2807SJeff Garzik /* all data read */ 5337c6fd2807SJeff Garzik status = ata_wait_idle(ap); 5338c6fd2807SJeff Garzik goto fsm_start; 5339c6fd2807SJeff Garzik } 5340c6fd2807SJeff Garzik } 5341c6fd2807SJeff Garzik 5342c6fd2807SJeff Garzik poll_next = 1; 5343c6fd2807SJeff Garzik break; 5344c6fd2807SJeff Garzik 5345c6fd2807SJeff Garzik case HSM_ST_LAST: 5346c6fd2807SJeff Garzik if (unlikely(!ata_ok(status))) { 5347c6fd2807SJeff Garzik qc->err_mask |= __ac_err_mask(status); 5348c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 5349c6fd2807SJeff Garzik goto fsm_start; 5350c6fd2807SJeff Garzik } 5351c6fd2807SJeff Garzik 5352c6fd2807SJeff Garzik /* no more data to transfer */ 5353c6fd2807SJeff Garzik DPRINTK("ata%u: dev %u command complete, drv_stat 0x%x\n", 535444877b4eSTejun Heo ap->print_id, qc->dev->devno, status); 5355c6fd2807SJeff Garzik 5356c6fd2807SJeff Garzik WARN_ON(qc->err_mask); 5357c6fd2807SJeff Garzik 5358c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_IDLE; 5359c6fd2807SJeff Garzik 5360c6fd2807SJeff Garzik /* complete taskfile transaction */ 5361c6fd2807SJeff Garzik ata_hsm_qc_complete(qc, in_wq); 5362c6fd2807SJeff Garzik 5363c6fd2807SJeff Garzik poll_next = 0; 5364c6fd2807SJeff Garzik break; 5365c6fd2807SJeff Garzik 5366c6fd2807SJeff Garzik case HSM_ST_ERR: 5367c6fd2807SJeff Garzik /* make sure qc->err_mask is available to 5368c6fd2807SJeff Garzik * know what's wrong and recover 5369c6fd2807SJeff Garzik */ 5370c6fd2807SJeff Garzik WARN_ON(qc->err_mask == 0); 5371c6fd2807SJeff Garzik 5372c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_IDLE; 5373c6fd2807SJeff Garzik 5374c6fd2807SJeff Garzik /* complete taskfile transaction */ 5375c6fd2807SJeff Garzik ata_hsm_qc_complete(qc, in_wq); 5376c6fd2807SJeff Garzik 5377c6fd2807SJeff Garzik poll_next = 0; 5378c6fd2807SJeff Garzik break; 5379c6fd2807SJeff Garzik default: 5380c6fd2807SJeff Garzik poll_next = 0; 5381c6fd2807SJeff Garzik BUG(); 5382c6fd2807SJeff Garzik } 5383c6fd2807SJeff Garzik 5384c6fd2807SJeff Garzik return poll_next; 5385c6fd2807SJeff Garzik } 5386c6fd2807SJeff Garzik 538765f27f38SDavid Howells static void ata_pio_task(struct work_struct *work) 5388c6fd2807SJeff Garzik { 538965f27f38SDavid Howells struct ata_port *ap = 539065f27f38SDavid Howells container_of(work, struct ata_port, port_task.work); 539165f27f38SDavid Howells struct ata_queued_cmd *qc = ap->port_task_data; 5392c6fd2807SJeff Garzik u8 status; 5393c6fd2807SJeff Garzik int poll_next; 5394c6fd2807SJeff Garzik 5395c6fd2807SJeff Garzik fsm_start: 5396c6fd2807SJeff Garzik WARN_ON(ap->hsm_task_state == HSM_ST_IDLE); 5397c6fd2807SJeff Garzik 5398c6fd2807SJeff Garzik /* 5399c6fd2807SJeff Garzik * This is purely heuristic. This is a fast path. 5400c6fd2807SJeff Garzik * Sometimes when we enter, BSY will be cleared in 5401c6fd2807SJeff Garzik * a chk-status or two. If not, the drive is probably seeking 5402c6fd2807SJeff Garzik * or something. Snooze for a couple msecs, then 5403c6fd2807SJeff Garzik * chk-status again. If still busy, queue delayed work. 5404c6fd2807SJeff Garzik */ 5405c6fd2807SJeff Garzik status = ata_busy_wait(ap, ATA_BUSY, 5); 5406c6fd2807SJeff Garzik if (status & ATA_BUSY) { 5407c6fd2807SJeff Garzik msleep(2); 5408c6fd2807SJeff Garzik status = ata_busy_wait(ap, ATA_BUSY, 10); 5409c6fd2807SJeff Garzik if (status & ATA_BUSY) { 5410c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, ATA_SHORT_PAUSE); 5411c6fd2807SJeff Garzik return; 5412c6fd2807SJeff Garzik } 5413c6fd2807SJeff Garzik } 5414c6fd2807SJeff Garzik 5415c6fd2807SJeff Garzik /* move the HSM */ 5416c6fd2807SJeff Garzik poll_next = ata_hsm_move(ap, qc, status, 1); 5417c6fd2807SJeff Garzik 5418c6fd2807SJeff Garzik /* another command or interrupt handler 5419c6fd2807SJeff Garzik * may be running at this point. 5420c6fd2807SJeff Garzik */ 5421c6fd2807SJeff Garzik if (poll_next) 5422c6fd2807SJeff Garzik goto fsm_start; 5423c6fd2807SJeff Garzik } 5424c6fd2807SJeff Garzik 5425c6fd2807SJeff Garzik /** 5426c6fd2807SJeff Garzik * ata_qc_new - Request an available ATA command, for queueing 5427c6fd2807SJeff Garzik * @ap: Port associated with device @dev 5428c6fd2807SJeff Garzik * @dev: Device from whom we request an available command structure 5429c6fd2807SJeff Garzik * 5430c6fd2807SJeff Garzik * LOCKING: 5431c6fd2807SJeff Garzik * None. 5432c6fd2807SJeff Garzik */ 5433c6fd2807SJeff Garzik 5434c6fd2807SJeff Garzik static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap) 5435c6fd2807SJeff Garzik { 5436c6fd2807SJeff Garzik struct ata_queued_cmd *qc = NULL; 5437c6fd2807SJeff Garzik unsigned int i; 5438c6fd2807SJeff Garzik 5439c6fd2807SJeff Garzik /* no command while frozen */ 5440c6fd2807SJeff Garzik if (unlikely(ap->pflags & ATA_PFLAG_FROZEN)) 5441c6fd2807SJeff Garzik return NULL; 5442c6fd2807SJeff Garzik 5443c6fd2807SJeff Garzik /* the last tag is reserved for internal command. */ 5444c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_QUEUE - 1; i++) 5445c6fd2807SJeff Garzik if (!test_and_set_bit(i, &ap->qc_allocated)) { 5446c6fd2807SJeff Garzik qc = __ata_qc_from_tag(ap, i); 5447c6fd2807SJeff Garzik break; 5448c6fd2807SJeff Garzik } 5449c6fd2807SJeff Garzik 5450c6fd2807SJeff Garzik if (qc) 5451c6fd2807SJeff Garzik qc->tag = i; 5452c6fd2807SJeff Garzik 5453c6fd2807SJeff Garzik return qc; 5454c6fd2807SJeff Garzik } 5455c6fd2807SJeff Garzik 5456c6fd2807SJeff Garzik /** 5457c6fd2807SJeff Garzik * ata_qc_new_init - Request an available ATA command, and initialize it 5458c6fd2807SJeff Garzik * @dev: Device from whom we request an available command structure 5459c6fd2807SJeff Garzik * 5460c6fd2807SJeff Garzik * LOCKING: 5461c6fd2807SJeff Garzik * None. 5462c6fd2807SJeff Garzik */ 5463c6fd2807SJeff Garzik 5464c6fd2807SJeff Garzik struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev) 5465c6fd2807SJeff Garzik { 54669af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 5467c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 5468c6fd2807SJeff Garzik 5469c6fd2807SJeff Garzik qc = ata_qc_new(ap); 5470c6fd2807SJeff Garzik if (qc) { 5471c6fd2807SJeff Garzik qc->scsicmd = NULL; 5472c6fd2807SJeff Garzik qc->ap = ap; 5473c6fd2807SJeff Garzik qc->dev = dev; 5474c6fd2807SJeff Garzik 5475c6fd2807SJeff Garzik ata_qc_reinit(qc); 5476c6fd2807SJeff Garzik } 5477c6fd2807SJeff Garzik 5478c6fd2807SJeff Garzik return qc; 5479c6fd2807SJeff Garzik } 5480c6fd2807SJeff Garzik 5481c6fd2807SJeff Garzik /** 5482c6fd2807SJeff Garzik * ata_qc_free - free unused ata_queued_cmd 5483c6fd2807SJeff Garzik * @qc: Command to complete 5484c6fd2807SJeff Garzik * 5485c6fd2807SJeff Garzik * Designed to free unused ata_queued_cmd object 5486c6fd2807SJeff Garzik * in case something prevents using it. 5487c6fd2807SJeff Garzik * 5488c6fd2807SJeff Garzik * LOCKING: 5489cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 5490c6fd2807SJeff Garzik */ 5491c6fd2807SJeff Garzik void ata_qc_free(struct ata_queued_cmd *qc) 5492c6fd2807SJeff Garzik { 5493c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 5494c6fd2807SJeff Garzik unsigned int tag; 5495c6fd2807SJeff Garzik 5496c6fd2807SJeff Garzik WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */ 5497c6fd2807SJeff Garzik 5498c6fd2807SJeff Garzik qc->flags = 0; 5499c6fd2807SJeff Garzik tag = qc->tag; 5500c6fd2807SJeff Garzik if (likely(ata_tag_valid(tag))) { 5501c6fd2807SJeff Garzik qc->tag = ATA_TAG_POISON; 5502c6fd2807SJeff Garzik clear_bit(tag, &ap->qc_allocated); 5503c6fd2807SJeff Garzik } 5504c6fd2807SJeff Garzik } 5505c6fd2807SJeff Garzik 5506c6fd2807SJeff Garzik void __ata_qc_complete(struct ata_queued_cmd *qc) 5507c6fd2807SJeff Garzik { 5508c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 55099af5c9c9STejun Heo struct ata_link *link = qc->dev->link; 5510c6fd2807SJeff Garzik 5511c6fd2807SJeff Garzik WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */ 5512c6fd2807SJeff Garzik WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE)); 5513c6fd2807SJeff Garzik 5514c6fd2807SJeff Garzik if (likely(qc->flags & ATA_QCFLAG_DMAMAP)) 5515c6fd2807SJeff Garzik ata_sg_clean(qc); 5516c6fd2807SJeff Garzik 5517c6fd2807SJeff Garzik /* command should be marked inactive atomically with qc completion */ 5518da917d69STejun Heo if (qc->tf.protocol == ATA_PROT_NCQ) { 55199af5c9c9STejun Heo link->sactive &= ~(1 << qc->tag); 5520da917d69STejun Heo if (!link->sactive) 5521da917d69STejun Heo ap->nr_active_links--; 5522da917d69STejun Heo } else { 55239af5c9c9STejun Heo link->active_tag = ATA_TAG_POISON; 5524da917d69STejun Heo ap->nr_active_links--; 5525da917d69STejun Heo } 5526da917d69STejun Heo 5527da917d69STejun Heo /* clear exclusive status */ 5528da917d69STejun Heo if (unlikely(qc->flags & ATA_QCFLAG_CLEAR_EXCL && 5529da917d69STejun Heo ap->excl_link == link)) 5530da917d69STejun Heo ap->excl_link = NULL; 5531c6fd2807SJeff Garzik 5532c6fd2807SJeff Garzik /* atapi: mark qc as inactive to prevent the interrupt handler 5533c6fd2807SJeff Garzik * from completing the command twice later, before the error handler 5534c6fd2807SJeff Garzik * is called. (when rc != 0 and atapi request sense is needed) 5535c6fd2807SJeff Garzik */ 5536c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_ACTIVE; 5537c6fd2807SJeff Garzik ap->qc_active &= ~(1 << qc->tag); 5538c6fd2807SJeff Garzik 5539c6fd2807SJeff Garzik /* call completion callback */ 5540c6fd2807SJeff Garzik qc->complete_fn(qc); 5541c6fd2807SJeff Garzik } 5542c6fd2807SJeff Garzik 554339599a53STejun Heo static void fill_result_tf(struct ata_queued_cmd *qc) 554439599a53STejun Heo { 554539599a53STejun Heo struct ata_port *ap = qc->ap; 554639599a53STejun Heo 554739599a53STejun Heo qc->result_tf.flags = qc->tf.flags; 55484742d54fSMark Lord ap->ops->tf_read(ap, &qc->result_tf); 554939599a53STejun Heo } 555039599a53STejun Heo 5551c6fd2807SJeff Garzik /** 5552c6fd2807SJeff Garzik * ata_qc_complete - Complete an active ATA command 5553c6fd2807SJeff Garzik * @qc: Command to complete 5554c6fd2807SJeff Garzik * @err_mask: ATA Status register contents 5555c6fd2807SJeff Garzik * 5556c6fd2807SJeff Garzik * Indicate to the mid and upper layers that an ATA 5557c6fd2807SJeff Garzik * command has completed, with either an ok or not-ok status. 5558c6fd2807SJeff Garzik * 5559c6fd2807SJeff Garzik * LOCKING: 5560cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 5561c6fd2807SJeff Garzik */ 5562c6fd2807SJeff Garzik void ata_qc_complete(struct ata_queued_cmd *qc) 5563c6fd2807SJeff Garzik { 5564c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 5565c6fd2807SJeff Garzik 5566c6fd2807SJeff Garzik /* XXX: New EH and old EH use different mechanisms to 5567c6fd2807SJeff Garzik * synchronize EH with regular execution path. 5568c6fd2807SJeff Garzik * 5569c6fd2807SJeff Garzik * In new EH, a failed qc is marked with ATA_QCFLAG_FAILED. 5570c6fd2807SJeff Garzik * Normal execution path is responsible for not accessing a 5571c6fd2807SJeff Garzik * failed qc. libata core enforces the rule by returning NULL 5572c6fd2807SJeff Garzik * from ata_qc_from_tag() for failed qcs. 5573c6fd2807SJeff Garzik * 5574c6fd2807SJeff Garzik * Old EH depends on ata_qc_complete() nullifying completion 5575c6fd2807SJeff Garzik * requests if ATA_QCFLAG_EH_SCHEDULED is set. Old EH does 5576c6fd2807SJeff Garzik * not synchronize with interrupt handler. Only PIO task is 5577c6fd2807SJeff Garzik * taken care of. 5578c6fd2807SJeff Garzik */ 5579c6fd2807SJeff Garzik if (ap->ops->error_handler) { 5580c6fd2807SJeff Garzik WARN_ON(ap->pflags & ATA_PFLAG_FROZEN); 5581c6fd2807SJeff Garzik 5582c6fd2807SJeff Garzik if (unlikely(qc->err_mask)) 5583c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_FAILED; 5584c6fd2807SJeff Garzik 5585c6fd2807SJeff Garzik if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) { 5586c6fd2807SJeff Garzik if (!ata_tag_internal(qc->tag)) { 5587c6fd2807SJeff Garzik /* always fill result TF for failed qc */ 558839599a53STejun Heo fill_result_tf(qc); 5589c6fd2807SJeff Garzik ata_qc_schedule_eh(qc); 5590c6fd2807SJeff Garzik return; 5591c6fd2807SJeff Garzik } 5592c6fd2807SJeff Garzik } 5593c6fd2807SJeff Garzik 5594c6fd2807SJeff Garzik /* read result TF if requested */ 5595c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_RESULT_TF) 559639599a53STejun Heo fill_result_tf(qc); 5597c6fd2807SJeff Garzik 5598c6fd2807SJeff Garzik __ata_qc_complete(qc); 5599c6fd2807SJeff Garzik } else { 5600c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_EH_SCHEDULED) 5601c6fd2807SJeff Garzik return; 5602c6fd2807SJeff Garzik 5603c6fd2807SJeff Garzik /* read result TF if failed or requested */ 5604c6fd2807SJeff Garzik if (qc->err_mask || qc->flags & ATA_QCFLAG_RESULT_TF) 560539599a53STejun Heo fill_result_tf(qc); 5606c6fd2807SJeff Garzik 5607c6fd2807SJeff Garzik __ata_qc_complete(qc); 5608c6fd2807SJeff Garzik } 5609c6fd2807SJeff Garzik } 5610c6fd2807SJeff Garzik 5611c6fd2807SJeff Garzik /** 5612c6fd2807SJeff Garzik * ata_qc_complete_multiple - Complete multiple qcs successfully 5613c6fd2807SJeff Garzik * @ap: port in question 5614c6fd2807SJeff Garzik * @qc_active: new qc_active mask 5615c6fd2807SJeff Garzik * @finish_qc: LLDD callback invoked before completing a qc 5616c6fd2807SJeff Garzik * 5617c6fd2807SJeff Garzik * Complete in-flight commands. This functions is meant to be 5618c6fd2807SJeff Garzik * called from low-level driver's interrupt routine to complete 5619c6fd2807SJeff Garzik * requests normally. ap->qc_active and @qc_active is compared 5620c6fd2807SJeff Garzik * and commands are completed accordingly. 5621c6fd2807SJeff Garzik * 5622c6fd2807SJeff Garzik * LOCKING: 5623cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 5624c6fd2807SJeff Garzik * 5625c6fd2807SJeff Garzik * RETURNS: 5626c6fd2807SJeff Garzik * Number of completed commands on success, -errno otherwise. 5627c6fd2807SJeff Garzik */ 5628c6fd2807SJeff Garzik int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active, 5629c6fd2807SJeff Garzik void (*finish_qc)(struct ata_queued_cmd *)) 5630c6fd2807SJeff Garzik { 5631c6fd2807SJeff Garzik int nr_done = 0; 5632c6fd2807SJeff Garzik u32 done_mask; 5633c6fd2807SJeff Garzik int i; 5634c6fd2807SJeff Garzik 5635c6fd2807SJeff Garzik done_mask = ap->qc_active ^ qc_active; 5636c6fd2807SJeff Garzik 5637c6fd2807SJeff Garzik if (unlikely(done_mask & qc_active)) { 5638c6fd2807SJeff Garzik ata_port_printk(ap, KERN_ERR, "illegal qc_active transition " 5639c6fd2807SJeff Garzik "(%08x->%08x)\n", ap->qc_active, qc_active); 5640c6fd2807SJeff Garzik return -EINVAL; 5641c6fd2807SJeff Garzik } 5642c6fd2807SJeff Garzik 5643c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_QUEUE; i++) { 5644c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 5645c6fd2807SJeff Garzik 5646c6fd2807SJeff Garzik if (!(done_mask & (1 << i))) 5647c6fd2807SJeff Garzik continue; 5648c6fd2807SJeff Garzik 5649c6fd2807SJeff Garzik if ((qc = ata_qc_from_tag(ap, i))) { 5650c6fd2807SJeff Garzik if (finish_qc) 5651c6fd2807SJeff Garzik finish_qc(qc); 5652c6fd2807SJeff Garzik ata_qc_complete(qc); 5653c6fd2807SJeff Garzik nr_done++; 5654c6fd2807SJeff Garzik } 5655c6fd2807SJeff Garzik } 5656c6fd2807SJeff Garzik 5657c6fd2807SJeff Garzik return nr_done; 5658c6fd2807SJeff Garzik } 5659c6fd2807SJeff Garzik 5660c6fd2807SJeff Garzik static inline int ata_should_dma_map(struct ata_queued_cmd *qc) 5661c6fd2807SJeff Garzik { 5662c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 5663c6fd2807SJeff Garzik 5664c6fd2807SJeff Garzik switch (qc->tf.protocol) { 5665c6fd2807SJeff Garzik case ATA_PROT_NCQ: 5666c6fd2807SJeff Garzik case ATA_PROT_DMA: 5667c6fd2807SJeff Garzik case ATA_PROT_ATAPI_DMA: 5668c6fd2807SJeff Garzik return 1; 5669c6fd2807SJeff Garzik 5670c6fd2807SJeff Garzik case ATA_PROT_ATAPI: 5671c6fd2807SJeff Garzik case ATA_PROT_PIO: 5672c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_PIO_DMA) 5673c6fd2807SJeff Garzik return 1; 5674c6fd2807SJeff Garzik 5675c6fd2807SJeff Garzik /* fall through */ 5676c6fd2807SJeff Garzik 5677c6fd2807SJeff Garzik default: 5678c6fd2807SJeff Garzik return 0; 5679c6fd2807SJeff Garzik } 5680c6fd2807SJeff Garzik 5681c6fd2807SJeff Garzik /* never reached */ 5682c6fd2807SJeff Garzik } 5683c6fd2807SJeff Garzik 5684c6fd2807SJeff Garzik /** 5685c6fd2807SJeff Garzik * ata_qc_issue - issue taskfile to device 5686c6fd2807SJeff Garzik * @qc: command to issue to device 5687c6fd2807SJeff Garzik * 5688c6fd2807SJeff Garzik * Prepare an ATA command to submission to device. 5689c6fd2807SJeff Garzik * This includes mapping the data into a DMA-able 5690c6fd2807SJeff Garzik * area, filling in the S/G table, and finally 5691c6fd2807SJeff Garzik * writing the taskfile to hardware, starting the command. 5692c6fd2807SJeff Garzik * 5693c6fd2807SJeff Garzik * LOCKING: 5694cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 5695c6fd2807SJeff Garzik */ 5696c6fd2807SJeff Garzik void ata_qc_issue(struct ata_queued_cmd *qc) 5697c6fd2807SJeff Garzik { 5698c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 56999af5c9c9STejun Heo struct ata_link *link = qc->dev->link; 5700c6fd2807SJeff Garzik 5701c6fd2807SJeff Garzik /* Make sure only one non-NCQ command is outstanding. The 5702c6fd2807SJeff Garzik * check is skipped for old EH because it reuses active qc to 5703c6fd2807SJeff Garzik * request ATAPI sense. 5704c6fd2807SJeff Garzik */ 57059af5c9c9STejun Heo WARN_ON(ap->ops->error_handler && ata_tag_valid(link->active_tag)); 5706c6fd2807SJeff Garzik 5707c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_NCQ) { 57089af5c9c9STejun Heo WARN_ON(link->sactive & (1 << qc->tag)); 5709da917d69STejun Heo 5710da917d69STejun Heo if (!link->sactive) 5711da917d69STejun Heo ap->nr_active_links++; 57129af5c9c9STejun Heo link->sactive |= 1 << qc->tag; 5713c6fd2807SJeff Garzik } else { 57149af5c9c9STejun Heo WARN_ON(link->sactive); 5715da917d69STejun Heo 5716da917d69STejun Heo ap->nr_active_links++; 57179af5c9c9STejun Heo link->active_tag = qc->tag; 5718c6fd2807SJeff Garzik } 5719c6fd2807SJeff Garzik 5720c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_ACTIVE; 5721c6fd2807SJeff Garzik ap->qc_active |= 1 << qc->tag; 5722c6fd2807SJeff Garzik 5723c6fd2807SJeff Garzik if (ata_should_dma_map(qc)) { 5724c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_SG) { 5725c6fd2807SJeff Garzik if (ata_sg_setup(qc)) 5726c6fd2807SJeff Garzik goto sg_err; 5727c6fd2807SJeff Garzik } else if (qc->flags & ATA_QCFLAG_SINGLE) { 5728c6fd2807SJeff Garzik if (ata_sg_setup_one(qc)) 5729c6fd2807SJeff Garzik goto sg_err; 5730c6fd2807SJeff Garzik } 5731c6fd2807SJeff Garzik } else { 5732c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_DMAMAP; 5733c6fd2807SJeff Garzik } 5734c6fd2807SJeff Garzik 5735c6fd2807SJeff Garzik ap->ops->qc_prep(qc); 5736c6fd2807SJeff Garzik 5737c6fd2807SJeff Garzik qc->err_mask |= ap->ops->qc_issue(qc); 5738c6fd2807SJeff Garzik if (unlikely(qc->err_mask)) 5739c6fd2807SJeff Garzik goto err; 5740c6fd2807SJeff Garzik return; 5741c6fd2807SJeff Garzik 5742c6fd2807SJeff Garzik sg_err: 5743c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_DMAMAP; 5744c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_SYSTEM; 5745c6fd2807SJeff Garzik err: 5746c6fd2807SJeff Garzik ata_qc_complete(qc); 5747c6fd2807SJeff Garzik } 5748c6fd2807SJeff Garzik 5749c6fd2807SJeff Garzik /** 5750c6fd2807SJeff Garzik * ata_qc_issue_prot - issue taskfile to device in proto-dependent manner 5751c6fd2807SJeff Garzik * @qc: command to issue to device 5752c6fd2807SJeff Garzik * 5753c6fd2807SJeff Garzik * Using various libata functions and hooks, this function 5754c6fd2807SJeff Garzik * starts an ATA command. ATA commands are grouped into 5755c6fd2807SJeff Garzik * classes called "protocols", and issuing each type of protocol 5756c6fd2807SJeff Garzik * is slightly different. 5757c6fd2807SJeff Garzik * 5758c6fd2807SJeff Garzik * May be used as the qc_issue() entry in ata_port_operations. 5759c6fd2807SJeff Garzik * 5760c6fd2807SJeff Garzik * LOCKING: 5761cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 5762c6fd2807SJeff Garzik * 5763c6fd2807SJeff Garzik * RETURNS: 5764c6fd2807SJeff Garzik * Zero on success, AC_ERR_* mask on failure 5765c6fd2807SJeff Garzik */ 5766c6fd2807SJeff Garzik 5767c6fd2807SJeff Garzik unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc) 5768c6fd2807SJeff Garzik { 5769c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 5770c6fd2807SJeff Garzik 5771c6fd2807SJeff Garzik /* Use polling pio if the LLD doesn't handle 5772c6fd2807SJeff Garzik * interrupt driven pio and atapi CDB interrupt. 5773c6fd2807SJeff Garzik */ 5774c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_PIO_POLLING) { 5775c6fd2807SJeff Garzik switch (qc->tf.protocol) { 5776c6fd2807SJeff Garzik case ATA_PROT_PIO: 5777e3472cbeSAlbert Lee case ATA_PROT_NODATA: 5778c6fd2807SJeff Garzik case ATA_PROT_ATAPI: 5779c6fd2807SJeff Garzik case ATA_PROT_ATAPI_NODATA: 5780c6fd2807SJeff Garzik qc->tf.flags |= ATA_TFLAG_POLLING; 5781c6fd2807SJeff Garzik break; 5782c6fd2807SJeff Garzik case ATA_PROT_ATAPI_DMA: 5783c6fd2807SJeff Garzik if (qc->dev->flags & ATA_DFLAG_CDB_INTR) 5784c6fd2807SJeff Garzik /* see ata_dma_blacklisted() */ 5785c6fd2807SJeff Garzik BUG(); 5786c6fd2807SJeff Garzik break; 5787c6fd2807SJeff Garzik default: 5788c6fd2807SJeff Garzik break; 5789c6fd2807SJeff Garzik } 5790c6fd2807SJeff Garzik } 5791c6fd2807SJeff Garzik 5792c6fd2807SJeff Garzik /* select the device */ 5793c6fd2807SJeff Garzik ata_dev_select(ap, qc->dev->devno, 1, 0); 5794c6fd2807SJeff Garzik 5795c6fd2807SJeff Garzik /* start the command */ 5796c6fd2807SJeff Garzik switch (qc->tf.protocol) { 5797c6fd2807SJeff Garzik case ATA_PROT_NODATA: 5798c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 5799c6fd2807SJeff Garzik ata_qc_set_polling(qc); 5800c6fd2807SJeff Garzik 5801c6fd2807SJeff Garzik ata_tf_to_host(ap, &qc->tf); 5802c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 5803c6fd2807SJeff Garzik 5804c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 5805c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, 0); 5806c6fd2807SJeff Garzik 5807c6fd2807SJeff Garzik break; 5808c6fd2807SJeff Garzik 5809c6fd2807SJeff Garzik case ATA_PROT_DMA: 5810c6fd2807SJeff Garzik WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING); 5811c6fd2807SJeff Garzik 5812c6fd2807SJeff Garzik ap->ops->tf_load(ap, &qc->tf); /* load tf registers */ 5813c6fd2807SJeff Garzik ap->ops->bmdma_setup(qc); /* set up bmdma */ 5814c6fd2807SJeff Garzik ap->ops->bmdma_start(qc); /* initiate bmdma */ 5815c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 5816c6fd2807SJeff Garzik break; 5817c6fd2807SJeff Garzik 5818c6fd2807SJeff Garzik case ATA_PROT_PIO: 5819c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 5820c6fd2807SJeff Garzik ata_qc_set_polling(qc); 5821c6fd2807SJeff Garzik 5822c6fd2807SJeff Garzik ata_tf_to_host(ap, &qc->tf); 5823c6fd2807SJeff Garzik 5824c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_WRITE) { 5825c6fd2807SJeff Garzik /* PIO data out protocol */ 5826c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_FIRST; 5827c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, 0); 5828c6fd2807SJeff Garzik 5829c6fd2807SJeff Garzik /* always send first data block using 5830c6fd2807SJeff Garzik * the ata_pio_task() codepath. 5831c6fd2807SJeff Garzik */ 5832c6fd2807SJeff Garzik } else { 5833c6fd2807SJeff Garzik /* PIO data in protocol */ 5834c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST; 5835c6fd2807SJeff Garzik 5836c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 5837c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, 0); 5838c6fd2807SJeff Garzik 5839c6fd2807SJeff Garzik /* if polling, ata_pio_task() handles the rest. 5840c6fd2807SJeff Garzik * otherwise, interrupt handler takes over from here. 5841c6fd2807SJeff Garzik */ 5842c6fd2807SJeff Garzik } 5843c6fd2807SJeff Garzik 5844c6fd2807SJeff Garzik break; 5845c6fd2807SJeff Garzik 5846c6fd2807SJeff Garzik case ATA_PROT_ATAPI: 5847c6fd2807SJeff Garzik case ATA_PROT_ATAPI_NODATA: 5848c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 5849c6fd2807SJeff Garzik ata_qc_set_polling(qc); 5850c6fd2807SJeff Garzik 5851c6fd2807SJeff Garzik ata_tf_to_host(ap, &qc->tf); 5852c6fd2807SJeff Garzik 5853c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_FIRST; 5854c6fd2807SJeff Garzik 5855c6fd2807SJeff Garzik /* send cdb by polling if no cdb interrupt */ 5856c6fd2807SJeff Garzik if ((!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) || 5857c6fd2807SJeff Garzik (qc->tf.flags & ATA_TFLAG_POLLING)) 5858c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, 0); 5859c6fd2807SJeff Garzik break; 5860c6fd2807SJeff Garzik 5861c6fd2807SJeff Garzik case ATA_PROT_ATAPI_DMA: 5862c6fd2807SJeff Garzik WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING); 5863c6fd2807SJeff Garzik 5864c6fd2807SJeff Garzik ap->ops->tf_load(ap, &qc->tf); /* load tf registers */ 5865c6fd2807SJeff Garzik ap->ops->bmdma_setup(qc); /* set up bmdma */ 5866c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_FIRST; 5867c6fd2807SJeff Garzik 5868c6fd2807SJeff Garzik /* send cdb by polling if no cdb interrupt */ 5869c6fd2807SJeff Garzik if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) 5870c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, 0); 5871c6fd2807SJeff Garzik break; 5872c6fd2807SJeff Garzik 5873c6fd2807SJeff Garzik default: 5874c6fd2807SJeff Garzik WARN_ON(1); 5875c6fd2807SJeff Garzik return AC_ERR_SYSTEM; 5876c6fd2807SJeff Garzik } 5877c6fd2807SJeff Garzik 5878c6fd2807SJeff Garzik return 0; 5879c6fd2807SJeff Garzik } 5880c6fd2807SJeff Garzik 5881c6fd2807SJeff Garzik /** 5882c6fd2807SJeff Garzik * ata_host_intr - Handle host interrupt for given (port, task) 5883c6fd2807SJeff Garzik * @ap: Port on which interrupt arrived (possibly...) 5884c6fd2807SJeff Garzik * @qc: Taskfile currently active in engine 5885c6fd2807SJeff Garzik * 5886c6fd2807SJeff Garzik * Handle host interrupt for given queued command. Currently, 5887c6fd2807SJeff Garzik * only DMA interrupts are handled. All other commands are 5888c6fd2807SJeff Garzik * handled via polling with interrupts disabled (nIEN bit). 5889c6fd2807SJeff Garzik * 5890c6fd2807SJeff Garzik * LOCKING: 5891cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 5892c6fd2807SJeff Garzik * 5893c6fd2807SJeff Garzik * RETURNS: 5894c6fd2807SJeff Garzik * One if interrupt was handled, zero if not (shared irq). 5895c6fd2807SJeff Garzik */ 5896c6fd2807SJeff Garzik 5897c6fd2807SJeff Garzik inline unsigned int ata_host_intr (struct ata_port *ap, 5898c6fd2807SJeff Garzik struct ata_queued_cmd *qc) 5899c6fd2807SJeff Garzik { 59009af5c9c9STejun Heo struct ata_eh_info *ehi = &ap->link.eh_info; 5901c6fd2807SJeff Garzik u8 status, host_stat = 0; 5902c6fd2807SJeff Garzik 5903c6fd2807SJeff Garzik VPRINTK("ata%u: protocol %d task_state %d\n", 590444877b4eSTejun Heo ap->print_id, qc->tf.protocol, ap->hsm_task_state); 5905c6fd2807SJeff Garzik 5906c6fd2807SJeff Garzik /* Check whether we are expecting interrupt in this state */ 5907c6fd2807SJeff Garzik switch (ap->hsm_task_state) { 5908c6fd2807SJeff Garzik case HSM_ST_FIRST: 5909c6fd2807SJeff Garzik /* Some pre-ATAPI-4 devices assert INTRQ 5910c6fd2807SJeff Garzik * at this state when ready to receive CDB. 5911c6fd2807SJeff Garzik */ 5912c6fd2807SJeff Garzik 5913c6fd2807SJeff Garzik /* Check the ATA_DFLAG_CDB_INTR flag is enough here. 5914c6fd2807SJeff Garzik * The flag was turned on only for atapi devices. 5915c6fd2807SJeff Garzik * No need to check is_atapi_taskfile(&qc->tf) again. 5916c6fd2807SJeff Garzik */ 5917c6fd2807SJeff Garzik if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) 5918c6fd2807SJeff Garzik goto idle_irq; 5919c6fd2807SJeff Garzik break; 5920c6fd2807SJeff Garzik case HSM_ST_LAST: 5921c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_DMA || 5922c6fd2807SJeff Garzik qc->tf.protocol == ATA_PROT_ATAPI_DMA) { 5923c6fd2807SJeff Garzik /* check status of DMA engine */ 5924c6fd2807SJeff Garzik host_stat = ap->ops->bmdma_status(ap); 592544877b4eSTejun Heo VPRINTK("ata%u: host_stat 0x%X\n", 592644877b4eSTejun Heo ap->print_id, host_stat); 5927c6fd2807SJeff Garzik 5928c6fd2807SJeff Garzik /* if it's not our irq... */ 5929c6fd2807SJeff Garzik if (!(host_stat & ATA_DMA_INTR)) 5930c6fd2807SJeff Garzik goto idle_irq; 5931c6fd2807SJeff Garzik 5932c6fd2807SJeff Garzik /* before we do anything else, clear DMA-Start bit */ 5933c6fd2807SJeff Garzik ap->ops->bmdma_stop(qc); 5934c6fd2807SJeff Garzik 5935c6fd2807SJeff Garzik if (unlikely(host_stat & ATA_DMA_ERR)) { 5936c6fd2807SJeff Garzik /* error when transfering data to/from memory */ 5937c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HOST_BUS; 5938c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 5939c6fd2807SJeff Garzik } 5940c6fd2807SJeff Garzik } 5941c6fd2807SJeff Garzik break; 5942c6fd2807SJeff Garzik case HSM_ST: 5943c6fd2807SJeff Garzik break; 5944c6fd2807SJeff Garzik default: 5945c6fd2807SJeff Garzik goto idle_irq; 5946c6fd2807SJeff Garzik } 5947c6fd2807SJeff Garzik 5948c6fd2807SJeff Garzik /* check altstatus */ 5949c6fd2807SJeff Garzik status = ata_altstatus(ap); 5950c6fd2807SJeff Garzik if (status & ATA_BUSY) 5951c6fd2807SJeff Garzik goto idle_irq; 5952c6fd2807SJeff Garzik 5953c6fd2807SJeff Garzik /* check main status, clearing INTRQ */ 5954c6fd2807SJeff Garzik status = ata_chk_status(ap); 5955c6fd2807SJeff Garzik if (unlikely(status & ATA_BUSY)) 5956c6fd2807SJeff Garzik goto idle_irq; 5957c6fd2807SJeff Garzik 5958c6fd2807SJeff Garzik /* ack bmdma irq events */ 5959c6fd2807SJeff Garzik ap->ops->irq_clear(ap); 5960c6fd2807SJeff Garzik 5961c6fd2807SJeff Garzik ata_hsm_move(ap, qc, status, 0); 5962ea54763fSTejun Heo 5963ea54763fSTejun Heo if (unlikely(qc->err_mask) && (qc->tf.protocol == ATA_PROT_DMA || 5964ea54763fSTejun Heo qc->tf.protocol == ATA_PROT_ATAPI_DMA)) 5965ea54763fSTejun Heo ata_ehi_push_desc(ehi, "BMDMA stat 0x%x", host_stat); 5966ea54763fSTejun Heo 5967c6fd2807SJeff Garzik return 1; /* irq handled */ 5968c6fd2807SJeff Garzik 5969c6fd2807SJeff Garzik idle_irq: 5970c6fd2807SJeff Garzik ap->stats.idle_irq++; 5971c6fd2807SJeff Garzik 5972c6fd2807SJeff Garzik #ifdef ATA_IRQ_TRAP 5973c6fd2807SJeff Garzik if ((ap->stats.idle_irq % 1000) == 0) { 59746d32d30fSJeff Garzik ata_chk_status(ap); 59756d32d30fSJeff Garzik ap->ops->irq_clear(ap); 5976c6fd2807SJeff Garzik ata_port_printk(ap, KERN_WARNING, "irq trap\n"); 5977c6fd2807SJeff Garzik return 1; 5978c6fd2807SJeff Garzik } 5979c6fd2807SJeff Garzik #endif 5980c6fd2807SJeff Garzik return 0; /* irq not handled */ 5981c6fd2807SJeff Garzik } 5982c6fd2807SJeff Garzik 5983c6fd2807SJeff Garzik /** 5984c6fd2807SJeff Garzik * ata_interrupt - Default ATA host interrupt handler 5985c6fd2807SJeff Garzik * @irq: irq line (unused) 5986cca3974eSJeff Garzik * @dev_instance: pointer to our ata_host information structure 5987c6fd2807SJeff Garzik * 5988c6fd2807SJeff Garzik * Default interrupt handler for PCI IDE devices. Calls 5989c6fd2807SJeff Garzik * ata_host_intr() for each port that is not disabled. 5990c6fd2807SJeff Garzik * 5991c6fd2807SJeff Garzik * LOCKING: 5992cca3974eSJeff Garzik * Obtains host lock during operation. 5993c6fd2807SJeff Garzik * 5994c6fd2807SJeff Garzik * RETURNS: 5995c6fd2807SJeff Garzik * IRQ_NONE or IRQ_HANDLED. 5996c6fd2807SJeff Garzik */ 5997c6fd2807SJeff Garzik 59987d12e780SDavid Howells irqreturn_t ata_interrupt (int irq, void *dev_instance) 5999c6fd2807SJeff Garzik { 6000cca3974eSJeff Garzik struct ata_host *host = dev_instance; 6001c6fd2807SJeff Garzik unsigned int i; 6002c6fd2807SJeff Garzik unsigned int handled = 0; 6003c6fd2807SJeff Garzik unsigned long flags; 6004c6fd2807SJeff Garzik 6005c6fd2807SJeff Garzik /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */ 6006cca3974eSJeff Garzik spin_lock_irqsave(&host->lock, flags); 6007c6fd2807SJeff Garzik 6008cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 6009c6fd2807SJeff Garzik struct ata_port *ap; 6010c6fd2807SJeff Garzik 6011cca3974eSJeff Garzik ap = host->ports[i]; 6012c6fd2807SJeff Garzik if (ap && 6013c6fd2807SJeff Garzik !(ap->flags & ATA_FLAG_DISABLED)) { 6014c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 6015c6fd2807SJeff Garzik 60169af5c9c9STejun Heo qc = ata_qc_from_tag(ap, ap->link.active_tag); 6017c6fd2807SJeff Garzik if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) && 6018c6fd2807SJeff Garzik (qc->flags & ATA_QCFLAG_ACTIVE)) 6019c6fd2807SJeff Garzik handled |= ata_host_intr(ap, qc); 6020c6fd2807SJeff Garzik } 6021c6fd2807SJeff Garzik } 6022c6fd2807SJeff Garzik 6023cca3974eSJeff Garzik spin_unlock_irqrestore(&host->lock, flags); 6024c6fd2807SJeff Garzik 6025c6fd2807SJeff Garzik return IRQ_RETVAL(handled); 6026c6fd2807SJeff Garzik } 6027c6fd2807SJeff Garzik 6028c6fd2807SJeff Garzik /** 6029c6fd2807SJeff Garzik * sata_scr_valid - test whether SCRs are accessible 6030936fd732STejun Heo * @link: ATA link to test SCR accessibility for 6031c6fd2807SJeff Garzik * 6032936fd732STejun Heo * Test whether SCRs are accessible for @link. 6033c6fd2807SJeff Garzik * 6034c6fd2807SJeff Garzik * LOCKING: 6035c6fd2807SJeff Garzik * None. 6036c6fd2807SJeff Garzik * 6037c6fd2807SJeff Garzik * RETURNS: 6038c6fd2807SJeff Garzik * 1 if SCRs are accessible, 0 otherwise. 6039c6fd2807SJeff Garzik */ 6040936fd732STejun Heo int sata_scr_valid(struct ata_link *link) 6041c6fd2807SJeff Garzik { 6042936fd732STejun Heo struct ata_port *ap = link->ap; 6043936fd732STejun Heo 6044a16abc0bSTejun Heo return (ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read; 6045c6fd2807SJeff Garzik } 6046c6fd2807SJeff Garzik 6047c6fd2807SJeff Garzik /** 6048c6fd2807SJeff Garzik * sata_scr_read - read SCR register of the specified port 6049936fd732STejun Heo * @link: ATA link to read SCR for 6050c6fd2807SJeff Garzik * @reg: SCR to read 6051c6fd2807SJeff Garzik * @val: Place to store read value 6052c6fd2807SJeff Garzik * 6053936fd732STejun Heo * Read SCR register @reg of @link into *@val. This function is 6054633273a3STejun Heo * guaranteed to succeed if @link is ap->link, the cable type of 6055633273a3STejun Heo * the port is SATA and the port implements ->scr_read. 6056c6fd2807SJeff Garzik * 6057c6fd2807SJeff Garzik * LOCKING: 6058633273a3STejun Heo * None if @link is ap->link. Kernel thread context otherwise. 6059c6fd2807SJeff Garzik * 6060c6fd2807SJeff Garzik * RETURNS: 6061c6fd2807SJeff Garzik * 0 on success, negative errno on failure. 6062c6fd2807SJeff Garzik */ 6063936fd732STejun Heo int sata_scr_read(struct ata_link *link, int reg, u32 *val) 6064c6fd2807SJeff Garzik { 6065633273a3STejun Heo if (ata_is_host_link(link)) { 6066936fd732STejun Heo struct ata_port *ap = link->ap; 6067936fd732STejun Heo 6068936fd732STejun Heo if (sata_scr_valid(link)) 6069da3dbb17STejun Heo return ap->ops->scr_read(ap, reg, val); 6070c6fd2807SJeff Garzik return -EOPNOTSUPP; 6071c6fd2807SJeff Garzik } 6072c6fd2807SJeff Garzik 6073633273a3STejun Heo return sata_pmp_scr_read(link, reg, val); 6074633273a3STejun Heo } 6075633273a3STejun Heo 6076c6fd2807SJeff Garzik /** 6077c6fd2807SJeff Garzik * sata_scr_write - write SCR register of the specified port 6078936fd732STejun Heo * @link: ATA link to write SCR for 6079c6fd2807SJeff Garzik * @reg: SCR to write 6080c6fd2807SJeff Garzik * @val: value to write 6081c6fd2807SJeff Garzik * 6082936fd732STejun Heo * Write @val to SCR register @reg of @link. This function is 6083633273a3STejun Heo * guaranteed to succeed if @link is ap->link, the cable type of 6084633273a3STejun Heo * the port is SATA and the port implements ->scr_read. 6085c6fd2807SJeff Garzik * 6086c6fd2807SJeff Garzik * LOCKING: 6087633273a3STejun Heo * None if @link is ap->link. Kernel thread context otherwise. 6088c6fd2807SJeff Garzik * 6089c6fd2807SJeff Garzik * RETURNS: 6090c6fd2807SJeff Garzik * 0 on success, negative errno on failure. 6091c6fd2807SJeff Garzik */ 6092936fd732STejun Heo int sata_scr_write(struct ata_link *link, int reg, u32 val) 6093c6fd2807SJeff Garzik { 6094633273a3STejun Heo if (ata_is_host_link(link)) { 6095936fd732STejun Heo struct ata_port *ap = link->ap; 6096936fd732STejun Heo 6097936fd732STejun Heo if (sata_scr_valid(link)) 6098da3dbb17STejun Heo return ap->ops->scr_write(ap, reg, val); 6099c6fd2807SJeff Garzik return -EOPNOTSUPP; 6100c6fd2807SJeff Garzik } 6101c6fd2807SJeff Garzik 6102633273a3STejun Heo return sata_pmp_scr_write(link, reg, val); 6103633273a3STejun Heo } 6104633273a3STejun Heo 6105c6fd2807SJeff Garzik /** 6106c6fd2807SJeff Garzik * sata_scr_write_flush - write SCR register of the specified port and flush 6107936fd732STejun Heo * @link: ATA link to write SCR for 6108c6fd2807SJeff Garzik * @reg: SCR to write 6109c6fd2807SJeff Garzik * @val: value to write 6110c6fd2807SJeff Garzik * 6111c6fd2807SJeff Garzik * This function is identical to sata_scr_write() except that this 6112c6fd2807SJeff Garzik * function performs flush after writing to the register. 6113c6fd2807SJeff Garzik * 6114c6fd2807SJeff Garzik * LOCKING: 6115633273a3STejun Heo * None if @link is ap->link. Kernel thread context otherwise. 6116c6fd2807SJeff Garzik * 6117c6fd2807SJeff Garzik * RETURNS: 6118c6fd2807SJeff Garzik * 0 on success, negative errno on failure. 6119c6fd2807SJeff Garzik */ 6120936fd732STejun Heo int sata_scr_write_flush(struct ata_link *link, int reg, u32 val) 6121c6fd2807SJeff Garzik { 6122633273a3STejun Heo if (ata_is_host_link(link)) { 6123936fd732STejun Heo struct ata_port *ap = link->ap; 6124da3dbb17STejun Heo int rc; 6125da3dbb17STejun Heo 6126936fd732STejun Heo if (sata_scr_valid(link)) { 6127da3dbb17STejun Heo rc = ap->ops->scr_write(ap, reg, val); 6128da3dbb17STejun Heo if (rc == 0) 6129da3dbb17STejun Heo rc = ap->ops->scr_read(ap, reg, &val); 6130da3dbb17STejun Heo return rc; 6131c6fd2807SJeff Garzik } 6132c6fd2807SJeff Garzik return -EOPNOTSUPP; 6133c6fd2807SJeff Garzik } 6134c6fd2807SJeff Garzik 6135633273a3STejun Heo return sata_pmp_scr_write(link, reg, val); 6136633273a3STejun Heo } 6137633273a3STejun Heo 6138c6fd2807SJeff Garzik /** 6139936fd732STejun Heo * ata_link_online - test whether the given link is online 6140936fd732STejun Heo * @link: ATA link to test 6141c6fd2807SJeff Garzik * 6142936fd732STejun Heo * Test whether @link is online. Note that this function returns 6143936fd732STejun Heo * 0 if online status of @link cannot be obtained, so 6144936fd732STejun Heo * ata_link_online(link) != !ata_link_offline(link). 6145c6fd2807SJeff Garzik * 6146c6fd2807SJeff Garzik * LOCKING: 6147c6fd2807SJeff Garzik * None. 6148c6fd2807SJeff Garzik * 6149c6fd2807SJeff Garzik * RETURNS: 6150c6fd2807SJeff Garzik * 1 if the port online status is available and online. 6151c6fd2807SJeff Garzik */ 6152936fd732STejun Heo int ata_link_online(struct ata_link *link) 6153c6fd2807SJeff Garzik { 6154c6fd2807SJeff Garzik u32 sstatus; 6155c6fd2807SJeff Garzik 6156936fd732STejun Heo if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 && 6157936fd732STejun Heo (sstatus & 0xf) == 0x3) 6158c6fd2807SJeff Garzik return 1; 6159c6fd2807SJeff Garzik return 0; 6160c6fd2807SJeff Garzik } 6161c6fd2807SJeff Garzik 6162c6fd2807SJeff Garzik /** 6163936fd732STejun Heo * ata_link_offline - test whether the given link is offline 6164936fd732STejun Heo * @link: ATA link to test 6165c6fd2807SJeff Garzik * 6166936fd732STejun Heo * Test whether @link is offline. Note that this function 6167936fd732STejun Heo * returns 0 if offline status of @link cannot be obtained, so 6168936fd732STejun Heo * ata_link_online(link) != !ata_link_offline(link). 6169c6fd2807SJeff Garzik * 6170c6fd2807SJeff Garzik * LOCKING: 6171c6fd2807SJeff Garzik * None. 6172c6fd2807SJeff Garzik * 6173c6fd2807SJeff Garzik * RETURNS: 6174c6fd2807SJeff Garzik * 1 if the port offline status is available and offline. 6175c6fd2807SJeff Garzik */ 6176936fd732STejun Heo int ata_link_offline(struct ata_link *link) 6177c6fd2807SJeff Garzik { 6178c6fd2807SJeff Garzik u32 sstatus; 6179c6fd2807SJeff Garzik 6180936fd732STejun Heo if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 && 6181936fd732STejun Heo (sstatus & 0xf) != 0x3) 6182c6fd2807SJeff Garzik return 1; 6183c6fd2807SJeff Garzik return 0; 6184c6fd2807SJeff Garzik } 6185c6fd2807SJeff Garzik 6186c6fd2807SJeff Garzik int ata_flush_cache(struct ata_device *dev) 6187c6fd2807SJeff Garzik { 6188c6fd2807SJeff Garzik unsigned int err_mask; 6189c6fd2807SJeff Garzik u8 cmd; 6190c6fd2807SJeff Garzik 6191c6fd2807SJeff Garzik if (!ata_try_flush_cache(dev)) 6192c6fd2807SJeff Garzik return 0; 6193c6fd2807SJeff Garzik 61946fc49adbSTejun Heo if (dev->flags & ATA_DFLAG_FLUSH_EXT) 6195c6fd2807SJeff Garzik cmd = ATA_CMD_FLUSH_EXT; 6196c6fd2807SJeff Garzik else 6197c6fd2807SJeff Garzik cmd = ATA_CMD_FLUSH; 6198c6fd2807SJeff Garzik 61994f34337bSAlan Cox /* This is wrong. On a failed flush we get back the LBA of the lost 62004f34337bSAlan Cox sector and we should (assuming it wasn't aborted as unknown) issue 62014f34337bSAlan Cox a further flush command to continue the writeback until it 62024f34337bSAlan Cox does not error */ 6203c6fd2807SJeff Garzik err_mask = ata_do_simple_cmd(dev, cmd); 6204c6fd2807SJeff Garzik if (err_mask) { 6205c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_ERR, "failed to flush cache\n"); 6206c6fd2807SJeff Garzik return -EIO; 6207c6fd2807SJeff Garzik } 6208c6fd2807SJeff Garzik 6209c6fd2807SJeff Garzik return 0; 6210c6fd2807SJeff Garzik } 6211c6fd2807SJeff Garzik 62126ffa01d8STejun Heo #ifdef CONFIG_PM 6213cca3974eSJeff Garzik static int ata_host_request_pm(struct ata_host *host, pm_message_t mesg, 6214cca3974eSJeff Garzik unsigned int action, unsigned int ehi_flags, 6215cca3974eSJeff Garzik int wait) 6216c6fd2807SJeff Garzik { 6217c6fd2807SJeff Garzik unsigned long flags; 6218c6fd2807SJeff Garzik int i, rc; 6219c6fd2807SJeff Garzik 6220cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 6221cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 6222e3667ebfSTejun Heo struct ata_link *link; 6223c6fd2807SJeff Garzik 6224c6fd2807SJeff Garzik /* Previous resume operation might still be in 6225c6fd2807SJeff Garzik * progress. Wait for PM_PENDING to clear. 6226c6fd2807SJeff Garzik */ 6227c6fd2807SJeff Garzik if (ap->pflags & ATA_PFLAG_PM_PENDING) { 6228c6fd2807SJeff Garzik ata_port_wait_eh(ap); 6229c6fd2807SJeff Garzik WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING); 6230c6fd2807SJeff Garzik } 6231c6fd2807SJeff Garzik 6232c6fd2807SJeff Garzik /* request PM ops to EH */ 6233c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 6234c6fd2807SJeff Garzik 6235c6fd2807SJeff Garzik ap->pm_mesg = mesg; 6236c6fd2807SJeff Garzik if (wait) { 6237c6fd2807SJeff Garzik rc = 0; 6238c6fd2807SJeff Garzik ap->pm_result = &rc; 6239c6fd2807SJeff Garzik } 6240c6fd2807SJeff Garzik 6241c6fd2807SJeff Garzik ap->pflags |= ATA_PFLAG_PM_PENDING; 6242e3667ebfSTejun Heo __ata_port_for_each_link(link, ap) { 6243e3667ebfSTejun Heo link->eh_info.action |= action; 6244e3667ebfSTejun Heo link->eh_info.flags |= ehi_flags; 6245e3667ebfSTejun Heo } 6246c6fd2807SJeff Garzik 6247c6fd2807SJeff Garzik ata_port_schedule_eh(ap); 6248c6fd2807SJeff Garzik 6249c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 6250c6fd2807SJeff Garzik 6251c6fd2807SJeff Garzik /* wait and check result */ 6252c6fd2807SJeff Garzik if (wait) { 6253c6fd2807SJeff Garzik ata_port_wait_eh(ap); 6254c6fd2807SJeff Garzik WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING); 6255c6fd2807SJeff Garzik if (rc) 6256c6fd2807SJeff Garzik return rc; 6257c6fd2807SJeff Garzik } 6258c6fd2807SJeff Garzik } 6259c6fd2807SJeff Garzik 6260c6fd2807SJeff Garzik return 0; 6261c6fd2807SJeff Garzik } 6262c6fd2807SJeff Garzik 6263c6fd2807SJeff Garzik /** 6264cca3974eSJeff Garzik * ata_host_suspend - suspend host 6265cca3974eSJeff Garzik * @host: host to suspend 6266c6fd2807SJeff Garzik * @mesg: PM message 6267c6fd2807SJeff Garzik * 6268cca3974eSJeff Garzik * Suspend @host. Actual operation is performed by EH. This 6269c6fd2807SJeff Garzik * function requests EH to perform PM operations and waits for EH 6270c6fd2807SJeff Garzik * to finish. 6271c6fd2807SJeff Garzik * 6272c6fd2807SJeff Garzik * LOCKING: 6273c6fd2807SJeff Garzik * Kernel thread context (may sleep). 6274c6fd2807SJeff Garzik * 6275c6fd2807SJeff Garzik * RETURNS: 6276c6fd2807SJeff Garzik * 0 on success, -errno on failure. 6277c6fd2807SJeff Garzik */ 6278cca3974eSJeff Garzik int ata_host_suspend(struct ata_host *host, pm_message_t mesg) 6279c6fd2807SJeff Garzik { 62809666f400STejun Heo int rc; 6281c6fd2807SJeff Garzik 6282cca3974eSJeff Garzik rc = ata_host_request_pm(host, mesg, 0, ATA_EHI_QUIET, 1); 62839666f400STejun Heo if (rc == 0) 6284cca3974eSJeff Garzik host->dev->power.power_state = mesg; 6285c6fd2807SJeff Garzik return rc; 6286c6fd2807SJeff Garzik } 6287c6fd2807SJeff Garzik 6288c6fd2807SJeff Garzik /** 6289cca3974eSJeff Garzik * ata_host_resume - resume host 6290cca3974eSJeff Garzik * @host: host to resume 6291c6fd2807SJeff Garzik * 6292cca3974eSJeff Garzik * Resume @host. Actual operation is performed by EH. This 6293c6fd2807SJeff Garzik * function requests EH to perform PM operations and returns. 6294c6fd2807SJeff Garzik * Note that all resume operations are performed parallely. 6295c6fd2807SJeff Garzik * 6296c6fd2807SJeff Garzik * LOCKING: 6297c6fd2807SJeff Garzik * Kernel thread context (may sleep). 6298c6fd2807SJeff Garzik */ 6299cca3974eSJeff Garzik void ata_host_resume(struct ata_host *host) 6300c6fd2807SJeff Garzik { 6301cca3974eSJeff Garzik ata_host_request_pm(host, PMSG_ON, ATA_EH_SOFTRESET, 6302c6fd2807SJeff Garzik ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET, 0); 6303cca3974eSJeff Garzik host->dev->power.power_state = PMSG_ON; 6304c6fd2807SJeff Garzik } 63056ffa01d8STejun Heo #endif 6306c6fd2807SJeff Garzik 6307c6fd2807SJeff Garzik /** 6308c6fd2807SJeff Garzik * ata_port_start - Set port up for dma. 6309c6fd2807SJeff Garzik * @ap: Port to initialize 6310c6fd2807SJeff Garzik * 6311c6fd2807SJeff Garzik * Called just after data structures for each port are 6312c6fd2807SJeff Garzik * initialized. Allocates space for PRD table. 6313c6fd2807SJeff Garzik * 6314c6fd2807SJeff Garzik * May be used as the port_start() entry in ata_port_operations. 6315c6fd2807SJeff Garzik * 6316c6fd2807SJeff Garzik * LOCKING: 6317c6fd2807SJeff Garzik * Inherited from caller. 6318c6fd2807SJeff Garzik */ 6319c6fd2807SJeff Garzik int ata_port_start(struct ata_port *ap) 6320c6fd2807SJeff Garzik { 6321c6fd2807SJeff Garzik struct device *dev = ap->dev; 6322c6fd2807SJeff Garzik int rc; 6323c6fd2807SJeff Garzik 6324f0d36efdSTejun Heo ap->prd = dmam_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, 6325f0d36efdSTejun Heo GFP_KERNEL); 6326c6fd2807SJeff Garzik if (!ap->prd) 6327c6fd2807SJeff Garzik return -ENOMEM; 6328c6fd2807SJeff Garzik 6329c6fd2807SJeff Garzik rc = ata_pad_alloc(ap, dev); 6330f0d36efdSTejun Heo if (rc) 6331c6fd2807SJeff Garzik return rc; 6332c6fd2807SJeff Garzik 6333f0d36efdSTejun Heo DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, 6334f0d36efdSTejun Heo (unsigned long long)ap->prd_dma); 6335c6fd2807SJeff Garzik return 0; 6336c6fd2807SJeff Garzik } 6337c6fd2807SJeff Garzik 6338c6fd2807SJeff Garzik /** 6339c6fd2807SJeff Garzik * ata_dev_init - Initialize an ata_device structure 6340c6fd2807SJeff Garzik * @dev: Device structure to initialize 6341c6fd2807SJeff Garzik * 6342c6fd2807SJeff Garzik * Initialize @dev in preparation for probing. 6343c6fd2807SJeff Garzik * 6344c6fd2807SJeff Garzik * LOCKING: 6345c6fd2807SJeff Garzik * Inherited from caller. 6346c6fd2807SJeff Garzik */ 6347c6fd2807SJeff Garzik void ata_dev_init(struct ata_device *dev) 6348c6fd2807SJeff Garzik { 63499af5c9c9STejun Heo struct ata_link *link = dev->link; 63509af5c9c9STejun Heo struct ata_port *ap = link->ap; 6351c6fd2807SJeff Garzik unsigned long flags; 6352c6fd2807SJeff Garzik 6353c6fd2807SJeff Garzik /* SATA spd limit is bound to the first device */ 63549af5c9c9STejun Heo link->sata_spd_limit = link->hw_sata_spd_limit; 63559af5c9c9STejun Heo link->sata_spd = 0; 6356c6fd2807SJeff Garzik 6357c6fd2807SJeff Garzik /* High bits of dev->flags are used to record warm plug 6358c6fd2807SJeff Garzik * requests which occur asynchronously. Synchronize using 6359cca3974eSJeff Garzik * host lock. 6360c6fd2807SJeff Garzik */ 6361c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 6362c6fd2807SJeff Garzik dev->flags &= ~ATA_DFLAG_INIT_MASK; 63633dcc323fSTejun Heo dev->horkage = 0; 6364c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 6365c6fd2807SJeff Garzik 6366c6fd2807SJeff Garzik memset((void *)dev + ATA_DEVICE_CLEAR_OFFSET, 0, 6367c6fd2807SJeff Garzik sizeof(*dev) - ATA_DEVICE_CLEAR_OFFSET); 6368c6fd2807SJeff Garzik dev->pio_mask = UINT_MAX; 6369c6fd2807SJeff Garzik dev->mwdma_mask = UINT_MAX; 6370c6fd2807SJeff Garzik dev->udma_mask = UINT_MAX; 6371c6fd2807SJeff Garzik } 6372c6fd2807SJeff Garzik 6373c6fd2807SJeff Garzik /** 63744fb37a25STejun Heo * ata_link_init - Initialize an ata_link structure 63754fb37a25STejun Heo * @ap: ATA port link is attached to 63764fb37a25STejun Heo * @link: Link structure to initialize 63778989805dSTejun Heo * @pmp: Port multiplier port number 63784fb37a25STejun Heo * 63794fb37a25STejun Heo * Initialize @link. 63804fb37a25STejun Heo * 63814fb37a25STejun Heo * LOCKING: 63824fb37a25STejun Heo * Kernel thread context (may sleep) 63834fb37a25STejun Heo */ 6384fb7fd614STejun Heo void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp) 63854fb37a25STejun Heo { 63864fb37a25STejun Heo int i; 63874fb37a25STejun Heo 63884fb37a25STejun Heo /* clear everything except for devices */ 63894fb37a25STejun Heo memset(link, 0, offsetof(struct ata_link, device[0])); 63904fb37a25STejun Heo 63914fb37a25STejun Heo link->ap = ap; 63928989805dSTejun Heo link->pmp = pmp; 63934fb37a25STejun Heo link->active_tag = ATA_TAG_POISON; 63944fb37a25STejun Heo link->hw_sata_spd_limit = UINT_MAX; 63954fb37a25STejun Heo 63964fb37a25STejun Heo /* can't use iterator, ap isn't initialized yet */ 63974fb37a25STejun Heo for (i = 0; i < ATA_MAX_DEVICES; i++) { 63984fb37a25STejun Heo struct ata_device *dev = &link->device[i]; 63994fb37a25STejun Heo 64004fb37a25STejun Heo dev->link = link; 64014fb37a25STejun Heo dev->devno = dev - link->device; 64024fb37a25STejun Heo ata_dev_init(dev); 64034fb37a25STejun Heo } 64044fb37a25STejun Heo } 64054fb37a25STejun Heo 64064fb37a25STejun Heo /** 64074fb37a25STejun Heo * sata_link_init_spd - Initialize link->sata_spd_limit 64084fb37a25STejun Heo * @link: Link to configure sata_spd_limit for 64094fb37a25STejun Heo * 64104fb37a25STejun Heo * Initialize @link->[hw_]sata_spd_limit to the currently 64114fb37a25STejun Heo * configured value. 64124fb37a25STejun Heo * 64134fb37a25STejun Heo * LOCKING: 64144fb37a25STejun Heo * Kernel thread context (may sleep). 64154fb37a25STejun Heo * 64164fb37a25STejun Heo * RETURNS: 64174fb37a25STejun Heo * 0 on success, -errno on failure. 64184fb37a25STejun Heo */ 6419fb7fd614STejun Heo int sata_link_init_spd(struct ata_link *link) 64204fb37a25STejun Heo { 64214fb37a25STejun Heo u32 scontrol, spd; 64224fb37a25STejun Heo int rc; 64234fb37a25STejun Heo 64244fb37a25STejun Heo rc = sata_scr_read(link, SCR_CONTROL, &scontrol); 64254fb37a25STejun Heo if (rc) 64264fb37a25STejun Heo return rc; 64274fb37a25STejun Heo 64284fb37a25STejun Heo spd = (scontrol >> 4) & 0xf; 64294fb37a25STejun Heo if (spd) 64304fb37a25STejun Heo link->hw_sata_spd_limit &= (1 << spd) - 1; 64314fb37a25STejun Heo 64324fb37a25STejun Heo link->sata_spd_limit = link->hw_sata_spd_limit; 64334fb37a25STejun Heo 64344fb37a25STejun Heo return 0; 64354fb37a25STejun Heo } 64364fb37a25STejun Heo 64374fb37a25STejun Heo /** 6438f3187195STejun Heo * ata_port_alloc - allocate and initialize basic ATA port resources 6439f3187195STejun Heo * @host: ATA host this allocated port belongs to 6440c6fd2807SJeff Garzik * 6441f3187195STejun Heo * Allocate and initialize basic ATA port resources. 6442f3187195STejun Heo * 6443f3187195STejun Heo * RETURNS: 6444f3187195STejun Heo * Allocate ATA port on success, NULL on failure. 6445c6fd2807SJeff Garzik * 6446c6fd2807SJeff Garzik * LOCKING: 6447f3187195STejun Heo * Inherited from calling layer (may sleep). 6448c6fd2807SJeff Garzik */ 6449f3187195STejun Heo struct ata_port *ata_port_alloc(struct ata_host *host) 6450c6fd2807SJeff Garzik { 6451f3187195STejun Heo struct ata_port *ap; 6452c6fd2807SJeff Garzik 6453f3187195STejun Heo DPRINTK("ENTER\n"); 6454f3187195STejun Heo 6455f3187195STejun Heo ap = kzalloc(sizeof(*ap), GFP_KERNEL); 6456f3187195STejun Heo if (!ap) 6457f3187195STejun Heo return NULL; 6458f3187195STejun Heo 6459f4d6d004STejun Heo ap->pflags |= ATA_PFLAG_INITIALIZING; 6460cca3974eSJeff Garzik ap->lock = &host->lock; 6461c6fd2807SJeff Garzik ap->flags = ATA_FLAG_DISABLED; 6462f3187195STejun Heo ap->print_id = -1; 6463c6fd2807SJeff Garzik ap->ctl = ATA_DEVCTL_OBS; 6464cca3974eSJeff Garzik ap->host = host; 6465f3187195STejun Heo ap->dev = host->dev; 6466c6fd2807SJeff Garzik ap->last_ctl = 0xFF; 6467c6fd2807SJeff Garzik 6468c6fd2807SJeff Garzik #if defined(ATA_VERBOSE_DEBUG) 6469c6fd2807SJeff Garzik /* turn on all debugging levels */ 6470c6fd2807SJeff Garzik ap->msg_enable = 0x00FF; 6471c6fd2807SJeff Garzik #elif defined(ATA_DEBUG) 6472c6fd2807SJeff Garzik ap->msg_enable = ATA_MSG_DRV | ATA_MSG_INFO | ATA_MSG_CTL | ATA_MSG_WARN | ATA_MSG_ERR; 6473c6fd2807SJeff Garzik #else 6474c6fd2807SJeff Garzik ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR | ATA_MSG_WARN; 6475c6fd2807SJeff Garzik #endif 6476c6fd2807SJeff Garzik 647765f27f38SDavid Howells INIT_DELAYED_WORK(&ap->port_task, NULL); 647865f27f38SDavid Howells INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug); 647965f27f38SDavid Howells INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan); 6480c6fd2807SJeff Garzik INIT_LIST_HEAD(&ap->eh_done_q); 6481c6fd2807SJeff Garzik init_waitqueue_head(&ap->eh_wait_q); 64825ddf24c5STejun Heo init_timer_deferrable(&ap->fastdrain_timer); 64835ddf24c5STejun Heo ap->fastdrain_timer.function = ata_eh_fastdrain_timerfn; 64845ddf24c5STejun Heo ap->fastdrain_timer.data = (unsigned long)ap; 6485c6fd2807SJeff Garzik 6486c6fd2807SJeff Garzik ap->cbl = ATA_CBL_NONE; 6487c6fd2807SJeff Garzik 64888989805dSTejun Heo ata_link_init(ap, &ap->link, 0); 6489c6fd2807SJeff Garzik 6490c6fd2807SJeff Garzik #ifdef ATA_IRQ_TRAP 6491c6fd2807SJeff Garzik ap->stats.unhandled_irq = 1; 6492c6fd2807SJeff Garzik ap->stats.idle_irq = 1; 6493c6fd2807SJeff Garzik #endif 6494c6fd2807SJeff Garzik return ap; 6495c6fd2807SJeff Garzik } 6496c6fd2807SJeff Garzik 6497f0d36efdSTejun Heo static void ata_host_release(struct device *gendev, void *res) 6498f0d36efdSTejun Heo { 6499f0d36efdSTejun Heo struct ata_host *host = dev_get_drvdata(gendev); 6500f0d36efdSTejun Heo int i; 6501f0d36efdSTejun Heo 6502f0d36efdSTejun Heo for (i = 0; i < host->n_ports; i++) { 6503f0d36efdSTejun Heo struct ata_port *ap = host->ports[i]; 6504f0d36efdSTejun Heo 6505ecef7253STejun Heo if (!ap) 6506ecef7253STejun Heo continue; 6507ecef7253STejun Heo 6508ecef7253STejun Heo if ((host->flags & ATA_HOST_STARTED) && ap->ops->port_stop) 6509f0d36efdSTejun Heo ap->ops->port_stop(ap); 6510f0d36efdSTejun Heo } 6511f0d36efdSTejun Heo 6512ecef7253STejun Heo if ((host->flags & ATA_HOST_STARTED) && host->ops->host_stop) 6513f0d36efdSTejun Heo host->ops->host_stop(host); 65141aa56ccaSTejun Heo 65151aa506e4STejun Heo for (i = 0; i < host->n_ports; i++) { 65161aa506e4STejun Heo struct ata_port *ap = host->ports[i]; 65171aa506e4STejun Heo 65184911487aSTejun Heo if (!ap) 65194911487aSTejun Heo continue; 65204911487aSTejun Heo 65214911487aSTejun Heo if (ap->scsi_host) 65221aa506e4STejun Heo scsi_host_put(ap->scsi_host); 65231aa506e4STejun Heo 6524633273a3STejun Heo kfree(ap->pmp_link); 65254911487aSTejun Heo kfree(ap); 65261aa506e4STejun Heo host->ports[i] = NULL; 65271aa506e4STejun Heo } 65281aa506e4STejun Heo 65291aa56ccaSTejun Heo dev_set_drvdata(gendev, NULL); 6530f0d36efdSTejun Heo } 6531f0d36efdSTejun Heo 6532c6fd2807SJeff Garzik /** 6533f3187195STejun Heo * ata_host_alloc - allocate and init basic ATA host resources 6534f3187195STejun Heo * @dev: generic device this host is associated with 6535f3187195STejun Heo * @max_ports: maximum number of ATA ports associated with this host 6536f3187195STejun Heo * 6537f3187195STejun Heo * Allocate and initialize basic ATA host resources. LLD calls 6538f3187195STejun Heo * this function to allocate a host, initializes it fully and 6539f3187195STejun Heo * attaches it using ata_host_register(). 6540f3187195STejun Heo * 6541f3187195STejun Heo * @max_ports ports are allocated and host->n_ports is 6542f3187195STejun Heo * initialized to @max_ports. The caller is allowed to decrease 6543f3187195STejun Heo * host->n_ports before calling ata_host_register(). The unused 6544f3187195STejun Heo * ports will be automatically freed on registration. 6545f3187195STejun Heo * 6546f3187195STejun Heo * RETURNS: 6547f3187195STejun Heo * Allocate ATA host on success, NULL on failure. 6548f3187195STejun Heo * 6549f3187195STejun Heo * LOCKING: 6550f3187195STejun Heo * Inherited from calling layer (may sleep). 6551f3187195STejun Heo */ 6552f3187195STejun Heo struct ata_host *ata_host_alloc(struct device *dev, int max_ports) 6553f3187195STejun Heo { 6554f3187195STejun Heo struct ata_host *host; 6555f3187195STejun Heo size_t sz; 6556f3187195STejun Heo int i; 6557f3187195STejun Heo 6558f3187195STejun Heo DPRINTK("ENTER\n"); 6559f3187195STejun Heo 6560f3187195STejun Heo if (!devres_open_group(dev, NULL, GFP_KERNEL)) 6561f3187195STejun Heo return NULL; 6562f3187195STejun Heo 6563f3187195STejun Heo /* alloc a container for our list of ATA ports (buses) */ 6564f3187195STejun Heo sz = sizeof(struct ata_host) + (max_ports + 1) * sizeof(void *); 6565f3187195STejun Heo /* alloc a container for our list of ATA ports (buses) */ 6566f3187195STejun Heo host = devres_alloc(ata_host_release, sz, GFP_KERNEL); 6567f3187195STejun Heo if (!host) 6568f3187195STejun Heo goto err_out; 6569f3187195STejun Heo 6570f3187195STejun Heo devres_add(dev, host); 6571f3187195STejun Heo dev_set_drvdata(dev, host); 6572f3187195STejun Heo 6573f3187195STejun Heo spin_lock_init(&host->lock); 6574f3187195STejun Heo host->dev = dev; 6575f3187195STejun Heo host->n_ports = max_ports; 6576f3187195STejun Heo 6577f3187195STejun Heo /* allocate ports bound to this host */ 6578f3187195STejun Heo for (i = 0; i < max_ports; i++) { 6579f3187195STejun Heo struct ata_port *ap; 6580f3187195STejun Heo 6581f3187195STejun Heo ap = ata_port_alloc(host); 6582f3187195STejun Heo if (!ap) 6583f3187195STejun Heo goto err_out; 6584f3187195STejun Heo 6585f3187195STejun Heo ap->port_no = i; 6586f3187195STejun Heo host->ports[i] = ap; 6587f3187195STejun Heo } 6588f3187195STejun Heo 6589f3187195STejun Heo devres_remove_group(dev, NULL); 6590f3187195STejun Heo return host; 6591f3187195STejun Heo 6592f3187195STejun Heo err_out: 6593f3187195STejun Heo devres_release_group(dev, NULL); 6594f3187195STejun Heo return NULL; 6595f3187195STejun Heo } 6596f3187195STejun Heo 6597f3187195STejun Heo /** 6598f5cda257STejun Heo * ata_host_alloc_pinfo - alloc host and init with port_info array 6599f5cda257STejun Heo * @dev: generic device this host is associated with 6600f5cda257STejun Heo * @ppi: array of ATA port_info to initialize host with 6601f5cda257STejun Heo * @n_ports: number of ATA ports attached to this host 6602f5cda257STejun Heo * 6603f5cda257STejun Heo * Allocate ATA host and initialize with info from @ppi. If NULL 6604f5cda257STejun Heo * terminated, @ppi may contain fewer entries than @n_ports. The 6605f5cda257STejun Heo * last entry will be used for the remaining ports. 6606f5cda257STejun Heo * 6607f5cda257STejun Heo * RETURNS: 6608f5cda257STejun Heo * Allocate ATA host on success, NULL on failure. 6609f5cda257STejun Heo * 6610f5cda257STejun Heo * LOCKING: 6611f5cda257STejun Heo * Inherited from calling layer (may sleep). 6612f5cda257STejun Heo */ 6613f5cda257STejun Heo struct ata_host *ata_host_alloc_pinfo(struct device *dev, 6614f5cda257STejun Heo const struct ata_port_info * const * ppi, 6615f5cda257STejun Heo int n_ports) 6616f5cda257STejun Heo { 6617f5cda257STejun Heo const struct ata_port_info *pi; 6618f5cda257STejun Heo struct ata_host *host; 6619f5cda257STejun Heo int i, j; 6620f5cda257STejun Heo 6621f5cda257STejun Heo host = ata_host_alloc(dev, n_ports); 6622f5cda257STejun Heo if (!host) 6623f5cda257STejun Heo return NULL; 6624f5cda257STejun Heo 6625f5cda257STejun Heo for (i = 0, j = 0, pi = NULL; i < host->n_ports; i++) { 6626f5cda257STejun Heo struct ata_port *ap = host->ports[i]; 6627f5cda257STejun Heo 6628f5cda257STejun Heo if (ppi[j]) 6629f5cda257STejun Heo pi = ppi[j++]; 6630f5cda257STejun Heo 6631f5cda257STejun Heo ap->pio_mask = pi->pio_mask; 6632f5cda257STejun Heo ap->mwdma_mask = pi->mwdma_mask; 6633f5cda257STejun Heo ap->udma_mask = pi->udma_mask; 6634f5cda257STejun Heo ap->flags |= pi->flags; 66350c88758bSTejun Heo ap->link.flags |= pi->link_flags; 6636f5cda257STejun Heo ap->ops = pi->port_ops; 6637f5cda257STejun Heo 6638f5cda257STejun Heo if (!host->ops && (pi->port_ops != &ata_dummy_port_ops)) 6639f5cda257STejun Heo host->ops = pi->port_ops; 6640f5cda257STejun Heo if (!host->private_data && pi->private_data) 6641f5cda257STejun Heo host->private_data = pi->private_data; 6642f5cda257STejun Heo } 6643f5cda257STejun Heo 6644f5cda257STejun Heo return host; 6645f5cda257STejun Heo } 6646f5cda257STejun Heo 6647f5cda257STejun Heo /** 6648ecef7253STejun Heo * ata_host_start - start and freeze ports of an ATA host 6649ecef7253STejun Heo * @host: ATA host to start ports for 6650ecef7253STejun Heo * 6651ecef7253STejun Heo * Start and then freeze ports of @host. Started status is 6652ecef7253STejun Heo * recorded in host->flags, so this function can be called 6653ecef7253STejun Heo * multiple times. Ports are guaranteed to get started only 6654f3187195STejun Heo * once. If host->ops isn't initialized yet, its set to the 6655f3187195STejun Heo * first non-dummy port ops. 6656ecef7253STejun Heo * 6657ecef7253STejun Heo * LOCKING: 6658ecef7253STejun Heo * Inherited from calling layer (may sleep). 6659ecef7253STejun Heo * 6660ecef7253STejun Heo * RETURNS: 6661ecef7253STejun Heo * 0 if all ports are started successfully, -errno otherwise. 6662ecef7253STejun Heo */ 6663ecef7253STejun Heo int ata_host_start(struct ata_host *host) 6664ecef7253STejun Heo { 6665ecef7253STejun Heo int i, rc; 6666ecef7253STejun Heo 6667ecef7253STejun Heo if (host->flags & ATA_HOST_STARTED) 6668ecef7253STejun Heo return 0; 6669ecef7253STejun Heo 6670ecef7253STejun Heo for (i = 0; i < host->n_ports; i++) { 6671ecef7253STejun Heo struct ata_port *ap = host->ports[i]; 6672ecef7253STejun Heo 6673f3187195STejun Heo if (!host->ops && !ata_port_is_dummy(ap)) 6674f3187195STejun Heo host->ops = ap->ops; 6675f3187195STejun Heo 6676ecef7253STejun Heo if (ap->ops->port_start) { 6677ecef7253STejun Heo rc = ap->ops->port_start(ap); 6678ecef7253STejun Heo if (rc) { 6679ecef7253STejun Heo ata_port_printk(ap, KERN_ERR, "failed to " 6680ecef7253STejun Heo "start port (errno=%d)\n", rc); 6681ecef7253STejun Heo goto err_out; 6682ecef7253STejun Heo } 6683ecef7253STejun Heo } 6684ecef7253STejun Heo 6685ecef7253STejun Heo ata_eh_freeze_port(ap); 6686ecef7253STejun Heo } 6687ecef7253STejun Heo 6688ecef7253STejun Heo host->flags |= ATA_HOST_STARTED; 6689ecef7253STejun Heo return 0; 6690ecef7253STejun Heo 6691ecef7253STejun Heo err_out: 6692ecef7253STejun Heo while (--i >= 0) { 6693ecef7253STejun Heo struct ata_port *ap = host->ports[i]; 6694ecef7253STejun Heo 6695ecef7253STejun Heo if (ap->ops->port_stop) 6696ecef7253STejun Heo ap->ops->port_stop(ap); 6697ecef7253STejun Heo } 6698ecef7253STejun Heo return rc; 6699ecef7253STejun Heo } 6700ecef7253STejun Heo 6701ecef7253STejun Heo /** 6702cca3974eSJeff Garzik * ata_sas_host_init - Initialize a host struct 6703cca3974eSJeff Garzik * @host: host to initialize 6704cca3974eSJeff Garzik * @dev: device host is attached to 6705cca3974eSJeff Garzik * @flags: host flags 6706c6fd2807SJeff Garzik * @ops: port_ops 6707c6fd2807SJeff Garzik * 6708c6fd2807SJeff Garzik * LOCKING: 6709c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 6710c6fd2807SJeff Garzik * 6711c6fd2807SJeff Garzik */ 6712f3187195STejun Heo /* KILLME - the only user left is ipr */ 6713cca3974eSJeff Garzik void ata_host_init(struct ata_host *host, struct device *dev, 6714cca3974eSJeff Garzik unsigned long flags, const struct ata_port_operations *ops) 6715c6fd2807SJeff Garzik { 6716cca3974eSJeff Garzik spin_lock_init(&host->lock); 6717cca3974eSJeff Garzik host->dev = dev; 6718cca3974eSJeff Garzik host->flags = flags; 6719cca3974eSJeff Garzik host->ops = ops; 6720c6fd2807SJeff Garzik } 6721c6fd2807SJeff Garzik 6722c6fd2807SJeff Garzik /** 6723f3187195STejun Heo * ata_host_register - register initialized ATA host 6724f3187195STejun Heo * @host: ATA host to register 6725f3187195STejun Heo * @sht: template for SCSI host 6726c6fd2807SJeff Garzik * 6727f3187195STejun Heo * Register initialized ATA host. @host is allocated using 6728f3187195STejun Heo * ata_host_alloc() and fully initialized by LLD. This function 6729f3187195STejun Heo * starts ports, registers @host with ATA and SCSI layers and 6730f3187195STejun Heo * probe registered devices. 6731c6fd2807SJeff Garzik * 6732c6fd2807SJeff Garzik * LOCKING: 6733f3187195STejun Heo * Inherited from calling layer (may sleep). 6734c6fd2807SJeff Garzik * 6735c6fd2807SJeff Garzik * RETURNS: 6736f3187195STejun Heo * 0 on success, -errno otherwise. 6737c6fd2807SJeff Garzik */ 6738f3187195STejun Heo int ata_host_register(struct ata_host *host, struct scsi_host_template *sht) 6739c6fd2807SJeff Garzik { 6740f3187195STejun Heo int i, rc; 6741c6fd2807SJeff Garzik 6742f3187195STejun Heo /* host must have been started */ 6743f3187195STejun Heo if (!(host->flags & ATA_HOST_STARTED)) { 6744f3187195STejun Heo dev_printk(KERN_ERR, host->dev, 6745f3187195STejun Heo "BUG: trying to register unstarted host\n"); 6746f3187195STejun Heo WARN_ON(1); 6747f3187195STejun Heo return -EINVAL; 674802f076aaSAlan Cox } 6749f0d36efdSTejun Heo 6750f3187195STejun Heo /* Blow away unused ports. This happens when LLD can't 6751f3187195STejun Heo * determine the exact number of ports to allocate at 6752f3187195STejun Heo * allocation time. 6753f3187195STejun Heo */ 6754f3187195STejun Heo for (i = host->n_ports; host->ports[i]; i++) 6755f3187195STejun Heo kfree(host->ports[i]); 6756f0d36efdSTejun Heo 6757f3187195STejun Heo /* give ports names and add SCSI hosts */ 6758f3187195STejun Heo for (i = 0; i < host->n_ports; i++) 6759f3187195STejun Heo host->ports[i]->print_id = ata_print_id++; 6760c6fd2807SJeff Garzik 6761f3187195STejun Heo rc = ata_scsi_add_hosts(host, sht); 6762ecef7253STejun Heo if (rc) 6763f3187195STejun Heo return rc; 6764ecef7253STejun Heo 6765fafbae87STejun Heo /* associate with ACPI nodes */ 6766fafbae87STejun Heo ata_acpi_associate(host); 6767fafbae87STejun Heo 6768f3187195STejun Heo /* set cable, sata_spd_limit and report */ 6769cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 6770cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 6771f3187195STejun Heo unsigned long xfer_mask; 6772f3187195STejun Heo 6773f3187195STejun Heo /* set SATA cable type if still unset */ 6774f3187195STejun Heo if (ap->cbl == ATA_CBL_NONE && (ap->flags & ATA_FLAG_SATA)) 6775f3187195STejun Heo ap->cbl = ATA_CBL_SATA; 6776c6fd2807SJeff Garzik 6777c6fd2807SJeff Garzik /* init sata_spd_limit to the current value */ 67784fb37a25STejun Heo sata_link_init_spd(&ap->link); 6779c6fd2807SJeff Garzik 6780cbcdd875STejun Heo /* print per-port info to dmesg */ 6781f3187195STejun Heo xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask, 6782f3187195STejun Heo ap->udma_mask); 6783f3187195STejun Heo 6784abf6e8edSTejun Heo if (!ata_port_is_dummy(ap)) { 6785cbcdd875STejun Heo ata_port_printk(ap, KERN_INFO, 6786cbcdd875STejun Heo "%cATA max %s %s\n", 6787a16abc0bSTejun Heo (ap->flags & ATA_FLAG_SATA) ? 'S' : 'P', 6788f3187195STejun Heo ata_mode_string(xfer_mask), 6789cbcdd875STejun Heo ap->link.eh_info.desc); 6790abf6e8edSTejun Heo ata_ehi_clear_desc(&ap->link.eh_info); 6791abf6e8edSTejun Heo } else 6792f3187195STejun Heo ata_port_printk(ap, KERN_INFO, "DUMMY\n"); 6793c6fd2807SJeff Garzik } 6794c6fd2807SJeff Garzik 6795f3187195STejun Heo /* perform each probe synchronously */ 6796f3187195STejun Heo DPRINTK("probe begin\n"); 6797f3187195STejun Heo for (i = 0; i < host->n_ports; i++) { 6798f3187195STejun Heo struct ata_port *ap = host->ports[i]; 6799f3187195STejun Heo int rc; 6800f3187195STejun Heo 6801f3187195STejun Heo /* probe */ 6802c6fd2807SJeff Garzik if (ap->ops->error_handler) { 68039af5c9c9STejun Heo struct ata_eh_info *ehi = &ap->link.eh_info; 6804c6fd2807SJeff Garzik unsigned long flags; 6805c6fd2807SJeff Garzik 6806c6fd2807SJeff Garzik ata_port_probe(ap); 6807c6fd2807SJeff Garzik 6808c6fd2807SJeff Garzik /* kick EH for boot probing */ 6809c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 6810c6fd2807SJeff Garzik 6811f58229f8STejun Heo ehi->probe_mask = 6812f58229f8STejun Heo (1 << ata_link_max_devices(&ap->link)) - 1; 6813c6fd2807SJeff Garzik ehi->action |= ATA_EH_SOFTRESET; 6814c6fd2807SJeff Garzik ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET; 6815c6fd2807SJeff Garzik 6816f4d6d004STejun Heo ap->pflags &= ~ATA_PFLAG_INITIALIZING; 6817c6fd2807SJeff Garzik ap->pflags |= ATA_PFLAG_LOADING; 6818c6fd2807SJeff Garzik ata_port_schedule_eh(ap); 6819c6fd2807SJeff Garzik 6820c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 6821c6fd2807SJeff Garzik 6822c6fd2807SJeff Garzik /* wait for EH to finish */ 6823c6fd2807SJeff Garzik ata_port_wait_eh(ap); 6824c6fd2807SJeff Garzik } else { 682544877b4eSTejun Heo DPRINTK("ata%u: bus probe begin\n", ap->print_id); 6826c6fd2807SJeff Garzik rc = ata_bus_probe(ap); 682744877b4eSTejun Heo DPRINTK("ata%u: bus probe end\n", ap->print_id); 6828c6fd2807SJeff Garzik 6829c6fd2807SJeff Garzik if (rc) { 6830c6fd2807SJeff Garzik /* FIXME: do something useful here? 6831c6fd2807SJeff Garzik * Current libata behavior will 6832c6fd2807SJeff Garzik * tear down everything when 6833c6fd2807SJeff Garzik * the module is removed 6834c6fd2807SJeff Garzik * or the h/w is unplugged. 6835c6fd2807SJeff Garzik */ 6836c6fd2807SJeff Garzik } 6837c6fd2807SJeff Garzik } 6838c6fd2807SJeff Garzik } 6839c6fd2807SJeff Garzik 6840c6fd2807SJeff Garzik /* probes are done, now scan each port's disk(s) */ 6841c6fd2807SJeff Garzik DPRINTK("host probe begin\n"); 6842cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 6843cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 6844c6fd2807SJeff Garzik 68451ae46317STejun Heo ata_scsi_scan_host(ap, 1); 6846c6fd2807SJeff Garzik } 6847c6fd2807SJeff Garzik 6848f3187195STejun Heo return 0; 6849f3187195STejun Heo } 6850f3187195STejun Heo 6851f3187195STejun Heo /** 6852f5cda257STejun Heo * ata_host_activate - start host, request IRQ and register it 6853f5cda257STejun Heo * @host: target ATA host 6854f5cda257STejun Heo * @irq: IRQ to request 6855f5cda257STejun Heo * @irq_handler: irq_handler used when requesting IRQ 6856f5cda257STejun Heo * @irq_flags: irq_flags used when requesting IRQ 6857f5cda257STejun Heo * @sht: scsi_host_template to use when registering the host 6858f5cda257STejun Heo * 6859f5cda257STejun Heo * After allocating an ATA host and initializing it, most libata 6860f5cda257STejun Heo * LLDs perform three steps to activate the host - start host, 6861f5cda257STejun Heo * request IRQ and register it. This helper takes necessasry 6862f5cda257STejun Heo * arguments and performs the three steps in one go. 6863f5cda257STejun Heo * 6864f5cda257STejun Heo * LOCKING: 6865f5cda257STejun Heo * Inherited from calling layer (may sleep). 6866f5cda257STejun Heo * 6867f5cda257STejun Heo * RETURNS: 6868f5cda257STejun Heo * 0 on success, -errno otherwise. 6869f5cda257STejun Heo */ 6870f5cda257STejun Heo int ata_host_activate(struct ata_host *host, int irq, 6871f5cda257STejun Heo irq_handler_t irq_handler, unsigned long irq_flags, 6872f5cda257STejun Heo struct scsi_host_template *sht) 6873f5cda257STejun Heo { 6874cbcdd875STejun Heo int i, rc; 6875f5cda257STejun Heo 6876f5cda257STejun Heo rc = ata_host_start(host); 6877f5cda257STejun Heo if (rc) 6878f5cda257STejun Heo return rc; 6879f5cda257STejun Heo 6880f5cda257STejun Heo rc = devm_request_irq(host->dev, irq, irq_handler, irq_flags, 6881f5cda257STejun Heo dev_driver_string(host->dev), host); 6882f5cda257STejun Heo if (rc) 6883f5cda257STejun Heo return rc; 6884f5cda257STejun Heo 6885cbcdd875STejun Heo for (i = 0; i < host->n_ports; i++) 6886cbcdd875STejun Heo ata_port_desc(host->ports[i], "irq %d", irq); 68874031826bSTejun Heo 6888f5cda257STejun Heo rc = ata_host_register(host, sht); 6889f5cda257STejun Heo /* if failed, just free the IRQ and leave ports alone */ 6890f5cda257STejun Heo if (rc) 6891f5cda257STejun Heo devm_free_irq(host->dev, irq, host); 6892f5cda257STejun Heo 6893f5cda257STejun Heo return rc; 6894f5cda257STejun Heo } 6895f5cda257STejun Heo 6896f5cda257STejun Heo /** 6897c6fd2807SJeff Garzik * ata_port_detach - Detach ATA port in prepration of device removal 6898c6fd2807SJeff Garzik * @ap: ATA port to be detached 6899c6fd2807SJeff Garzik * 6900c6fd2807SJeff Garzik * Detach all ATA devices and the associated SCSI devices of @ap; 6901c6fd2807SJeff Garzik * then, remove the associated SCSI host. @ap is guaranteed to 6902c6fd2807SJeff Garzik * be quiescent on return from this function. 6903c6fd2807SJeff Garzik * 6904c6fd2807SJeff Garzik * LOCKING: 6905c6fd2807SJeff Garzik * Kernel thread context (may sleep). 6906c6fd2807SJeff Garzik */ 6907c6fd2807SJeff Garzik void ata_port_detach(struct ata_port *ap) 6908c6fd2807SJeff Garzik { 6909c6fd2807SJeff Garzik unsigned long flags; 691041bda9c9STejun Heo struct ata_link *link; 6911f58229f8STejun Heo struct ata_device *dev; 6912c6fd2807SJeff Garzik 6913c6fd2807SJeff Garzik if (!ap->ops->error_handler) 6914c6fd2807SJeff Garzik goto skip_eh; 6915c6fd2807SJeff Garzik 6916c6fd2807SJeff Garzik /* tell EH we're leaving & flush EH */ 6917c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 6918c6fd2807SJeff Garzik ap->pflags |= ATA_PFLAG_UNLOADING; 6919c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 6920c6fd2807SJeff Garzik 6921c6fd2807SJeff Garzik ata_port_wait_eh(ap); 6922c6fd2807SJeff Garzik 6923c6fd2807SJeff Garzik /* EH is now guaranteed to see UNLOADING, so no new device 6924c6fd2807SJeff Garzik * will be attached. Disable all existing devices. 6925c6fd2807SJeff Garzik */ 6926c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 6927c6fd2807SJeff Garzik 692841bda9c9STejun Heo ata_port_for_each_link(link, ap) { 692941bda9c9STejun Heo ata_link_for_each_dev(dev, link) 6930f58229f8STejun Heo ata_dev_disable(dev); 693141bda9c9STejun Heo } 6932c6fd2807SJeff Garzik 6933c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 6934c6fd2807SJeff Garzik 6935c6fd2807SJeff Garzik /* Final freeze & EH. All in-flight commands are aborted. EH 6936c6fd2807SJeff Garzik * will be skipped and retrials will be terminated with bad 6937c6fd2807SJeff Garzik * target. 6938c6fd2807SJeff Garzik */ 6939c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 6940c6fd2807SJeff Garzik ata_port_freeze(ap); /* won't be thawed */ 6941c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 6942c6fd2807SJeff Garzik 6943c6fd2807SJeff Garzik ata_port_wait_eh(ap); 694445a66c1cSOleg Nesterov cancel_rearming_delayed_work(&ap->hotplug_task); 6945c6fd2807SJeff Garzik 6946c6fd2807SJeff Garzik skip_eh: 6947c6fd2807SJeff Garzik /* remove the associated SCSI host */ 6948cca3974eSJeff Garzik scsi_remove_host(ap->scsi_host); 6949c6fd2807SJeff Garzik } 6950c6fd2807SJeff Garzik 6951c6fd2807SJeff Garzik /** 69520529c159STejun Heo * ata_host_detach - Detach all ports of an ATA host 69530529c159STejun Heo * @host: Host to detach 69540529c159STejun Heo * 69550529c159STejun Heo * Detach all ports of @host. 69560529c159STejun Heo * 69570529c159STejun Heo * LOCKING: 69580529c159STejun Heo * Kernel thread context (may sleep). 69590529c159STejun Heo */ 69600529c159STejun Heo void ata_host_detach(struct ata_host *host) 69610529c159STejun Heo { 69620529c159STejun Heo int i; 69630529c159STejun Heo 69640529c159STejun Heo for (i = 0; i < host->n_ports; i++) 69650529c159STejun Heo ata_port_detach(host->ports[i]); 69660529c159STejun Heo } 69670529c159STejun Heo 6968c6fd2807SJeff Garzik /** 6969c6fd2807SJeff Garzik * ata_std_ports - initialize ioaddr with standard port offsets. 6970c6fd2807SJeff Garzik * @ioaddr: IO address structure to be initialized 6971c6fd2807SJeff Garzik * 6972c6fd2807SJeff Garzik * Utility function which initializes data_addr, error_addr, 6973c6fd2807SJeff Garzik * feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr, 6974c6fd2807SJeff Garzik * device_addr, status_addr, and command_addr to standard offsets 6975c6fd2807SJeff Garzik * relative to cmd_addr. 6976c6fd2807SJeff Garzik * 6977c6fd2807SJeff Garzik * Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr. 6978c6fd2807SJeff Garzik */ 6979c6fd2807SJeff Garzik 6980c6fd2807SJeff Garzik void ata_std_ports(struct ata_ioports *ioaddr) 6981c6fd2807SJeff Garzik { 6982c6fd2807SJeff Garzik ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA; 6983c6fd2807SJeff Garzik ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR; 6984c6fd2807SJeff Garzik ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE; 6985c6fd2807SJeff Garzik ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT; 6986c6fd2807SJeff Garzik ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL; 6987c6fd2807SJeff Garzik ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM; 6988c6fd2807SJeff Garzik ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH; 6989c6fd2807SJeff Garzik ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE; 6990c6fd2807SJeff Garzik ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS; 6991c6fd2807SJeff Garzik ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD; 6992c6fd2807SJeff Garzik } 6993c6fd2807SJeff Garzik 6994c6fd2807SJeff Garzik 6995c6fd2807SJeff Garzik #ifdef CONFIG_PCI 6996c6fd2807SJeff Garzik 6997c6fd2807SJeff Garzik /** 6998c6fd2807SJeff Garzik * ata_pci_remove_one - PCI layer callback for device removal 6999c6fd2807SJeff Garzik * @pdev: PCI device that was removed 7000c6fd2807SJeff Garzik * 7001b878ca5dSTejun Heo * PCI layer indicates to libata via this hook that hot-unplug or 7002b878ca5dSTejun Heo * module unload event has occurred. Detach all ports. Resource 7003b878ca5dSTejun Heo * release is handled via devres. 7004c6fd2807SJeff Garzik * 7005c6fd2807SJeff Garzik * LOCKING: 7006c6fd2807SJeff Garzik * Inherited from PCI layer (may sleep). 7007c6fd2807SJeff Garzik */ 7008c6fd2807SJeff Garzik void ata_pci_remove_one(struct pci_dev *pdev) 7009c6fd2807SJeff Garzik { 70102855568bSJeff Garzik struct device *dev = &pdev->dev; 7011cca3974eSJeff Garzik struct ata_host *host = dev_get_drvdata(dev); 7012c6fd2807SJeff Garzik 7013f0d36efdSTejun Heo ata_host_detach(host); 7014c6fd2807SJeff Garzik } 7015c6fd2807SJeff Garzik 7016c6fd2807SJeff Garzik /* move to PCI subsystem */ 7017c6fd2807SJeff Garzik int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits) 7018c6fd2807SJeff Garzik { 7019c6fd2807SJeff Garzik unsigned long tmp = 0; 7020c6fd2807SJeff Garzik 7021c6fd2807SJeff Garzik switch (bits->width) { 7022c6fd2807SJeff Garzik case 1: { 7023c6fd2807SJeff Garzik u8 tmp8 = 0; 7024c6fd2807SJeff Garzik pci_read_config_byte(pdev, bits->reg, &tmp8); 7025c6fd2807SJeff Garzik tmp = tmp8; 7026c6fd2807SJeff Garzik break; 7027c6fd2807SJeff Garzik } 7028c6fd2807SJeff Garzik case 2: { 7029c6fd2807SJeff Garzik u16 tmp16 = 0; 7030c6fd2807SJeff Garzik pci_read_config_word(pdev, bits->reg, &tmp16); 7031c6fd2807SJeff Garzik tmp = tmp16; 7032c6fd2807SJeff Garzik break; 7033c6fd2807SJeff Garzik } 7034c6fd2807SJeff Garzik case 4: { 7035c6fd2807SJeff Garzik u32 tmp32 = 0; 7036c6fd2807SJeff Garzik pci_read_config_dword(pdev, bits->reg, &tmp32); 7037c6fd2807SJeff Garzik tmp = tmp32; 7038c6fd2807SJeff Garzik break; 7039c6fd2807SJeff Garzik } 7040c6fd2807SJeff Garzik 7041c6fd2807SJeff Garzik default: 7042c6fd2807SJeff Garzik return -EINVAL; 7043c6fd2807SJeff Garzik } 7044c6fd2807SJeff Garzik 7045c6fd2807SJeff Garzik tmp &= bits->mask; 7046c6fd2807SJeff Garzik 7047c6fd2807SJeff Garzik return (tmp == bits->val) ? 1 : 0; 7048c6fd2807SJeff Garzik } 7049c6fd2807SJeff Garzik 70506ffa01d8STejun Heo #ifdef CONFIG_PM 7051c6fd2807SJeff Garzik void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg) 7052c6fd2807SJeff Garzik { 7053c6fd2807SJeff Garzik pci_save_state(pdev); 7054c6fd2807SJeff Garzik pci_disable_device(pdev); 70554c90d971STejun Heo 70564c90d971STejun Heo if (mesg.event == PM_EVENT_SUSPEND) 7057c6fd2807SJeff Garzik pci_set_power_state(pdev, PCI_D3hot); 7058c6fd2807SJeff Garzik } 7059c6fd2807SJeff Garzik 7060553c4aa6STejun Heo int ata_pci_device_do_resume(struct pci_dev *pdev) 7061c6fd2807SJeff Garzik { 7062553c4aa6STejun Heo int rc; 7063553c4aa6STejun Heo 7064c6fd2807SJeff Garzik pci_set_power_state(pdev, PCI_D0); 7065c6fd2807SJeff Garzik pci_restore_state(pdev); 7066553c4aa6STejun Heo 7067f0d36efdSTejun Heo rc = pcim_enable_device(pdev); 7068553c4aa6STejun Heo if (rc) { 7069553c4aa6STejun Heo dev_printk(KERN_ERR, &pdev->dev, 7070553c4aa6STejun Heo "failed to enable device after resume (%d)\n", rc); 7071553c4aa6STejun Heo return rc; 7072553c4aa6STejun Heo } 7073553c4aa6STejun Heo 7074c6fd2807SJeff Garzik pci_set_master(pdev); 7075553c4aa6STejun Heo return 0; 7076c6fd2807SJeff Garzik } 7077c6fd2807SJeff Garzik 7078c6fd2807SJeff Garzik int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg) 7079c6fd2807SJeff Garzik { 7080cca3974eSJeff Garzik struct ata_host *host = dev_get_drvdata(&pdev->dev); 7081c6fd2807SJeff Garzik int rc = 0; 7082c6fd2807SJeff Garzik 7083cca3974eSJeff Garzik rc = ata_host_suspend(host, mesg); 7084c6fd2807SJeff Garzik if (rc) 7085c6fd2807SJeff Garzik return rc; 7086c6fd2807SJeff Garzik 7087c6fd2807SJeff Garzik ata_pci_device_do_suspend(pdev, mesg); 7088c6fd2807SJeff Garzik 7089c6fd2807SJeff Garzik return 0; 7090c6fd2807SJeff Garzik } 7091c6fd2807SJeff Garzik 7092c6fd2807SJeff Garzik int ata_pci_device_resume(struct pci_dev *pdev) 7093c6fd2807SJeff Garzik { 7094cca3974eSJeff Garzik struct ata_host *host = dev_get_drvdata(&pdev->dev); 7095553c4aa6STejun Heo int rc; 7096c6fd2807SJeff Garzik 7097553c4aa6STejun Heo rc = ata_pci_device_do_resume(pdev); 7098553c4aa6STejun Heo if (rc == 0) 7099cca3974eSJeff Garzik ata_host_resume(host); 7100553c4aa6STejun Heo return rc; 7101c6fd2807SJeff Garzik } 71026ffa01d8STejun Heo #endif /* CONFIG_PM */ 71036ffa01d8STejun Heo 7104c6fd2807SJeff Garzik #endif /* CONFIG_PCI */ 7105c6fd2807SJeff Garzik 7106c6fd2807SJeff Garzik 7107c6fd2807SJeff Garzik static int __init ata_init(void) 7108c6fd2807SJeff Garzik { 7109c6fd2807SJeff Garzik ata_probe_timeout *= HZ; 7110c6fd2807SJeff Garzik ata_wq = create_workqueue("ata"); 7111c6fd2807SJeff Garzik if (!ata_wq) 7112c6fd2807SJeff Garzik return -ENOMEM; 7113c6fd2807SJeff Garzik 7114c6fd2807SJeff Garzik ata_aux_wq = create_singlethread_workqueue("ata_aux"); 7115c6fd2807SJeff Garzik if (!ata_aux_wq) { 7116c6fd2807SJeff Garzik destroy_workqueue(ata_wq); 7117c6fd2807SJeff Garzik return -ENOMEM; 7118c6fd2807SJeff Garzik } 7119c6fd2807SJeff Garzik 7120c6fd2807SJeff Garzik printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n"); 7121c6fd2807SJeff Garzik return 0; 7122c6fd2807SJeff Garzik } 7123c6fd2807SJeff Garzik 7124c6fd2807SJeff Garzik static void __exit ata_exit(void) 7125c6fd2807SJeff Garzik { 7126c6fd2807SJeff Garzik destroy_workqueue(ata_wq); 7127c6fd2807SJeff Garzik destroy_workqueue(ata_aux_wq); 7128c6fd2807SJeff Garzik } 7129c6fd2807SJeff Garzik 7130a4625085SBrian King subsys_initcall(ata_init); 7131c6fd2807SJeff Garzik module_exit(ata_exit); 7132c6fd2807SJeff Garzik 7133c6fd2807SJeff Garzik static unsigned long ratelimit_time; 7134c6fd2807SJeff Garzik static DEFINE_SPINLOCK(ata_ratelimit_lock); 7135c6fd2807SJeff Garzik 7136c6fd2807SJeff Garzik int ata_ratelimit(void) 7137c6fd2807SJeff Garzik { 7138c6fd2807SJeff Garzik int rc; 7139c6fd2807SJeff Garzik unsigned long flags; 7140c6fd2807SJeff Garzik 7141c6fd2807SJeff Garzik spin_lock_irqsave(&ata_ratelimit_lock, flags); 7142c6fd2807SJeff Garzik 7143c6fd2807SJeff Garzik if (time_after(jiffies, ratelimit_time)) { 7144c6fd2807SJeff Garzik rc = 1; 7145c6fd2807SJeff Garzik ratelimit_time = jiffies + (HZ/5); 7146c6fd2807SJeff Garzik } else 7147c6fd2807SJeff Garzik rc = 0; 7148c6fd2807SJeff Garzik 7149c6fd2807SJeff Garzik spin_unlock_irqrestore(&ata_ratelimit_lock, flags); 7150c6fd2807SJeff Garzik 7151c6fd2807SJeff Garzik return rc; 7152c6fd2807SJeff Garzik } 7153c6fd2807SJeff Garzik 7154c6fd2807SJeff Garzik /** 7155c6fd2807SJeff Garzik * ata_wait_register - wait until register value changes 7156c6fd2807SJeff Garzik * @reg: IO-mapped register 7157c6fd2807SJeff Garzik * @mask: Mask to apply to read register value 7158c6fd2807SJeff Garzik * @val: Wait condition 7159c6fd2807SJeff Garzik * @interval_msec: polling interval in milliseconds 7160c6fd2807SJeff Garzik * @timeout_msec: timeout in milliseconds 7161c6fd2807SJeff Garzik * 7162c6fd2807SJeff Garzik * Waiting for some bits of register to change is a common 7163c6fd2807SJeff Garzik * operation for ATA controllers. This function reads 32bit LE 7164c6fd2807SJeff Garzik * IO-mapped register @reg and tests for the following condition. 7165c6fd2807SJeff Garzik * 7166c6fd2807SJeff Garzik * (*@reg & mask) != val 7167c6fd2807SJeff Garzik * 7168c6fd2807SJeff Garzik * If the condition is met, it returns; otherwise, the process is 7169c6fd2807SJeff Garzik * repeated after @interval_msec until timeout. 7170c6fd2807SJeff Garzik * 7171c6fd2807SJeff Garzik * LOCKING: 7172c6fd2807SJeff Garzik * Kernel thread context (may sleep) 7173c6fd2807SJeff Garzik * 7174c6fd2807SJeff Garzik * RETURNS: 7175c6fd2807SJeff Garzik * The final register value. 7176c6fd2807SJeff Garzik */ 7177c6fd2807SJeff Garzik u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val, 7178c6fd2807SJeff Garzik unsigned long interval_msec, 7179c6fd2807SJeff Garzik unsigned long timeout_msec) 7180c6fd2807SJeff Garzik { 7181c6fd2807SJeff Garzik unsigned long timeout; 7182c6fd2807SJeff Garzik u32 tmp; 7183c6fd2807SJeff Garzik 7184c6fd2807SJeff Garzik tmp = ioread32(reg); 7185c6fd2807SJeff Garzik 7186c6fd2807SJeff Garzik /* Calculate timeout _after_ the first read to make sure 7187c6fd2807SJeff Garzik * preceding writes reach the controller before starting to 7188c6fd2807SJeff Garzik * eat away the timeout. 7189c6fd2807SJeff Garzik */ 7190c6fd2807SJeff Garzik timeout = jiffies + (timeout_msec * HZ) / 1000; 7191c6fd2807SJeff Garzik 7192c6fd2807SJeff Garzik while ((tmp & mask) == val && time_before(jiffies, timeout)) { 7193c6fd2807SJeff Garzik msleep(interval_msec); 7194c6fd2807SJeff Garzik tmp = ioread32(reg); 7195c6fd2807SJeff Garzik } 7196c6fd2807SJeff Garzik 7197c6fd2807SJeff Garzik return tmp; 7198c6fd2807SJeff Garzik } 7199c6fd2807SJeff Garzik 7200c6fd2807SJeff Garzik /* 7201c6fd2807SJeff Garzik * Dummy port_ops 7202c6fd2807SJeff Garzik */ 7203c6fd2807SJeff Garzik static void ata_dummy_noret(struct ata_port *ap) { } 7204c6fd2807SJeff Garzik static int ata_dummy_ret0(struct ata_port *ap) { return 0; } 7205c6fd2807SJeff Garzik static void ata_dummy_qc_noret(struct ata_queued_cmd *qc) { } 7206c6fd2807SJeff Garzik 7207c6fd2807SJeff Garzik static u8 ata_dummy_check_status(struct ata_port *ap) 7208c6fd2807SJeff Garzik { 7209c6fd2807SJeff Garzik return ATA_DRDY; 7210c6fd2807SJeff Garzik } 7211c6fd2807SJeff Garzik 7212c6fd2807SJeff Garzik static unsigned int ata_dummy_qc_issue(struct ata_queued_cmd *qc) 7213c6fd2807SJeff Garzik { 7214c6fd2807SJeff Garzik return AC_ERR_SYSTEM; 7215c6fd2807SJeff Garzik } 7216c6fd2807SJeff Garzik 7217c6fd2807SJeff Garzik const struct ata_port_operations ata_dummy_port_ops = { 7218c6fd2807SJeff Garzik .check_status = ata_dummy_check_status, 7219c6fd2807SJeff Garzik .check_altstatus = ata_dummy_check_status, 7220c6fd2807SJeff Garzik .dev_select = ata_noop_dev_select, 7221c6fd2807SJeff Garzik .qc_prep = ata_noop_qc_prep, 7222c6fd2807SJeff Garzik .qc_issue = ata_dummy_qc_issue, 7223c6fd2807SJeff Garzik .freeze = ata_dummy_noret, 7224c6fd2807SJeff Garzik .thaw = ata_dummy_noret, 7225c6fd2807SJeff Garzik .error_handler = ata_dummy_noret, 7226c6fd2807SJeff Garzik .post_internal_cmd = ata_dummy_qc_noret, 7227c6fd2807SJeff Garzik .irq_clear = ata_dummy_noret, 7228c6fd2807SJeff Garzik .port_start = ata_dummy_ret0, 7229c6fd2807SJeff Garzik .port_stop = ata_dummy_noret, 7230c6fd2807SJeff Garzik }; 7231c6fd2807SJeff Garzik 723221b0ad4fSTejun Heo const struct ata_port_info ata_dummy_port_info = { 723321b0ad4fSTejun Heo .port_ops = &ata_dummy_port_ops, 723421b0ad4fSTejun Heo }; 723521b0ad4fSTejun Heo 7236c6fd2807SJeff Garzik /* 7237c6fd2807SJeff Garzik * libata is essentially a library of internal helper functions for 7238c6fd2807SJeff Garzik * low-level ATA host controller drivers. As such, the API/ABI is 7239c6fd2807SJeff Garzik * likely to change as new drivers are added and updated. 7240c6fd2807SJeff Garzik * Do not depend on ABI/API stability. 7241c6fd2807SJeff Garzik */ 7242c6fd2807SJeff Garzik 7243c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_deb_timing_normal); 7244c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_deb_timing_hotplug); 7245c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_deb_timing_long); 7246c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_dummy_port_ops); 724721b0ad4fSTejun Heo EXPORT_SYMBOL_GPL(ata_dummy_port_info); 7248c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_bios_param); 7249c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_ports); 7250cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_init); 7251f3187195STejun Heo EXPORT_SYMBOL_GPL(ata_host_alloc); 7252f5cda257STejun Heo EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo); 7253ecef7253STejun Heo EXPORT_SYMBOL_GPL(ata_host_start); 7254f3187195STejun Heo EXPORT_SYMBOL_GPL(ata_host_register); 7255f5cda257STejun Heo EXPORT_SYMBOL_GPL(ata_host_activate); 72560529c159STejun Heo EXPORT_SYMBOL_GPL(ata_host_detach); 7257c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_sg_init); 7258c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_sg_init_one); 7259c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_hsm_move); 7260c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_complete); 7261c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_complete_multiple); 7262c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_issue_prot); 7263c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_load); 7264c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_read); 7265c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_noop_dev_select); 7266c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_dev_select); 726743727fbcSJeff Garzik EXPORT_SYMBOL_GPL(sata_print_link_status); 7268c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_to_fis); 7269c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_from_fis); 7270c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_check_status); 7271c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_altstatus); 7272c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_exec_command); 7273c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_start); 7274d92e74d3SAlan Cox EXPORT_SYMBOL_GPL(ata_sff_port_start); 7275c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_interrupt); 727604351821SAlan EXPORT_SYMBOL_GPL(ata_do_set_mode); 72770d5ff566STejun Heo EXPORT_SYMBOL_GPL(ata_data_xfer); 72780d5ff566STejun Heo EXPORT_SYMBOL_GPL(ata_data_xfer_noirq); 727931cc23b3STejun Heo EXPORT_SYMBOL_GPL(ata_std_qc_defer); 7280c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_prep); 7281d26fc955SAlan Cox EXPORT_SYMBOL_GPL(ata_dumb_qc_prep); 7282c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_noop_qc_prep); 7283c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_setup); 7284c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_start); 7285c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear); 7286c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_status); 7287c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_stop); 7288c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_freeze); 7289c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_thaw); 7290c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_drive_eh); 7291c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_error_handler); 7292c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_post_internal_cmd); 7293c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_probe); 729410305f0fSAlan EXPORT_SYMBOL_GPL(ata_dev_disable); 7295c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_set_spd); 7296936fd732STejun Heo EXPORT_SYMBOL_GPL(sata_link_debounce); 7297936fd732STejun Heo EXPORT_SYMBOL_GPL(sata_link_resume); 7298c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_phy_reset); 7299c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(__sata_phy_reset); 7300c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bus_reset); 7301c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_prereset); 7302c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_softreset); 7303cc0680a5STejun Heo EXPORT_SYMBOL_GPL(sata_link_hardreset); 7304c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_std_hardreset); 7305c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_postreset); 7306c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_dev_classify); 7307c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_dev_pair); 7308c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_disable); 7309c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_ratelimit); 7310c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_wait_register); 7311c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_busy_sleep); 7312d4b2bab4STejun Heo EXPORT_SYMBOL_GPL(ata_wait_ready); 7313c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_queue_task); 7314c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_ioctl); 7315c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_queuecmd); 7316c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_slave_config); 7317c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_slave_destroy); 7318c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth); 7319c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_host_intr); 7320c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_valid); 7321c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_read); 7322c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_write); 7323c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_write_flush); 7324936fd732STejun Heo EXPORT_SYMBOL_GPL(ata_link_online); 7325936fd732STejun Heo EXPORT_SYMBOL_GPL(ata_link_offline); 73266ffa01d8STejun Heo #ifdef CONFIG_PM 7327cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_suspend); 7328cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_resume); 73296ffa01d8STejun Heo #endif /* CONFIG_PM */ 7330c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_id_string); 7331c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_id_c_string); 733210305f0fSAlan EXPORT_SYMBOL_GPL(ata_id_to_dma_mode); 7333c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_simulate); 7334c6fd2807SJeff Garzik 7335c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pio_need_iordy); 7336c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_timing_compute); 7337c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_timing_merge); 7338c6fd2807SJeff Garzik 7339c6fd2807SJeff Garzik #ifdef CONFIG_PCI 7340c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(pci_test_config_bits); 7341d583bc18STejun Heo EXPORT_SYMBOL_GPL(ata_pci_init_sff_host); 73421626aeb8STejun Heo EXPORT_SYMBOL_GPL(ata_pci_init_bmdma); 7343d583bc18STejun Heo EXPORT_SYMBOL_GPL(ata_pci_prepare_sff_host); 7344c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_init_one); 7345c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_remove_one); 73466ffa01d8STejun Heo #ifdef CONFIG_PM 7347c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_do_suspend); 7348c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_do_resume); 7349c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_suspend); 7350c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_resume); 73516ffa01d8STejun Heo #endif /* CONFIG_PM */ 7352c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_default_filter); 7353c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_clear_simplex); 7354c6fd2807SJeff Garzik #endif /* CONFIG_PCI */ 7355c6fd2807SJeff Garzik 735631f88384STejun Heo EXPORT_SYMBOL_GPL(sata_pmp_qc_defer_cmd_switch); 73573af9a77aSTejun Heo EXPORT_SYMBOL_GPL(sata_pmp_std_prereset); 73583af9a77aSTejun Heo EXPORT_SYMBOL_GPL(sata_pmp_std_hardreset); 73593af9a77aSTejun Heo EXPORT_SYMBOL_GPL(sata_pmp_std_postreset); 73603af9a77aSTejun Heo EXPORT_SYMBOL_GPL(sata_pmp_do_eh); 73613af9a77aSTejun Heo 7362b64bbc39STejun Heo EXPORT_SYMBOL_GPL(__ata_ehi_push_desc); 7363b64bbc39STejun Heo EXPORT_SYMBOL_GPL(ata_ehi_push_desc); 7364b64bbc39STejun Heo EXPORT_SYMBOL_GPL(ata_ehi_clear_desc); 7365cbcdd875STejun Heo EXPORT_SYMBOL_GPL(ata_port_desc); 7366cbcdd875STejun Heo #ifdef CONFIG_PCI 7367cbcdd875STejun Heo EXPORT_SYMBOL_GPL(ata_port_pbar_desc); 7368cbcdd875STejun Heo #endif /* CONFIG_PCI */ 7369c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eng_timeout); 7370c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_schedule_eh); 7371dbd82616STejun Heo EXPORT_SYMBOL_GPL(ata_link_abort); 7372c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_abort); 7373c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_freeze); 73747d77b247STejun Heo EXPORT_SYMBOL_GPL(sata_async_notification); 7375c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_freeze_port); 7376c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_thaw_port); 7377c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_qc_complete); 7378c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_qc_retry); 7379c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_do_eh); 738083625006SAkira Iguchi EXPORT_SYMBOL_GPL(ata_irq_on); 7381a619f981SAkira Iguchi EXPORT_SYMBOL_GPL(ata_dev_try_classify); 7382be0d18dfSAlan Cox 7383be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_40wire); 7384be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_80wire); 7385be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_unknown); 7386be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_sata); 7387