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 628bc3fc47SJeff Garzik #define DRV_VERSION "2.21" /* must be exactly four chars */ 63fda0efc5SJeff Garzik 64fda0efc5SJeff Garzik 65c6fd2807SJeff Garzik /* debounce timing parameters in msecs { interval, duration, timeout } */ 66c6fd2807SJeff Garzik const unsigned long sata_deb_timing_normal[] = { 5, 100, 2000 }; 67c6fd2807SJeff Garzik const unsigned long sata_deb_timing_hotplug[] = { 25, 500, 2000 }; 68c6fd2807SJeff Garzik const unsigned long sata_deb_timing_long[] = { 100, 2000, 5000 }; 69c6fd2807SJeff Garzik 70c6fd2807SJeff Garzik static unsigned int ata_dev_init_params(struct ata_device *dev, 71c6fd2807SJeff Garzik u16 heads, u16 sectors); 72c6fd2807SJeff Garzik static unsigned int ata_dev_set_xfermode(struct ata_device *dev); 73c6fd2807SJeff Garzik static void ata_dev_xfermask(struct ata_device *dev); 7475683fe7STejun Heo static unsigned long ata_dev_blacklisted(const struct ata_device *dev); 75c6fd2807SJeff Garzik 76f3187195STejun Heo unsigned int ata_print_id = 1; 77c6fd2807SJeff Garzik static struct workqueue_struct *ata_wq; 78c6fd2807SJeff Garzik 79c6fd2807SJeff Garzik struct workqueue_struct *ata_aux_wq; 80c6fd2807SJeff Garzik 81c6fd2807SJeff Garzik int atapi_enabled = 1; 82c6fd2807SJeff Garzik module_param(atapi_enabled, int, 0444); 83c6fd2807SJeff Garzik MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)"); 84c6fd2807SJeff Garzik 85c6fd2807SJeff Garzik int atapi_dmadir = 0; 86c6fd2807SJeff Garzik module_param(atapi_dmadir, int, 0444); 87c6fd2807SJeff Garzik MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)"); 88c6fd2807SJeff Garzik 89c6fd2807SJeff Garzik int libata_fua = 0; 90c6fd2807SJeff Garzik module_param_named(fua, libata_fua, int, 0444); 91c6fd2807SJeff Garzik MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)"); 92c6fd2807SJeff Garzik 931e999736SAlan Cox static int ata_ignore_hpa = 0; 941e999736SAlan Cox module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644); 951e999736SAlan Cox MODULE_PARM_DESC(ignore_hpa, "Ignore HPA limit (0=keep BIOS limits, 1=ignore limits, using full disk)"); 961e999736SAlan Cox 97c6fd2807SJeff Garzik static int ata_probe_timeout = ATA_TMOUT_INTERNAL / HZ; 98c6fd2807SJeff Garzik module_param(ata_probe_timeout, int, 0444); 99c6fd2807SJeff Garzik MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)"); 100c6fd2807SJeff Garzik 101d7d0dad6SJeff Garzik int libata_noacpi = 1; 102d7d0dad6SJeff Garzik module_param_named(noacpi, libata_noacpi, int, 0444); 10311ef697bSKristen Carlson Accardi MODULE_PARM_DESC(noacpi, "Disables the use of ACPI in suspend/resume when set"); 10411ef697bSKristen Carlson Accardi 105c6fd2807SJeff Garzik MODULE_AUTHOR("Jeff Garzik"); 106c6fd2807SJeff Garzik MODULE_DESCRIPTION("Library module for ATA devices"); 107c6fd2807SJeff Garzik MODULE_LICENSE("GPL"); 108c6fd2807SJeff Garzik MODULE_VERSION(DRV_VERSION); 109c6fd2807SJeff Garzik 110c6fd2807SJeff Garzik 111c6fd2807SJeff Garzik /** 112c6fd2807SJeff Garzik * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure 113c6fd2807SJeff Garzik * @tf: Taskfile to convert 114c6fd2807SJeff Garzik * @pmp: Port multiplier port 1159977126cSTejun Heo * @is_cmd: This FIS is for command 1169977126cSTejun Heo * @fis: Buffer into which data will output 117c6fd2807SJeff Garzik * 118c6fd2807SJeff Garzik * Converts a standard ATA taskfile to a Serial ATA 119c6fd2807SJeff Garzik * FIS structure (Register - Host to Device). 120c6fd2807SJeff Garzik * 121c6fd2807SJeff Garzik * LOCKING: 122c6fd2807SJeff Garzik * Inherited from caller. 123c6fd2807SJeff Garzik */ 1249977126cSTejun Heo void ata_tf_to_fis(const struct ata_taskfile *tf, u8 pmp, int is_cmd, u8 *fis) 125c6fd2807SJeff Garzik { 126c6fd2807SJeff Garzik fis[0] = 0x27; /* Register - Host to Device FIS */ 1279977126cSTejun Heo fis[1] = pmp & 0xf; /* Port multiplier number*/ 1289977126cSTejun Heo if (is_cmd) 1299977126cSTejun Heo fis[1] |= (1 << 7); /* bit 7 indicates Command FIS */ 1309977126cSTejun Heo 131c6fd2807SJeff Garzik fis[2] = tf->command; 132c6fd2807SJeff Garzik fis[3] = tf->feature; 133c6fd2807SJeff Garzik 134c6fd2807SJeff Garzik fis[4] = tf->lbal; 135c6fd2807SJeff Garzik fis[5] = tf->lbam; 136c6fd2807SJeff Garzik fis[6] = tf->lbah; 137c6fd2807SJeff Garzik fis[7] = tf->device; 138c6fd2807SJeff Garzik 139c6fd2807SJeff Garzik fis[8] = tf->hob_lbal; 140c6fd2807SJeff Garzik fis[9] = tf->hob_lbam; 141c6fd2807SJeff Garzik fis[10] = tf->hob_lbah; 142c6fd2807SJeff Garzik fis[11] = tf->hob_feature; 143c6fd2807SJeff Garzik 144c6fd2807SJeff Garzik fis[12] = tf->nsect; 145c6fd2807SJeff Garzik fis[13] = tf->hob_nsect; 146c6fd2807SJeff Garzik fis[14] = 0; 147c6fd2807SJeff Garzik fis[15] = tf->ctl; 148c6fd2807SJeff Garzik 149c6fd2807SJeff Garzik fis[16] = 0; 150c6fd2807SJeff Garzik fis[17] = 0; 151c6fd2807SJeff Garzik fis[18] = 0; 152c6fd2807SJeff Garzik fis[19] = 0; 153c6fd2807SJeff Garzik } 154c6fd2807SJeff Garzik 155c6fd2807SJeff Garzik /** 156c6fd2807SJeff Garzik * ata_tf_from_fis - Convert SATA FIS to ATA taskfile 157c6fd2807SJeff Garzik * @fis: Buffer from which data will be input 158c6fd2807SJeff Garzik * @tf: Taskfile to output 159c6fd2807SJeff Garzik * 160c6fd2807SJeff Garzik * Converts a serial ATA FIS structure to a standard ATA taskfile. 161c6fd2807SJeff Garzik * 162c6fd2807SJeff Garzik * LOCKING: 163c6fd2807SJeff Garzik * Inherited from caller. 164c6fd2807SJeff Garzik */ 165c6fd2807SJeff Garzik 166c6fd2807SJeff Garzik void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf) 167c6fd2807SJeff Garzik { 168c6fd2807SJeff Garzik tf->command = fis[2]; /* status */ 169c6fd2807SJeff Garzik tf->feature = fis[3]; /* error */ 170c6fd2807SJeff Garzik 171c6fd2807SJeff Garzik tf->lbal = fis[4]; 172c6fd2807SJeff Garzik tf->lbam = fis[5]; 173c6fd2807SJeff Garzik tf->lbah = fis[6]; 174c6fd2807SJeff Garzik tf->device = fis[7]; 175c6fd2807SJeff Garzik 176c6fd2807SJeff Garzik tf->hob_lbal = fis[8]; 177c6fd2807SJeff Garzik tf->hob_lbam = fis[9]; 178c6fd2807SJeff Garzik tf->hob_lbah = fis[10]; 179c6fd2807SJeff Garzik 180c6fd2807SJeff Garzik tf->nsect = fis[12]; 181c6fd2807SJeff Garzik tf->hob_nsect = fis[13]; 182c6fd2807SJeff Garzik } 183c6fd2807SJeff Garzik 184c6fd2807SJeff Garzik static const u8 ata_rw_cmds[] = { 185c6fd2807SJeff Garzik /* pio multi */ 186c6fd2807SJeff Garzik ATA_CMD_READ_MULTI, 187c6fd2807SJeff Garzik ATA_CMD_WRITE_MULTI, 188c6fd2807SJeff Garzik ATA_CMD_READ_MULTI_EXT, 189c6fd2807SJeff Garzik ATA_CMD_WRITE_MULTI_EXT, 190c6fd2807SJeff Garzik 0, 191c6fd2807SJeff Garzik 0, 192c6fd2807SJeff Garzik 0, 193c6fd2807SJeff Garzik ATA_CMD_WRITE_MULTI_FUA_EXT, 194c6fd2807SJeff Garzik /* pio */ 195c6fd2807SJeff Garzik ATA_CMD_PIO_READ, 196c6fd2807SJeff Garzik ATA_CMD_PIO_WRITE, 197c6fd2807SJeff Garzik ATA_CMD_PIO_READ_EXT, 198c6fd2807SJeff Garzik ATA_CMD_PIO_WRITE_EXT, 199c6fd2807SJeff Garzik 0, 200c6fd2807SJeff Garzik 0, 201c6fd2807SJeff Garzik 0, 202c6fd2807SJeff Garzik 0, 203c6fd2807SJeff Garzik /* dma */ 204c6fd2807SJeff Garzik ATA_CMD_READ, 205c6fd2807SJeff Garzik ATA_CMD_WRITE, 206c6fd2807SJeff Garzik ATA_CMD_READ_EXT, 207c6fd2807SJeff Garzik ATA_CMD_WRITE_EXT, 208c6fd2807SJeff Garzik 0, 209c6fd2807SJeff Garzik 0, 210c6fd2807SJeff Garzik 0, 211c6fd2807SJeff Garzik ATA_CMD_WRITE_FUA_EXT 212c6fd2807SJeff Garzik }; 213c6fd2807SJeff Garzik 214c6fd2807SJeff Garzik /** 215c6fd2807SJeff Garzik * ata_rwcmd_protocol - set taskfile r/w commands and protocol 216bd056d7eSTejun Heo * @tf: command to examine and configure 217bd056d7eSTejun Heo * @dev: device tf belongs to 218c6fd2807SJeff Garzik * 219c6fd2807SJeff Garzik * Examine the device configuration and tf->flags to calculate 220c6fd2807SJeff Garzik * the proper read/write commands and protocol to use. 221c6fd2807SJeff Garzik * 222c6fd2807SJeff Garzik * LOCKING: 223c6fd2807SJeff Garzik * caller. 224c6fd2807SJeff Garzik */ 225bd056d7eSTejun Heo static int ata_rwcmd_protocol(struct ata_taskfile *tf, struct ata_device *dev) 226c6fd2807SJeff Garzik { 227c6fd2807SJeff Garzik u8 cmd; 228c6fd2807SJeff Garzik 229c6fd2807SJeff Garzik int index, fua, lba48, write; 230c6fd2807SJeff Garzik 231c6fd2807SJeff Garzik fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0; 232c6fd2807SJeff Garzik lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0; 233c6fd2807SJeff Garzik write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0; 234c6fd2807SJeff Garzik 235c6fd2807SJeff Garzik if (dev->flags & ATA_DFLAG_PIO) { 236c6fd2807SJeff Garzik tf->protocol = ATA_PROT_PIO; 237c6fd2807SJeff Garzik index = dev->multi_count ? 0 : 8; 2389af5c9c9STejun Heo } else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) { 239c6fd2807SJeff Garzik /* Unable to use DMA due to host limitation */ 240c6fd2807SJeff Garzik tf->protocol = ATA_PROT_PIO; 241c6fd2807SJeff Garzik index = dev->multi_count ? 0 : 8; 242c6fd2807SJeff Garzik } else { 243c6fd2807SJeff Garzik tf->protocol = ATA_PROT_DMA; 244c6fd2807SJeff Garzik index = 16; 245c6fd2807SJeff Garzik } 246c6fd2807SJeff Garzik 247c6fd2807SJeff Garzik cmd = ata_rw_cmds[index + fua + lba48 + write]; 248c6fd2807SJeff Garzik if (cmd) { 249c6fd2807SJeff Garzik tf->command = cmd; 250c6fd2807SJeff Garzik return 0; 251c6fd2807SJeff Garzik } 252c6fd2807SJeff Garzik return -1; 253c6fd2807SJeff Garzik } 254c6fd2807SJeff Garzik 255c6fd2807SJeff Garzik /** 25635b649feSTejun Heo * ata_tf_read_block - Read block address from ATA taskfile 25735b649feSTejun Heo * @tf: ATA taskfile of interest 25835b649feSTejun Heo * @dev: ATA device @tf belongs to 25935b649feSTejun Heo * 26035b649feSTejun Heo * LOCKING: 26135b649feSTejun Heo * None. 26235b649feSTejun Heo * 26335b649feSTejun Heo * Read block address from @tf. This function can handle all 26435b649feSTejun Heo * three address formats - LBA, LBA48 and CHS. tf->protocol and 26535b649feSTejun Heo * flags select the address format to use. 26635b649feSTejun Heo * 26735b649feSTejun Heo * RETURNS: 26835b649feSTejun Heo * Block address read from @tf. 26935b649feSTejun Heo */ 27035b649feSTejun Heo u64 ata_tf_read_block(struct ata_taskfile *tf, struct ata_device *dev) 27135b649feSTejun Heo { 27235b649feSTejun Heo u64 block = 0; 27335b649feSTejun Heo 27435b649feSTejun Heo if (tf->flags & ATA_TFLAG_LBA) { 27535b649feSTejun Heo if (tf->flags & ATA_TFLAG_LBA48) { 27635b649feSTejun Heo block |= (u64)tf->hob_lbah << 40; 27735b649feSTejun Heo block |= (u64)tf->hob_lbam << 32; 27835b649feSTejun Heo block |= tf->hob_lbal << 24; 27935b649feSTejun Heo } else 28035b649feSTejun Heo block |= (tf->device & 0xf) << 24; 28135b649feSTejun Heo 28235b649feSTejun Heo block |= tf->lbah << 16; 28335b649feSTejun Heo block |= tf->lbam << 8; 28435b649feSTejun Heo block |= tf->lbal; 28535b649feSTejun Heo } else { 28635b649feSTejun Heo u32 cyl, head, sect; 28735b649feSTejun Heo 28835b649feSTejun Heo cyl = tf->lbam | (tf->lbah << 8); 28935b649feSTejun Heo head = tf->device & 0xf; 29035b649feSTejun Heo sect = tf->lbal; 29135b649feSTejun Heo 29235b649feSTejun Heo block = (cyl * dev->heads + head) * dev->sectors + sect; 29335b649feSTejun Heo } 29435b649feSTejun Heo 29535b649feSTejun Heo return block; 29635b649feSTejun Heo } 29735b649feSTejun Heo 29835b649feSTejun Heo /** 299bd056d7eSTejun Heo * ata_build_rw_tf - Build ATA taskfile for given read/write request 300bd056d7eSTejun Heo * @tf: Target ATA taskfile 301bd056d7eSTejun Heo * @dev: ATA device @tf belongs to 302bd056d7eSTejun Heo * @block: Block address 303bd056d7eSTejun Heo * @n_block: Number of blocks 304bd056d7eSTejun Heo * @tf_flags: RW/FUA etc... 305bd056d7eSTejun Heo * @tag: tag 306bd056d7eSTejun Heo * 307bd056d7eSTejun Heo * LOCKING: 308bd056d7eSTejun Heo * None. 309bd056d7eSTejun Heo * 310bd056d7eSTejun Heo * Build ATA taskfile @tf for read/write request described by 311bd056d7eSTejun Heo * @block, @n_block, @tf_flags and @tag on @dev. 312bd056d7eSTejun Heo * 313bd056d7eSTejun Heo * RETURNS: 314bd056d7eSTejun Heo * 315bd056d7eSTejun Heo * 0 on success, -ERANGE if the request is too large for @dev, 316bd056d7eSTejun Heo * -EINVAL if the request is invalid. 317bd056d7eSTejun Heo */ 318bd056d7eSTejun Heo int ata_build_rw_tf(struct ata_taskfile *tf, struct ata_device *dev, 319bd056d7eSTejun Heo u64 block, u32 n_block, unsigned int tf_flags, 320bd056d7eSTejun Heo unsigned int tag) 321bd056d7eSTejun Heo { 322bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 323bd056d7eSTejun Heo tf->flags |= tf_flags; 324bd056d7eSTejun Heo 3256d1245bfSTejun Heo if (ata_ncq_enabled(dev) && likely(tag != ATA_TAG_INTERNAL)) { 326bd056d7eSTejun Heo /* yay, NCQ */ 327bd056d7eSTejun Heo if (!lba_48_ok(block, n_block)) 328bd056d7eSTejun Heo return -ERANGE; 329bd056d7eSTejun Heo 330bd056d7eSTejun Heo tf->protocol = ATA_PROT_NCQ; 331bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48; 332bd056d7eSTejun Heo 333bd056d7eSTejun Heo if (tf->flags & ATA_TFLAG_WRITE) 334bd056d7eSTejun Heo tf->command = ATA_CMD_FPDMA_WRITE; 335bd056d7eSTejun Heo else 336bd056d7eSTejun Heo tf->command = ATA_CMD_FPDMA_READ; 337bd056d7eSTejun Heo 338bd056d7eSTejun Heo tf->nsect = tag << 3; 339bd056d7eSTejun Heo tf->hob_feature = (n_block >> 8) & 0xff; 340bd056d7eSTejun Heo tf->feature = n_block & 0xff; 341bd056d7eSTejun Heo 342bd056d7eSTejun Heo tf->hob_lbah = (block >> 40) & 0xff; 343bd056d7eSTejun Heo tf->hob_lbam = (block >> 32) & 0xff; 344bd056d7eSTejun Heo tf->hob_lbal = (block >> 24) & 0xff; 345bd056d7eSTejun Heo tf->lbah = (block >> 16) & 0xff; 346bd056d7eSTejun Heo tf->lbam = (block >> 8) & 0xff; 347bd056d7eSTejun Heo tf->lbal = block & 0xff; 348bd056d7eSTejun Heo 349bd056d7eSTejun Heo tf->device = 1 << 6; 350bd056d7eSTejun Heo if (tf->flags & ATA_TFLAG_FUA) 351bd056d7eSTejun Heo tf->device |= 1 << 7; 352bd056d7eSTejun Heo } else if (dev->flags & ATA_DFLAG_LBA) { 353bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_LBA; 354bd056d7eSTejun Heo 355bd056d7eSTejun Heo if (lba_28_ok(block, n_block)) { 356bd056d7eSTejun Heo /* use LBA28 */ 357bd056d7eSTejun Heo tf->device |= (block >> 24) & 0xf; 358bd056d7eSTejun Heo } else if (lba_48_ok(block, n_block)) { 359bd056d7eSTejun Heo if (!(dev->flags & ATA_DFLAG_LBA48)) 360bd056d7eSTejun Heo return -ERANGE; 361bd056d7eSTejun Heo 362bd056d7eSTejun Heo /* use LBA48 */ 363bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_LBA48; 364bd056d7eSTejun Heo 365bd056d7eSTejun Heo tf->hob_nsect = (n_block >> 8) & 0xff; 366bd056d7eSTejun Heo 367bd056d7eSTejun Heo tf->hob_lbah = (block >> 40) & 0xff; 368bd056d7eSTejun Heo tf->hob_lbam = (block >> 32) & 0xff; 369bd056d7eSTejun Heo tf->hob_lbal = (block >> 24) & 0xff; 370bd056d7eSTejun Heo } else 371bd056d7eSTejun Heo /* request too large even for LBA48 */ 372bd056d7eSTejun Heo return -ERANGE; 373bd056d7eSTejun Heo 374bd056d7eSTejun Heo if (unlikely(ata_rwcmd_protocol(tf, dev) < 0)) 375bd056d7eSTejun Heo return -EINVAL; 376bd056d7eSTejun Heo 377bd056d7eSTejun Heo tf->nsect = n_block & 0xff; 378bd056d7eSTejun Heo 379bd056d7eSTejun Heo tf->lbah = (block >> 16) & 0xff; 380bd056d7eSTejun Heo tf->lbam = (block >> 8) & 0xff; 381bd056d7eSTejun Heo tf->lbal = block & 0xff; 382bd056d7eSTejun Heo 383bd056d7eSTejun Heo tf->device |= ATA_LBA; 384bd056d7eSTejun Heo } else { 385bd056d7eSTejun Heo /* CHS */ 386bd056d7eSTejun Heo u32 sect, head, cyl, track; 387bd056d7eSTejun Heo 388bd056d7eSTejun Heo /* The request -may- be too large for CHS addressing. */ 389bd056d7eSTejun Heo if (!lba_28_ok(block, n_block)) 390bd056d7eSTejun Heo return -ERANGE; 391bd056d7eSTejun Heo 392bd056d7eSTejun Heo if (unlikely(ata_rwcmd_protocol(tf, dev) < 0)) 393bd056d7eSTejun Heo return -EINVAL; 394bd056d7eSTejun Heo 395bd056d7eSTejun Heo /* Convert LBA to CHS */ 396bd056d7eSTejun Heo track = (u32)block / dev->sectors; 397bd056d7eSTejun Heo cyl = track / dev->heads; 398bd056d7eSTejun Heo head = track % dev->heads; 399bd056d7eSTejun Heo sect = (u32)block % dev->sectors + 1; 400bd056d7eSTejun Heo 401bd056d7eSTejun Heo DPRINTK("block %u track %u cyl %u head %u sect %u\n", 402bd056d7eSTejun Heo (u32)block, track, cyl, head, sect); 403bd056d7eSTejun Heo 404bd056d7eSTejun Heo /* Check whether the converted CHS can fit. 405bd056d7eSTejun Heo Cylinder: 0-65535 406bd056d7eSTejun Heo Head: 0-15 407bd056d7eSTejun Heo Sector: 1-255*/ 408bd056d7eSTejun Heo if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect)) 409bd056d7eSTejun Heo return -ERANGE; 410bd056d7eSTejun Heo 411bd056d7eSTejun Heo tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */ 412bd056d7eSTejun Heo tf->lbal = sect; 413bd056d7eSTejun Heo tf->lbam = cyl; 414bd056d7eSTejun Heo tf->lbah = cyl >> 8; 415bd056d7eSTejun Heo tf->device |= head; 416bd056d7eSTejun Heo } 417bd056d7eSTejun Heo 418bd056d7eSTejun Heo return 0; 419bd056d7eSTejun Heo } 420bd056d7eSTejun Heo 421bd056d7eSTejun Heo /** 422c6fd2807SJeff Garzik * ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask 423c6fd2807SJeff Garzik * @pio_mask: pio_mask 424c6fd2807SJeff Garzik * @mwdma_mask: mwdma_mask 425c6fd2807SJeff Garzik * @udma_mask: udma_mask 426c6fd2807SJeff Garzik * 427c6fd2807SJeff Garzik * Pack @pio_mask, @mwdma_mask and @udma_mask into a single 428c6fd2807SJeff Garzik * unsigned int xfer_mask. 429c6fd2807SJeff Garzik * 430c6fd2807SJeff Garzik * LOCKING: 431c6fd2807SJeff Garzik * None. 432c6fd2807SJeff Garzik * 433c6fd2807SJeff Garzik * RETURNS: 434c6fd2807SJeff Garzik * Packed xfer_mask. 435c6fd2807SJeff Garzik */ 436c6fd2807SJeff Garzik static unsigned int ata_pack_xfermask(unsigned int pio_mask, 437c6fd2807SJeff Garzik unsigned int mwdma_mask, 438c6fd2807SJeff Garzik unsigned int udma_mask) 439c6fd2807SJeff Garzik { 440c6fd2807SJeff Garzik return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) | 441c6fd2807SJeff Garzik ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) | 442c6fd2807SJeff Garzik ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA); 443c6fd2807SJeff Garzik } 444c6fd2807SJeff Garzik 445c6fd2807SJeff Garzik /** 446c6fd2807SJeff Garzik * ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks 447c6fd2807SJeff Garzik * @xfer_mask: xfer_mask to unpack 448c6fd2807SJeff Garzik * @pio_mask: resulting pio_mask 449c6fd2807SJeff Garzik * @mwdma_mask: resulting mwdma_mask 450c6fd2807SJeff Garzik * @udma_mask: resulting udma_mask 451c6fd2807SJeff Garzik * 452c6fd2807SJeff Garzik * Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask. 453c6fd2807SJeff Garzik * Any NULL distination masks will be ignored. 454c6fd2807SJeff Garzik */ 455c6fd2807SJeff Garzik static void ata_unpack_xfermask(unsigned int xfer_mask, 456c6fd2807SJeff Garzik unsigned int *pio_mask, 457c6fd2807SJeff Garzik unsigned int *mwdma_mask, 458c6fd2807SJeff Garzik unsigned int *udma_mask) 459c6fd2807SJeff Garzik { 460c6fd2807SJeff Garzik if (pio_mask) 461c6fd2807SJeff Garzik *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO; 462c6fd2807SJeff Garzik if (mwdma_mask) 463c6fd2807SJeff Garzik *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA; 464c6fd2807SJeff Garzik if (udma_mask) 465c6fd2807SJeff Garzik *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA; 466c6fd2807SJeff Garzik } 467c6fd2807SJeff Garzik 468c6fd2807SJeff Garzik static const struct ata_xfer_ent { 469c6fd2807SJeff Garzik int shift, bits; 470c6fd2807SJeff Garzik u8 base; 471c6fd2807SJeff Garzik } ata_xfer_tbl[] = { 472c6fd2807SJeff Garzik { ATA_SHIFT_PIO, ATA_BITS_PIO, XFER_PIO_0 }, 473c6fd2807SJeff Garzik { ATA_SHIFT_MWDMA, ATA_BITS_MWDMA, XFER_MW_DMA_0 }, 474c6fd2807SJeff Garzik { ATA_SHIFT_UDMA, ATA_BITS_UDMA, XFER_UDMA_0 }, 475c6fd2807SJeff Garzik { -1, }, 476c6fd2807SJeff Garzik }; 477c6fd2807SJeff Garzik 478c6fd2807SJeff Garzik /** 479c6fd2807SJeff Garzik * ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask 480c6fd2807SJeff Garzik * @xfer_mask: xfer_mask of interest 481c6fd2807SJeff Garzik * 482c6fd2807SJeff Garzik * Return matching XFER_* value for @xfer_mask. Only the highest 483c6fd2807SJeff Garzik * bit of @xfer_mask is considered. 484c6fd2807SJeff Garzik * 485c6fd2807SJeff Garzik * LOCKING: 486c6fd2807SJeff Garzik * None. 487c6fd2807SJeff Garzik * 488c6fd2807SJeff Garzik * RETURNS: 489c6fd2807SJeff Garzik * Matching XFER_* value, 0 if no match found. 490c6fd2807SJeff Garzik */ 491c6fd2807SJeff Garzik static u8 ata_xfer_mask2mode(unsigned int xfer_mask) 492c6fd2807SJeff Garzik { 493c6fd2807SJeff Garzik int highbit = fls(xfer_mask) - 1; 494c6fd2807SJeff Garzik const struct ata_xfer_ent *ent; 495c6fd2807SJeff Garzik 496c6fd2807SJeff Garzik for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 497c6fd2807SJeff Garzik if (highbit >= ent->shift && highbit < ent->shift + ent->bits) 498c6fd2807SJeff Garzik return ent->base + highbit - ent->shift; 499c6fd2807SJeff Garzik return 0; 500c6fd2807SJeff Garzik } 501c6fd2807SJeff Garzik 502c6fd2807SJeff Garzik /** 503c6fd2807SJeff Garzik * ata_xfer_mode2mask - Find matching xfer_mask for XFER_* 504c6fd2807SJeff Garzik * @xfer_mode: XFER_* of interest 505c6fd2807SJeff Garzik * 506c6fd2807SJeff Garzik * Return matching xfer_mask for @xfer_mode. 507c6fd2807SJeff Garzik * 508c6fd2807SJeff Garzik * LOCKING: 509c6fd2807SJeff Garzik * None. 510c6fd2807SJeff Garzik * 511c6fd2807SJeff Garzik * RETURNS: 512c6fd2807SJeff Garzik * Matching xfer_mask, 0 if no match found. 513c6fd2807SJeff Garzik */ 514c6fd2807SJeff Garzik static unsigned int ata_xfer_mode2mask(u8 xfer_mode) 515c6fd2807SJeff Garzik { 516c6fd2807SJeff Garzik const struct ata_xfer_ent *ent; 517c6fd2807SJeff Garzik 518c6fd2807SJeff Garzik for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 519c6fd2807SJeff Garzik if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits) 520c6fd2807SJeff Garzik return 1 << (ent->shift + xfer_mode - ent->base); 521c6fd2807SJeff Garzik return 0; 522c6fd2807SJeff Garzik } 523c6fd2807SJeff Garzik 524c6fd2807SJeff Garzik /** 525c6fd2807SJeff Garzik * ata_xfer_mode2shift - Find matching xfer_shift for XFER_* 526c6fd2807SJeff Garzik * @xfer_mode: XFER_* of interest 527c6fd2807SJeff Garzik * 528c6fd2807SJeff Garzik * Return matching xfer_shift for @xfer_mode. 529c6fd2807SJeff Garzik * 530c6fd2807SJeff Garzik * LOCKING: 531c6fd2807SJeff Garzik * None. 532c6fd2807SJeff Garzik * 533c6fd2807SJeff Garzik * RETURNS: 534c6fd2807SJeff Garzik * Matching xfer_shift, -1 if no match found. 535c6fd2807SJeff Garzik */ 536c6fd2807SJeff Garzik static int ata_xfer_mode2shift(unsigned int xfer_mode) 537c6fd2807SJeff Garzik { 538c6fd2807SJeff Garzik const struct ata_xfer_ent *ent; 539c6fd2807SJeff Garzik 540c6fd2807SJeff Garzik for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 541c6fd2807SJeff Garzik if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits) 542c6fd2807SJeff Garzik return ent->shift; 543c6fd2807SJeff Garzik return -1; 544c6fd2807SJeff Garzik } 545c6fd2807SJeff Garzik 546c6fd2807SJeff Garzik /** 547c6fd2807SJeff Garzik * ata_mode_string - convert xfer_mask to string 548c6fd2807SJeff Garzik * @xfer_mask: mask of bits supported; only highest bit counts. 549c6fd2807SJeff Garzik * 550c6fd2807SJeff Garzik * Determine string which represents the highest speed 551c6fd2807SJeff Garzik * (highest bit in @modemask). 552c6fd2807SJeff Garzik * 553c6fd2807SJeff Garzik * LOCKING: 554c6fd2807SJeff Garzik * None. 555c6fd2807SJeff Garzik * 556c6fd2807SJeff Garzik * RETURNS: 557c6fd2807SJeff Garzik * Constant C string representing highest speed listed in 558c6fd2807SJeff Garzik * @mode_mask, or the constant C string "<n/a>". 559c6fd2807SJeff Garzik */ 560c6fd2807SJeff Garzik static const char *ata_mode_string(unsigned int xfer_mask) 561c6fd2807SJeff Garzik { 562c6fd2807SJeff Garzik static const char * const xfer_mode_str[] = { 563c6fd2807SJeff Garzik "PIO0", 564c6fd2807SJeff Garzik "PIO1", 565c6fd2807SJeff Garzik "PIO2", 566c6fd2807SJeff Garzik "PIO3", 567c6fd2807SJeff Garzik "PIO4", 568b352e57dSAlan Cox "PIO5", 569b352e57dSAlan Cox "PIO6", 570c6fd2807SJeff Garzik "MWDMA0", 571c6fd2807SJeff Garzik "MWDMA1", 572c6fd2807SJeff Garzik "MWDMA2", 573b352e57dSAlan Cox "MWDMA3", 574b352e57dSAlan Cox "MWDMA4", 575c6fd2807SJeff Garzik "UDMA/16", 576c6fd2807SJeff Garzik "UDMA/25", 577c6fd2807SJeff Garzik "UDMA/33", 578c6fd2807SJeff Garzik "UDMA/44", 579c6fd2807SJeff Garzik "UDMA/66", 580c6fd2807SJeff Garzik "UDMA/100", 581c6fd2807SJeff Garzik "UDMA/133", 582c6fd2807SJeff Garzik "UDMA7", 583c6fd2807SJeff Garzik }; 584c6fd2807SJeff Garzik int highbit; 585c6fd2807SJeff Garzik 586c6fd2807SJeff Garzik highbit = fls(xfer_mask) - 1; 587c6fd2807SJeff Garzik if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str)) 588c6fd2807SJeff Garzik return xfer_mode_str[highbit]; 589c6fd2807SJeff Garzik return "<n/a>"; 590c6fd2807SJeff Garzik } 591c6fd2807SJeff Garzik 592c6fd2807SJeff Garzik static const char *sata_spd_string(unsigned int spd) 593c6fd2807SJeff Garzik { 594c6fd2807SJeff Garzik static const char * const spd_str[] = { 595c6fd2807SJeff Garzik "1.5 Gbps", 596c6fd2807SJeff Garzik "3.0 Gbps", 597c6fd2807SJeff Garzik }; 598c6fd2807SJeff Garzik 599c6fd2807SJeff Garzik if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str)) 600c6fd2807SJeff Garzik return "<unknown>"; 601c6fd2807SJeff Garzik return spd_str[spd - 1]; 602c6fd2807SJeff Garzik } 603c6fd2807SJeff Garzik 604c6fd2807SJeff Garzik void ata_dev_disable(struct ata_device *dev) 605c6fd2807SJeff Garzik { 60609d7f9b0STejun Heo if (ata_dev_enabled(dev)) { 6079af5c9c9STejun Heo if (ata_msg_drv(dev->link->ap)) 608c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "disabled\n"); 6094ae72a1eSTejun Heo ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | 6104ae72a1eSTejun Heo ATA_DNXFER_QUIET); 611c6fd2807SJeff Garzik dev->class++; 612c6fd2807SJeff Garzik } 613c6fd2807SJeff Garzik } 614c6fd2807SJeff Garzik 615c6fd2807SJeff Garzik /** 616c6fd2807SJeff Garzik * ata_devchk - PATA device presence detection 617c6fd2807SJeff Garzik * @ap: ATA channel to examine 618c6fd2807SJeff Garzik * @device: Device to examine (starting at zero) 619c6fd2807SJeff Garzik * 6200d5ff566STejun Heo * This technique was originally described in 6210d5ff566STejun Heo * Hale Landis's ATADRVR (www.ata-atapi.com), and 6220d5ff566STejun Heo * later found its way into the ATA/ATAPI spec. 6230d5ff566STejun Heo * 6240d5ff566STejun Heo * Write a pattern to the ATA shadow registers, 6250d5ff566STejun Heo * and if a device is present, it will respond by 6260d5ff566STejun Heo * correctly storing and echoing back the 6270d5ff566STejun Heo * ATA shadow register contents. 628c6fd2807SJeff Garzik * 629c6fd2807SJeff Garzik * LOCKING: 630c6fd2807SJeff Garzik * caller. 631c6fd2807SJeff Garzik */ 632c6fd2807SJeff Garzik 6330d5ff566STejun Heo static unsigned int ata_devchk(struct ata_port *ap, unsigned int device) 634c6fd2807SJeff Garzik { 6350d5ff566STejun Heo struct ata_ioports *ioaddr = &ap->ioaddr; 6360d5ff566STejun Heo u8 nsect, lbal; 6370d5ff566STejun Heo 6380d5ff566STejun Heo ap->ops->dev_select(ap, device); 6390d5ff566STejun Heo 6400d5ff566STejun Heo iowrite8(0x55, ioaddr->nsect_addr); 6410d5ff566STejun Heo iowrite8(0xaa, ioaddr->lbal_addr); 6420d5ff566STejun Heo 6430d5ff566STejun Heo iowrite8(0xaa, ioaddr->nsect_addr); 6440d5ff566STejun Heo iowrite8(0x55, ioaddr->lbal_addr); 6450d5ff566STejun Heo 6460d5ff566STejun Heo iowrite8(0x55, ioaddr->nsect_addr); 6470d5ff566STejun Heo iowrite8(0xaa, ioaddr->lbal_addr); 6480d5ff566STejun Heo 6490d5ff566STejun Heo nsect = ioread8(ioaddr->nsect_addr); 6500d5ff566STejun Heo lbal = ioread8(ioaddr->lbal_addr); 6510d5ff566STejun Heo 6520d5ff566STejun Heo if ((nsect == 0x55) && (lbal == 0xaa)) 6530d5ff566STejun Heo return 1; /* we found a device */ 6540d5ff566STejun Heo 6550d5ff566STejun Heo return 0; /* nothing found */ 656c6fd2807SJeff Garzik } 657c6fd2807SJeff Garzik 658c6fd2807SJeff Garzik /** 659c6fd2807SJeff Garzik * ata_dev_classify - determine device type based on ATA-spec signature 660c6fd2807SJeff Garzik * @tf: ATA taskfile register set for device to be identified 661c6fd2807SJeff Garzik * 662c6fd2807SJeff Garzik * Determine from taskfile register contents whether a device is 663c6fd2807SJeff Garzik * ATA or ATAPI, as per "Signature and persistence" section 664c6fd2807SJeff Garzik * of ATA/PI spec (volume 1, sect 5.14). 665c6fd2807SJeff Garzik * 666c6fd2807SJeff Garzik * LOCKING: 667c6fd2807SJeff Garzik * None. 668c6fd2807SJeff Garzik * 669c6fd2807SJeff Garzik * RETURNS: 670c6fd2807SJeff Garzik * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN 671c6fd2807SJeff Garzik * the event of failure. 672c6fd2807SJeff Garzik */ 673c6fd2807SJeff Garzik 674c6fd2807SJeff Garzik unsigned int ata_dev_classify(const struct ata_taskfile *tf) 675c6fd2807SJeff Garzik { 676c6fd2807SJeff Garzik /* Apple's open source Darwin code hints that some devices only 677c6fd2807SJeff Garzik * put a proper signature into the LBA mid/high registers, 678c6fd2807SJeff Garzik * So, we only check those. It's sufficient for uniqueness. 679c6fd2807SJeff Garzik */ 680c6fd2807SJeff Garzik 681c6fd2807SJeff Garzik if (((tf->lbam == 0) && (tf->lbah == 0)) || 682c6fd2807SJeff Garzik ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) { 683c6fd2807SJeff Garzik DPRINTK("found ATA device by sig\n"); 684c6fd2807SJeff Garzik return ATA_DEV_ATA; 685c6fd2807SJeff Garzik } 686c6fd2807SJeff Garzik 687c6fd2807SJeff Garzik if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) || 688c6fd2807SJeff Garzik ((tf->lbam == 0x69) && (tf->lbah == 0x96))) { 689c6fd2807SJeff Garzik DPRINTK("found ATAPI device by sig\n"); 690c6fd2807SJeff Garzik return ATA_DEV_ATAPI; 691c6fd2807SJeff Garzik } 692c6fd2807SJeff Garzik 693c6fd2807SJeff Garzik DPRINTK("unknown device\n"); 694c6fd2807SJeff Garzik return ATA_DEV_UNKNOWN; 695c6fd2807SJeff Garzik } 696c6fd2807SJeff Garzik 697c6fd2807SJeff Garzik /** 698c6fd2807SJeff Garzik * ata_dev_try_classify - Parse returned ATA device signature 699c6fd2807SJeff Garzik * @ap: ATA channel to examine 700c6fd2807SJeff Garzik * @device: Device to examine (starting at zero) 701c6fd2807SJeff Garzik * @r_err: Value of error register on completion 702c6fd2807SJeff Garzik * 703c6fd2807SJeff Garzik * After an event -- SRST, E.D.D., or SATA COMRESET -- occurs, 704c6fd2807SJeff Garzik * an ATA/ATAPI-defined set of values is placed in the ATA 705c6fd2807SJeff Garzik * shadow registers, indicating the results of device detection 706c6fd2807SJeff Garzik * and diagnostics. 707c6fd2807SJeff Garzik * 708c6fd2807SJeff Garzik * Select the ATA device, and read the values from the ATA shadow 709c6fd2807SJeff Garzik * registers. Then parse according to the Error register value, 710c6fd2807SJeff Garzik * and the spec-defined values examined by ata_dev_classify(). 711c6fd2807SJeff Garzik * 712c6fd2807SJeff Garzik * LOCKING: 713c6fd2807SJeff Garzik * caller. 714c6fd2807SJeff Garzik * 715c6fd2807SJeff Garzik * RETURNS: 716c6fd2807SJeff Garzik * Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE. 717c6fd2807SJeff Garzik */ 718c6fd2807SJeff Garzik 719a619f981SAkira Iguchi unsigned int 720c6fd2807SJeff Garzik ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err) 721c6fd2807SJeff Garzik { 722c6fd2807SJeff Garzik struct ata_taskfile tf; 723c6fd2807SJeff Garzik unsigned int class; 724c6fd2807SJeff Garzik u8 err; 725c6fd2807SJeff Garzik 726c6fd2807SJeff Garzik ap->ops->dev_select(ap, device); 727c6fd2807SJeff Garzik 728c6fd2807SJeff Garzik memset(&tf, 0, sizeof(tf)); 729c6fd2807SJeff Garzik 730c6fd2807SJeff Garzik ap->ops->tf_read(ap, &tf); 731c6fd2807SJeff Garzik err = tf.feature; 732c6fd2807SJeff Garzik if (r_err) 733c6fd2807SJeff Garzik *r_err = err; 734c6fd2807SJeff Garzik 73593590859SAlan Cox /* see if device passed diags: if master then continue and warn later */ 73693590859SAlan Cox if (err == 0 && device == 0) 73793590859SAlan Cox /* diagnostic fail : do nothing _YET_ */ 7389af5c9c9STejun Heo ap->link.device[device].horkage |= ATA_HORKAGE_DIAGNOSTIC; 73993590859SAlan Cox else if (err == 1) 740c6fd2807SJeff Garzik /* do nothing */ ; 741c6fd2807SJeff Garzik else if ((device == 0) && (err == 0x81)) 742c6fd2807SJeff Garzik /* do nothing */ ; 743c6fd2807SJeff Garzik else 744c6fd2807SJeff Garzik return ATA_DEV_NONE; 745c6fd2807SJeff Garzik 746c6fd2807SJeff Garzik /* determine if device is ATA or ATAPI */ 747c6fd2807SJeff Garzik class = ata_dev_classify(&tf); 748c6fd2807SJeff Garzik 749c6fd2807SJeff Garzik if (class == ATA_DEV_UNKNOWN) 750c6fd2807SJeff Garzik return ATA_DEV_NONE; 751c6fd2807SJeff Garzik if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0)) 752c6fd2807SJeff Garzik return ATA_DEV_NONE; 753c6fd2807SJeff Garzik return class; 754c6fd2807SJeff Garzik } 755c6fd2807SJeff Garzik 756c6fd2807SJeff Garzik /** 757c6fd2807SJeff Garzik * ata_id_string - Convert IDENTIFY DEVICE page into string 758c6fd2807SJeff Garzik * @id: IDENTIFY DEVICE results we will examine 759c6fd2807SJeff Garzik * @s: string into which data is output 760c6fd2807SJeff Garzik * @ofs: offset into identify device page 761c6fd2807SJeff Garzik * @len: length of string to return. must be an even number. 762c6fd2807SJeff Garzik * 763c6fd2807SJeff Garzik * The strings in the IDENTIFY DEVICE page are broken up into 764c6fd2807SJeff Garzik * 16-bit chunks. Run through the string, and output each 765c6fd2807SJeff Garzik * 8-bit chunk linearly, regardless of platform. 766c6fd2807SJeff Garzik * 767c6fd2807SJeff Garzik * LOCKING: 768c6fd2807SJeff Garzik * caller. 769c6fd2807SJeff Garzik */ 770c6fd2807SJeff Garzik 771c6fd2807SJeff Garzik void ata_id_string(const u16 *id, unsigned char *s, 772c6fd2807SJeff Garzik unsigned int ofs, unsigned int len) 773c6fd2807SJeff Garzik { 774c6fd2807SJeff Garzik unsigned int c; 775c6fd2807SJeff Garzik 776c6fd2807SJeff Garzik while (len > 0) { 777c6fd2807SJeff Garzik c = id[ofs] >> 8; 778c6fd2807SJeff Garzik *s = c; 779c6fd2807SJeff Garzik s++; 780c6fd2807SJeff Garzik 781c6fd2807SJeff Garzik c = id[ofs] & 0xff; 782c6fd2807SJeff Garzik *s = c; 783c6fd2807SJeff Garzik s++; 784c6fd2807SJeff Garzik 785c6fd2807SJeff Garzik ofs++; 786c6fd2807SJeff Garzik len -= 2; 787c6fd2807SJeff Garzik } 788c6fd2807SJeff Garzik } 789c6fd2807SJeff Garzik 790c6fd2807SJeff Garzik /** 791c6fd2807SJeff Garzik * ata_id_c_string - Convert IDENTIFY DEVICE page into C string 792c6fd2807SJeff Garzik * @id: IDENTIFY DEVICE results we will examine 793c6fd2807SJeff Garzik * @s: string into which data is output 794c6fd2807SJeff Garzik * @ofs: offset into identify device page 795c6fd2807SJeff Garzik * @len: length of string to return. must be an odd number. 796c6fd2807SJeff Garzik * 797c6fd2807SJeff Garzik * This function is identical to ata_id_string except that it 798c6fd2807SJeff Garzik * trims trailing spaces and terminates the resulting string with 799c6fd2807SJeff Garzik * null. @len must be actual maximum length (even number) + 1. 800c6fd2807SJeff Garzik * 801c6fd2807SJeff Garzik * LOCKING: 802c6fd2807SJeff Garzik * caller. 803c6fd2807SJeff Garzik */ 804c6fd2807SJeff Garzik void ata_id_c_string(const u16 *id, unsigned char *s, 805c6fd2807SJeff Garzik unsigned int ofs, unsigned int len) 806c6fd2807SJeff Garzik { 807c6fd2807SJeff Garzik unsigned char *p; 808c6fd2807SJeff Garzik 809c6fd2807SJeff Garzik WARN_ON(!(len & 1)); 810c6fd2807SJeff Garzik 811c6fd2807SJeff Garzik ata_id_string(id, s, ofs, len - 1); 812c6fd2807SJeff Garzik 813c6fd2807SJeff Garzik p = s + strnlen(s, len - 1); 814c6fd2807SJeff Garzik while (p > s && p[-1] == ' ') 815c6fd2807SJeff Garzik p--; 816c6fd2807SJeff Garzik *p = '\0'; 817c6fd2807SJeff Garzik } 818c6fd2807SJeff Garzik 8191e999736SAlan Cox static u64 ata_tf_to_lba48(struct ata_taskfile *tf) 8201e999736SAlan Cox { 8211e999736SAlan Cox u64 sectors = 0; 8221e999736SAlan Cox 8231e999736SAlan Cox sectors |= ((u64)(tf->hob_lbah & 0xff)) << 40; 8241e999736SAlan Cox sectors |= ((u64)(tf->hob_lbam & 0xff)) << 32; 8251e999736SAlan Cox sectors |= (tf->hob_lbal & 0xff) << 24; 8261e999736SAlan Cox sectors |= (tf->lbah & 0xff) << 16; 8271e999736SAlan Cox sectors |= (tf->lbam & 0xff) << 8; 8281e999736SAlan Cox sectors |= (tf->lbal & 0xff); 8291e999736SAlan Cox 8301e999736SAlan Cox return ++sectors; 8311e999736SAlan Cox } 8321e999736SAlan Cox 8331e999736SAlan Cox static u64 ata_tf_to_lba(struct ata_taskfile *tf) 8341e999736SAlan Cox { 8351e999736SAlan Cox u64 sectors = 0; 8361e999736SAlan Cox 8371e999736SAlan Cox sectors |= (tf->device & 0x0f) << 24; 8381e999736SAlan Cox sectors |= (tf->lbah & 0xff) << 16; 8391e999736SAlan Cox sectors |= (tf->lbam & 0xff) << 8; 8401e999736SAlan Cox sectors |= (tf->lbal & 0xff); 8411e999736SAlan Cox 8421e999736SAlan Cox return ++sectors; 8431e999736SAlan Cox } 8441e999736SAlan Cox 8451e999736SAlan Cox /** 8461e999736SAlan Cox * ata_read_native_max_address_ext - LBA48 native max query 8471e999736SAlan Cox * @dev: Device to query 8481e999736SAlan Cox * 8491e999736SAlan Cox * Perform an LBA48 size query upon the device in question. Return the 8501e999736SAlan Cox * actual LBA48 size or zero if the command fails. 8511e999736SAlan Cox */ 8521e999736SAlan Cox 8531e999736SAlan Cox static u64 ata_read_native_max_address_ext(struct ata_device *dev) 8541e999736SAlan Cox { 8551e999736SAlan Cox unsigned int err; 8561e999736SAlan Cox struct ata_taskfile tf; 8571e999736SAlan Cox 8581e999736SAlan Cox ata_tf_init(dev, &tf); 8591e999736SAlan Cox 8601e999736SAlan Cox tf.command = ATA_CMD_READ_NATIVE_MAX_EXT; 8611e999736SAlan Cox tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_LBA48 | ATA_TFLAG_ISADDR; 8621e999736SAlan Cox tf.protocol |= ATA_PROT_NODATA; 8631e999736SAlan Cox tf.device |= 0x40; 8641e999736SAlan Cox 8651e999736SAlan Cox err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0); 8661e999736SAlan Cox if (err) 8671e999736SAlan Cox return 0; 8681e999736SAlan Cox 8691e999736SAlan Cox return ata_tf_to_lba48(&tf); 8701e999736SAlan Cox } 8711e999736SAlan Cox 8721e999736SAlan Cox /** 8731e999736SAlan Cox * ata_read_native_max_address - LBA28 native max query 8741e999736SAlan Cox * @dev: Device to query 8751e999736SAlan Cox * 8761e999736SAlan Cox * Performa an LBA28 size query upon the device in question. Return the 8771e999736SAlan Cox * actual LBA28 size or zero if the command fails. 8781e999736SAlan Cox */ 8791e999736SAlan Cox 8801e999736SAlan Cox static u64 ata_read_native_max_address(struct ata_device *dev) 8811e999736SAlan Cox { 8821e999736SAlan Cox unsigned int err; 8831e999736SAlan Cox struct ata_taskfile tf; 8841e999736SAlan Cox 8851e999736SAlan Cox ata_tf_init(dev, &tf); 8861e999736SAlan Cox 8871e999736SAlan Cox tf.command = ATA_CMD_READ_NATIVE_MAX; 8881e999736SAlan Cox tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR; 8891e999736SAlan Cox tf.protocol |= ATA_PROT_NODATA; 8901e999736SAlan Cox tf.device |= 0x40; 8911e999736SAlan Cox 8921e999736SAlan Cox err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0); 8931e999736SAlan Cox if (err) 8941e999736SAlan Cox return 0; 8951e999736SAlan Cox 8961e999736SAlan Cox return ata_tf_to_lba(&tf); 8971e999736SAlan Cox } 8981e999736SAlan Cox 8991e999736SAlan Cox /** 9001e999736SAlan Cox * ata_set_native_max_address_ext - LBA48 native max set 9011e999736SAlan Cox * @dev: Device to query 9026b38d1d1SRandy Dunlap * @new_sectors: new max sectors value to set for the device 9031e999736SAlan Cox * 9041e999736SAlan Cox * Perform an LBA48 size set max upon the device in question. Return the 9051e999736SAlan Cox * actual LBA48 size or zero if the command fails. 9061e999736SAlan Cox */ 9071e999736SAlan Cox 9081e999736SAlan Cox static u64 ata_set_native_max_address_ext(struct ata_device *dev, u64 new_sectors) 9091e999736SAlan Cox { 9101e999736SAlan Cox unsigned int err; 9111e999736SAlan Cox struct ata_taskfile tf; 9121e999736SAlan Cox 9131e999736SAlan Cox new_sectors--; 9141e999736SAlan Cox 9151e999736SAlan Cox ata_tf_init(dev, &tf); 9161e999736SAlan Cox 9171e999736SAlan Cox tf.command = ATA_CMD_SET_MAX_EXT; 9181e999736SAlan Cox tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_LBA48 | ATA_TFLAG_ISADDR; 9191e999736SAlan Cox tf.protocol |= ATA_PROT_NODATA; 9201e999736SAlan Cox tf.device |= 0x40; 9211e999736SAlan Cox 9221e999736SAlan Cox tf.lbal = (new_sectors >> 0) & 0xff; 9231e999736SAlan Cox tf.lbam = (new_sectors >> 8) & 0xff; 9241e999736SAlan Cox tf.lbah = (new_sectors >> 16) & 0xff; 9251e999736SAlan Cox 9261e999736SAlan Cox tf.hob_lbal = (new_sectors >> 24) & 0xff; 9271e999736SAlan Cox tf.hob_lbam = (new_sectors >> 32) & 0xff; 9281e999736SAlan Cox tf.hob_lbah = (new_sectors >> 40) & 0xff; 9291e999736SAlan Cox 9301e999736SAlan Cox err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0); 9311e999736SAlan Cox if (err) 9321e999736SAlan Cox return 0; 9331e999736SAlan Cox 9341e999736SAlan Cox return ata_tf_to_lba48(&tf); 9351e999736SAlan Cox } 9361e999736SAlan Cox 9371e999736SAlan Cox /** 9381e999736SAlan Cox * ata_set_native_max_address - LBA28 native max set 9391e999736SAlan Cox * @dev: Device to query 9406b38d1d1SRandy Dunlap * @new_sectors: new max sectors value to set for the device 9411e999736SAlan Cox * 9421e999736SAlan Cox * Perform an LBA28 size set max upon the device in question. Return the 9431e999736SAlan Cox * actual LBA28 size or zero if the command fails. 9441e999736SAlan Cox */ 9451e999736SAlan Cox 9461e999736SAlan Cox static u64 ata_set_native_max_address(struct ata_device *dev, u64 new_sectors) 9471e999736SAlan Cox { 9481e999736SAlan Cox unsigned int err; 9491e999736SAlan Cox struct ata_taskfile tf; 9501e999736SAlan Cox 9511e999736SAlan Cox new_sectors--; 9521e999736SAlan Cox 9531e999736SAlan Cox ata_tf_init(dev, &tf); 9541e999736SAlan Cox 9551e999736SAlan Cox tf.command = ATA_CMD_SET_MAX; 9561e999736SAlan Cox tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR; 9571e999736SAlan Cox tf.protocol |= ATA_PROT_NODATA; 9581e999736SAlan Cox 9591e999736SAlan Cox tf.lbal = (new_sectors >> 0) & 0xff; 9601e999736SAlan Cox tf.lbam = (new_sectors >> 8) & 0xff; 9611e999736SAlan Cox tf.lbah = (new_sectors >> 16) & 0xff; 9621e999736SAlan Cox tf.device |= ((new_sectors >> 24) & 0x0f) | 0x40; 9631e999736SAlan Cox 9641e999736SAlan Cox err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0); 9651e999736SAlan Cox if (err) 9661e999736SAlan Cox return 0; 9671e999736SAlan Cox 9681e999736SAlan Cox return ata_tf_to_lba(&tf); 9691e999736SAlan Cox } 9701e999736SAlan Cox 9711e999736SAlan Cox /** 9721e999736SAlan Cox * ata_hpa_resize - Resize a device with an HPA set 9731e999736SAlan Cox * @dev: Device to resize 9741e999736SAlan Cox * 9751e999736SAlan Cox * Read the size of an LBA28 or LBA48 disk with HPA features and resize 9761e999736SAlan Cox * it if required to the full size of the media. The caller must check 9771e999736SAlan Cox * the drive has the HPA feature set enabled. 9781e999736SAlan Cox */ 9791e999736SAlan Cox 9801e999736SAlan Cox static u64 ata_hpa_resize(struct ata_device *dev) 9811e999736SAlan Cox { 9821e999736SAlan Cox u64 sectors = dev->n_sectors; 9831e999736SAlan Cox u64 hpa_sectors; 9841e999736SAlan Cox 9851e999736SAlan Cox if (ata_id_has_lba48(dev->id)) 9861e999736SAlan Cox hpa_sectors = ata_read_native_max_address_ext(dev); 9871e999736SAlan Cox else 9881e999736SAlan Cox hpa_sectors = ata_read_native_max_address(dev); 9891e999736SAlan Cox 9901e999736SAlan Cox if (hpa_sectors > sectors) { 9911e999736SAlan Cox ata_dev_printk(dev, KERN_INFO, 9921e999736SAlan Cox "Host Protected Area detected:\n" 9931e999736SAlan Cox "\tcurrent size: %lld sectors\n" 9941e999736SAlan Cox "\tnative size: %lld sectors\n", 995bd1d5ec6SAndrew Morton (long long)sectors, (long long)hpa_sectors); 9961e999736SAlan Cox 9971e999736SAlan Cox if (ata_ignore_hpa) { 9981e999736SAlan Cox if (ata_id_has_lba48(dev->id)) 9991e999736SAlan Cox hpa_sectors = ata_set_native_max_address_ext(dev, hpa_sectors); 10001e999736SAlan Cox else 1001bd1d5ec6SAndrew Morton hpa_sectors = ata_set_native_max_address(dev, 1002bd1d5ec6SAndrew Morton hpa_sectors); 10031e999736SAlan Cox 10041e999736SAlan Cox if (hpa_sectors) { 1005bd1d5ec6SAndrew Morton ata_dev_printk(dev, KERN_INFO, "native size " 1006bd1d5ec6SAndrew Morton "increased to %lld sectors\n", 1007bd1d5ec6SAndrew Morton (long long)hpa_sectors); 10081e999736SAlan Cox return hpa_sectors; 10091e999736SAlan Cox } 10101e999736SAlan Cox } 101137301a55STejun Heo } else if (hpa_sectors < sectors) 101237301a55STejun Heo ata_dev_printk(dev, KERN_WARNING, "%s 1: hpa sectors (%lld) " 101337301a55STejun Heo "is smaller than sectors (%lld)\n", __FUNCTION__, 101437301a55STejun Heo (long long)hpa_sectors, (long long)sectors); 101537301a55STejun Heo 10161e999736SAlan Cox return sectors; 10171e999736SAlan Cox } 10181e999736SAlan Cox 1019c6fd2807SJeff Garzik static u64 ata_id_n_sectors(const u16 *id) 1020c6fd2807SJeff Garzik { 1021c6fd2807SJeff Garzik if (ata_id_has_lba(id)) { 1022c6fd2807SJeff Garzik if (ata_id_has_lba48(id)) 1023c6fd2807SJeff Garzik return ata_id_u64(id, 100); 1024c6fd2807SJeff Garzik else 1025c6fd2807SJeff Garzik return ata_id_u32(id, 60); 1026c6fd2807SJeff Garzik } else { 1027c6fd2807SJeff Garzik if (ata_id_current_chs_valid(id)) 1028c6fd2807SJeff Garzik return ata_id_u32(id, 57); 1029c6fd2807SJeff Garzik else 1030c6fd2807SJeff Garzik return id[1] * id[3] * id[6]; 1031c6fd2807SJeff Garzik } 1032c6fd2807SJeff Garzik } 1033c6fd2807SJeff Garzik 1034c6fd2807SJeff Garzik /** 103510305f0fSAlan * ata_id_to_dma_mode - Identify DMA mode from id block 103610305f0fSAlan * @dev: device to identify 1037cc261267SRandy Dunlap * @unknown: mode to assume if we cannot tell 103810305f0fSAlan * 103910305f0fSAlan * Set up the timing values for the device based upon the identify 104010305f0fSAlan * reported values for the DMA mode. This function is used by drivers 104110305f0fSAlan * which rely upon firmware configured modes, but wish to report the 104210305f0fSAlan * mode correctly when possible. 104310305f0fSAlan * 104410305f0fSAlan * In addition we emit similarly formatted messages to the default 104510305f0fSAlan * ata_dev_set_mode handler, in order to provide consistency of 104610305f0fSAlan * presentation. 104710305f0fSAlan */ 104810305f0fSAlan 104910305f0fSAlan void ata_id_to_dma_mode(struct ata_device *dev, u8 unknown) 105010305f0fSAlan { 105110305f0fSAlan unsigned int mask; 105210305f0fSAlan u8 mode; 105310305f0fSAlan 105410305f0fSAlan /* Pack the DMA modes */ 105510305f0fSAlan mask = ((dev->id[63] >> 8) << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA; 105610305f0fSAlan if (dev->id[53] & 0x04) 105710305f0fSAlan mask |= ((dev->id[88] >> 8) << ATA_SHIFT_UDMA) & ATA_MASK_UDMA; 105810305f0fSAlan 105910305f0fSAlan /* Select the mode in use */ 106010305f0fSAlan mode = ata_xfer_mask2mode(mask); 106110305f0fSAlan 106210305f0fSAlan if (mode != 0) { 106310305f0fSAlan ata_dev_printk(dev, KERN_INFO, "configured for %s\n", 106410305f0fSAlan ata_mode_string(mask)); 106510305f0fSAlan } else { 106610305f0fSAlan /* SWDMA perhaps ? */ 106710305f0fSAlan mode = unknown; 106810305f0fSAlan ata_dev_printk(dev, KERN_INFO, "configured for DMA\n"); 106910305f0fSAlan } 107010305f0fSAlan 107110305f0fSAlan /* Configure the device reporting */ 107210305f0fSAlan dev->xfer_mode = mode; 107310305f0fSAlan dev->xfer_shift = ata_xfer_mode2shift(mode); 107410305f0fSAlan } 107510305f0fSAlan 107610305f0fSAlan /** 1077c6fd2807SJeff Garzik * ata_noop_dev_select - Select device 0/1 on ATA bus 1078c6fd2807SJeff Garzik * @ap: ATA channel to manipulate 1079c6fd2807SJeff Garzik * @device: ATA device (numbered from zero) to select 1080c6fd2807SJeff Garzik * 1081c6fd2807SJeff Garzik * This function performs no actual function. 1082c6fd2807SJeff Garzik * 1083c6fd2807SJeff Garzik * May be used as the dev_select() entry in ata_port_operations. 1084c6fd2807SJeff Garzik * 1085c6fd2807SJeff Garzik * LOCKING: 1086c6fd2807SJeff Garzik * caller. 1087c6fd2807SJeff Garzik */ 1088c6fd2807SJeff Garzik void ata_noop_dev_select (struct ata_port *ap, unsigned int device) 1089c6fd2807SJeff Garzik { 1090c6fd2807SJeff Garzik } 1091c6fd2807SJeff Garzik 1092c6fd2807SJeff Garzik 1093c6fd2807SJeff Garzik /** 1094c6fd2807SJeff Garzik * ata_std_dev_select - Select device 0/1 on ATA bus 1095c6fd2807SJeff Garzik * @ap: ATA channel to manipulate 1096c6fd2807SJeff Garzik * @device: ATA device (numbered from zero) to select 1097c6fd2807SJeff Garzik * 1098c6fd2807SJeff Garzik * Use the method defined in the ATA specification to 1099c6fd2807SJeff Garzik * make either device 0, or device 1, active on the 1100c6fd2807SJeff Garzik * ATA channel. Works with both PIO and MMIO. 1101c6fd2807SJeff Garzik * 1102c6fd2807SJeff Garzik * May be used as the dev_select() entry in ata_port_operations. 1103c6fd2807SJeff Garzik * 1104c6fd2807SJeff Garzik * LOCKING: 1105c6fd2807SJeff Garzik * caller. 1106c6fd2807SJeff Garzik */ 1107c6fd2807SJeff Garzik 1108c6fd2807SJeff Garzik void ata_std_dev_select (struct ata_port *ap, unsigned int device) 1109c6fd2807SJeff Garzik { 1110c6fd2807SJeff Garzik u8 tmp; 1111c6fd2807SJeff Garzik 1112c6fd2807SJeff Garzik if (device == 0) 1113c6fd2807SJeff Garzik tmp = ATA_DEVICE_OBS; 1114c6fd2807SJeff Garzik else 1115c6fd2807SJeff Garzik tmp = ATA_DEVICE_OBS | ATA_DEV1; 1116c6fd2807SJeff Garzik 11170d5ff566STejun Heo iowrite8(tmp, ap->ioaddr.device_addr); 1118c6fd2807SJeff Garzik ata_pause(ap); /* needed; also flushes, for mmio */ 1119c6fd2807SJeff Garzik } 1120c6fd2807SJeff Garzik 1121c6fd2807SJeff Garzik /** 1122c6fd2807SJeff Garzik * ata_dev_select - Select device 0/1 on ATA bus 1123c6fd2807SJeff Garzik * @ap: ATA channel to manipulate 1124c6fd2807SJeff Garzik * @device: ATA device (numbered from zero) to select 1125c6fd2807SJeff Garzik * @wait: non-zero to wait for Status register BSY bit to clear 1126c6fd2807SJeff Garzik * @can_sleep: non-zero if context allows sleeping 1127c6fd2807SJeff Garzik * 1128c6fd2807SJeff Garzik * Use the method defined in the ATA specification to 1129c6fd2807SJeff Garzik * make either device 0, or device 1, active on the 1130c6fd2807SJeff Garzik * ATA channel. 1131c6fd2807SJeff Garzik * 1132c6fd2807SJeff Garzik * This is a high-level version of ata_std_dev_select(), 1133c6fd2807SJeff Garzik * which additionally provides the services of inserting 1134c6fd2807SJeff Garzik * the proper pauses and status polling, where needed. 1135c6fd2807SJeff Garzik * 1136c6fd2807SJeff Garzik * LOCKING: 1137c6fd2807SJeff Garzik * caller. 1138c6fd2807SJeff Garzik */ 1139c6fd2807SJeff Garzik 1140c6fd2807SJeff Garzik void ata_dev_select(struct ata_port *ap, unsigned int device, 1141c6fd2807SJeff Garzik unsigned int wait, unsigned int can_sleep) 1142c6fd2807SJeff Garzik { 1143c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 114444877b4eSTejun Heo ata_port_printk(ap, KERN_INFO, "ata_dev_select: ENTER, " 114544877b4eSTejun Heo "device %u, wait %u\n", device, wait); 1146c6fd2807SJeff Garzik 1147c6fd2807SJeff Garzik if (wait) 1148c6fd2807SJeff Garzik ata_wait_idle(ap); 1149c6fd2807SJeff Garzik 1150c6fd2807SJeff Garzik ap->ops->dev_select(ap, device); 1151c6fd2807SJeff Garzik 1152c6fd2807SJeff Garzik if (wait) { 11539af5c9c9STejun Heo if (can_sleep && ap->link.device[device].class == ATA_DEV_ATAPI) 1154c6fd2807SJeff Garzik msleep(150); 1155c6fd2807SJeff Garzik ata_wait_idle(ap); 1156c6fd2807SJeff Garzik } 1157c6fd2807SJeff Garzik } 1158c6fd2807SJeff Garzik 1159c6fd2807SJeff Garzik /** 1160c6fd2807SJeff Garzik * ata_dump_id - IDENTIFY DEVICE info debugging output 1161c6fd2807SJeff Garzik * @id: IDENTIFY DEVICE page to dump 1162c6fd2807SJeff Garzik * 1163c6fd2807SJeff Garzik * Dump selected 16-bit words from the given IDENTIFY DEVICE 1164c6fd2807SJeff Garzik * page. 1165c6fd2807SJeff Garzik * 1166c6fd2807SJeff Garzik * LOCKING: 1167c6fd2807SJeff Garzik * caller. 1168c6fd2807SJeff Garzik */ 1169c6fd2807SJeff Garzik 1170c6fd2807SJeff Garzik static inline void ata_dump_id(const u16 *id) 1171c6fd2807SJeff Garzik { 1172c6fd2807SJeff Garzik DPRINTK("49==0x%04x " 1173c6fd2807SJeff Garzik "53==0x%04x " 1174c6fd2807SJeff Garzik "63==0x%04x " 1175c6fd2807SJeff Garzik "64==0x%04x " 1176c6fd2807SJeff Garzik "75==0x%04x \n", 1177c6fd2807SJeff Garzik id[49], 1178c6fd2807SJeff Garzik id[53], 1179c6fd2807SJeff Garzik id[63], 1180c6fd2807SJeff Garzik id[64], 1181c6fd2807SJeff Garzik id[75]); 1182c6fd2807SJeff Garzik DPRINTK("80==0x%04x " 1183c6fd2807SJeff Garzik "81==0x%04x " 1184c6fd2807SJeff Garzik "82==0x%04x " 1185c6fd2807SJeff Garzik "83==0x%04x " 1186c6fd2807SJeff Garzik "84==0x%04x \n", 1187c6fd2807SJeff Garzik id[80], 1188c6fd2807SJeff Garzik id[81], 1189c6fd2807SJeff Garzik id[82], 1190c6fd2807SJeff Garzik id[83], 1191c6fd2807SJeff Garzik id[84]); 1192c6fd2807SJeff Garzik DPRINTK("88==0x%04x " 1193c6fd2807SJeff Garzik "93==0x%04x\n", 1194c6fd2807SJeff Garzik id[88], 1195c6fd2807SJeff Garzik id[93]); 1196c6fd2807SJeff Garzik } 1197c6fd2807SJeff Garzik 1198c6fd2807SJeff Garzik /** 1199c6fd2807SJeff Garzik * ata_id_xfermask - Compute xfermask from the given IDENTIFY data 1200c6fd2807SJeff Garzik * @id: IDENTIFY data to compute xfer mask from 1201c6fd2807SJeff Garzik * 1202c6fd2807SJeff Garzik * Compute the xfermask for this device. This is not as trivial 1203c6fd2807SJeff Garzik * as it seems if we must consider early devices correctly. 1204c6fd2807SJeff Garzik * 1205c6fd2807SJeff Garzik * FIXME: pre IDE drive timing (do we care ?). 1206c6fd2807SJeff Garzik * 1207c6fd2807SJeff Garzik * LOCKING: 1208c6fd2807SJeff Garzik * None. 1209c6fd2807SJeff Garzik * 1210c6fd2807SJeff Garzik * RETURNS: 1211c6fd2807SJeff Garzik * Computed xfermask 1212c6fd2807SJeff Garzik */ 1213c6fd2807SJeff Garzik static unsigned int ata_id_xfermask(const u16 *id) 1214c6fd2807SJeff Garzik { 1215c6fd2807SJeff Garzik unsigned int pio_mask, mwdma_mask, udma_mask; 1216c6fd2807SJeff Garzik 1217c6fd2807SJeff Garzik /* Usual case. Word 53 indicates word 64 is valid */ 1218c6fd2807SJeff Garzik if (id[ATA_ID_FIELD_VALID] & (1 << 1)) { 1219c6fd2807SJeff Garzik pio_mask = id[ATA_ID_PIO_MODES] & 0x03; 1220c6fd2807SJeff Garzik pio_mask <<= 3; 1221c6fd2807SJeff Garzik pio_mask |= 0x7; 1222c6fd2807SJeff Garzik } else { 1223c6fd2807SJeff Garzik /* If word 64 isn't valid then Word 51 high byte holds 1224c6fd2807SJeff Garzik * the PIO timing number for the maximum. Turn it into 1225c6fd2807SJeff Garzik * a mask. 1226c6fd2807SJeff Garzik */ 12277a0f1c8aSLennert Buytenhek u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF; 122846767aebSAlan Cox if (mode < 5) /* Valid PIO range */ 122946767aebSAlan Cox pio_mask = (2 << mode) - 1; 123046767aebSAlan Cox else 123146767aebSAlan Cox pio_mask = 1; 1232c6fd2807SJeff Garzik 1233c6fd2807SJeff Garzik /* But wait.. there's more. Design your standards by 1234c6fd2807SJeff Garzik * committee and you too can get a free iordy field to 1235c6fd2807SJeff Garzik * process. However its the speeds not the modes that 1236c6fd2807SJeff Garzik * are supported... Note drivers using the timing API 1237c6fd2807SJeff Garzik * will get this right anyway 1238c6fd2807SJeff Garzik */ 1239c6fd2807SJeff Garzik } 1240c6fd2807SJeff Garzik 1241c6fd2807SJeff Garzik mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07; 1242c6fd2807SJeff Garzik 1243b352e57dSAlan Cox if (ata_id_is_cfa(id)) { 1244b352e57dSAlan Cox /* 1245b352e57dSAlan Cox * Process compact flash extended modes 1246b352e57dSAlan Cox */ 1247b352e57dSAlan Cox int pio = id[163] & 0x7; 1248b352e57dSAlan Cox int dma = (id[163] >> 3) & 7; 1249b352e57dSAlan Cox 1250b352e57dSAlan Cox if (pio) 1251b352e57dSAlan Cox pio_mask |= (1 << 5); 1252b352e57dSAlan Cox if (pio > 1) 1253b352e57dSAlan Cox pio_mask |= (1 << 6); 1254b352e57dSAlan Cox if (dma) 1255b352e57dSAlan Cox mwdma_mask |= (1 << 3); 1256b352e57dSAlan Cox if (dma > 1) 1257b352e57dSAlan Cox mwdma_mask |= (1 << 4); 1258b352e57dSAlan Cox } 1259b352e57dSAlan Cox 1260c6fd2807SJeff Garzik udma_mask = 0; 1261c6fd2807SJeff Garzik if (id[ATA_ID_FIELD_VALID] & (1 << 2)) 1262c6fd2807SJeff Garzik udma_mask = id[ATA_ID_UDMA_MODES] & 0xff; 1263c6fd2807SJeff Garzik 1264c6fd2807SJeff Garzik return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask); 1265c6fd2807SJeff Garzik } 1266c6fd2807SJeff Garzik 1267c6fd2807SJeff Garzik /** 1268c6fd2807SJeff Garzik * ata_port_queue_task - Queue port_task 1269c6fd2807SJeff Garzik * @ap: The ata_port to queue port_task for 1270c6fd2807SJeff Garzik * @fn: workqueue function to be scheduled 127165f27f38SDavid Howells * @data: data for @fn to use 1272c6fd2807SJeff Garzik * @delay: delay time for workqueue function 1273c6fd2807SJeff Garzik * 1274c6fd2807SJeff Garzik * Schedule @fn(@data) for execution after @delay jiffies using 1275c6fd2807SJeff Garzik * port_task. There is one port_task per port and it's the 1276c6fd2807SJeff Garzik * user(low level driver)'s responsibility to make sure that only 1277c6fd2807SJeff Garzik * one task is active at any given time. 1278c6fd2807SJeff Garzik * 1279c6fd2807SJeff Garzik * libata core layer takes care of synchronization between 1280c6fd2807SJeff Garzik * port_task and EH. ata_port_queue_task() may be ignored for EH 1281c6fd2807SJeff Garzik * synchronization. 1282c6fd2807SJeff Garzik * 1283c6fd2807SJeff Garzik * LOCKING: 1284c6fd2807SJeff Garzik * Inherited from caller. 1285c6fd2807SJeff Garzik */ 128665f27f38SDavid Howells void ata_port_queue_task(struct ata_port *ap, work_func_t fn, void *data, 1287c6fd2807SJeff Garzik unsigned long delay) 1288c6fd2807SJeff Garzik { 128965f27f38SDavid Howells PREPARE_DELAYED_WORK(&ap->port_task, fn); 129065f27f38SDavid Howells ap->port_task_data = data; 1291c6fd2807SJeff Garzik 129245a66c1cSOleg Nesterov /* may fail if ata_port_flush_task() in progress */ 129345a66c1cSOleg Nesterov queue_delayed_work(ata_wq, &ap->port_task, delay); 1294c6fd2807SJeff Garzik } 1295c6fd2807SJeff Garzik 1296c6fd2807SJeff Garzik /** 1297c6fd2807SJeff Garzik * ata_port_flush_task - Flush port_task 1298c6fd2807SJeff Garzik * @ap: The ata_port to flush port_task for 1299c6fd2807SJeff Garzik * 1300c6fd2807SJeff Garzik * After this function completes, port_task is guranteed not to 1301c6fd2807SJeff Garzik * be running or scheduled. 1302c6fd2807SJeff Garzik * 1303c6fd2807SJeff Garzik * LOCKING: 1304c6fd2807SJeff Garzik * Kernel thread context (may sleep) 1305c6fd2807SJeff Garzik */ 1306c6fd2807SJeff Garzik void ata_port_flush_task(struct ata_port *ap) 1307c6fd2807SJeff Garzik { 1308c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 1309c6fd2807SJeff Garzik 131045a66c1cSOleg Nesterov cancel_rearming_delayed_work(&ap->port_task); 1311c6fd2807SJeff Garzik 1312c6fd2807SJeff Garzik if (ata_msg_ctl(ap)) 1313c6fd2807SJeff Garzik ata_port_printk(ap, KERN_DEBUG, "%s: EXIT\n", __FUNCTION__); 1314c6fd2807SJeff Garzik } 1315c6fd2807SJeff Garzik 13167102d230SAdrian Bunk static void ata_qc_complete_internal(struct ata_queued_cmd *qc) 1317c6fd2807SJeff Garzik { 1318c6fd2807SJeff Garzik struct completion *waiting = qc->private_data; 1319c6fd2807SJeff Garzik 1320c6fd2807SJeff Garzik complete(waiting); 1321c6fd2807SJeff Garzik } 1322c6fd2807SJeff Garzik 1323c6fd2807SJeff Garzik /** 13242432697bSTejun Heo * ata_exec_internal_sg - execute libata internal command 1325c6fd2807SJeff Garzik * @dev: Device to which the command is sent 1326c6fd2807SJeff Garzik * @tf: Taskfile registers for the command and the result 1327c6fd2807SJeff Garzik * @cdb: CDB for packet command 1328c6fd2807SJeff Garzik * @dma_dir: Data tranfer direction of the command 13292432697bSTejun Heo * @sg: sg list for the data buffer of the command 13302432697bSTejun Heo * @n_elem: Number of sg entries 1331c6fd2807SJeff Garzik * 1332c6fd2807SJeff Garzik * Executes libata internal command with timeout. @tf contains 1333c6fd2807SJeff Garzik * command on entry and result on return. Timeout and error 1334c6fd2807SJeff Garzik * conditions are reported via return value. No recovery action 1335c6fd2807SJeff Garzik * is taken after a command times out. It's caller's duty to 1336c6fd2807SJeff Garzik * clean up after timeout. 1337c6fd2807SJeff Garzik * 1338c6fd2807SJeff Garzik * LOCKING: 1339c6fd2807SJeff Garzik * None. Should be called with kernel context, might sleep. 1340c6fd2807SJeff Garzik * 1341c6fd2807SJeff Garzik * RETURNS: 1342c6fd2807SJeff Garzik * Zero on success, AC_ERR_* mask on failure 1343c6fd2807SJeff Garzik */ 13442432697bSTejun Heo unsigned ata_exec_internal_sg(struct ata_device *dev, 1345c6fd2807SJeff Garzik struct ata_taskfile *tf, const u8 *cdb, 13462432697bSTejun Heo int dma_dir, struct scatterlist *sg, 13472432697bSTejun Heo unsigned int n_elem) 1348c6fd2807SJeff Garzik { 13499af5c9c9STejun Heo struct ata_link *link = dev->link; 13509af5c9c9STejun Heo struct ata_port *ap = link->ap; 1351c6fd2807SJeff Garzik u8 command = tf->command; 1352c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 1353c6fd2807SJeff Garzik unsigned int tag, preempted_tag; 1354c6fd2807SJeff Garzik u32 preempted_sactive, preempted_qc_active; 1355c6fd2807SJeff Garzik DECLARE_COMPLETION_ONSTACK(wait); 1356c6fd2807SJeff Garzik unsigned long flags; 1357c6fd2807SJeff Garzik unsigned int err_mask; 1358c6fd2807SJeff Garzik int rc; 1359c6fd2807SJeff Garzik 1360c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1361c6fd2807SJeff Garzik 1362c6fd2807SJeff Garzik /* no internal command while frozen */ 1363c6fd2807SJeff Garzik if (ap->pflags & ATA_PFLAG_FROZEN) { 1364c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1365c6fd2807SJeff Garzik return AC_ERR_SYSTEM; 1366c6fd2807SJeff Garzik } 1367c6fd2807SJeff Garzik 1368c6fd2807SJeff Garzik /* initialize internal qc */ 1369c6fd2807SJeff Garzik 1370c6fd2807SJeff Garzik /* XXX: Tag 0 is used for drivers with legacy EH as some 1371c6fd2807SJeff Garzik * drivers choke if any other tag is given. This breaks 1372c6fd2807SJeff Garzik * ata_tag_internal() test for those drivers. Don't use new 1373c6fd2807SJeff Garzik * EH stuff without converting to it. 1374c6fd2807SJeff Garzik */ 1375c6fd2807SJeff Garzik if (ap->ops->error_handler) 1376c6fd2807SJeff Garzik tag = ATA_TAG_INTERNAL; 1377c6fd2807SJeff Garzik else 1378c6fd2807SJeff Garzik tag = 0; 1379c6fd2807SJeff Garzik 1380c6fd2807SJeff Garzik if (test_and_set_bit(tag, &ap->qc_allocated)) 1381c6fd2807SJeff Garzik BUG(); 1382c6fd2807SJeff Garzik qc = __ata_qc_from_tag(ap, tag); 1383c6fd2807SJeff Garzik 1384c6fd2807SJeff Garzik qc->tag = tag; 1385c6fd2807SJeff Garzik qc->scsicmd = NULL; 1386c6fd2807SJeff Garzik qc->ap = ap; 1387c6fd2807SJeff Garzik qc->dev = dev; 1388c6fd2807SJeff Garzik ata_qc_reinit(qc); 1389c6fd2807SJeff Garzik 13909af5c9c9STejun Heo preempted_tag = link->active_tag; 13919af5c9c9STejun Heo preempted_sactive = link->sactive; 1392c6fd2807SJeff Garzik preempted_qc_active = ap->qc_active; 13939af5c9c9STejun Heo link->active_tag = ATA_TAG_POISON; 13949af5c9c9STejun Heo link->sactive = 0; 1395c6fd2807SJeff Garzik ap->qc_active = 0; 1396c6fd2807SJeff Garzik 1397c6fd2807SJeff Garzik /* prepare & issue qc */ 1398c6fd2807SJeff Garzik qc->tf = *tf; 1399c6fd2807SJeff Garzik if (cdb) 1400c6fd2807SJeff Garzik memcpy(qc->cdb, cdb, ATAPI_CDB_LEN); 1401c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_RESULT_TF; 1402c6fd2807SJeff Garzik qc->dma_dir = dma_dir; 1403c6fd2807SJeff Garzik if (dma_dir != DMA_NONE) { 14042432697bSTejun Heo unsigned int i, buflen = 0; 14052432697bSTejun Heo 14062432697bSTejun Heo for (i = 0; i < n_elem; i++) 14072432697bSTejun Heo buflen += sg[i].length; 14082432697bSTejun Heo 14092432697bSTejun Heo ata_sg_init(qc, sg, n_elem); 141049c80429SBrian King qc->nbytes = buflen; 1411c6fd2807SJeff Garzik } 1412c6fd2807SJeff Garzik 1413c6fd2807SJeff Garzik qc->private_data = &wait; 1414c6fd2807SJeff Garzik qc->complete_fn = ata_qc_complete_internal; 1415c6fd2807SJeff Garzik 1416c6fd2807SJeff Garzik ata_qc_issue(qc); 1417c6fd2807SJeff Garzik 1418c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1419c6fd2807SJeff Garzik 1420c6fd2807SJeff Garzik rc = wait_for_completion_timeout(&wait, ata_probe_timeout); 1421c6fd2807SJeff Garzik 1422c6fd2807SJeff Garzik ata_port_flush_task(ap); 1423c6fd2807SJeff Garzik 1424c6fd2807SJeff Garzik if (!rc) { 1425c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1426c6fd2807SJeff Garzik 1427c6fd2807SJeff Garzik /* We're racing with irq here. If we lose, the 1428c6fd2807SJeff Garzik * following test prevents us from completing the qc 1429c6fd2807SJeff Garzik * twice. If we win, the port is frozen and will be 1430c6fd2807SJeff Garzik * cleaned up by ->post_internal_cmd(). 1431c6fd2807SJeff Garzik */ 1432c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_ACTIVE) { 1433c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_TIMEOUT; 1434c6fd2807SJeff Garzik 1435c6fd2807SJeff Garzik if (ap->ops->error_handler) 1436c6fd2807SJeff Garzik ata_port_freeze(ap); 1437c6fd2807SJeff Garzik else 1438c6fd2807SJeff Garzik ata_qc_complete(qc); 1439c6fd2807SJeff Garzik 1440c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 1441c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 1442c6fd2807SJeff Garzik "qc timeout (cmd 0x%x)\n", command); 1443c6fd2807SJeff Garzik } 1444c6fd2807SJeff Garzik 1445c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1446c6fd2807SJeff Garzik } 1447c6fd2807SJeff Garzik 1448c6fd2807SJeff Garzik /* do post_internal_cmd */ 1449c6fd2807SJeff Garzik if (ap->ops->post_internal_cmd) 1450c6fd2807SJeff Garzik ap->ops->post_internal_cmd(qc); 1451c6fd2807SJeff Garzik 1452a51d644aSTejun Heo /* perform minimal error analysis */ 1453a51d644aSTejun Heo if (qc->flags & ATA_QCFLAG_FAILED) { 1454a51d644aSTejun Heo if (qc->result_tf.command & (ATA_ERR | ATA_DF)) 1455a51d644aSTejun Heo qc->err_mask |= AC_ERR_DEV; 1456a51d644aSTejun Heo 1457a51d644aSTejun Heo if (!qc->err_mask) 1458c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_OTHER; 1459a51d644aSTejun Heo 1460a51d644aSTejun Heo if (qc->err_mask & ~AC_ERR_OTHER) 1461a51d644aSTejun Heo qc->err_mask &= ~AC_ERR_OTHER; 1462c6fd2807SJeff Garzik } 1463c6fd2807SJeff Garzik 1464c6fd2807SJeff Garzik /* finish up */ 1465c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1466c6fd2807SJeff Garzik 1467c6fd2807SJeff Garzik *tf = qc->result_tf; 1468c6fd2807SJeff Garzik err_mask = qc->err_mask; 1469c6fd2807SJeff Garzik 1470c6fd2807SJeff Garzik ata_qc_free(qc); 14719af5c9c9STejun Heo link->active_tag = preempted_tag; 14729af5c9c9STejun Heo link->sactive = preempted_sactive; 1473c6fd2807SJeff Garzik ap->qc_active = preempted_qc_active; 1474c6fd2807SJeff Garzik 1475c6fd2807SJeff Garzik /* XXX - Some LLDDs (sata_mv) disable port on command failure. 1476c6fd2807SJeff Garzik * Until those drivers are fixed, we detect the condition 1477c6fd2807SJeff Garzik * here, fail the command with AC_ERR_SYSTEM and reenable the 1478c6fd2807SJeff Garzik * port. 1479c6fd2807SJeff Garzik * 1480c6fd2807SJeff Garzik * Note that this doesn't change any behavior as internal 1481c6fd2807SJeff Garzik * command failure results in disabling the device in the 1482c6fd2807SJeff Garzik * higher layer for LLDDs without new reset/EH callbacks. 1483c6fd2807SJeff Garzik * 1484c6fd2807SJeff Garzik * Kill the following code as soon as those drivers are fixed. 1485c6fd2807SJeff Garzik */ 1486c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_DISABLED) { 1487c6fd2807SJeff Garzik err_mask |= AC_ERR_SYSTEM; 1488c6fd2807SJeff Garzik ata_port_probe(ap); 1489c6fd2807SJeff Garzik } 1490c6fd2807SJeff Garzik 1491c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1492c6fd2807SJeff Garzik 1493c6fd2807SJeff Garzik return err_mask; 1494c6fd2807SJeff Garzik } 1495c6fd2807SJeff Garzik 1496c6fd2807SJeff Garzik /** 149733480a0eSTejun Heo * ata_exec_internal - execute libata internal command 14982432697bSTejun Heo * @dev: Device to which the command is sent 14992432697bSTejun Heo * @tf: Taskfile registers for the command and the result 15002432697bSTejun Heo * @cdb: CDB for packet command 15012432697bSTejun Heo * @dma_dir: Data tranfer direction of the command 15022432697bSTejun Heo * @buf: Data buffer of the command 15032432697bSTejun Heo * @buflen: Length of data buffer 15042432697bSTejun Heo * 15052432697bSTejun Heo * Wrapper around ata_exec_internal_sg() which takes simple 15062432697bSTejun Heo * buffer instead of sg list. 15072432697bSTejun Heo * 15082432697bSTejun Heo * LOCKING: 15092432697bSTejun Heo * None. Should be called with kernel context, might sleep. 15102432697bSTejun Heo * 15112432697bSTejun Heo * RETURNS: 15122432697bSTejun Heo * Zero on success, AC_ERR_* mask on failure 15132432697bSTejun Heo */ 15142432697bSTejun Heo unsigned ata_exec_internal(struct ata_device *dev, 15152432697bSTejun Heo struct ata_taskfile *tf, const u8 *cdb, 15162432697bSTejun Heo int dma_dir, void *buf, unsigned int buflen) 15172432697bSTejun Heo { 151833480a0eSTejun Heo struct scatterlist *psg = NULL, sg; 151933480a0eSTejun Heo unsigned int n_elem = 0; 15202432697bSTejun Heo 152133480a0eSTejun Heo if (dma_dir != DMA_NONE) { 152233480a0eSTejun Heo WARN_ON(!buf); 15232432697bSTejun Heo sg_init_one(&sg, buf, buflen); 152433480a0eSTejun Heo psg = &sg; 152533480a0eSTejun Heo n_elem++; 152633480a0eSTejun Heo } 15272432697bSTejun Heo 152833480a0eSTejun Heo return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem); 15292432697bSTejun Heo } 15302432697bSTejun Heo 15312432697bSTejun Heo /** 1532c6fd2807SJeff Garzik * ata_do_simple_cmd - execute simple internal command 1533c6fd2807SJeff Garzik * @dev: Device to which the command is sent 1534c6fd2807SJeff Garzik * @cmd: Opcode to execute 1535c6fd2807SJeff Garzik * 1536c6fd2807SJeff Garzik * Execute a 'simple' command, that only consists of the opcode 1537c6fd2807SJeff Garzik * 'cmd' itself, without filling any other registers 1538c6fd2807SJeff Garzik * 1539c6fd2807SJeff Garzik * LOCKING: 1540c6fd2807SJeff Garzik * Kernel thread context (may sleep). 1541c6fd2807SJeff Garzik * 1542c6fd2807SJeff Garzik * RETURNS: 1543c6fd2807SJeff Garzik * Zero on success, AC_ERR_* mask on failure 1544c6fd2807SJeff Garzik */ 1545c6fd2807SJeff Garzik unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd) 1546c6fd2807SJeff Garzik { 1547c6fd2807SJeff Garzik struct ata_taskfile tf; 1548c6fd2807SJeff Garzik 1549c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 1550c6fd2807SJeff Garzik 1551c6fd2807SJeff Garzik tf.command = cmd; 1552c6fd2807SJeff Garzik tf.flags |= ATA_TFLAG_DEVICE; 1553c6fd2807SJeff Garzik tf.protocol = ATA_PROT_NODATA; 1554c6fd2807SJeff Garzik 1555c6fd2807SJeff Garzik return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0); 1556c6fd2807SJeff Garzik } 1557c6fd2807SJeff Garzik 1558c6fd2807SJeff Garzik /** 1559c6fd2807SJeff Garzik * ata_pio_need_iordy - check if iordy needed 1560c6fd2807SJeff Garzik * @adev: ATA device 1561c6fd2807SJeff Garzik * 1562c6fd2807SJeff Garzik * Check if the current speed of the device requires IORDY. Used 1563c6fd2807SJeff Garzik * by various controllers for chip configuration. 1564c6fd2807SJeff Garzik */ 1565c6fd2807SJeff Garzik 1566c6fd2807SJeff Garzik unsigned int ata_pio_need_iordy(const struct ata_device *adev) 1567c6fd2807SJeff Garzik { 1568432729f0SAlan Cox /* Controller doesn't support IORDY. Probably a pointless check 1569432729f0SAlan Cox as the caller should know this */ 15709af5c9c9STejun Heo if (adev->link->ap->flags & ATA_FLAG_NO_IORDY) 1571c6fd2807SJeff Garzik return 0; 1572432729f0SAlan Cox /* PIO3 and higher it is mandatory */ 1573432729f0SAlan Cox if (adev->pio_mode > XFER_PIO_2) 1574c6fd2807SJeff Garzik return 1; 1575432729f0SAlan Cox /* We turn it on when possible */ 1576432729f0SAlan Cox if (ata_id_has_iordy(adev->id)) 1577432729f0SAlan Cox return 1; 1578432729f0SAlan Cox return 0; 1579432729f0SAlan Cox } 1580c6fd2807SJeff Garzik 1581432729f0SAlan Cox /** 1582432729f0SAlan Cox * ata_pio_mask_no_iordy - Return the non IORDY mask 1583432729f0SAlan Cox * @adev: ATA device 1584432729f0SAlan Cox * 1585432729f0SAlan Cox * Compute the highest mode possible if we are not using iordy. Return 1586432729f0SAlan Cox * -1 if no iordy mode is available. 1587432729f0SAlan Cox */ 1588432729f0SAlan Cox 1589432729f0SAlan Cox static u32 ata_pio_mask_no_iordy(const struct ata_device *adev) 1590432729f0SAlan Cox { 1591c6fd2807SJeff Garzik /* If we have no drive specific rule, then PIO 2 is non IORDY */ 1592c6fd2807SJeff Garzik if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */ 1593432729f0SAlan Cox u16 pio = adev->id[ATA_ID_EIDE_PIO]; 1594c6fd2807SJeff Garzik /* Is the speed faster than the drive allows non IORDY ? */ 1595c6fd2807SJeff Garzik if (pio) { 1596c6fd2807SJeff Garzik /* This is cycle times not frequency - watch the logic! */ 1597c6fd2807SJeff Garzik if (pio > 240) /* PIO2 is 240nS per cycle */ 1598432729f0SAlan Cox return 3 << ATA_SHIFT_PIO; 1599432729f0SAlan Cox return 7 << ATA_SHIFT_PIO; 1600c6fd2807SJeff Garzik } 1601c6fd2807SJeff Garzik } 1602432729f0SAlan Cox return 3 << ATA_SHIFT_PIO; 1603c6fd2807SJeff Garzik } 1604c6fd2807SJeff Garzik 1605c6fd2807SJeff Garzik /** 1606c6fd2807SJeff Garzik * ata_dev_read_id - Read ID data from the specified device 1607c6fd2807SJeff Garzik * @dev: target device 1608c6fd2807SJeff Garzik * @p_class: pointer to class of the target device (may be changed) 1609bff04647STejun Heo * @flags: ATA_READID_* flags 1610c6fd2807SJeff Garzik * @id: buffer to read IDENTIFY data into 1611c6fd2807SJeff Garzik * 1612c6fd2807SJeff Garzik * Read ID data from the specified device. ATA_CMD_ID_ATA is 1613c6fd2807SJeff Garzik * performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI 1614c6fd2807SJeff Garzik * devices. This function also issues ATA_CMD_INIT_DEV_PARAMS 1615c6fd2807SJeff Garzik * for pre-ATA4 drives. 1616c6fd2807SJeff Garzik * 1617c6fd2807SJeff Garzik * LOCKING: 1618c6fd2807SJeff Garzik * Kernel thread context (may sleep) 1619c6fd2807SJeff Garzik * 1620c6fd2807SJeff Garzik * RETURNS: 1621c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 1622c6fd2807SJeff Garzik */ 1623c6fd2807SJeff Garzik int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class, 1624bff04647STejun Heo unsigned int flags, u16 *id) 1625c6fd2807SJeff Garzik { 16269af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 1627c6fd2807SJeff Garzik unsigned int class = *p_class; 1628c6fd2807SJeff Garzik struct ata_taskfile tf; 1629c6fd2807SJeff Garzik unsigned int err_mask = 0; 1630c6fd2807SJeff Garzik const char *reason; 163154936f8bSTejun Heo int may_fallback = 1, tried_spinup = 0; 1632c6fd2807SJeff Garzik int rc; 1633c6fd2807SJeff Garzik 1634c6fd2807SJeff Garzik if (ata_msg_ctl(ap)) 163544877b4eSTejun Heo ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __FUNCTION__); 1636c6fd2807SJeff Garzik 1637c6fd2807SJeff Garzik ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */ 1638c6fd2807SJeff Garzik retry: 1639c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 1640c6fd2807SJeff Garzik 1641c6fd2807SJeff Garzik switch (class) { 1642c6fd2807SJeff Garzik case ATA_DEV_ATA: 1643c6fd2807SJeff Garzik tf.command = ATA_CMD_ID_ATA; 1644c6fd2807SJeff Garzik break; 1645c6fd2807SJeff Garzik case ATA_DEV_ATAPI: 1646c6fd2807SJeff Garzik tf.command = ATA_CMD_ID_ATAPI; 1647c6fd2807SJeff Garzik break; 1648c6fd2807SJeff Garzik default: 1649c6fd2807SJeff Garzik rc = -ENODEV; 1650c6fd2807SJeff Garzik reason = "unsupported class"; 1651c6fd2807SJeff Garzik goto err_out; 1652c6fd2807SJeff Garzik } 1653c6fd2807SJeff Garzik 1654c6fd2807SJeff Garzik tf.protocol = ATA_PROT_PIO; 165581afe893STejun Heo 165681afe893STejun Heo /* Some devices choke if TF registers contain garbage. Make 165781afe893STejun Heo * sure those are properly initialized. 165881afe893STejun Heo */ 165981afe893STejun Heo tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 166081afe893STejun Heo 166181afe893STejun Heo /* Device presence detection is unreliable on some 166281afe893STejun Heo * controllers. Always poll IDENTIFY if available. 166381afe893STejun Heo */ 166481afe893STejun Heo tf.flags |= ATA_TFLAG_POLLING; 1665c6fd2807SJeff Garzik 1666c6fd2807SJeff Garzik err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE, 1667c6fd2807SJeff Garzik id, sizeof(id[0]) * ATA_ID_WORDS); 1668c6fd2807SJeff Garzik if (err_mask) { 1669800b3996STejun Heo if (err_mask & AC_ERR_NODEV_HINT) { 167055a8e2c8STejun Heo DPRINTK("ata%u.%d: NODEV after polling detection\n", 167144877b4eSTejun Heo ap->print_id, dev->devno); 167255a8e2c8STejun Heo return -ENOENT; 167355a8e2c8STejun Heo } 167455a8e2c8STejun Heo 167554936f8bSTejun Heo /* Device or controller might have reported the wrong 167654936f8bSTejun Heo * device class. Give a shot at the other IDENTIFY if 167754936f8bSTejun Heo * the current one is aborted by the device. 167854936f8bSTejun Heo */ 167954936f8bSTejun Heo if (may_fallback && 168054936f8bSTejun Heo (err_mask == AC_ERR_DEV) && (tf.feature & ATA_ABORTED)) { 168154936f8bSTejun Heo may_fallback = 0; 168254936f8bSTejun Heo 168354936f8bSTejun Heo if (class == ATA_DEV_ATA) 168454936f8bSTejun Heo class = ATA_DEV_ATAPI; 168554936f8bSTejun Heo else 168654936f8bSTejun Heo class = ATA_DEV_ATA; 168754936f8bSTejun Heo goto retry; 168854936f8bSTejun Heo } 168954936f8bSTejun Heo 1690c6fd2807SJeff Garzik rc = -EIO; 1691c6fd2807SJeff Garzik reason = "I/O error"; 1692c6fd2807SJeff Garzik goto err_out; 1693c6fd2807SJeff Garzik } 1694c6fd2807SJeff Garzik 169554936f8bSTejun Heo /* Falling back doesn't make sense if ID data was read 169654936f8bSTejun Heo * successfully at least once. 169754936f8bSTejun Heo */ 169854936f8bSTejun Heo may_fallback = 0; 169954936f8bSTejun Heo 1700c6fd2807SJeff Garzik swap_buf_le16(id, ATA_ID_WORDS); 1701c6fd2807SJeff Garzik 1702c6fd2807SJeff Garzik /* sanity check */ 1703c6fd2807SJeff Garzik rc = -EINVAL; 17046070068bSAlan Cox reason = "device reports invalid type"; 17054a3381feSJeff Garzik 17064a3381feSJeff Garzik if (class == ATA_DEV_ATA) { 17074a3381feSJeff Garzik if (!ata_id_is_ata(id) && !ata_id_is_cfa(id)) 17084a3381feSJeff Garzik goto err_out; 17094a3381feSJeff Garzik } else { 17104a3381feSJeff Garzik if (ata_id_is_ata(id)) 1711c6fd2807SJeff Garzik goto err_out; 1712c6fd2807SJeff Garzik } 1713c6fd2807SJeff Garzik 1714169439c2SMark Lord if (!tried_spinup && (id[2] == 0x37c8 || id[2] == 0x738c)) { 1715169439c2SMark Lord tried_spinup = 1; 1716169439c2SMark Lord /* 1717169439c2SMark Lord * Drive powered-up in standby mode, and requires a specific 1718169439c2SMark Lord * SET_FEATURES spin-up subcommand before it will accept 1719169439c2SMark Lord * anything other than the original IDENTIFY command. 1720169439c2SMark Lord */ 1721169439c2SMark Lord ata_tf_init(dev, &tf); 1722169439c2SMark Lord tf.command = ATA_CMD_SET_FEATURES; 1723169439c2SMark Lord tf.feature = SETFEATURES_SPINUP; 1724169439c2SMark Lord tf.protocol = ATA_PROT_NODATA; 1725169439c2SMark Lord tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 1726169439c2SMark Lord err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0); 1727fb0582f9SRyan Power if (err_mask && id[2] != 0x738c) { 1728169439c2SMark Lord rc = -EIO; 1729169439c2SMark Lord reason = "SPINUP failed"; 1730169439c2SMark Lord goto err_out; 1731169439c2SMark Lord } 1732169439c2SMark Lord /* 1733169439c2SMark Lord * If the drive initially returned incomplete IDENTIFY info, 1734169439c2SMark Lord * we now must reissue the IDENTIFY command. 1735169439c2SMark Lord */ 1736169439c2SMark Lord if (id[2] == 0x37c8) 1737169439c2SMark Lord goto retry; 1738169439c2SMark Lord } 1739169439c2SMark Lord 1740bff04647STejun Heo if ((flags & ATA_READID_POSTRESET) && class == ATA_DEV_ATA) { 1741c6fd2807SJeff Garzik /* 1742c6fd2807SJeff Garzik * The exact sequence expected by certain pre-ATA4 drives is: 1743c6fd2807SJeff Garzik * SRST RESET 1744c6fd2807SJeff Garzik * IDENTIFY 1745c6fd2807SJeff Garzik * INITIALIZE DEVICE PARAMETERS 1746c6fd2807SJeff Garzik * anything else.. 1747c6fd2807SJeff Garzik * Some drives were very specific about that exact sequence. 1748c6fd2807SJeff Garzik */ 1749c6fd2807SJeff Garzik if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) { 1750c6fd2807SJeff Garzik err_mask = ata_dev_init_params(dev, id[3], id[6]); 1751c6fd2807SJeff Garzik if (err_mask) { 1752c6fd2807SJeff Garzik rc = -EIO; 1753c6fd2807SJeff Garzik reason = "INIT_DEV_PARAMS failed"; 1754c6fd2807SJeff Garzik goto err_out; 1755c6fd2807SJeff Garzik } 1756c6fd2807SJeff Garzik 1757c6fd2807SJeff Garzik /* current CHS translation info (id[53-58]) might be 1758c6fd2807SJeff Garzik * changed. reread the identify device info. 1759c6fd2807SJeff Garzik */ 1760bff04647STejun Heo flags &= ~ATA_READID_POSTRESET; 1761c6fd2807SJeff Garzik goto retry; 1762c6fd2807SJeff Garzik } 1763c6fd2807SJeff Garzik } 1764c6fd2807SJeff Garzik 1765c6fd2807SJeff Garzik *p_class = class; 1766c6fd2807SJeff Garzik 1767c6fd2807SJeff Garzik return 0; 1768c6fd2807SJeff Garzik 1769c6fd2807SJeff Garzik err_out: 1770c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 1771c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "failed to IDENTIFY " 1772c6fd2807SJeff Garzik "(%s, err_mask=0x%x)\n", reason, err_mask); 1773c6fd2807SJeff Garzik return rc; 1774c6fd2807SJeff Garzik } 1775c6fd2807SJeff Garzik 1776c6fd2807SJeff Garzik static inline u8 ata_dev_knobble(struct ata_device *dev) 1777c6fd2807SJeff Garzik { 17789af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 17799af5c9c9STejun Heo return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id))); 1780c6fd2807SJeff Garzik } 1781c6fd2807SJeff Garzik 1782c6fd2807SJeff Garzik static void ata_dev_config_ncq(struct ata_device *dev, 1783c6fd2807SJeff Garzik char *desc, size_t desc_sz) 1784c6fd2807SJeff Garzik { 17859af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 1786c6fd2807SJeff Garzik int hdepth = 0, ddepth = ata_id_queue_depth(dev->id); 1787c6fd2807SJeff Garzik 1788c6fd2807SJeff Garzik if (!ata_id_has_ncq(dev->id)) { 1789c6fd2807SJeff Garzik desc[0] = '\0'; 1790c6fd2807SJeff Garzik return; 1791c6fd2807SJeff Garzik } 179275683fe7STejun Heo if (dev->horkage & ATA_HORKAGE_NONCQ) { 17936919a0a6SAlan Cox snprintf(desc, desc_sz, "NCQ (not used)"); 17946919a0a6SAlan Cox return; 17956919a0a6SAlan Cox } 1796c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_NCQ) { 1797cca3974eSJeff Garzik hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE - 1); 1798c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_NCQ; 1799c6fd2807SJeff Garzik } 1800c6fd2807SJeff Garzik 1801c6fd2807SJeff Garzik if (hdepth >= ddepth) 1802c6fd2807SJeff Garzik snprintf(desc, desc_sz, "NCQ (depth %d)", ddepth); 1803c6fd2807SJeff Garzik else 1804c6fd2807SJeff Garzik snprintf(desc, desc_sz, "NCQ (depth %d/%d)", hdepth, ddepth); 1805c6fd2807SJeff Garzik } 1806c6fd2807SJeff Garzik 1807c6fd2807SJeff Garzik /** 1808c6fd2807SJeff Garzik * ata_dev_configure - Configure the specified ATA/ATAPI device 1809c6fd2807SJeff Garzik * @dev: Target device to configure 1810c6fd2807SJeff Garzik * 1811c6fd2807SJeff Garzik * Configure @dev according to @dev->id. Generic and low-level 1812c6fd2807SJeff Garzik * driver specific fixups are also applied. 1813c6fd2807SJeff Garzik * 1814c6fd2807SJeff Garzik * LOCKING: 1815c6fd2807SJeff Garzik * Kernel thread context (may sleep) 1816c6fd2807SJeff Garzik * 1817c6fd2807SJeff Garzik * RETURNS: 1818c6fd2807SJeff Garzik * 0 on success, -errno otherwise 1819c6fd2807SJeff Garzik */ 1820efdaedc4STejun Heo int ata_dev_configure(struct ata_device *dev) 1821c6fd2807SJeff Garzik { 18229af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 18239af5c9c9STejun Heo struct ata_eh_context *ehc = &dev->link->eh_context; 18246746544cSTejun Heo int print_info = ehc->i.flags & ATA_EHI_PRINTINFO; 1825c6fd2807SJeff Garzik const u16 *id = dev->id; 1826c6fd2807SJeff Garzik unsigned int xfer_mask; 1827b352e57dSAlan Cox char revbuf[7]; /* XYZ-99\0 */ 18283f64f565SEric D. Mudama char fwrevbuf[ATA_ID_FW_REV_LEN+1]; 18293f64f565SEric D. Mudama char modelbuf[ATA_ID_PROD_LEN+1]; 1830c6fd2807SJeff Garzik int rc; 1831c6fd2807SJeff Garzik 1832c6fd2807SJeff Garzik if (!ata_dev_enabled(dev) && ata_msg_info(ap)) { 183344877b4eSTejun Heo ata_dev_printk(dev, KERN_INFO, "%s: ENTER/EXIT -- nodev\n", 183444877b4eSTejun Heo __FUNCTION__); 1835c6fd2807SJeff Garzik return 0; 1836c6fd2807SJeff Garzik } 1837c6fd2807SJeff Garzik 1838c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 183944877b4eSTejun Heo ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __FUNCTION__); 1840c6fd2807SJeff Garzik 184175683fe7STejun Heo /* set horkage */ 184275683fe7STejun Heo dev->horkage |= ata_dev_blacklisted(dev); 184375683fe7STejun Heo 18446746544cSTejun Heo /* let ACPI work its magic */ 18456746544cSTejun Heo rc = ata_acpi_on_devcfg(dev); 18466746544cSTejun Heo if (rc) 18476746544cSTejun Heo return rc; 184808573a86SKristen Carlson Accardi 1849c6fd2807SJeff Garzik /* print device capabilities */ 1850c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 1851c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_DEBUG, 1852c6fd2807SJeff Garzik "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x " 1853c6fd2807SJeff Garzik "85:%04x 86:%04x 87:%04x 88:%04x\n", 1854c6fd2807SJeff Garzik __FUNCTION__, 1855c6fd2807SJeff Garzik id[49], id[82], id[83], id[84], 1856c6fd2807SJeff Garzik id[85], id[86], id[87], id[88]); 1857c6fd2807SJeff Garzik 1858c6fd2807SJeff Garzik /* initialize to-be-configured parameters */ 1859c6fd2807SJeff Garzik dev->flags &= ~ATA_DFLAG_CFG_MASK; 1860c6fd2807SJeff Garzik dev->max_sectors = 0; 1861c6fd2807SJeff Garzik dev->cdb_len = 0; 1862c6fd2807SJeff Garzik dev->n_sectors = 0; 1863c6fd2807SJeff Garzik dev->cylinders = 0; 1864c6fd2807SJeff Garzik dev->heads = 0; 1865c6fd2807SJeff Garzik dev->sectors = 0; 1866c6fd2807SJeff Garzik 1867c6fd2807SJeff Garzik /* 1868c6fd2807SJeff Garzik * common ATA, ATAPI feature tests 1869c6fd2807SJeff Garzik */ 1870c6fd2807SJeff Garzik 1871c6fd2807SJeff Garzik /* find max transfer mode; for printk only */ 1872c6fd2807SJeff Garzik xfer_mask = ata_id_xfermask(id); 1873c6fd2807SJeff Garzik 1874c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 1875c6fd2807SJeff Garzik ata_dump_id(id); 1876c6fd2807SJeff Garzik 1877ef143d57SAlbert Lee /* SCSI only uses 4-char revisions, dump full 8 chars from ATA */ 1878ef143d57SAlbert Lee ata_id_c_string(dev->id, fwrevbuf, ATA_ID_FW_REV, 1879ef143d57SAlbert Lee sizeof(fwrevbuf)); 1880ef143d57SAlbert Lee 1881ef143d57SAlbert Lee ata_id_c_string(dev->id, modelbuf, ATA_ID_PROD, 1882ef143d57SAlbert Lee sizeof(modelbuf)); 1883ef143d57SAlbert Lee 1884c6fd2807SJeff Garzik /* ATA-specific feature tests */ 1885c6fd2807SJeff Garzik if (dev->class == ATA_DEV_ATA) { 1886b352e57dSAlan Cox if (ata_id_is_cfa(id)) { 1887b352e57dSAlan Cox if (id[162] & 1) /* CPRM may make this media unusable */ 188844877b4eSTejun Heo ata_dev_printk(dev, KERN_WARNING, 188944877b4eSTejun Heo "supports DRM functions and may " 189044877b4eSTejun Heo "not be fully accessable.\n"); 1891b352e57dSAlan Cox snprintf(revbuf, 7, "CFA"); 1892b352e57dSAlan Cox } 1893b352e57dSAlan Cox else 1894b352e57dSAlan Cox snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id)); 1895b352e57dSAlan Cox 1896c6fd2807SJeff Garzik dev->n_sectors = ata_id_n_sectors(id); 1897c6fd2807SJeff Garzik 18983f64f565SEric D. Mudama if (dev->id[59] & 0x100) 18993f64f565SEric D. Mudama dev->multi_count = dev->id[59] & 0xff; 19003f64f565SEric D. Mudama 1901c6fd2807SJeff Garzik if (ata_id_has_lba(id)) { 1902c6fd2807SJeff Garzik const char *lba_desc; 1903c6fd2807SJeff Garzik char ncq_desc[20]; 1904c6fd2807SJeff Garzik 1905c6fd2807SJeff Garzik lba_desc = "LBA"; 1906c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_LBA; 1907c6fd2807SJeff Garzik if (ata_id_has_lba48(id)) { 1908c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_LBA48; 1909c6fd2807SJeff Garzik lba_desc = "LBA48"; 19106fc49adbSTejun Heo 19116fc49adbSTejun Heo if (dev->n_sectors >= (1UL << 28) && 19126fc49adbSTejun Heo ata_id_has_flush_ext(id)) 19136fc49adbSTejun Heo dev->flags |= ATA_DFLAG_FLUSH_EXT; 1914c6fd2807SJeff Garzik } 1915c6fd2807SJeff Garzik 191616c55b03STejun Heo if (!(dev->horkage & ATA_HORKAGE_BROKEN_HPA) && 191716c55b03STejun Heo ata_id_hpa_enabled(dev->id)) 19181e999736SAlan Cox dev->n_sectors = ata_hpa_resize(dev); 19191e999736SAlan Cox 1920c6fd2807SJeff Garzik /* config NCQ */ 1921c6fd2807SJeff Garzik ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc)); 1922c6fd2807SJeff Garzik 1923c6fd2807SJeff Garzik /* print device info to dmesg */ 19243f64f565SEric D. Mudama if (ata_msg_drv(ap) && print_info) { 19253f64f565SEric D. Mudama ata_dev_printk(dev, KERN_INFO, 19263f64f565SEric D. Mudama "%s: %s, %s, max %s\n", 19273f64f565SEric D. Mudama revbuf, modelbuf, fwrevbuf, 19283f64f565SEric D. Mudama ata_mode_string(xfer_mask)); 19293f64f565SEric D. Mudama ata_dev_printk(dev, KERN_INFO, 19303f64f565SEric D. Mudama "%Lu sectors, multi %u: %s %s\n", 1931c6fd2807SJeff Garzik (unsigned long long)dev->n_sectors, 19323f64f565SEric D. Mudama dev->multi_count, lba_desc, ncq_desc); 19333f64f565SEric D. Mudama } 1934c6fd2807SJeff Garzik } else { 1935c6fd2807SJeff Garzik /* CHS */ 1936c6fd2807SJeff Garzik 1937c6fd2807SJeff Garzik /* Default translation */ 1938c6fd2807SJeff Garzik dev->cylinders = id[1]; 1939c6fd2807SJeff Garzik dev->heads = id[3]; 1940c6fd2807SJeff Garzik dev->sectors = id[6]; 1941c6fd2807SJeff Garzik 1942c6fd2807SJeff Garzik if (ata_id_current_chs_valid(id)) { 1943c6fd2807SJeff Garzik /* Current CHS translation is valid. */ 1944c6fd2807SJeff Garzik dev->cylinders = id[54]; 1945c6fd2807SJeff Garzik dev->heads = id[55]; 1946c6fd2807SJeff Garzik dev->sectors = id[56]; 1947c6fd2807SJeff Garzik } 1948c6fd2807SJeff Garzik 1949c6fd2807SJeff Garzik /* print device info to dmesg */ 19503f64f565SEric D. Mudama if (ata_msg_drv(ap) && print_info) { 1951c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, 19523f64f565SEric D. Mudama "%s: %s, %s, max %s\n", 19533f64f565SEric D. Mudama revbuf, modelbuf, fwrevbuf, 19543f64f565SEric D. Mudama ata_mode_string(xfer_mask)); 19553f64f565SEric D. Mudama ata_dev_printk(dev, KERN_INFO, 19563f64f565SEric D. Mudama "%Lu sectors, multi %u, CHS %u/%u/%u\n", 19573f64f565SEric D. Mudama (unsigned long long)dev->n_sectors, 19583f64f565SEric D. Mudama dev->multi_count, dev->cylinders, 19593f64f565SEric D. Mudama dev->heads, dev->sectors); 19603f64f565SEric D. Mudama } 1961c6fd2807SJeff Garzik } 1962c6fd2807SJeff Garzik 1963c6fd2807SJeff Garzik dev->cdb_len = 16; 1964c6fd2807SJeff Garzik } 1965c6fd2807SJeff Garzik 1966c6fd2807SJeff Garzik /* ATAPI-specific feature tests */ 1967c6fd2807SJeff Garzik else if (dev->class == ATA_DEV_ATAPI) { 1968c6fd2807SJeff Garzik char *cdb_intr_string = ""; 1969c6fd2807SJeff Garzik 1970c6fd2807SJeff Garzik rc = atapi_cdb_len(id); 1971c6fd2807SJeff Garzik if ((rc < 12) || (rc > ATAPI_CDB_LEN)) { 1972c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 1973c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 1974c6fd2807SJeff Garzik "unsupported CDB len\n"); 1975c6fd2807SJeff Garzik rc = -EINVAL; 1976c6fd2807SJeff Garzik goto err_out_nosup; 1977c6fd2807SJeff Garzik } 1978c6fd2807SJeff Garzik dev->cdb_len = (unsigned int) rc; 1979c6fd2807SJeff Garzik 1980c6fd2807SJeff Garzik if (ata_id_cdb_intr(dev->id)) { 1981c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_CDB_INTR; 1982c6fd2807SJeff Garzik cdb_intr_string = ", CDB intr"; 1983c6fd2807SJeff Garzik } 1984c6fd2807SJeff Garzik 1985c6fd2807SJeff Garzik /* print device info to dmesg */ 1986c6fd2807SJeff Garzik if (ata_msg_drv(ap) && print_info) 1987ef143d57SAlbert Lee ata_dev_printk(dev, KERN_INFO, 1988ef143d57SAlbert Lee "ATAPI: %s, %s, max %s%s\n", 1989ef143d57SAlbert Lee modelbuf, fwrevbuf, 1990c6fd2807SJeff Garzik ata_mode_string(xfer_mask), 1991c6fd2807SJeff Garzik cdb_intr_string); 1992c6fd2807SJeff Garzik } 1993c6fd2807SJeff Garzik 1994914ed354STejun Heo /* determine max_sectors */ 1995914ed354STejun Heo dev->max_sectors = ATA_MAX_SECTORS; 1996914ed354STejun Heo if (dev->flags & ATA_DFLAG_LBA48) 1997914ed354STejun Heo dev->max_sectors = ATA_MAX_SECTORS_LBA48; 1998914ed354STejun Heo 199993590859SAlan Cox if (dev->horkage & ATA_HORKAGE_DIAGNOSTIC) { 200093590859SAlan Cox /* Let the user know. We don't want to disallow opens for 200193590859SAlan Cox rescue purposes, or in case the vendor is just a blithering 200293590859SAlan Cox idiot */ 200393590859SAlan Cox if (print_info) { 200493590859SAlan Cox ata_dev_printk(dev, KERN_WARNING, 200593590859SAlan Cox "Drive reports diagnostics failure. This may indicate a drive\n"); 200693590859SAlan Cox ata_dev_printk(dev, KERN_WARNING, 200793590859SAlan Cox "fault or invalid emulation. Contact drive vendor for information.\n"); 200893590859SAlan Cox } 200993590859SAlan Cox } 201093590859SAlan Cox 2011c6fd2807SJeff Garzik /* limit bridge transfers to udma5, 200 sectors */ 2012c6fd2807SJeff Garzik if (ata_dev_knobble(dev)) { 2013c6fd2807SJeff Garzik if (ata_msg_drv(ap) && print_info) 2014c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, 2015c6fd2807SJeff Garzik "applying bridge limits\n"); 2016c6fd2807SJeff Garzik dev->udma_mask &= ATA_UDMA5; 2017c6fd2807SJeff Garzik dev->max_sectors = ATA_MAX_SECTORS; 2018c6fd2807SJeff Garzik } 2019c6fd2807SJeff Garzik 202075683fe7STejun Heo if (dev->horkage & ATA_HORKAGE_MAX_SEC_128) 202103ec52deSTejun Heo dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128, 202203ec52deSTejun Heo dev->max_sectors); 202318d6e9d5SAlbert Lee 2024c6fd2807SJeff Garzik if (ap->ops->dev_config) 2025cd0d3bbcSAlan ap->ops->dev_config(dev); 2026c6fd2807SJeff Garzik 2027c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 2028c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_DEBUG, "%s: EXIT, drv_stat = 0x%x\n", 2029c6fd2807SJeff Garzik __FUNCTION__, ata_chk_status(ap)); 2030c6fd2807SJeff Garzik return 0; 2031c6fd2807SJeff Garzik 2032c6fd2807SJeff Garzik err_out_nosup: 2033c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 2034c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_DEBUG, 2035c6fd2807SJeff Garzik "%s: EXIT, err\n", __FUNCTION__); 2036c6fd2807SJeff Garzik return rc; 2037c6fd2807SJeff Garzik } 2038c6fd2807SJeff Garzik 2039c6fd2807SJeff Garzik /** 20402e41e8e6SAlan Cox * ata_cable_40wire - return 40 wire cable type 2041be0d18dfSAlan Cox * @ap: port 2042be0d18dfSAlan Cox * 20432e41e8e6SAlan Cox * Helper method for drivers which want to hardwire 40 wire cable 2044be0d18dfSAlan Cox * detection. 2045be0d18dfSAlan Cox */ 2046be0d18dfSAlan Cox 2047be0d18dfSAlan Cox int ata_cable_40wire(struct ata_port *ap) 2048be0d18dfSAlan Cox { 2049be0d18dfSAlan Cox return ATA_CBL_PATA40; 2050be0d18dfSAlan Cox } 2051be0d18dfSAlan Cox 2052be0d18dfSAlan Cox /** 20532e41e8e6SAlan Cox * ata_cable_80wire - return 80 wire cable type 2054be0d18dfSAlan Cox * @ap: port 2055be0d18dfSAlan Cox * 20562e41e8e6SAlan Cox * Helper method for drivers which want to hardwire 80 wire cable 2057be0d18dfSAlan Cox * detection. 2058be0d18dfSAlan Cox */ 2059be0d18dfSAlan Cox 2060be0d18dfSAlan Cox int ata_cable_80wire(struct ata_port *ap) 2061be0d18dfSAlan Cox { 2062be0d18dfSAlan Cox return ATA_CBL_PATA80; 2063be0d18dfSAlan Cox } 2064be0d18dfSAlan Cox 2065be0d18dfSAlan Cox /** 2066be0d18dfSAlan Cox * ata_cable_unknown - return unknown PATA cable. 2067be0d18dfSAlan Cox * @ap: port 2068be0d18dfSAlan Cox * 2069be0d18dfSAlan Cox * Helper method for drivers which have no PATA cable detection. 2070be0d18dfSAlan Cox */ 2071be0d18dfSAlan Cox 2072be0d18dfSAlan Cox int ata_cable_unknown(struct ata_port *ap) 2073be0d18dfSAlan Cox { 2074be0d18dfSAlan Cox return ATA_CBL_PATA_UNK; 2075be0d18dfSAlan Cox } 2076be0d18dfSAlan Cox 2077be0d18dfSAlan Cox /** 2078be0d18dfSAlan Cox * ata_cable_sata - return SATA cable type 2079be0d18dfSAlan Cox * @ap: port 2080be0d18dfSAlan Cox * 2081be0d18dfSAlan Cox * Helper method for drivers which have SATA cables 2082be0d18dfSAlan Cox */ 2083be0d18dfSAlan Cox 2084be0d18dfSAlan Cox int ata_cable_sata(struct ata_port *ap) 2085be0d18dfSAlan Cox { 2086be0d18dfSAlan Cox return ATA_CBL_SATA; 2087be0d18dfSAlan Cox } 2088be0d18dfSAlan Cox 2089be0d18dfSAlan Cox /** 2090c6fd2807SJeff Garzik * ata_bus_probe - Reset and probe ATA bus 2091c6fd2807SJeff Garzik * @ap: Bus to probe 2092c6fd2807SJeff Garzik * 2093c6fd2807SJeff Garzik * Master ATA bus probing function. Initiates a hardware-dependent 2094c6fd2807SJeff Garzik * bus reset, then attempts to identify any devices found on 2095c6fd2807SJeff Garzik * the bus. 2096c6fd2807SJeff Garzik * 2097c6fd2807SJeff Garzik * LOCKING: 2098c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 2099c6fd2807SJeff Garzik * 2100c6fd2807SJeff Garzik * RETURNS: 2101c6fd2807SJeff Garzik * Zero on success, negative errno otherwise. 2102c6fd2807SJeff Garzik */ 2103c6fd2807SJeff Garzik 2104c6fd2807SJeff Garzik int ata_bus_probe(struct ata_port *ap) 2105c6fd2807SJeff Garzik { 2106c6fd2807SJeff Garzik unsigned int classes[ATA_MAX_DEVICES]; 2107c6fd2807SJeff Garzik int tries[ATA_MAX_DEVICES]; 2108f58229f8STejun Heo int rc; 2109c6fd2807SJeff Garzik struct ata_device *dev; 2110c6fd2807SJeff Garzik 2111c6fd2807SJeff Garzik ata_port_probe(ap); 2112c6fd2807SJeff Garzik 2113f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) 2114f58229f8STejun Heo tries[dev->devno] = ATA_PROBE_MAX_TRIES; 2115c6fd2807SJeff Garzik 2116c6fd2807SJeff Garzik retry: 2117c6fd2807SJeff Garzik /* reset and determine device classes */ 2118c6fd2807SJeff Garzik ap->ops->phy_reset(ap); 2119c6fd2807SJeff Garzik 2120f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) { 2121c6fd2807SJeff Garzik if (!(ap->flags & ATA_FLAG_DISABLED) && 2122c6fd2807SJeff Garzik dev->class != ATA_DEV_UNKNOWN) 2123c6fd2807SJeff Garzik classes[dev->devno] = dev->class; 2124c6fd2807SJeff Garzik else 2125c6fd2807SJeff Garzik classes[dev->devno] = ATA_DEV_NONE; 2126c6fd2807SJeff Garzik 2127c6fd2807SJeff Garzik dev->class = ATA_DEV_UNKNOWN; 2128c6fd2807SJeff Garzik } 2129c6fd2807SJeff Garzik 2130c6fd2807SJeff Garzik ata_port_probe(ap); 2131c6fd2807SJeff Garzik 2132c6fd2807SJeff Garzik /* after the reset the device state is PIO 0 and the controller 2133c6fd2807SJeff Garzik state is undefined. Record the mode */ 2134c6fd2807SJeff Garzik 2135f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) 2136f58229f8STejun Heo dev->pio_mode = XFER_PIO_0; 2137c6fd2807SJeff Garzik 2138f31f0cc2SJeff Garzik /* read IDENTIFY page and configure devices. We have to do the identify 2139f31f0cc2SJeff Garzik specific sequence bass-ackwards so that PDIAG- is released by 2140f31f0cc2SJeff Garzik the slave device */ 2141f31f0cc2SJeff Garzik 2142f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) { 2143f58229f8STejun Heo if (tries[dev->devno]) 2144f58229f8STejun Heo dev->class = classes[dev->devno]; 2145c6fd2807SJeff Garzik 2146c6fd2807SJeff Garzik if (!ata_dev_enabled(dev)) 2147c6fd2807SJeff Garzik continue; 2148c6fd2807SJeff Garzik 2149bff04647STejun Heo rc = ata_dev_read_id(dev, &dev->class, ATA_READID_POSTRESET, 2150bff04647STejun Heo dev->id); 2151c6fd2807SJeff Garzik if (rc) 2152c6fd2807SJeff Garzik goto fail; 2153f31f0cc2SJeff Garzik } 2154f31f0cc2SJeff Garzik 2155be0d18dfSAlan Cox /* Now ask for the cable type as PDIAG- should have been released */ 2156be0d18dfSAlan Cox if (ap->ops->cable_detect) 2157be0d18dfSAlan Cox ap->cbl = ap->ops->cable_detect(ap); 2158be0d18dfSAlan Cox 2159f31f0cc2SJeff Garzik /* After the identify sequence we can now set up the devices. We do 2160f31f0cc2SJeff Garzik this in the normal order so that the user doesn't get confused */ 2161f31f0cc2SJeff Garzik 2162f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) { 2163f31f0cc2SJeff Garzik if (!ata_dev_enabled(dev)) 2164f31f0cc2SJeff Garzik continue; 2165c6fd2807SJeff Garzik 21669af5c9c9STejun Heo ap->link.eh_context.i.flags |= ATA_EHI_PRINTINFO; 2167efdaedc4STejun Heo rc = ata_dev_configure(dev); 21689af5c9c9STejun Heo ap->link.eh_context.i.flags &= ~ATA_EHI_PRINTINFO; 2169c6fd2807SJeff Garzik if (rc) 2170c6fd2807SJeff Garzik goto fail; 2171c6fd2807SJeff Garzik } 2172c6fd2807SJeff Garzik 2173c6fd2807SJeff Garzik /* configure transfer mode */ 21740260731fSTejun Heo rc = ata_set_mode(&ap->link, &dev); 21754ae72a1eSTejun Heo if (rc) 2176c6fd2807SJeff Garzik goto fail; 2177c6fd2807SJeff Garzik 2178f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) 2179f58229f8STejun Heo if (ata_dev_enabled(dev)) 2180c6fd2807SJeff Garzik return 0; 2181c6fd2807SJeff Garzik 2182c6fd2807SJeff Garzik /* no device present, disable port */ 2183c6fd2807SJeff Garzik ata_port_disable(ap); 2184c6fd2807SJeff Garzik ap->ops->port_disable(ap); 2185c6fd2807SJeff Garzik return -ENODEV; 2186c6fd2807SJeff Garzik 2187c6fd2807SJeff Garzik fail: 21884ae72a1eSTejun Heo tries[dev->devno]--; 21894ae72a1eSTejun Heo 2190c6fd2807SJeff Garzik switch (rc) { 2191c6fd2807SJeff Garzik case -EINVAL: 21924ae72a1eSTejun Heo /* eeek, something went very wrong, give up */ 2193c6fd2807SJeff Garzik tries[dev->devno] = 0; 2194c6fd2807SJeff Garzik break; 21954ae72a1eSTejun Heo 21964ae72a1eSTejun Heo case -ENODEV: 21974ae72a1eSTejun Heo /* give it just one more chance */ 21984ae72a1eSTejun Heo tries[dev->devno] = min(tries[dev->devno], 1); 2199c6fd2807SJeff Garzik case -EIO: 22004ae72a1eSTejun Heo if (tries[dev->devno] == 1) { 22014ae72a1eSTejun Heo /* This is the last chance, better to slow 22024ae72a1eSTejun Heo * down than lose it. 22034ae72a1eSTejun Heo */ 2204936fd732STejun Heo sata_down_spd_limit(&ap->link); 22054ae72a1eSTejun Heo ata_down_xfermask_limit(dev, ATA_DNXFER_PIO); 22064ae72a1eSTejun Heo } 2207c6fd2807SJeff Garzik } 2208c6fd2807SJeff Garzik 22094ae72a1eSTejun Heo if (!tries[dev->devno]) 2210c6fd2807SJeff Garzik ata_dev_disable(dev); 2211c6fd2807SJeff Garzik 2212c6fd2807SJeff Garzik goto retry; 2213c6fd2807SJeff Garzik } 2214c6fd2807SJeff Garzik 2215c6fd2807SJeff Garzik /** 2216c6fd2807SJeff Garzik * ata_port_probe - Mark port as enabled 2217c6fd2807SJeff Garzik * @ap: Port for which we indicate enablement 2218c6fd2807SJeff Garzik * 2219c6fd2807SJeff Garzik * Modify @ap data structure such that the system 2220c6fd2807SJeff Garzik * thinks that the entire port is enabled. 2221c6fd2807SJeff Garzik * 2222cca3974eSJeff Garzik * LOCKING: host lock, or some other form of 2223c6fd2807SJeff Garzik * serialization. 2224c6fd2807SJeff Garzik */ 2225c6fd2807SJeff Garzik 2226c6fd2807SJeff Garzik void ata_port_probe(struct ata_port *ap) 2227c6fd2807SJeff Garzik { 2228c6fd2807SJeff Garzik ap->flags &= ~ATA_FLAG_DISABLED; 2229c6fd2807SJeff Garzik } 2230c6fd2807SJeff Garzik 2231c6fd2807SJeff Garzik /** 2232c6fd2807SJeff Garzik * sata_print_link_status - Print SATA link status 2233936fd732STejun Heo * @link: SATA link to printk link status about 2234c6fd2807SJeff Garzik * 2235c6fd2807SJeff Garzik * This function prints link speed and status of a SATA link. 2236c6fd2807SJeff Garzik * 2237c6fd2807SJeff Garzik * LOCKING: 2238c6fd2807SJeff Garzik * None. 2239c6fd2807SJeff Garzik */ 2240936fd732STejun Heo void sata_print_link_status(struct ata_link *link) 2241c6fd2807SJeff Garzik { 2242c6fd2807SJeff Garzik u32 sstatus, scontrol, tmp; 2243c6fd2807SJeff Garzik 2244936fd732STejun Heo if (sata_scr_read(link, SCR_STATUS, &sstatus)) 2245c6fd2807SJeff Garzik return; 2246936fd732STejun Heo sata_scr_read(link, SCR_CONTROL, &scontrol); 2247c6fd2807SJeff Garzik 2248936fd732STejun Heo if (ata_link_online(link)) { 2249c6fd2807SJeff Garzik tmp = (sstatus >> 4) & 0xf; 2250936fd732STejun Heo ata_link_printk(link, KERN_INFO, 2251c6fd2807SJeff Garzik "SATA link up %s (SStatus %X SControl %X)\n", 2252c6fd2807SJeff Garzik sata_spd_string(tmp), sstatus, scontrol); 2253c6fd2807SJeff Garzik } else { 2254936fd732STejun Heo ata_link_printk(link, KERN_INFO, 2255c6fd2807SJeff Garzik "SATA link down (SStatus %X SControl %X)\n", 2256c6fd2807SJeff Garzik sstatus, scontrol); 2257c6fd2807SJeff Garzik } 2258c6fd2807SJeff Garzik } 2259c6fd2807SJeff Garzik 2260c6fd2807SJeff Garzik /** 2261c6fd2807SJeff Garzik * __sata_phy_reset - Wake/reset a low-level SATA PHY 2262c6fd2807SJeff Garzik * @ap: SATA port associated with target SATA PHY. 2263c6fd2807SJeff Garzik * 2264c6fd2807SJeff Garzik * This function issues commands to standard SATA Sxxx 2265c6fd2807SJeff Garzik * PHY registers, to wake up the phy (and device), and 2266c6fd2807SJeff Garzik * clear any reset condition. 2267c6fd2807SJeff Garzik * 2268c6fd2807SJeff Garzik * LOCKING: 2269c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 2270c6fd2807SJeff Garzik * 2271c6fd2807SJeff Garzik */ 2272c6fd2807SJeff Garzik void __sata_phy_reset(struct ata_port *ap) 2273c6fd2807SJeff Garzik { 2274936fd732STejun Heo struct ata_link *link = &ap->link; 2275c6fd2807SJeff Garzik unsigned long timeout = jiffies + (HZ * 5); 2276936fd732STejun Heo u32 sstatus; 2277c6fd2807SJeff Garzik 2278c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_SATA_RESET) { 2279c6fd2807SJeff Garzik /* issue phy wake/reset */ 2280936fd732STejun Heo sata_scr_write_flush(link, SCR_CONTROL, 0x301); 2281c6fd2807SJeff Garzik /* Couldn't find anything in SATA I/II specs, but 2282c6fd2807SJeff Garzik * AHCI-1.1 10.4.2 says at least 1 ms. */ 2283c6fd2807SJeff Garzik mdelay(1); 2284c6fd2807SJeff Garzik } 2285c6fd2807SJeff Garzik /* phy wake/clear reset */ 2286936fd732STejun Heo sata_scr_write_flush(link, SCR_CONTROL, 0x300); 2287c6fd2807SJeff Garzik 2288c6fd2807SJeff Garzik /* wait for phy to become ready, if necessary */ 2289c6fd2807SJeff Garzik do { 2290c6fd2807SJeff Garzik msleep(200); 2291936fd732STejun Heo sata_scr_read(link, SCR_STATUS, &sstatus); 2292c6fd2807SJeff Garzik if ((sstatus & 0xf) != 1) 2293c6fd2807SJeff Garzik break; 2294c6fd2807SJeff Garzik } while (time_before(jiffies, timeout)); 2295c6fd2807SJeff Garzik 2296c6fd2807SJeff Garzik /* print link status */ 2297936fd732STejun Heo sata_print_link_status(link); 2298c6fd2807SJeff Garzik 2299c6fd2807SJeff Garzik /* TODO: phy layer with polling, timeouts, etc. */ 2300936fd732STejun Heo if (!ata_link_offline(link)) 2301c6fd2807SJeff Garzik ata_port_probe(ap); 2302c6fd2807SJeff Garzik else 2303c6fd2807SJeff Garzik ata_port_disable(ap); 2304c6fd2807SJeff Garzik 2305c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_DISABLED) 2306c6fd2807SJeff Garzik return; 2307c6fd2807SJeff Garzik 2308c6fd2807SJeff Garzik if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) { 2309c6fd2807SJeff Garzik ata_port_disable(ap); 2310c6fd2807SJeff Garzik return; 2311c6fd2807SJeff Garzik } 2312c6fd2807SJeff Garzik 2313c6fd2807SJeff Garzik ap->cbl = ATA_CBL_SATA; 2314c6fd2807SJeff Garzik } 2315c6fd2807SJeff Garzik 2316c6fd2807SJeff Garzik /** 2317c6fd2807SJeff Garzik * sata_phy_reset - Reset SATA bus. 2318c6fd2807SJeff Garzik * @ap: SATA port associated with target SATA PHY. 2319c6fd2807SJeff Garzik * 2320c6fd2807SJeff Garzik * This function resets the SATA bus, and then probes 2321c6fd2807SJeff Garzik * the bus for devices. 2322c6fd2807SJeff Garzik * 2323c6fd2807SJeff Garzik * LOCKING: 2324c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 2325c6fd2807SJeff Garzik * 2326c6fd2807SJeff Garzik */ 2327c6fd2807SJeff Garzik void sata_phy_reset(struct ata_port *ap) 2328c6fd2807SJeff Garzik { 2329c6fd2807SJeff Garzik __sata_phy_reset(ap); 2330c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_DISABLED) 2331c6fd2807SJeff Garzik return; 2332c6fd2807SJeff Garzik ata_bus_reset(ap); 2333c6fd2807SJeff Garzik } 2334c6fd2807SJeff Garzik 2335c6fd2807SJeff Garzik /** 2336c6fd2807SJeff Garzik * ata_dev_pair - return other device on cable 2337c6fd2807SJeff Garzik * @adev: device 2338c6fd2807SJeff Garzik * 2339c6fd2807SJeff Garzik * Obtain the other device on the same cable, or if none is 2340c6fd2807SJeff Garzik * present NULL is returned 2341c6fd2807SJeff Garzik */ 2342c6fd2807SJeff Garzik 2343c6fd2807SJeff Garzik struct ata_device *ata_dev_pair(struct ata_device *adev) 2344c6fd2807SJeff Garzik { 23459af5c9c9STejun Heo struct ata_link *link = adev->link; 23469af5c9c9STejun Heo struct ata_device *pair = &link->device[1 - adev->devno]; 2347c6fd2807SJeff Garzik if (!ata_dev_enabled(pair)) 2348c6fd2807SJeff Garzik return NULL; 2349c6fd2807SJeff Garzik return pair; 2350c6fd2807SJeff Garzik } 2351c6fd2807SJeff Garzik 2352c6fd2807SJeff Garzik /** 2353c6fd2807SJeff Garzik * ata_port_disable - Disable port. 2354c6fd2807SJeff Garzik * @ap: Port to be disabled. 2355c6fd2807SJeff Garzik * 2356c6fd2807SJeff Garzik * Modify @ap data structure such that the system 2357c6fd2807SJeff Garzik * thinks that the entire port is disabled, and should 2358c6fd2807SJeff Garzik * never attempt to probe or communicate with devices 2359c6fd2807SJeff Garzik * on this port. 2360c6fd2807SJeff Garzik * 2361cca3974eSJeff Garzik * LOCKING: host lock, or some other form of 2362c6fd2807SJeff Garzik * serialization. 2363c6fd2807SJeff Garzik */ 2364c6fd2807SJeff Garzik 2365c6fd2807SJeff Garzik void ata_port_disable(struct ata_port *ap) 2366c6fd2807SJeff Garzik { 23679af5c9c9STejun Heo ap->link.device[0].class = ATA_DEV_NONE; 23689af5c9c9STejun Heo ap->link.device[1].class = ATA_DEV_NONE; 2369c6fd2807SJeff Garzik ap->flags |= ATA_FLAG_DISABLED; 2370c6fd2807SJeff Garzik } 2371c6fd2807SJeff Garzik 2372c6fd2807SJeff Garzik /** 2373c6fd2807SJeff Garzik * sata_down_spd_limit - adjust SATA spd limit downward 2374936fd732STejun Heo * @link: Link to adjust SATA spd limit for 2375c6fd2807SJeff Garzik * 2376936fd732STejun Heo * Adjust SATA spd limit of @link downward. Note that this 2377c6fd2807SJeff Garzik * function only adjusts the limit. The change must be applied 2378c6fd2807SJeff Garzik * using sata_set_spd(). 2379c6fd2807SJeff Garzik * 2380c6fd2807SJeff Garzik * LOCKING: 2381c6fd2807SJeff Garzik * Inherited from caller. 2382c6fd2807SJeff Garzik * 2383c6fd2807SJeff Garzik * RETURNS: 2384c6fd2807SJeff Garzik * 0 on success, negative errno on failure 2385c6fd2807SJeff Garzik */ 2386936fd732STejun Heo int sata_down_spd_limit(struct ata_link *link) 2387c6fd2807SJeff Garzik { 2388c6fd2807SJeff Garzik u32 sstatus, spd, mask; 2389c6fd2807SJeff Garzik int rc, highbit; 2390c6fd2807SJeff Garzik 2391936fd732STejun Heo if (!sata_scr_valid(link)) 2392008a7896STejun Heo return -EOPNOTSUPP; 2393008a7896STejun Heo 2394008a7896STejun Heo /* If SCR can be read, use it to determine the current SPD. 2395936fd732STejun Heo * If not, use cached value in link->sata_spd. 2396008a7896STejun Heo */ 2397936fd732STejun Heo rc = sata_scr_read(link, SCR_STATUS, &sstatus); 2398008a7896STejun Heo if (rc == 0) 2399008a7896STejun Heo spd = (sstatus >> 4) & 0xf; 2400008a7896STejun Heo else 2401936fd732STejun Heo spd = link->sata_spd; 2402c6fd2807SJeff Garzik 2403936fd732STejun Heo mask = link->sata_spd_limit; 2404c6fd2807SJeff Garzik if (mask <= 1) 2405c6fd2807SJeff Garzik return -EINVAL; 2406008a7896STejun Heo 2407008a7896STejun Heo /* unconditionally mask off the highest bit */ 2408c6fd2807SJeff Garzik highbit = fls(mask) - 1; 2409c6fd2807SJeff Garzik mask &= ~(1 << highbit); 2410c6fd2807SJeff Garzik 2411008a7896STejun Heo /* Mask off all speeds higher than or equal to the current 2412008a7896STejun Heo * one. Force 1.5Gbps if current SPD is not available. 2413008a7896STejun Heo */ 2414008a7896STejun Heo if (spd > 1) 2415008a7896STejun Heo mask &= (1 << (spd - 1)) - 1; 2416008a7896STejun Heo else 2417008a7896STejun Heo mask &= 1; 2418008a7896STejun Heo 2419008a7896STejun Heo /* were we already at the bottom? */ 2420c6fd2807SJeff Garzik if (!mask) 2421c6fd2807SJeff Garzik return -EINVAL; 2422c6fd2807SJeff Garzik 2423936fd732STejun Heo link->sata_spd_limit = mask; 2424c6fd2807SJeff Garzik 2425936fd732STejun Heo ata_link_printk(link, KERN_WARNING, "limiting SATA link speed to %s\n", 2426c6fd2807SJeff Garzik sata_spd_string(fls(mask))); 2427c6fd2807SJeff Garzik 2428c6fd2807SJeff Garzik return 0; 2429c6fd2807SJeff Garzik } 2430c6fd2807SJeff Garzik 2431936fd732STejun Heo static int __sata_set_spd_needed(struct ata_link *link, u32 *scontrol) 2432c6fd2807SJeff Garzik { 2433c6fd2807SJeff Garzik u32 spd, limit; 2434c6fd2807SJeff Garzik 2435936fd732STejun Heo if (link->sata_spd_limit == UINT_MAX) 2436c6fd2807SJeff Garzik limit = 0; 2437c6fd2807SJeff Garzik else 2438936fd732STejun Heo limit = fls(link->sata_spd_limit); 2439c6fd2807SJeff Garzik 2440c6fd2807SJeff Garzik spd = (*scontrol >> 4) & 0xf; 2441c6fd2807SJeff Garzik *scontrol = (*scontrol & ~0xf0) | ((limit & 0xf) << 4); 2442c6fd2807SJeff Garzik 2443c6fd2807SJeff Garzik return spd != limit; 2444c6fd2807SJeff Garzik } 2445c6fd2807SJeff Garzik 2446c6fd2807SJeff Garzik /** 2447c6fd2807SJeff Garzik * sata_set_spd_needed - is SATA spd configuration needed 2448936fd732STejun Heo * @link: Link in question 2449c6fd2807SJeff Garzik * 2450c6fd2807SJeff Garzik * Test whether the spd limit in SControl matches 2451936fd732STejun Heo * @link->sata_spd_limit. This function is used to determine 2452c6fd2807SJeff Garzik * whether hardreset is necessary to apply SATA spd 2453c6fd2807SJeff Garzik * configuration. 2454c6fd2807SJeff Garzik * 2455c6fd2807SJeff Garzik * LOCKING: 2456c6fd2807SJeff Garzik * Inherited from caller. 2457c6fd2807SJeff Garzik * 2458c6fd2807SJeff Garzik * RETURNS: 2459c6fd2807SJeff Garzik * 1 if SATA spd configuration is needed, 0 otherwise. 2460c6fd2807SJeff Garzik */ 2461936fd732STejun Heo int sata_set_spd_needed(struct ata_link *link) 2462c6fd2807SJeff Garzik { 2463c6fd2807SJeff Garzik u32 scontrol; 2464c6fd2807SJeff Garzik 2465936fd732STejun Heo if (sata_scr_read(link, SCR_CONTROL, &scontrol)) 2466c6fd2807SJeff Garzik return 0; 2467c6fd2807SJeff Garzik 2468936fd732STejun Heo return __sata_set_spd_needed(link, &scontrol); 2469c6fd2807SJeff Garzik } 2470c6fd2807SJeff Garzik 2471c6fd2807SJeff Garzik /** 2472c6fd2807SJeff Garzik * sata_set_spd - set SATA spd according to spd limit 2473936fd732STejun Heo * @link: Link to set SATA spd for 2474c6fd2807SJeff Garzik * 2475936fd732STejun Heo * Set SATA spd of @link according to sata_spd_limit. 2476c6fd2807SJeff Garzik * 2477c6fd2807SJeff Garzik * LOCKING: 2478c6fd2807SJeff Garzik * Inherited from caller. 2479c6fd2807SJeff Garzik * 2480c6fd2807SJeff Garzik * RETURNS: 2481c6fd2807SJeff Garzik * 0 if spd doesn't need to be changed, 1 if spd has been 2482c6fd2807SJeff Garzik * changed. Negative errno if SCR registers are inaccessible. 2483c6fd2807SJeff Garzik */ 2484936fd732STejun Heo int sata_set_spd(struct ata_link *link) 2485c6fd2807SJeff Garzik { 2486c6fd2807SJeff Garzik u32 scontrol; 2487c6fd2807SJeff Garzik int rc; 2488c6fd2807SJeff Garzik 2489936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 2490c6fd2807SJeff Garzik return rc; 2491c6fd2807SJeff Garzik 2492936fd732STejun Heo if (!__sata_set_spd_needed(link, &scontrol)) 2493c6fd2807SJeff Garzik return 0; 2494c6fd2807SJeff Garzik 2495936fd732STejun Heo if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol))) 2496c6fd2807SJeff Garzik return rc; 2497c6fd2807SJeff Garzik 2498c6fd2807SJeff Garzik return 1; 2499c6fd2807SJeff Garzik } 2500c6fd2807SJeff Garzik 2501c6fd2807SJeff Garzik /* 2502c6fd2807SJeff Garzik * This mode timing computation functionality is ported over from 2503c6fd2807SJeff Garzik * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik 2504c6fd2807SJeff Garzik */ 2505c6fd2807SJeff Garzik /* 2506b352e57dSAlan Cox * PIO 0-4, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds). 2507c6fd2807SJeff Garzik * These were taken from ATA/ATAPI-6 standard, rev 0a, except 2508b352e57dSAlan Cox * for UDMA6, which is currently supported only by Maxtor drives. 2509b352e57dSAlan Cox * 2510b352e57dSAlan Cox * For PIO 5/6 MWDMA 3/4 see the CFA specification 3.0. 2511c6fd2807SJeff Garzik */ 2512c6fd2807SJeff Garzik 2513c6fd2807SJeff Garzik static const struct ata_timing ata_timing[] = { 2514c6fd2807SJeff Garzik 2515c6fd2807SJeff Garzik { XFER_UDMA_6, 0, 0, 0, 0, 0, 0, 0, 15 }, 2516c6fd2807SJeff Garzik { XFER_UDMA_5, 0, 0, 0, 0, 0, 0, 0, 20 }, 2517c6fd2807SJeff Garzik { XFER_UDMA_4, 0, 0, 0, 0, 0, 0, 0, 30 }, 2518c6fd2807SJeff Garzik { XFER_UDMA_3, 0, 0, 0, 0, 0, 0, 0, 45 }, 2519c6fd2807SJeff Garzik 2520b352e57dSAlan Cox { XFER_MW_DMA_4, 25, 0, 0, 0, 55, 20, 80, 0 }, 2521b352e57dSAlan Cox { XFER_MW_DMA_3, 25, 0, 0, 0, 65, 25, 100, 0 }, 2522c6fd2807SJeff Garzik { XFER_UDMA_2, 0, 0, 0, 0, 0, 0, 0, 60 }, 2523c6fd2807SJeff Garzik { XFER_UDMA_1, 0, 0, 0, 0, 0, 0, 0, 80 }, 2524c6fd2807SJeff Garzik { XFER_UDMA_0, 0, 0, 0, 0, 0, 0, 0, 120 }, 2525c6fd2807SJeff Garzik 2526c6fd2807SJeff Garzik /* { XFER_UDMA_SLOW, 0, 0, 0, 0, 0, 0, 0, 150 }, */ 2527c6fd2807SJeff Garzik 2528c6fd2807SJeff Garzik { XFER_MW_DMA_2, 25, 0, 0, 0, 70, 25, 120, 0 }, 2529c6fd2807SJeff Garzik { XFER_MW_DMA_1, 45, 0, 0, 0, 80, 50, 150, 0 }, 2530c6fd2807SJeff Garzik { XFER_MW_DMA_0, 60, 0, 0, 0, 215, 215, 480, 0 }, 2531c6fd2807SJeff Garzik 2532c6fd2807SJeff Garzik { XFER_SW_DMA_2, 60, 0, 0, 0, 120, 120, 240, 0 }, 2533c6fd2807SJeff Garzik { XFER_SW_DMA_1, 90, 0, 0, 0, 240, 240, 480, 0 }, 2534c6fd2807SJeff Garzik { XFER_SW_DMA_0, 120, 0, 0, 0, 480, 480, 960, 0 }, 2535c6fd2807SJeff Garzik 2536b352e57dSAlan Cox { XFER_PIO_6, 10, 55, 20, 80, 55, 20, 80, 0 }, 2537b352e57dSAlan Cox { XFER_PIO_5, 15, 65, 25, 100, 65, 25, 100, 0 }, 2538c6fd2807SJeff Garzik { XFER_PIO_4, 25, 70, 25, 120, 70, 25, 120, 0 }, 2539c6fd2807SJeff Garzik { XFER_PIO_3, 30, 80, 70, 180, 80, 70, 180, 0 }, 2540c6fd2807SJeff Garzik 2541c6fd2807SJeff Garzik { XFER_PIO_2, 30, 290, 40, 330, 100, 90, 240, 0 }, 2542c6fd2807SJeff Garzik { XFER_PIO_1, 50, 290, 93, 383, 125, 100, 383, 0 }, 2543c6fd2807SJeff Garzik { XFER_PIO_0, 70, 290, 240, 600, 165, 150, 600, 0 }, 2544c6fd2807SJeff Garzik 2545c6fd2807SJeff Garzik /* { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960, 0 }, */ 2546c6fd2807SJeff Garzik 2547c6fd2807SJeff Garzik { 0xFF } 2548c6fd2807SJeff Garzik }; 2549c6fd2807SJeff Garzik 2550c6fd2807SJeff Garzik #define ENOUGH(v,unit) (((v)-1)/(unit)+1) 2551c6fd2807SJeff Garzik #define EZ(v,unit) ((v)?ENOUGH(v,unit):0) 2552c6fd2807SJeff Garzik 2553c6fd2807SJeff Garzik static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT) 2554c6fd2807SJeff Garzik { 2555c6fd2807SJeff Garzik q->setup = EZ(t->setup * 1000, T); 2556c6fd2807SJeff Garzik q->act8b = EZ(t->act8b * 1000, T); 2557c6fd2807SJeff Garzik q->rec8b = EZ(t->rec8b * 1000, T); 2558c6fd2807SJeff Garzik q->cyc8b = EZ(t->cyc8b * 1000, T); 2559c6fd2807SJeff Garzik q->active = EZ(t->active * 1000, T); 2560c6fd2807SJeff Garzik q->recover = EZ(t->recover * 1000, T); 2561c6fd2807SJeff Garzik q->cycle = EZ(t->cycle * 1000, T); 2562c6fd2807SJeff Garzik q->udma = EZ(t->udma * 1000, UT); 2563c6fd2807SJeff Garzik } 2564c6fd2807SJeff Garzik 2565c6fd2807SJeff Garzik void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b, 2566c6fd2807SJeff Garzik struct ata_timing *m, unsigned int what) 2567c6fd2807SJeff Garzik { 2568c6fd2807SJeff Garzik if (what & ATA_TIMING_SETUP ) m->setup = max(a->setup, b->setup); 2569c6fd2807SJeff Garzik if (what & ATA_TIMING_ACT8B ) m->act8b = max(a->act8b, b->act8b); 2570c6fd2807SJeff Garzik if (what & ATA_TIMING_REC8B ) m->rec8b = max(a->rec8b, b->rec8b); 2571c6fd2807SJeff Garzik if (what & ATA_TIMING_CYC8B ) m->cyc8b = max(a->cyc8b, b->cyc8b); 2572c6fd2807SJeff Garzik if (what & ATA_TIMING_ACTIVE ) m->active = max(a->active, b->active); 2573c6fd2807SJeff Garzik if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover); 2574c6fd2807SJeff Garzik if (what & ATA_TIMING_CYCLE ) m->cycle = max(a->cycle, b->cycle); 2575c6fd2807SJeff Garzik if (what & ATA_TIMING_UDMA ) m->udma = max(a->udma, b->udma); 2576c6fd2807SJeff Garzik } 2577c6fd2807SJeff Garzik 2578c6fd2807SJeff Garzik static const struct ata_timing* ata_timing_find_mode(unsigned short speed) 2579c6fd2807SJeff Garzik { 2580c6fd2807SJeff Garzik const struct ata_timing *t; 2581c6fd2807SJeff Garzik 2582c6fd2807SJeff Garzik for (t = ata_timing; t->mode != speed; t++) 2583c6fd2807SJeff Garzik if (t->mode == 0xFF) 2584c6fd2807SJeff Garzik return NULL; 2585c6fd2807SJeff Garzik return t; 2586c6fd2807SJeff Garzik } 2587c6fd2807SJeff Garzik 2588c6fd2807SJeff Garzik int ata_timing_compute(struct ata_device *adev, unsigned short speed, 2589c6fd2807SJeff Garzik struct ata_timing *t, int T, int UT) 2590c6fd2807SJeff Garzik { 2591c6fd2807SJeff Garzik const struct ata_timing *s; 2592c6fd2807SJeff Garzik struct ata_timing p; 2593c6fd2807SJeff Garzik 2594c6fd2807SJeff Garzik /* 2595c6fd2807SJeff Garzik * Find the mode. 2596c6fd2807SJeff Garzik */ 2597c6fd2807SJeff Garzik 2598c6fd2807SJeff Garzik if (!(s = ata_timing_find_mode(speed))) 2599c6fd2807SJeff Garzik return -EINVAL; 2600c6fd2807SJeff Garzik 2601c6fd2807SJeff Garzik memcpy(t, s, sizeof(*s)); 2602c6fd2807SJeff Garzik 2603c6fd2807SJeff Garzik /* 2604c6fd2807SJeff Garzik * If the drive is an EIDE drive, it can tell us it needs extended 2605c6fd2807SJeff Garzik * PIO/MW_DMA cycle timing. 2606c6fd2807SJeff Garzik */ 2607c6fd2807SJeff Garzik 2608c6fd2807SJeff Garzik if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */ 2609c6fd2807SJeff Garzik memset(&p, 0, sizeof(p)); 2610c6fd2807SJeff Garzik if(speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) { 2611c6fd2807SJeff Garzik if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO]; 2612c6fd2807SJeff Garzik else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY]; 2613c6fd2807SJeff Garzik } else if(speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) { 2614c6fd2807SJeff Garzik p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN]; 2615c6fd2807SJeff Garzik } 2616c6fd2807SJeff Garzik ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B); 2617c6fd2807SJeff Garzik } 2618c6fd2807SJeff Garzik 2619c6fd2807SJeff Garzik /* 2620c6fd2807SJeff Garzik * Convert the timing to bus clock counts. 2621c6fd2807SJeff Garzik */ 2622c6fd2807SJeff Garzik 2623c6fd2807SJeff Garzik ata_timing_quantize(t, t, T, UT); 2624c6fd2807SJeff Garzik 2625c6fd2807SJeff Garzik /* 2626c6fd2807SJeff Garzik * Even in DMA/UDMA modes we still use PIO access for IDENTIFY, 2627c6fd2807SJeff Garzik * S.M.A.R.T * and some other commands. We have to ensure that the 2628c6fd2807SJeff Garzik * DMA cycle timing is slower/equal than the fastest PIO timing. 2629c6fd2807SJeff Garzik */ 2630c6fd2807SJeff Garzik 2631fd3367afSAlan if (speed > XFER_PIO_6) { 2632c6fd2807SJeff Garzik ata_timing_compute(adev, adev->pio_mode, &p, T, UT); 2633c6fd2807SJeff Garzik ata_timing_merge(&p, t, t, ATA_TIMING_ALL); 2634c6fd2807SJeff Garzik } 2635c6fd2807SJeff Garzik 2636c6fd2807SJeff Garzik /* 2637c6fd2807SJeff Garzik * Lengthen active & recovery time so that cycle time is correct. 2638c6fd2807SJeff Garzik */ 2639c6fd2807SJeff Garzik 2640c6fd2807SJeff Garzik if (t->act8b + t->rec8b < t->cyc8b) { 2641c6fd2807SJeff Garzik t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2; 2642c6fd2807SJeff Garzik t->rec8b = t->cyc8b - t->act8b; 2643c6fd2807SJeff Garzik } 2644c6fd2807SJeff Garzik 2645c6fd2807SJeff Garzik if (t->active + t->recover < t->cycle) { 2646c6fd2807SJeff Garzik t->active += (t->cycle - (t->active + t->recover)) / 2; 2647c6fd2807SJeff Garzik t->recover = t->cycle - t->active; 2648c6fd2807SJeff Garzik } 26494f701d1eSAlan Cox 26504f701d1eSAlan Cox /* In a few cases quantisation may produce enough errors to 26514f701d1eSAlan Cox leave t->cycle too low for the sum of active and recovery 26524f701d1eSAlan Cox if so we must correct this */ 26534f701d1eSAlan Cox if (t->active + t->recover > t->cycle) 26544f701d1eSAlan Cox t->cycle = t->active + t->recover; 2655c6fd2807SJeff Garzik 2656c6fd2807SJeff Garzik return 0; 2657c6fd2807SJeff Garzik } 2658c6fd2807SJeff Garzik 2659c6fd2807SJeff Garzik /** 2660c6fd2807SJeff Garzik * ata_down_xfermask_limit - adjust dev xfer masks downward 2661c6fd2807SJeff Garzik * @dev: Device to adjust xfer masks 2662458337dbSTejun Heo * @sel: ATA_DNXFER_* selector 2663c6fd2807SJeff Garzik * 2664c6fd2807SJeff Garzik * Adjust xfer masks of @dev downward. Note that this function 2665c6fd2807SJeff Garzik * does not apply the change. Invoking ata_set_mode() afterwards 2666c6fd2807SJeff Garzik * will apply the limit. 2667c6fd2807SJeff Garzik * 2668c6fd2807SJeff Garzik * LOCKING: 2669c6fd2807SJeff Garzik * Inherited from caller. 2670c6fd2807SJeff Garzik * 2671c6fd2807SJeff Garzik * RETURNS: 2672c6fd2807SJeff Garzik * 0 on success, negative errno on failure 2673c6fd2807SJeff Garzik */ 2674458337dbSTejun Heo int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel) 2675c6fd2807SJeff Garzik { 2676458337dbSTejun Heo char buf[32]; 2677458337dbSTejun Heo unsigned int orig_mask, xfer_mask; 2678458337dbSTejun Heo unsigned int pio_mask, mwdma_mask, udma_mask; 2679458337dbSTejun Heo int quiet, highbit; 2680c6fd2807SJeff Garzik 2681458337dbSTejun Heo quiet = !!(sel & ATA_DNXFER_QUIET); 2682458337dbSTejun Heo sel &= ~ATA_DNXFER_QUIET; 2683458337dbSTejun Heo 2684458337dbSTejun Heo xfer_mask = orig_mask = ata_pack_xfermask(dev->pio_mask, 2685458337dbSTejun Heo dev->mwdma_mask, 2686c6fd2807SJeff Garzik dev->udma_mask); 2687458337dbSTejun Heo ata_unpack_xfermask(xfer_mask, &pio_mask, &mwdma_mask, &udma_mask); 2688c6fd2807SJeff Garzik 2689458337dbSTejun Heo switch (sel) { 2690458337dbSTejun Heo case ATA_DNXFER_PIO: 2691458337dbSTejun Heo highbit = fls(pio_mask) - 1; 2692458337dbSTejun Heo pio_mask &= ~(1 << highbit); 2693458337dbSTejun Heo break; 2694458337dbSTejun Heo 2695458337dbSTejun Heo case ATA_DNXFER_DMA: 2696458337dbSTejun Heo if (udma_mask) { 2697458337dbSTejun Heo highbit = fls(udma_mask) - 1; 2698458337dbSTejun Heo udma_mask &= ~(1 << highbit); 2699458337dbSTejun Heo if (!udma_mask) 2700458337dbSTejun Heo return -ENOENT; 2701458337dbSTejun Heo } else if (mwdma_mask) { 2702458337dbSTejun Heo highbit = fls(mwdma_mask) - 1; 2703458337dbSTejun Heo mwdma_mask &= ~(1 << highbit); 2704458337dbSTejun Heo if (!mwdma_mask) 2705458337dbSTejun Heo return -ENOENT; 2706458337dbSTejun Heo } 2707458337dbSTejun Heo break; 2708458337dbSTejun Heo 2709458337dbSTejun Heo case ATA_DNXFER_40C: 2710458337dbSTejun Heo udma_mask &= ATA_UDMA_MASK_40C; 2711458337dbSTejun Heo break; 2712458337dbSTejun Heo 2713458337dbSTejun Heo case ATA_DNXFER_FORCE_PIO0: 2714458337dbSTejun Heo pio_mask &= 1; 2715458337dbSTejun Heo case ATA_DNXFER_FORCE_PIO: 2716458337dbSTejun Heo mwdma_mask = 0; 2717458337dbSTejun Heo udma_mask = 0; 2718458337dbSTejun Heo break; 2719458337dbSTejun Heo 2720458337dbSTejun Heo default: 2721458337dbSTejun Heo BUG(); 2722458337dbSTejun Heo } 2723458337dbSTejun Heo 2724458337dbSTejun Heo xfer_mask &= ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask); 2725458337dbSTejun Heo 2726458337dbSTejun Heo if (!(xfer_mask & ATA_MASK_PIO) || xfer_mask == orig_mask) 2727458337dbSTejun Heo return -ENOENT; 2728458337dbSTejun Heo 2729458337dbSTejun Heo if (!quiet) { 2730458337dbSTejun Heo if (xfer_mask & (ATA_MASK_MWDMA | ATA_MASK_UDMA)) 2731458337dbSTejun Heo snprintf(buf, sizeof(buf), "%s:%s", 2732458337dbSTejun Heo ata_mode_string(xfer_mask), 2733458337dbSTejun Heo ata_mode_string(xfer_mask & ATA_MASK_PIO)); 2734458337dbSTejun Heo else 2735458337dbSTejun Heo snprintf(buf, sizeof(buf), "%s", 2736458337dbSTejun Heo ata_mode_string(xfer_mask)); 2737458337dbSTejun Heo 2738458337dbSTejun Heo ata_dev_printk(dev, KERN_WARNING, 2739458337dbSTejun Heo "limiting speed to %s\n", buf); 2740458337dbSTejun Heo } 2741c6fd2807SJeff Garzik 2742c6fd2807SJeff Garzik ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask, 2743c6fd2807SJeff Garzik &dev->udma_mask); 2744c6fd2807SJeff Garzik 2745c6fd2807SJeff Garzik return 0; 2746c6fd2807SJeff Garzik } 2747c6fd2807SJeff Garzik 2748c6fd2807SJeff Garzik static int ata_dev_set_mode(struct ata_device *dev) 2749c6fd2807SJeff Garzik { 27509af5c9c9STejun Heo struct ata_eh_context *ehc = &dev->link->eh_context; 2751c6fd2807SJeff Garzik unsigned int err_mask; 2752c6fd2807SJeff Garzik int rc; 2753c6fd2807SJeff Garzik 2754c6fd2807SJeff Garzik dev->flags &= ~ATA_DFLAG_PIO; 2755c6fd2807SJeff Garzik if (dev->xfer_shift == ATA_SHIFT_PIO) 2756c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_PIO; 2757c6fd2807SJeff Garzik 2758c6fd2807SJeff Garzik err_mask = ata_dev_set_xfermode(dev); 275911750a40SAlan /* Old CFA may refuse this command, which is just fine */ 276011750a40SAlan if (dev->xfer_shift == ATA_SHIFT_PIO && ata_id_is_cfa(dev->id)) 276111750a40SAlan err_mask &= ~AC_ERR_DEV; 2762*0bc2a79aSAlan Cox /* Some very old devices and some bad newer ones fail any kind of 2763*0bc2a79aSAlan Cox SET_XFERMODE request but support PIO0-2 timings and no IORDY */ 2764*0bc2a79aSAlan Cox if (dev->xfer_shift == ATA_SHIFT_PIO && !ata_id_has_iordy(dev->id) && 2765*0bc2a79aSAlan Cox dev->pio_mode <= XFER_PIO_2) 2766*0bc2a79aSAlan Cox err_mask &= ~AC_ERR_DEV; 2767c6fd2807SJeff Garzik if (err_mask) { 2768c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_ERR, "failed to set xfermode " 2769c6fd2807SJeff Garzik "(err_mask=0x%x)\n", err_mask); 2770c6fd2807SJeff Garzik return -EIO; 2771c6fd2807SJeff Garzik } 2772c6fd2807SJeff Garzik 2773baa1e78aSTejun Heo ehc->i.flags |= ATA_EHI_POST_SETMODE; 2774c6fd2807SJeff Garzik rc = ata_dev_revalidate(dev, 0); 2775baa1e78aSTejun Heo ehc->i.flags &= ~ATA_EHI_POST_SETMODE; 2776c6fd2807SJeff Garzik if (rc) 2777c6fd2807SJeff Garzik return rc; 2778c6fd2807SJeff Garzik 2779c6fd2807SJeff Garzik DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n", 2780c6fd2807SJeff Garzik dev->xfer_shift, (int)dev->xfer_mode); 2781c6fd2807SJeff Garzik 2782c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "configured for %s\n", 2783c6fd2807SJeff Garzik ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode))); 2784c6fd2807SJeff Garzik return 0; 2785c6fd2807SJeff Garzik } 2786c6fd2807SJeff Garzik 2787c6fd2807SJeff Garzik /** 278804351821SAlan * ata_do_set_mode - Program timings and issue SET FEATURES - XFER 27890260731fSTejun Heo * @link: link on which timings will be programmed 2790c6fd2807SJeff Garzik * @r_failed_dev: out paramter for failed device 2791c6fd2807SJeff Garzik * 279204351821SAlan * Standard implementation of the function used to tune and set 279304351821SAlan * ATA device disk transfer mode (PIO3, UDMA6, etc.). If 279404351821SAlan * ata_dev_set_mode() fails, pointer to the failing device is 2795c6fd2807SJeff Garzik * returned in @r_failed_dev. 2796c6fd2807SJeff Garzik * 2797c6fd2807SJeff Garzik * LOCKING: 2798c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 2799c6fd2807SJeff Garzik * 2800c6fd2807SJeff Garzik * RETURNS: 2801c6fd2807SJeff Garzik * 0 on success, negative errno otherwise 2802c6fd2807SJeff Garzik */ 280304351821SAlan 28040260731fSTejun Heo int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev) 2805c6fd2807SJeff Garzik { 28060260731fSTejun Heo struct ata_port *ap = link->ap; 2807c6fd2807SJeff Garzik struct ata_device *dev; 2808f58229f8STejun Heo int rc = 0, used_dma = 0, found = 0; 2809c6fd2807SJeff Garzik 2810c6fd2807SJeff Garzik /* step 1: calculate xfer_mask */ 2811f58229f8STejun Heo ata_link_for_each_dev(dev, link) { 2812c6fd2807SJeff Garzik unsigned int pio_mask, dma_mask; 2813c6fd2807SJeff Garzik 2814c6fd2807SJeff Garzik if (!ata_dev_enabled(dev)) 2815c6fd2807SJeff Garzik continue; 2816c6fd2807SJeff Garzik 2817c6fd2807SJeff Garzik ata_dev_xfermask(dev); 2818c6fd2807SJeff Garzik 2819c6fd2807SJeff Garzik pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0); 2820c6fd2807SJeff Garzik dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask); 2821c6fd2807SJeff Garzik dev->pio_mode = ata_xfer_mask2mode(pio_mask); 2822c6fd2807SJeff Garzik dev->dma_mode = ata_xfer_mask2mode(dma_mask); 2823c6fd2807SJeff Garzik 2824c6fd2807SJeff Garzik found = 1; 2825c6fd2807SJeff Garzik if (dev->dma_mode) 2826c6fd2807SJeff Garzik used_dma = 1; 2827c6fd2807SJeff Garzik } 2828c6fd2807SJeff Garzik if (!found) 2829c6fd2807SJeff Garzik goto out; 2830c6fd2807SJeff Garzik 2831c6fd2807SJeff Garzik /* step 2: always set host PIO timings */ 2832f58229f8STejun Heo ata_link_for_each_dev(dev, link) { 2833c6fd2807SJeff Garzik if (!ata_dev_enabled(dev)) 2834c6fd2807SJeff Garzik continue; 2835c6fd2807SJeff Garzik 2836c6fd2807SJeff Garzik if (!dev->pio_mode) { 2837c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "no PIO support\n"); 2838c6fd2807SJeff Garzik rc = -EINVAL; 2839c6fd2807SJeff Garzik goto out; 2840c6fd2807SJeff Garzik } 2841c6fd2807SJeff Garzik 2842c6fd2807SJeff Garzik dev->xfer_mode = dev->pio_mode; 2843c6fd2807SJeff Garzik dev->xfer_shift = ATA_SHIFT_PIO; 2844c6fd2807SJeff Garzik if (ap->ops->set_piomode) 2845c6fd2807SJeff Garzik ap->ops->set_piomode(ap, dev); 2846c6fd2807SJeff Garzik } 2847c6fd2807SJeff Garzik 2848c6fd2807SJeff Garzik /* step 3: set host DMA timings */ 2849f58229f8STejun Heo ata_link_for_each_dev(dev, link) { 2850c6fd2807SJeff Garzik if (!ata_dev_enabled(dev) || !dev->dma_mode) 2851c6fd2807SJeff Garzik continue; 2852c6fd2807SJeff Garzik 2853c6fd2807SJeff Garzik dev->xfer_mode = dev->dma_mode; 2854c6fd2807SJeff Garzik dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode); 2855c6fd2807SJeff Garzik if (ap->ops->set_dmamode) 2856c6fd2807SJeff Garzik ap->ops->set_dmamode(ap, dev); 2857c6fd2807SJeff Garzik } 2858c6fd2807SJeff Garzik 2859c6fd2807SJeff Garzik /* step 4: update devices' xfer mode */ 2860f58229f8STejun Heo ata_link_for_each_dev(dev, link) { 286118d90debSAlan /* don't update suspended devices' xfer mode */ 28629666f400STejun Heo if (!ata_dev_enabled(dev)) 2863c6fd2807SJeff Garzik continue; 2864c6fd2807SJeff Garzik 2865c6fd2807SJeff Garzik rc = ata_dev_set_mode(dev); 2866c6fd2807SJeff Garzik if (rc) 2867c6fd2807SJeff Garzik goto out; 2868c6fd2807SJeff Garzik } 2869c6fd2807SJeff Garzik 2870c6fd2807SJeff Garzik /* Record simplex status. If we selected DMA then the other 2871c6fd2807SJeff Garzik * host channels are not permitted to do so. 2872c6fd2807SJeff Garzik */ 2873cca3974eSJeff Garzik if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX)) 2874032af1ceSAlan ap->host->simplex_claimed = ap; 2875c6fd2807SJeff Garzik 2876c6fd2807SJeff Garzik out: 2877c6fd2807SJeff Garzik if (rc) 2878c6fd2807SJeff Garzik *r_failed_dev = dev; 2879c6fd2807SJeff Garzik return rc; 2880c6fd2807SJeff Garzik } 2881c6fd2807SJeff Garzik 2882c6fd2807SJeff Garzik /** 288304351821SAlan * ata_set_mode - Program timings and issue SET FEATURES - XFER 28840260731fSTejun Heo * @link: link on which timings will be programmed 288504351821SAlan * @r_failed_dev: out paramter for failed device 288604351821SAlan * 288704351821SAlan * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If 288804351821SAlan * ata_set_mode() fails, pointer to the failing device is 288904351821SAlan * returned in @r_failed_dev. 289004351821SAlan * 289104351821SAlan * LOCKING: 289204351821SAlan * PCI/etc. bus probe sem. 289304351821SAlan * 289404351821SAlan * RETURNS: 289504351821SAlan * 0 on success, negative errno otherwise 289604351821SAlan */ 28970260731fSTejun Heo int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev) 289804351821SAlan { 28990260731fSTejun Heo struct ata_port *ap = link->ap; 29000260731fSTejun Heo 290104351821SAlan /* has private set_mode? */ 290204351821SAlan if (ap->ops->set_mode) 29030260731fSTejun Heo return ap->ops->set_mode(link, r_failed_dev); 29040260731fSTejun Heo return ata_do_set_mode(link, r_failed_dev); 290504351821SAlan } 290604351821SAlan 290704351821SAlan /** 2908c6fd2807SJeff Garzik * ata_tf_to_host - issue ATA taskfile to host controller 2909c6fd2807SJeff Garzik * @ap: port to which command is being issued 2910c6fd2807SJeff Garzik * @tf: ATA taskfile register set 2911c6fd2807SJeff Garzik * 2912c6fd2807SJeff Garzik * Issues ATA taskfile register set to ATA host controller, 2913c6fd2807SJeff Garzik * with proper synchronization with interrupt handler and 2914c6fd2807SJeff Garzik * other threads. 2915c6fd2807SJeff Garzik * 2916c6fd2807SJeff Garzik * LOCKING: 2917cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 2918c6fd2807SJeff Garzik */ 2919c6fd2807SJeff Garzik 2920c6fd2807SJeff Garzik static inline void ata_tf_to_host(struct ata_port *ap, 2921c6fd2807SJeff Garzik const struct ata_taskfile *tf) 2922c6fd2807SJeff Garzik { 2923c6fd2807SJeff Garzik ap->ops->tf_load(ap, tf); 2924c6fd2807SJeff Garzik ap->ops->exec_command(ap, tf); 2925c6fd2807SJeff Garzik } 2926c6fd2807SJeff Garzik 2927c6fd2807SJeff Garzik /** 2928c6fd2807SJeff Garzik * ata_busy_sleep - sleep until BSY clears, or timeout 2929c6fd2807SJeff Garzik * @ap: port containing status register to be polled 2930c6fd2807SJeff Garzik * @tmout_pat: impatience timeout 2931c6fd2807SJeff Garzik * @tmout: overall timeout 2932c6fd2807SJeff Garzik * 2933c6fd2807SJeff Garzik * Sleep until ATA Status register bit BSY clears, 2934c6fd2807SJeff Garzik * or a timeout occurs. 2935c6fd2807SJeff Garzik * 2936d1adc1bbSTejun Heo * LOCKING: 2937d1adc1bbSTejun Heo * Kernel thread context (may sleep). 2938d1adc1bbSTejun Heo * 2939d1adc1bbSTejun Heo * RETURNS: 2940d1adc1bbSTejun Heo * 0 on success, -errno otherwise. 2941c6fd2807SJeff Garzik */ 2942d1adc1bbSTejun Heo int ata_busy_sleep(struct ata_port *ap, 2943c6fd2807SJeff Garzik unsigned long tmout_pat, unsigned long tmout) 2944c6fd2807SJeff Garzik { 2945c6fd2807SJeff Garzik unsigned long timer_start, timeout; 2946c6fd2807SJeff Garzik u8 status; 2947c6fd2807SJeff Garzik 2948c6fd2807SJeff Garzik status = ata_busy_wait(ap, ATA_BUSY, 300); 2949c6fd2807SJeff Garzik timer_start = jiffies; 2950c6fd2807SJeff Garzik timeout = timer_start + tmout_pat; 2951d1adc1bbSTejun Heo while (status != 0xff && (status & ATA_BUSY) && 2952d1adc1bbSTejun Heo time_before(jiffies, timeout)) { 2953c6fd2807SJeff Garzik msleep(50); 2954c6fd2807SJeff Garzik status = ata_busy_wait(ap, ATA_BUSY, 3); 2955c6fd2807SJeff Garzik } 2956c6fd2807SJeff Garzik 2957d1adc1bbSTejun Heo if (status != 0xff && (status & ATA_BUSY)) 2958c6fd2807SJeff Garzik ata_port_printk(ap, KERN_WARNING, 295935aa7a43SJeff Garzik "port is slow to respond, please be patient " 296035aa7a43SJeff Garzik "(Status 0x%x)\n", status); 2961c6fd2807SJeff Garzik 2962c6fd2807SJeff Garzik timeout = timer_start + tmout; 2963d1adc1bbSTejun Heo while (status != 0xff && (status & ATA_BUSY) && 2964d1adc1bbSTejun Heo time_before(jiffies, timeout)) { 2965c6fd2807SJeff Garzik msleep(50); 2966c6fd2807SJeff Garzik status = ata_chk_status(ap); 2967c6fd2807SJeff Garzik } 2968c6fd2807SJeff Garzik 2969d1adc1bbSTejun Heo if (status == 0xff) 2970d1adc1bbSTejun Heo return -ENODEV; 2971d1adc1bbSTejun Heo 2972c6fd2807SJeff Garzik if (status & ATA_BUSY) { 2973c6fd2807SJeff Garzik ata_port_printk(ap, KERN_ERR, "port failed to respond " 297435aa7a43SJeff Garzik "(%lu secs, Status 0x%x)\n", 297535aa7a43SJeff Garzik tmout / HZ, status); 2976d1adc1bbSTejun Heo return -EBUSY; 2977c6fd2807SJeff Garzik } 2978c6fd2807SJeff Garzik 2979c6fd2807SJeff Garzik return 0; 2980c6fd2807SJeff Garzik } 2981c6fd2807SJeff Garzik 2982d4b2bab4STejun Heo /** 2983d4b2bab4STejun Heo * ata_wait_ready - sleep until BSY clears, or timeout 2984d4b2bab4STejun Heo * @ap: port containing status register to be polled 2985d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 2986d4b2bab4STejun Heo * 2987d4b2bab4STejun Heo * Sleep until ATA Status register bit BSY clears, or timeout 2988d4b2bab4STejun Heo * occurs. 2989d4b2bab4STejun Heo * 2990d4b2bab4STejun Heo * LOCKING: 2991d4b2bab4STejun Heo * Kernel thread context (may sleep). 2992d4b2bab4STejun Heo * 2993d4b2bab4STejun Heo * RETURNS: 2994d4b2bab4STejun Heo * 0 on success, -errno otherwise. 2995d4b2bab4STejun Heo */ 2996d4b2bab4STejun Heo int ata_wait_ready(struct ata_port *ap, unsigned long deadline) 2997d4b2bab4STejun Heo { 2998d4b2bab4STejun Heo unsigned long start = jiffies; 2999d4b2bab4STejun Heo int warned = 0; 3000d4b2bab4STejun Heo 3001d4b2bab4STejun Heo while (1) { 3002d4b2bab4STejun Heo u8 status = ata_chk_status(ap); 3003d4b2bab4STejun Heo unsigned long now = jiffies; 3004d4b2bab4STejun Heo 3005d4b2bab4STejun Heo if (!(status & ATA_BUSY)) 3006d4b2bab4STejun Heo return 0; 3007936fd732STejun Heo if (!ata_link_online(&ap->link) && status == 0xff) 3008d4b2bab4STejun Heo return -ENODEV; 3009d4b2bab4STejun Heo if (time_after(now, deadline)) 3010d4b2bab4STejun Heo return -EBUSY; 3011d4b2bab4STejun Heo 3012d4b2bab4STejun Heo if (!warned && time_after(now, start + 5 * HZ) && 3013d4b2bab4STejun Heo (deadline - now > 3 * HZ)) { 3014d4b2bab4STejun Heo ata_port_printk(ap, KERN_WARNING, 3015d4b2bab4STejun Heo "port is slow to respond, please be patient " 3016d4b2bab4STejun Heo "(Status 0x%x)\n", status); 3017d4b2bab4STejun Heo warned = 1; 3018d4b2bab4STejun Heo } 3019d4b2bab4STejun Heo 3020d4b2bab4STejun Heo msleep(50); 3021d4b2bab4STejun Heo } 3022d4b2bab4STejun Heo } 3023d4b2bab4STejun Heo 3024d4b2bab4STejun Heo static int ata_bus_post_reset(struct ata_port *ap, unsigned int devmask, 3025d4b2bab4STejun Heo unsigned long deadline) 3026c6fd2807SJeff Garzik { 3027c6fd2807SJeff Garzik struct ata_ioports *ioaddr = &ap->ioaddr; 3028c6fd2807SJeff Garzik unsigned int dev0 = devmask & (1 << 0); 3029c6fd2807SJeff Garzik unsigned int dev1 = devmask & (1 << 1); 30309b89391cSTejun Heo int rc, ret = 0; 3031c6fd2807SJeff Garzik 3032c6fd2807SJeff Garzik /* if device 0 was found in ata_devchk, wait for its 3033c6fd2807SJeff Garzik * BSY bit to clear 3034c6fd2807SJeff Garzik */ 3035d4b2bab4STejun Heo if (dev0) { 3036d4b2bab4STejun Heo rc = ata_wait_ready(ap, deadline); 30379b89391cSTejun Heo if (rc) { 30389b89391cSTejun Heo if (rc != -ENODEV) 3039d4b2bab4STejun Heo return rc; 30409b89391cSTejun Heo ret = rc; 30419b89391cSTejun Heo } 3042d4b2bab4STejun Heo } 3043c6fd2807SJeff Garzik 3044e141d999STejun Heo /* if device 1 was found in ata_devchk, wait for register 3045e141d999STejun Heo * access briefly, then wait for BSY to clear. 3046c6fd2807SJeff Garzik */ 3047e141d999STejun Heo if (dev1) { 3048e141d999STejun Heo int i; 3049c6fd2807SJeff Garzik 3050c6fd2807SJeff Garzik ap->ops->dev_select(ap, 1); 3051e141d999STejun Heo 3052e141d999STejun Heo /* Wait for register access. Some ATAPI devices fail 3053e141d999STejun Heo * to set nsect/lbal after reset, so don't waste too 3054e141d999STejun Heo * much time on it. We're gonna wait for !BSY anyway. 3055e141d999STejun Heo */ 3056e141d999STejun Heo for (i = 0; i < 2; i++) { 3057e141d999STejun Heo u8 nsect, lbal; 3058e141d999STejun Heo 30590d5ff566STejun Heo nsect = ioread8(ioaddr->nsect_addr); 30600d5ff566STejun Heo lbal = ioread8(ioaddr->lbal_addr); 3061c6fd2807SJeff Garzik if ((nsect == 1) && (lbal == 1)) 3062c6fd2807SJeff Garzik break; 3063c6fd2807SJeff Garzik msleep(50); /* give drive a breather */ 3064c6fd2807SJeff Garzik } 3065e141d999STejun Heo 3066d4b2bab4STejun Heo rc = ata_wait_ready(ap, deadline); 30679b89391cSTejun Heo if (rc) { 30689b89391cSTejun Heo if (rc != -ENODEV) 3069d4b2bab4STejun Heo return rc; 30709b89391cSTejun Heo ret = rc; 30719b89391cSTejun Heo } 3072d4b2bab4STejun Heo } 3073c6fd2807SJeff Garzik 3074c6fd2807SJeff Garzik /* is all this really necessary? */ 3075c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 3076c6fd2807SJeff Garzik if (dev1) 3077c6fd2807SJeff Garzik ap->ops->dev_select(ap, 1); 3078c6fd2807SJeff Garzik if (dev0) 3079c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 3080d4b2bab4STejun Heo 30819b89391cSTejun Heo return ret; 3082c6fd2807SJeff Garzik } 3083c6fd2807SJeff Garzik 3084d4b2bab4STejun Heo static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask, 3085d4b2bab4STejun Heo unsigned long deadline) 3086c6fd2807SJeff Garzik { 3087c6fd2807SJeff Garzik struct ata_ioports *ioaddr = &ap->ioaddr; 3088c6fd2807SJeff Garzik 308944877b4eSTejun Heo DPRINTK("ata%u: bus reset via SRST\n", ap->print_id); 3090c6fd2807SJeff Garzik 3091c6fd2807SJeff Garzik /* software reset. causes dev0 to be selected */ 30920d5ff566STejun Heo iowrite8(ap->ctl, ioaddr->ctl_addr); 3093c6fd2807SJeff Garzik udelay(20); /* FIXME: flush */ 30940d5ff566STejun Heo iowrite8(ap->ctl | ATA_SRST, ioaddr->ctl_addr); 3095c6fd2807SJeff Garzik udelay(20); /* FIXME: flush */ 30960d5ff566STejun Heo iowrite8(ap->ctl, ioaddr->ctl_addr); 3097c6fd2807SJeff Garzik 3098c6fd2807SJeff Garzik /* spec mandates ">= 2ms" before checking status. 3099c6fd2807SJeff Garzik * We wait 150ms, because that was the magic delay used for 3100c6fd2807SJeff Garzik * ATAPI devices in Hale Landis's ATADRVR, for the period of time 3101c6fd2807SJeff Garzik * between when the ATA command register is written, and then 3102c6fd2807SJeff Garzik * status is checked. Because waiting for "a while" before 3103c6fd2807SJeff Garzik * checking status is fine, post SRST, we perform this magic 3104c6fd2807SJeff Garzik * delay here as well. 3105c6fd2807SJeff Garzik * 3106c6fd2807SJeff Garzik * Old drivers/ide uses the 2mS rule and then waits for ready 3107c6fd2807SJeff Garzik */ 3108c6fd2807SJeff Garzik msleep(150); 3109c6fd2807SJeff Garzik 3110c6fd2807SJeff Garzik /* Before we perform post reset processing we want to see if 3111c6fd2807SJeff Garzik * the bus shows 0xFF because the odd clown forgets the D7 3112c6fd2807SJeff Garzik * pulldown resistor. 3113c6fd2807SJeff Garzik */ 3114d1adc1bbSTejun Heo if (ata_check_status(ap) == 0xFF) 31159b89391cSTejun Heo return -ENODEV; 3116c6fd2807SJeff Garzik 3117d4b2bab4STejun Heo return ata_bus_post_reset(ap, devmask, deadline); 3118c6fd2807SJeff Garzik } 3119c6fd2807SJeff Garzik 3120c6fd2807SJeff Garzik /** 3121c6fd2807SJeff Garzik * ata_bus_reset - reset host port and associated ATA channel 3122c6fd2807SJeff Garzik * @ap: port to reset 3123c6fd2807SJeff Garzik * 3124c6fd2807SJeff Garzik * This is typically the first time we actually start issuing 3125c6fd2807SJeff Garzik * commands to the ATA channel. We wait for BSY to clear, then 3126c6fd2807SJeff Garzik * issue EXECUTE DEVICE DIAGNOSTIC command, polling for its 3127c6fd2807SJeff Garzik * result. Determine what devices, if any, are on the channel 3128c6fd2807SJeff Garzik * by looking at the device 0/1 error register. Look at the signature 3129c6fd2807SJeff Garzik * stored in each device's taskfile registers, to determine if 3130c6fd2807SJeff Garzik * the device is ATA or ATAPI. 3131c6fd2807SJeff Garzik * 3132c6fd2807SJeff Garzik * LOCKING: 3133c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 3134cca3974eSJeff Garzik * Obtains host lock. 3135c6fd2807SJeff Garzik * 3136c6fd2807SJeff Garzik * SIDE EFFECTS: 3137c6fd2807SJeff Garzik * Sets ATA_FLAG_DISABLED if bus reset fails. 3138c6fd2807SJeff Garzik */ 3139c6fd2807SJeff Garzik 3140c6fd2807SJeff Garzik void ata_bus_reset(struct ata_port *ap) 3141c6fd2807SJeff Garzik { 31429af5c9c9STejun Heo struct ata_device *device = ap->link.device; 3143c6fd2807SJeff Garzik struct ata_ioports *ioaddr = &ap->ioaddr; 3144c6fd2807SJeff Garzik unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS; 3145c6fd2807SJeff Garzik u8 err; 3146c6fd2807SJeff Garzik unsigned int dev0, dev1 = 0, devmask = 0; 31479b89391cSTejun Heo int rc; 3148c6fd2807SJeff Garzik 314944877b4eSTejun Heo DPRINTK("ENTER, host %u, port %u\n", ap->print_id, ap->port_no); 3150c6fd2807SJeff Garzik 3151c6fd2807SJeff Garzik /* determine if device 0/1 are present */ 3152c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_SATA_RESET) 3153c6fd2807SJeff Garzik dev0 = 1; 3154c6fd2807SJeff Garzik else { 3155c6fd2807SJeff Garzik dev0 = ata_devchk(ap, 0); 3156c6fd2807SJeff Garzik if (slave_possible) 3157c6fd2807SJeff Garzik dev1 = ata_devchk(ap, 1); 3158c6fd2807SJeff Garzik } 3159c6fd2807SJeff Garzik 3160c6fd2807SJeff Garzik if (dev0) 3161c6fd2807SJeff Garzik devmask |= (1 << 0); 3162c6fd2807SJeff Garzik if (dev1) 3163c6fd2807SJeff Garzik devmask |= (1 << 1); 3164c6fd2807SJeff Garzik 3165c6fd2807SJeff Garzik /* select device 0 again */ 3166c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 3167c6fd2807SJeff Garzik 3168c6fd2807SJeff Garzik /* issue bus reset */ 31699b89391cSTejun Heo if (ap->flags & ATA_FLAG_SRST) { 31709b89391cSTejun Heo rc = ata_bus_softreset(ap, devmask, jiffies + 40 * HZ); 31719b89391cSTejun Heo if (rc && rc != -ENODEV) 3172c6fd2807SJeff Garzik goto err_out; 31739b89391cSTejun Heo } 3174c6fd2807SJeff Garzik 3175c6fd2807SJeff Garzik /* 3176c6fd2807SJeff Garzik * determine by signature whether we have ATA or ATAPI devices 3177c6fd2807SJeff Garzik */ 31789af5c9c9STejun Heo device[0].class = ata_dev_try_classify(ap, 0, &err); 3179c6fd2807SJeff Garzik if ((slave_possible) && (err != 0x81)) 31809af5c9c9STejun Heo device[1].class = ata_dev_try_classify(ap, 1, &err); 3181c6fd2807SJeff Garzik 3182c6fd2807SJeff Garzik /* is double-select really necessary? */ 31839af5c9c9STejun Heo if (device[1].class != ATA_DEV_NONE) 3184c6fd2807SJeff Garzik ap->ops->dev_select(ap, 1); 31859af5c9c9STejun Heo if (device[0].class != ATA_DEV_NONE) 3186c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 3187c6fd2807SJeff Garzik 3188c6fd2807SJeff Garzik /* if no devices were detected, disable this port */ 31899af5c9c9STejun Heo if ((device[0].class == ATA_DEV_NONE) && 31909af5c9c9STejun Heo (device[1].class == ATA_DEV_NONE)) 3191c6fd2807SJeff Garzik goto err_out; 3192c6fd2807SJeff Garzik 3193c6fd2807SJeff Garzik if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) { 3194c6fd2807SJeff Garzik /* set up device control for ATA_FLAG_SATA_RESET */ 31950d5ff566STejun Heo iowrite8(ap->ctl, ioaddr->ctl_addr); 3196c6fd2807SJeff Garzik } 3197c6fd2807SJeff Garzik 3198c6fd2807SJeff Garzik DPRINTK("EXIT\n"); 3199c6fd2807SJeff Garzik return; 3200c6fd2807SJeff Garzik 3201c6fd2807SJeff Garzik err_out: 3202c6fd2807SJeff Garzik ata_port_printk(ap, KERN_ERR, "disabling port\n"); 3203c6fd2807SJeff Garzik ap->ops->port_disable(ap); 3204c6fd2807SJeff Garzik 3205c6fd2807SJeff Garzik DPRINTK("EXIT\n"); 3206c6fd2807SJeff Garzik } 3207c6fd2807SJeff Garzik 3208c6fd2807SJeff Garzik /** 3209936fd732STejun Heo * sata_link_debounce - debounce SATA phy status 3210936fd732STejun Heo * @link: ATA link to debounce SATA phy status for 3211c6fd2807SJeff Garzik * @params: timing parameters { interval, duratinon, timeout } in msec 3212d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3213c6fd2807SJeff Garzik * 3214936fd732STejun Heo * Make sure SStatus of @link reaches stable state, determined by 3215c6fd2807SJeff Garzik * holding the same value where DET is not 1 for @duration polled 3216c6fd2807SJeff Garzik * every @interval, before @timeout. Timeout constraints the 3217d4b2bab4STejun Heo * beginning of the stable state. Because DET gets stuck at 1 on 3218d4b2bab4STejun Heo * some controllers after hot unplugging, this functions waits 3219c6fd2807SJeff Garzik * until timeout then returns 0 if DET is stable at 1. 3220c6fd2807SJeff Garzik * 3221d4b2bab4STejun Heo * @timeout is further limited by @deadline. The sooner of the 3222d4b2bab4STejun Heo * two is used. 3223d4b2bab4STejun Heo * 3224c6fd2807SJeff Garzik * LOCKING: 3225c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3226c6fd2807SJeff Garzik * 3227c6fd2807SJeff Garzik * RETURNS: 3228c6fd2807SJeff Garzik * 0 on success, -errno on failure. 3229c6fd2807SJeff Garzik */ 3230936fd732STejun Heo int sata_link_debounce(struct ata_link *link, const unsigned long *params, 3231d4b2bab4STejun Heo unsigned long deadline) 3232c6fd2807SJeff Garzik { 3233c6fd2807SJeff Garzik unsigned long interval_msec = params[0]; 3234d4b2bab4STejun Heo unsigned long duration = msecs_to_jiffies(params[1]); 3235d4b2bab4STejun Heo unsigned long last_jiffies, t; 3236c6fd2807SJeff Garzik u32 last, cur; 3237c6fd2807SJeff Garzik int rc; 3238c6fd2807SJeff Garzik 3239d4b2bab4STejun Heo t = jiffies + msecs_to_jiffies(params[2]); 3240d4b2bab4STejun Heo if (time_before(t, deadline)) 3241d4b2bab4STejun Heo deadline = t; 3242d4b2bab4STejun Heo 3243936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_STATUS, &cur))) 3244c6fd2807SJeff Garzik return rc; 3245c6fd2807SJeff Garzik cur &= 0xf; 3246c6fd2807SJeff Garzik 3247c6fd2807SJeff Garzik last = cur; 3248c6fd2807SJeff Garzik last_jiffies = jiffies; 3249c6fd2807SJeff Garzik 3250c6fd2807SJeff Garzik while (1) { 3251c6fd2807SJeff Garzik msleep(interval_msec); 3252936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_STATUS, &cur))) 3253c6fd2807SJeff Garzik return rc; 3254c6fd2807SJeff Garzik cur &= 0xf; 3255c6fd2807SJeff Garzik 3256c6fd2807SJeff Garzik /* DET stable? */ 3257c6fd2807SJeff Garzik if (cur == last) { 3258d4b2bab4STejun Heo if (cur == 1 && time_before(jiffies, deadline)) 3259c6fd2807SJeff Garzik continue; 3260c6fd2807SJeff Garzik if (time_after(jiffies, last_jiffies + duration)) 3261c6fd2807SJeff Garzik return 0; 3262c6fd2807SJeff Garzik continue; 3263c6fd2807SJeff Garzik } 3264c6fd2807SJeff Garzik 3265c6fd2807SJeff Garzik /* unstable, start over */ 3266c6fd2807SJeff Garzik last = cur; 3267c6fd2807SJeff Garzik last_jiffies = jiffies; 3268c6fd2807SJeff Garzik 3269f1545154STejun Heo /* Check deadline. If debouncing failed, return 3270f1545154STejun Heo * -EPIPE to tell upper layer to lower link speed. 3271f1545154STejun Heo */ 3272d4b2bab4STejun Heo if (time_after(jiffies, deadline)) 3273f1545154STejun Heo return -EPIPE; 3274c6fd2807SJeff Garzik } 3275c6fd2807SJeff Garzik } 3276c6fd2807SJeff Garzik 3277c6fd2807SJeff Garzik /** 3278936fd732STejun Heo * sata_link_resume - resume SATA link 3279936fd732STejun Heo * @link: ATA link to resume SATA 3280c6fd2807SJeff Garzik * @params: timing parameters { interval, duratinon, timeout } in msec 3281d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3282c6fd2807SJeff Garzik * 3283936fd732STejun Heo * Resume SATA phy @link and debounce it. 3284c6fd2807SJeff Garzik * 3285c6fd2807SJeff Garzik * LOCKING: 3286c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3287c6fd2807SJeff Garzik * 3288c6fd2807SJeff Garzik * RETURNS: 3289c6fd2807SJeff Garzik * 0 on success, -errno on failure. 3290c6fd2807SJeff Garzik */ 3291936fd732STejun Heo int sata_link_resume(struct ata_link *link, const unsigned long *params, 3292d4b2bab4STejun Heo unsigned long deadline) 3293c6fd2807SJeff Garzik { 3294c6fd2807SJeff Garzik u32 scontrol; 3295c6fd2807SJeff Garzik int rc; 3296c6fd2807SJeff Garzik 3297936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 3298c6fd2807SJeff Garzik return rc; 3299c6fd2807SJeff Garzik 3300c6fd2807SJeff Garzik scontrol = (scontrol & 0x0f0) | 0x300; 3301c6fd2807SJeff Garzik 3302936fd732STejun Heo if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol))) 3303c6fd2807SJeff Garzik return rc; 3304c6fd2807SJeff Garzik 3305c6fd2807SJeff Garzik /* Some PHYs react badly if SStatus is pounded immediately 3306c6fd2807SJeff Garzik * after resuming. Delay 200ms before debouncing. 3307c6fd2807SJeff Garzik */ 3308c6fd2807SJeff Garzik msleep(200); 3309c6fd2807SJeff Garzik 3310936fd732STejun Heo return sata_link_debounce(link, params, deadline); 3311c6fd2807SJeff Garzik } 3312c6fd2807SJeff Garzik 3313c6fd2807SJeff Garzik /** 3314c6fd2807SJeff Garzik * ata_std_prereset - prepare for reset 3315cc0680a5STejun Heo * @link: ATA link to be reset 3316d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3317c6fd2807SJeff Garzik * 3318cc0680a5STejun Heo * @link is about to be reset. Initialize it. Failure from 3319b8cffc6aSTejun Heo * prereset makes libata abort whole reset sequence and give up 3320b8cffc6aSTejun Heo * that port, so prereset should be best-effort. It does its 3321b8cffc6aSTejun Heo * best to prepare for reset sequence but if things go wrong, it 3322b8cffc6aSTejun Heo * should just whine, not fail. 3323c6fd2807SJeff Garzik * 3324c6fd2807SJeff Garzik * LOCKING: 3325c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3326c6fd2807SJeff Garzik * 3327c6fd2807SJeff Garzik * RETURNS: 3328c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 3329c6fd2807SJeff Garzik */ 3330cc0680a5STejun Heo int ata_std_prereset(struct ata_link *link, unsigned long deadline) 3331c6fd2807SJeff Garzik { 3332cc0680a5STejun Heo struct ata_port *ap = link->ap; 3333936fd732STejun Heo struct ata_eh_context *ehc = &link->eh_context; 3334c6fd2807SJeff Garzik const unsigned long *timing = sata_ehc_deb_timing(ehc); 3335c6fd2807SJeff Garzik int rc; 3336c6fd2807SJeff Garzik 333731daabdaSTejun Heo /* handle link resume */ 3338c6fd2807SJeff Garzik if ((ehc->i.flags & ATA_EHI_RESUME_LINK) && 33390c88758bSTejun Heo (link->flags & ATA_LFLAG_HRST_TO_RESUME)) 3340c6fd2807SJeff Garzik ehc->i.action |= ATA_EH_HARDRESET; 3341c6fd2807SJeff Garzik 3342c6fd2807SJeff Garzik /* if we're about to do hardreset, nothing more to do */ 3343c6fd2807SJeff Garzik if (ehc->i.action & ATA_EH_HARDRESET) 3344c6fd2807SJeff Garzik return 0; 3345c6fd2807SJeff Garzik 3346936fd732STejun Heo /* if SATA, resume link */ 3347a16abc0bSTejun Heo if (ap->flags & ATA_FLAG_SATA) { 3348936fd732STejun Heo rc = sata_link_resume(link, timing, deadline); 3349b8cffc6aSTejun Heo /* whine about phy resume failure but proceed */ 3350b8cffc6aSTejun Heo if (rc && rc != -EOPNOTSUPP) 3351cc0680a5STejun Heo ata_link_printk(link, KERN_WARNING, "failed to resume " 3352c6fd2807SJeff Garzik "link for reset (errno=%d)\n", rc); 3353c6fd2807SJeff Garzik } 3354c6fd2807SJeff Garzik 3355c6fd2807SJeff Garzik /* Wait for !BSY if the controller can wait for the first D2H 3356c6fd2807SJeff Garzik * Reg FIS and we don't know that no device is attached. 3357c6fd2807SJeff Garzik */ 33580c88758bSTejun Heo if (!(link->flags & ATA_LFLAG_SKIP_D2H_BSY) && !ata_link_offline(link)) { 3359b8cffc6aSTejun Heo rc = ata_wait_ready(ap, deadline); 33606dffaf61STejun Heo if (rc && rc != -ENODEV) { 3361cc0680a5STejun Heo ata_link_printk(link, KERN_WARNING, "device not ready " 3362b8cffc6aSTejun Heo "(errno=%d), forcing hardreset\n", rc); 3363b8cffc6aSTejun Heo ehc->i.action |= ATA_EH_HARDRESET; 3364b8cffc6aSTejun Heo } 3365b8cffc6aSTejun Heo } 3366c6fd2807SJeff Garzik 3367c6fd2807SJeff Garzik return 0; 3368c6fd2807SJeff Garzik } 3369c6fd2807SJeff Garzik 3370c6fd2807SJeff Garzik /** 3371c6fd2807SJeff Garzik * ata_std_softreset - reset host port via ATA SRST 3372cc0680a5STejun Heo * @link: ATA link to reset 3373c6fd2807SJeff Garzik * @classes: resulting classes of attached devices 3374d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3375c6fd2807SJeff Garzik * 3376c6fd2807SJeff Garzik * Reset host port using ATA SRST. 3377c6fd2807SJeff Garzik * 3378c6fd2807SJeff Garzik * LOCKING: 3379c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3380c6fd2807SJeff Garzik * 3381c6fd2807SJeff Garzik * RETURNS: 3382c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 3383c6fd2807SJeff Garzik */ 3384cc0680a5STejun Heo int ata_std_softreset(struct ata_link *link, unsigned int *classes, 3385d4b2bab4STejun Heo unsigned long deadline) 3386c6fd2807SJeff Garzik { 3387cc0680a5STejun Heo struct ata_port *ap = link->ap; 3388c6fd2807SJeff Garzik unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS; 3389d4b2bab4STejun Heo unsigned int devmask = 0; 3390d4b2bab4STejun Heo int rc; 3391c6fd2807SJeff Garzik u8 err; 3392c6fd2807SJeff Garzik 3393c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 3394c6fd2807SJeff Garzik 3395936fd732STejun Heo if (ata_link_offline(link)) { 3396c6fd2807SJeff Garzik classes[0] = ATA_DEV_NONE; 3397c6fd2807SJeff Garzik goto out; 3398c6fd2807SJeff Garzik } 3399c6fd2807SJeff Garzik 3400c6fd2807SJeff Garzik /* determine if device 0/1 are present */ 3401c6fd2807SJeff Garzik if (ata_devchk(ap, 0)) 3402c6fd2807SJeff Garzik devmask |= (1 << 0); 3403c6fd2807SJeff Garzik if (slave_possible && ata_devchk(ap, 1)) 3404c6fd2807SJeff Garzik devmask |= (1 << 1); 3405c6fd2807SJeff Garzik 3406c6fd2807SJeff Garzik /* select device 0 again */ 3407c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 3408c6fd2807SJeff Garzik 3409c6fd2807SJeff Garzik /* issue bus reset */ 3410c6fd2807SJeff Garzik DPRINTK("about to softreset, devmask=%x\n", devmask); 3411d4b2bab4STejun Heo rc = ata_bus_softreset(ap, devmask, deadline); 34129b89391cSTejun Heo /* if link is occupied, -ENODEV too is an error */ 3413936fd732STejun Heo if (rc && (rc != -ENODEV || sata_scr_valid(link))) { 3414cc0680a5STejun Heo ata_link_printk(link, KERN_ERR, "SRST failed (errno=%d)\n", rc); 3415d4b2bab4STejun Heo return rc; 3416c6fd2807SJeff Garzik } 3417c6fd2807SJeff Garzik 3418c6fd2807SJeff Garzik /* determine by signature whether we have ATA or ATAPI devices */ 3419c6fd2807SJeff Garzik classes[0] = ata_dev_try_classify(ap, 0, &err); 3420c6fd2807SJeff Garzik if (slave_possible && err != 0x81) 3421c6fd2807SJeff Garzik classes[1] = ata_dev_try_classify(ap, 1, &err); 3422c6fd2807SJeff Garzik 3423c6fd2807SJeff Garzik out: 3424c6fd2807SJeff Garzik DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]); 3425c6fd2807SJeff Garzik return 0; 3426c6fd2807SJeff Garzik } 3427c6fd2807SJeff Garzik 3428c6fd2807SJeff Garzik /** 3429cc0680a5STejun Heo * sata_link_hardreset - reset link via SATA phy reset 3430cc0680a5STejun Heo * @link: link to reset 3431b6103f6dSTejun Heo * @timing: timing parameters { interval, duratinon, timeout } in msec 3432d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3433c6fd2807SJeff Garzik * 3434cc0680a5STejun Heo * SATA phy-reset @link using DET bits of SControl register. 3435c6fd2807SJeff Garzik * 3436c6fd2807SJeff Garzik * LOCKING: 3437c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3438c6fd2807SJeff Garzik * 3439c6fd2807SJeff Garzik * RETURNS: 3440c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 3441c6fd2807SJeff Garzik */ 3442cc0680a5STejun Heo int sata_link_hardreset(struct ata_link *link, const unsigned long *timing, 3443d4b2bab4STejun Heo unsigned long deadline) 3444c6fd2807SJeff Garzik { 3445c6fd2807SJeff Garzik u32 scontrol; 3446c6fd2807SJeff Garzik int rc; 3447c6fd2807SJeff Garzik 3448c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 3449c6fd2807SJeff Garzik 3450936fd732STejun Heo if (sata_set_spd_needed(link)) { 3451c6fd2807SJeff Garzik /* SATA spec says nothing about how to reconfigure 3452c6fd2807SJeff Garzik * spd. To be on the safe side, turn off phy during 3453c6fd2807SJeff Garzik * reconfiguration. This works for at least ICH7 AHCI 3454c6fd2807SJeff Garzik * and Sil3124. 3455c6fd2807SJeff Garzik */ 3456936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 3457b6103f6dSTejun Heo goto out; 3458c6fd2807SJeff Garzik 3459cea0d336SJeff Garzik scontrol = (scontrol & 0x0f0) | 0x304; 3460c6fd2807SJeff Garzik 3461936fd732STejun Heo if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol))) 3462b6103f6dSTejun Heo goto out; 3463c6fd2807SJeff Garzik 3464936fd732STejun Heo sata_set_spd(link); 3465c6fd2807SJeff Garzik } 3466c6fd2807SJeff Garzik 3467c6fd2807SJeff Garzik /* issue phy wake/reset */ 3468936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 3469b6103f6dSTejun Heo goto out; 3470c6fd2807SJeff Garzik 3471c6fd2807SJeff Garzik scontrol = (scontrol & 0x0f0) | 0x301; 3472c6fd2807SJeff Garzik 3473936fd732STejun Heo if ((rc = sata_scr_write_flush(link, SCR_CONTROL, scontrol))) 3474b6103f6dSTejun Heo goto out; 3475c6fd2807SJeff Garzik 3476c6fd2807SJeff Garzik /* Couldn't find anything in SATA I/II specs, but AHCI-1.1 3477c6fd2807SJeff Garzik * 10.4.2 says at least 1 ms. 3478c6fd2807SJeff Garzik */ 3479c6fd2807SJeff Garzik msleep(1); 3480c6fd2807SJeff Garzik 3481936fd732STejun Heo /* bring link back */ 3482936fd732STejun Heo rc = sata_link_resume(link, timing, deadline); 3483b6103f6dSTejun Heo out: 3484b6103f6dSTejun Heo DPRINTK("EXIT, rc=%d\n", rc); 3485b6103f6dSTejun Heo return rc; 3486b6103f6dSTejun Heo } 3487b6103f6dSTejun Heo 3488b6103f6dSTejun Heo /** 3489b6103f6dSTejun Heo * sata_std_hardreset - reset host port via SATA phy reset 3490cc0680a5STejun Heo * @link: link to reset 3491b6103f6dSTejun Heo * @class: resulting class of attached device 3492d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3493b6103f6dSTejun Heo * 3494b6103f6dSTejun Heo * SATA phy-reset host port using DET bits of SControl register, 3495b6103f6dSTejun Heo * wait for !BSY and classify the attached device. 3496b6103f6dSTejun Heo * 3497b6103f6dSTejun Heo * LOCKING: 3498b6103f6dSTejun Heo * Kernel thread context (may sleep) 3499b6103f6dSTejun Heo * 3500b6103f6dSTejun Heo * RETURNS: 3501b6103f6dSTejun Heo * 0 on success, -errno otherwise. 3502b6103f6dSTejun Heo */ 3503cc0680a5STejun Heo int sata_std_hardreset(struct ata_link *link, unsigned int *class, 3504d4b2bab4STejun Heo unsigned long deadline) 3505b6103f6dSTejun Heo { 3506cc0680a5STejun Heo struct ata_port *ap = link->ap; 3507936fd732STejun Heo const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context); 3508b6103f6dSTejun Heo int rc; 3509b6103f6dSTejun Heo 3510b6103f6dSTejun Heo DPRINTK("ENTER\n"); 3511b6103f6dSTejun Heo 3512b6103f6dSTejun Heo /* do hardreset */ 3513cc0680a5STejun Heo rc = sata_link_hardreset(link, timing, deadline); 3514b6103f6dSTejun Heo if (rc) { 3515cc0680a5STejun Heo ata_link_printk(link, KERN_ERR, 3516b6103f6dSTejun Heo "COMRESET failed (errno=%d)\n", rc); 3517b6103f6dSTejun Heo return rc; 3518b6103f6dSTejun Heo } 3519c6fd2807SJeff Garzik 3520c6fd2807SJeff Garzik /* TODO: phy layer with polling, timeouts, etc. */ 3521936fd732STejun Heo if (ata_link_offline(link)) { 3522c6fd2807SJeff Garzik *class = ATA_DEV_NONE; 3523c6fd2807SJeff Garzik DPRINTK("EXIT, link offline\n"); 3524c6fd2807SJeff Garzik return 0; 3525c6fd2807SJeff Garzik } 3526c6fd2807SJeff Garzik 352734fee227STejun Heo /* wait a while before checking status, see SRST for more info */ 352834fee227STejun Heo msleep(150); 352934fee227STejun Heo 3530d4b2bab4STejun Heo rc = ata_wait_ready(ap, deadline); 35319b89391cSTejun Heo /* link occupied, -ENODEV too is an error */ 35329b89391cSTejun Heo if (rc) { 3533cc0680a5STejun Heo ata_link_printk(link, KERN_ERR, 3534d4b2bab4STejun Heo "COMRESET failed (errno=%d)\n", rc); 3535d4b2bab4STejun Heo return rc; 3536c6fd2807SJeff Garzik } 3537c6fd2807SJeff Garzik 3538c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); /* probably unnecessary */ 3539c6fd2807SJeff Garzik 3540c6fd2807SJeff Garzik *class = ata_dev_try_classify(ap, 0, NULL); 3541c6fd2807SJeff Garzik 3542c6fd2807SJeff Garzik DPRINTK("EXIT, class=%u\n", *class); 3543c6fd2807SJeff Garzik return 0; 3544c6fd2807SJeff Garzik } 3545c6fd2807SJeff Garzik 3546c6fd2807SJeff Garzik /** 3547c6fd2807SJeff Garzik * ata_std_postreset - standard postreset callback 3548cc0680a5STejun Heo * @link: the target ata_link 3549c6fd2807SJeff Garzik * @classes: classes of attached devices 3550c6fd2807SJeff Garzik * 3551c6fd2807SJeff Garzik * This function is invoked after a successful reset. Note that 3552c6fd2807SJeff Garzik * the device might have been reset more than once using 3553c6fd2807SJeff Garzik * different reset methods before postreset is invoked. 3554c6fd2807SJeff Garzik * 3555c6fd2807SJeff Garzik * LOCKING: 3556c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3557c6fd2807SJeff Garzik */ 3558cc0680a5STejun Heo void ata_std_postreset(struct ata_link *link, unsigned int *classes) 3559c6fd2807SJeff Garzik { 3560cc0680a5STejun Heo struct ata_port *ap = link->ap; 3561c6fd2807SJeff Garzik u32 serror; 3562c6fd2807SJeff Garzik 3563c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 3564c6fd2807SJeff Garzik 3565c6fd2807SJeff Garzik /* print link status */ 3566936fd732STejun Heo sata_print_link_status(link); 3567c6fd2807SJeff Garzik 3568c6fd2807SJeff Garzik /* clear SError */ 3569936fd732STejun Heo if (sata_scr_read(link, SCR_ERROR, &serror) == 0) 3570936fd732STejun Heo sata_scr_write(link, SCR_ERROR, serror); 3571c6fd2807SJeff Garzik 3572c6fd2807SJeff Garzik /* is double-select really necessary? */ 3573c6fd2807SJeff Garzik if (classes[0] != ATA_DEV_NONE) 3574c6fd2807SJeff Garzik ap->ops->dev_select(ap, 1); 3575c6fd2807SJeff Garzik if (classes[1] != ATA_DEV_NONE) 3576c6fd2807SJeff Garzik ap->ops->dev_select(ap, 0); 3577c6fd2807SJeff Garzik 3578c6fd2807SJeff Garzik /* bail out if no device is present */ 3579c6fd2807SJeff Garzik if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) { 3580c6fd2807SJeff Garzik DPRINTK("EXIT, no device\n"); 3581c6fd2807SJeff Garzik return; 3582c6fd2807SJeff Garzik } 3583c6fd2807SJeff Garzik 3584c6fd2807SJeff Garzik /* set up device control */ 35850d5ff566STejun Heo if (ap->ioaddr.ctl_addr) 35860d5ff566STejun Heo iowrite8(ap->ctl, ap->ioaddr.ctl_addr); 3587c6fd2807SJeff Garzik 3588c6fd2807SJeff Garzik DPRINTK("EXIT\n"); 3589c6fd2807SJeff Garzik } 3590c6fd2807SJeff Garzik 3591c6fd2807SJeff Garzik /** 3592c6fd2807SJeff Garzik * ata_dev_same_device - Determine whether new ID matches configured device 3593c6fd2807SJeff Garzik * @dev: device to compare against 3594c6fd2807SJeff Garzik * @new_class: class of the new device 3595c6fd2807SJeff Garzik * @new_id: IDENTIFY page of the new device 3596c6fd2807SJeff Garzik * 3597c6fd2807SJeff Garzik * Compare @new_class and @new_id against @dev and determine 3598c6fd2807SJeff Garzik * whether @dev is the device indicated by @new_class and 3599c6fd2807SJeff Garzik * @new_id. 3600c6fd2807SJeff Garzik * 3601c6fd2807SJeff Garzik * LOCKING: 3602c6fd2807SJeff Garzik * None. 3603c6fd2807SJeff Garzik * 3604c6fd2807SJeff Garzik * RETURNS: 3605c6fd2807SJeff Garzik * 1 if @dev matches @new_class and @new_id, 0 otherwise. 3606c6fd2807SJeff Garzik */ 3607c6fd2807SJeff Garzik static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class, 3608c6fd2807SJeff Garzik const u16 *new_id) 3609c6fd2807SJeff Garzik { 3610c6fd2807SJeff Garzik const u16 *old_id = dev->id; 3611a0cf733bSTejun Heo unsigned char model[2][ATA_ID_PROD_LEN + 1]; 3612a0cf733bSTejun Heo unsigned char serial[2][ATA_ID_SERNO_LEN + 1]; 3613c6fd2807SJeff Garzik 3614c6fd2807SJeff Garzik if (dev->class != new_class) { 3615c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "class mismatch %d != %d\n", 3616c6fd2807SJeff Garzik dev->class, new_class); 3617c6fd2807SJeff Garzik return 0; 3618c6fd2807SJeff Garzik } 3619c6fd2807SJeff Garzik 3620a0cf733bSTejun Heo ata_id_c_string(old_id, model[0], ATA_ID_PROD, sizeof(model[0])); 3621a0cf733bSTejun Heo ata_id_c_string(new_id, model[1], ATA_ID_PROD, sizeof(model[1])); 3622a0cf733bSTejun Heo ata_id_c_string(old_id, serial[0], ATA_ID_SERNO, sizeof(serial[0])); 3623a0cf733bSTejun Heo ata_id_c_string(new_id, serial[1], ATA_ID_SERNO, sizeof(serial[1])); 3624c6fd2807SJeff Garzik 3625c6fd2807SJeff Garzik if (strcmp(model[0], model[1])) { 3626c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "model number mismatch " 3627c6fd2807SJeff Garzik "'%s' != '%s'\n", model[0], model[1]); 3628c6fd2807SJeff Garzik return 0; 3629c6fd2807SJeff Garzik } 3630c6fd2807SJeff Garzik 3631c6fd2807SJeff Garzik if (strcmp(serial[0], serial[1])) { 3632c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "serial number mismatch " 3633c6fd2807SJeff Garzik "'%s' != '%s'\n", serial[0], serial[1]); 3634c6fd2807SJeff Garzik return 0; 3635c6fd2807SJeff Garzik } 3636c6fd2807SJeff Garzik 3637c6fd2807SJeff Garzik return 1; 3638c6fd2807SJeff Garzik } 3639c6fd2807SJeff Garzik 3640c6fd2807SJeff Garzik /** 3641fe30911bSTejun Heo * ata_dev_reread_id - Re-read IDENTIFY data 36423fae450cSHenrik Kretzschmar * @dev: target ATA device 3643bff04647STejun Heo * @readid_flags: read ID flags 3644c6fd2807SJeff Garzik * 3645c6fd2807SJeff Garzik * Re-read IDENTIFY page and make sure @dev is still attached to 3646c6fd2807SJeff Garzik * the port. 3647c6fd2807SJeff Garzik * 3648c6fd2807SJeff Garzik * LOCKING: 3649c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3650c6fd2807SJeff Garzik * 3651c6fd2807SJeff Garzik * RETURNS: 3652c6fd2807SJeff Garzik * 0 on success, negative errno otherwise 3653c6fd2807SJeff Garzik */ 3654fe30911bSTejun Heo int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags) 3655c6fd2807SJeff Garzik { 3656c6fd2807SJeff Garzik unsigned int class = dev->class; 36579af5c9c9STejun Heo u16 *id = (void *)dev->link->ap->sector_buf; 3658c6fd2807SJeff Garzik int rc; 3659c6fd2807SJeff Garzik 3660c6fd2807SJeff Garzik /* read ID data */ 3661bff04647STejun Heo rc = ata_dev_read_id(dev, &class, readid_flags, id); 3662c6fd2807SJeff Garzik if (rc) 3663fe30911bSTejun Heo return rc; 3664c6fd2807SJeff Garzik 3665c6fd2807SJeff Garzik /* is the device still there? */ 3666fe30911bSTejun Heo if (!ata_dev_same_device(dev, class, id)) 3667fe30911bSTejun Heo return -ENODEV; 3668c6fd2807SJeff Garzik 3669c6fd2807SJeff Garzik memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS); 3670fe30911bSTejun Heo return 0; 3671fe30911bSTejun Heo } 3672fe30911bSTejun Heo 3673fe30911bSTejun Heo /** 3674fe30911bSTejun Heo * ata_dev_revalidate - Revalidate ATA device 3675fe30911bSTejun Heo * @dev: device to revalidate 3676fe30911bSTejun Heo * @readid_flags: read ID flags 3677fe30911bSTejun Heo * 3678fe30911bSTejun Heo * Re-read IDENTIFY page, make sure @dev is still attached to the 3679fe30911bSTejun Heo * port and reconfigure it according to the new IDENTIFY page. 3680fe30911bSTejun Heo * 3681fe30911bSTejun Heo * LOCKING: 3682fe30911bSTejun Heo * Kernel thread context (may sleep) 3683fe30911bSTejun Heo * 3684fe30911bSTejun Heo * RETURNS: 3685fe30911bSTejun Heo * 0 on success, negative errno otherwise 3686fe30911bSTejun Heo */ 3687fe30911bSTejun Heo int ata_dev_revalidate(struct ata_device *dev, unsigned int readid_flags) 3688fe30911bSTejun Heo { 36896ddcd3b0STejun Heo u64 n_sectors = dev->n_sectors; 3690fe30911bSTejun Heo int rc; 3691fe30911bSTejun Heo 3692fe30911bSTejun Heo if (!ata_dev_enabled(dev)) 3693fe30911bSTejun Heo return -ENODEV; 3694fe30911bSTejun Heo 3695fe30911bSTejun Heo /* re-read ID */ 3696fe30911bSTejun Heo rc = ata_dev_reread_id(dev, readid_flags); 3697fe30911bSTejun Heo if (rc) 3698fe30911bSTejun Heo goto fail; 3699c6fd2807SJeff Garzik 3700c6fd2807SJeff Garzik /* configure device according to the new ID */ 3701efdaedc4STejun Heo rc = ata_dev_configure(dev); 37026ddcd3b0STejun Heo if (rc) 37036ddcd3b0STejun Heo goto fail; 37046ddcd3b0STejun Heo 37056ddcd3b0STejun Heo /* verify n_sectors hasn't changed */ 3706b54eebd6STejun Heo if (dev->class == ATA_DEV_ATA && n_sectors && 3707b54eebd6STejun Heo dev->n_sectors != n_sectors) { 37086ddcd3b0STejun Heo ata_dev_printk(dev, KERN_INFO, "n_sectors mismatch " 37096ddcd3b0STejun Heo "%llu != %llu\n", 37106ddcd3b0STejun Heo (unsigned long long)n_sectors, 37116ddcd3b0STejun Heo (unsigned long long)dev->n_sectors); 37128270bec4STejun Heo 37138270bec4STejun Heo /* restore original n_sectors */ 37148270bec4STejun Heo dev->n_sectors = n_sectors; 37158270bec4STejun Heo 37166ddcd3b0STejun Heo rc = -ENODEV; 37176ddcd3b0STejun Heo goto fail; 37186ddcd3b0STejun Heo } 37196ddcd3b0STejun Heo 3720c6fd2807SJeff Garzik return 0; 3721c6fd2807SJeff Garzik 3722c6fd2807SJeff Garzik fail: 3723c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_ERR, "revalidation failed (errno=%d)\n", rc); 3724c6fd2807SJeff Garzik return rc; 3725c6fd2807SJeff Garzik } 3726c6fd2807SJeff Garzik 37276919a0a6SAlan Cox struct ata_blacklist_entry { 37286919a0a6SAlan Cox const char *model_num; 37296919a0a6SAlan Cox const char *model_rev; 37306919a0a6SAlan Cox unsigned long horkage; 37316919a0a6SAlan Cox }; 37326919a0a6SAlan Cox 37336919a0a6SAlan Cox static const struct ata_blacklist_entry ata_device_blacklist [] = { 37346919a0a6SAlan Cox /* Devices with DMA related problems under Linux */ 37356919a0a6SAlan Cox { "WDC AC11000H", NULL, ATA_HORKAGE_NODMA }, 37366919a0a6SAlan Cox { "WDC AC22100H", NULL, ATA_HORKAGE_NODMA }, 37376919a0a6SAlan Cox { "WDC AC32500H", NULL, ATA_HORKAGE_NODMA }, 37386919a0a6SAlan Cox { "WDC AC33100H", NULL, ATA_HORKAGE_NODMA }, 37396919a0a6SAlan Cox { "WDC AC31600H", NULL, ATA_HORKAGE_NODMA }, 37406919a0a6SAlan Cox { "WDC AC32100H", "24.09P07", ATA_HORKAGE_NODMA }, 37416919a0a6SAlan Cox { "WDC AC23200L", "21.10N21", ATA_HORKAGE_NODMA }, 37426919a0a6SAlan Cox { "Compaq CRD-8241B", NULL, ATA_HORKAGE_NODMA }, 37436919a0a6SAlan Cox { "CRD-8400B", NULL, ATA_HORKAGE_NODMA }, 37446919a0a6SAlan Cox { "CRD-8480B", NULL, ATA_HORKAGE_NODMA }, 37456919a0a6SAlan Cox { "CRD-8482B", NULL, ATA_HORKAGE_NODMA }, 37466919a0a6SAlan Cox { "CRD-84", NULL, ATA_HORKAGE_NODMA }, 37476919a0a6SAlan Cox { "SanDisk SDP3B", NULL, ATA_HORKAGE_NODMA }, 37486919a0a6SAlan Cox { "SanDisk SDP3B-64", NULL, ATA_HORKAGE_NODMA }, 37496919a0a6SAlan Cox { "SANYO CD-ROM CRD", NULL, ATA_HORKAGE_NODMA }, 37506919a0a6SAlan Cox { "HITACHI CDR-8", NULL, ATA_HORKAGE_NODMA }, 37516919a0a6SAlan Cox { "HITACHI CDR-8335", NULL, ATA_HORKAGE_NODMA }, 37526919a0a6SAlan Cox { "HITACHI CDR-8435", NULL, ATA_HORKAGE_NODMA }, 37536919a0a6SAlan Cox { "Toshiba CD-ROM XM-6202B", NULL, ATA_HORKAGE_NODMA }, 37546919a0a6SAlan Cox { "TOSHIBA CD-ROM XM-1702BC", NULL, ATA_HORKAGE_NODMA }, 37556919a0a6SAlan Cox { "CD-532E-A", NULL, ATA_HORKAGE_NODMA }, 37566919a0a6SAlan Cox { "E-IDE CD-ROM CR-840",NULL, ATA_HORKAGE_NODMA }, 37576919a0a6SAlan Cox { "CD-ROM Drive/F5A", NULL, ATA_HORKAGE_NODMA }, 37586919a0a6SAlan Cox { "WPI CDD-820", NULL, ATA_HORKAGE_NODMA }, 37596919a0a6SAlan Cox { "SAMSUNG CD-ROM SC-148C", NULL, ATA_HORKAGE_NODMA }, 37606919a0a6SAlan Cox { "SAMSUNG CD-ROM SC", NULL, ATA_HORKAGE_NODMA }, 37616919a0a6SAlan Cox { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA }, 37626919a0a6SAlan Cox { "_NEC DV5800A", NULL, ATA_HORKAGE_NODMA }, 37636919a0a6SAlan Cox { "SAMSUNG CD-ROM SN-124","N001", ATA_HORKAGE_NODMA }, 376439f19886SDave Jones { "Seagate STT20000A", NULL, ATA_HORKAGE_NODMA }, 37655acd50f6STejun Heo { "IOMEGA ZIP 250 ATAPI", NULL, ATA_HORKAGE_NODMA }, /* temporary fix */ 376639ce7128STejun Heo { "IOMEGA ZIP 250 ATAPI Floppy", 376739ce7128STejun Heo NULL, ATA_HORKAGE_NODMA }, 37686919a0a6SAlan Cox 376918d6e9d5SAlbert Lee /* Weird ATAPI devices */ 377040a1d531STejun Heo { "TORiSAN DVD-ROM DRD-N216", NULL, ATA_HORKAGE_MAX_SEC_128 }, 377118d6e9d5SAlbert Lee 37726919a0a6SAlan Cox /* Devices we expect to fail diagnostics */ 37736919a0a6SAlan Cox 37746919a0a6SAlan Cox /* Devices where NCQ should be avoided */ 37756919a0a6SAlan Cox /* NCQ is slow */ 37766919a0a6SAlan Cox { "WDC WD740ADFD-00", NULL, ATA_HORKAGE_NONCQ }, 377709125ea6STejun Heo /* http://thread.gmane.org/gmane.linux.ide/14907 */ 377809125ea6STejun Heo { "FUJITSU MHT2060BH", NULL, ATA_HORKAGE_NONCQ }, 37797acfaf30SPaul Rolland /* NCQ is broken */ 37807acfaf30SPaul Rolland { "Maxtor 6L250S0", "BANC1G10", ATA_HORKAGE_NONCQ }, 3781e8361fc4SChuck Ebbert { "Maxtor 6B200M0", "BANC1BM0", ATA_HORKAGE_NONCQ }, 3782471e44b2SJeff Garzik { "Maxtor 6B200M0", "BANC1B10", ATA_HORKAGE_NONCQ }, 37830e3dbc01SAlan Cox { "Maxtor 7B250S0", "BANC1B70", ATA_HORKAGE_NONCQ, }, 37840e3dbc01SAlan Cox { "Maxtor 7B300S0", "BANC1B70", ATA_HORKAGE_NONCQ }, 37850e3dbc01SAlan Cox { "Maxtor 7V300F0", "VA111630", ATA_HORKAGE_NONCQ }, 37862f8d90abSPrarit Bhargava { "HITACHI HDS7250SASUN500G 0621KTAWSD", "K2AOAJ0AHITACHI", 37872f8d90abSPrarit Bhargava ATA_HORKAGE_NONCQ }, 378896442925SJens Axboe /* NCQ hard hangs device under heavier load, needs hard power cycle */ 378996442925SJens Axboe { "Maxtor 6B250S0", "BANC1B70", ATA_HORKAGE_NONCQ }, 379036e337d0SRobert Hancock /* Blacklist entries taken from Silicon Image 3124/3132 379136e337d0SRobert Hancock Windows driver .inf file - also several Linux problem reports */ 379236e337d0SRobert Hancock { "HTS541060G9SA00", "MB3OC60D", ATA_HORKAGE_NONCQ, }, 379336e337d0SRobert Hancock { "HTS541080G9SA00", "MB4OC60D", ATA_HORKAGE_NONCQ, }, 379436e337d0SRobert Hancock { "HTS541010G9SA00", "MBZOC60D", ATA_HORKAGE_NONCQ, }, 3795bd9c5a39STejun Heo /* Drives which do spurious command completion */ 3796bd9c5a39STejun Heo { "HTS541680J9SA00", "SB2IC7EP", ATA_HORKAGE_NONCQ, }, 37972f8fcebbSTejun Heo { "HTS541612J9SA00", "SBDIC7JP", ATA_HORKAGE_NONCQ, }, 3798e14cbfa6STejun Heo { "Hitachi HTS541616J9SA00", "SB4OC70P", ATA_HORKAGE_NONCQ, }, 37992f8fcebbSTejun Heo { "WDC WD740ADFD-00NLR1", NULL, ATA_HORKAGE_NONCQ, }, 3800a520f261STejun Heo { "FUJITSU MHV2080BH", "00840028", ATA_HORKAGE_NONCQ, }, 38013fb6589cSTejun Heo { "ST9160821AS", "3.CLF", ATA_HORKAGE_NONCQ, }, 38020e3dbc01SAlan Cox { "ST3160812AS", "3.AD", ATA_HORKAGE_NONCQ, }, 38035d6aca8dSTejun Heo { "SAMSUNG HD401LJ", "ZZ100-15", ATA_HORKAGE_NONCQ, }, 38046919a0a6SAlan Cox 380516c55b03STejun Heo /* devices which puke on READ_NATIVE_MAX */ 380616c55b03STejun Heo { "HDS724040KLSA80", "KFAOA20N", ATA_HORKAGE_BROKEN_HPA, }, 380716c55b03STejun Heo { "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_HORKAGE_BROKEN_HPA }, 380816c55b03STejun Heo { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA }, 380916c55b03STejun Heo { "MAXTOR 6L080L4", "A93.0500", ATA_HORKAGE_BROKEN_HPA }, 38106919a0a6SAlan Cox 38116919a0a6SAlan Cox /* End Marker */ 38126919a0a6SAlan Cox { } 3813c6fd2807SJeff Garzik }; 3814c6fd2807SJeff Garzik 381575683fe7STejun Heo static unsigned long ata_dev_blacklisted(const struct ata_device *dev) 3816c6fd2807SJeff Garzik { 38178bfa79fcSTejun Heo unsigned char model_num[ATA_ID_PROD_LEN + 1]; 38188bfa79fcSTejun Heo unsigned char model_rev[ATA_ID_FW_REV_LEN + 1]; 38196919a0a6SAlan Cox const struct ata_blacklist_entry *ad = ata_device_blacklist; 3820c6fd2807SJeff Garzik 38218bfa79fcSTejun Heo ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num)); 38228bfa79fcSTejun Heo ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev)); 3823c6fd2807SJeff Garzik 38246919a0a6SAlan Cox while (ad->model_num) { 38258bfa79fcSTejun Heo if (!strcmp(ad->model_num, model_num)) { 38266919a0a6SAlan Cox if (ad->model_rev == NULL) 38276919a0a6SAlan Cox return ad->horkage; 38288bfa79fcSTejun Heo if (!strcmp(ad->model_rev, model_rev)) 38296919a0a6SAlan Cox return ad->horkage; 3830c6fd2807SJeff Garzik } 38316919a0a6SAlan Cox ad++; 3832c6fd2807SJeff Garzik } 3833c6fd2807SJeff Garzik return 0; 3834c6fd2807SJeff Garzik } 3835c6fd2807SJeff Garzik 38366919a0a6SAlan Cox static int ata_dma_blacklisted(const struct ata_device *dev) 38376919a0a6SAlan Cox { 38386919a0a6SAlan Cox /* We don't support polling DMA. 38396919a0a6SAlan Cox * DMA blacklist those ATAPI devices with CDB-intr (and use PIO) 38406919a0a6SAlan Cox * if the LLDD handles only interrupts in the HSM_ST_LAST state. 38416919a0a6SAlan Cox */ 38429af5c9c9STejun Heo if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) && 38436919a0a6SAlan Cox (dev->flags & ATA_DFLAG_CDB_INTR)) 38446919a0a6SAlan Cox return 1; 384575683fe7STejun Heo return (dev->horkage & ATA_HORKAGE_NODMA) ? 1 : 0; 38466919a0a6SAlan Cox } 38476919a0a6SAlan Cox 3848c6fd2807SJeff Garzik /** 3849c6fd2807SJeff Garzik * ata_dev_xfermask - Compute supported xfermask of the given device 3850c6fd2807SJeff Garzik * @dev: Device to compute xfermask for 3851c6fd2807SJeff Garzik * 3852c6fd2807SJeff Garzik * Compute supported xfermask of @dev and store it in 3853c6fd2807SJeff Garzik * dev->*_mask. This function is responsible for applying all 3854c6fd2807SJeff Garzik * known limits including host controller limits, device 3855c6fd2807SJeff Garzik * blacklist, etc... 3856c6fd2807SJeff Garzik * 3857c6fd2807SJeff Garzik * LOCKING: 3858c6fd2807SJeff Garzik * None. 3859c6fd2807SJeff Garzik */ 3860c6fd2807SJeff Garzik static void ata_dev_xfermask(struct ata_device *dev) 3861c6fd2807SJeff Garzik { 38629af5c9c9STejun Heo struct ata_link *link = dev->link; 38639af5c9c9STejun Heo struct ata_port *ap = link->ap; 3864cca3974eSJeff Garzik struct ata_host *host = ap->host; 3865c6fd2807SJeff Garzik unsigned long xfer_mask; 3866c6fd2807SJeff Garzik 3867c6fd2807SJeff Garzik /* controller modes available */ 3868c6fd2807SJeff Garzik xfer_mask = ata_pack_xfermask(ap->pio_mask, 3869c6fd2807SJeff Garzik ap->mwdma_mask, ap->udma_mask); 3870c6fd2807SJeff Garzik 38718343f889SRobert Hancock /* drive modes available */ 3872c6fd2807SJeff Garzik xfer_mask &= ata_pack_xfermask(dev->pio_mask, 3873c6fd2807SJeff Garzik dev->mwdma_mask, dev->udma_mask); 3874c6fd2807SJeff Garzik xfer_mask &= ata_id_xfermask(dev->id); 3875c6fd2807SJeff Garzik 3876b352e57dSAlan Cox /* 3877b352e57dSAlan Cox * CFA Advanced TrueIDE timings are not allowed on a shared 3878b352e57dSAlan Cox * cable 3879b352e57dSAlan Cox */ 3880b352e57dSAlan Cox if (ata_dev_pair(dev)) { 3881b352e57dSAlan Cox /* No PIO5 or PIO6 */ 3882b352e57dSAlan Cox xfer_mask &= ~(0x03 << (ATA_SHIFT_PIO + 5)); 3883b352e57dSAlan Cox /* No MWDMA3 or MWDMA 4 */ 3884b352e57dSAlan Cox xfer_mask &= ~(0x03 << (ATA_SHIFT_MWDMA + 3)); 3885b352e57dSAlan Cox } 3886b352e57dSAlan Cox 3887c6fd2807SJeff Garzik if (ata_dma_blacklisted(dev)) { 3888c6fd2807SJeff Garzik xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA); 3889c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 3890c6fd2807SJeff Garzik "device is on DMA blacklist, disabling DMA\n"); 3891c6fd2807SJeff Garzik } 3892c6fd2807SJeff Garzik 389314d66ab7SPetr Vandrovec if ((host->flags & ATA_HOST_SIMPLEX) && 389414d66ab7SPetr Vandrovec host->simplex_claimed && host->simplex_claimed != ap) { 3895c6fd2807SJeff Garzik xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA); 3896c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "simplex DMA is claimed by " 3897c6fd2807SJeff Garzik "other device, disabling DMA\n"); 3898c6fd2807SJeff Garzik } 3899c6fd2807SJeff Garzik 3900e424675fSJeff Garzik if (ap->flags & ATA_FLAG_NO_IORDY) 3901e424675fSJeff Garzik xfer_mask &= ata_pio_mask_no_iordy(dev); 3902e424675fSJeff Garzik 3903c6fd2807SJeff Garzik if (ap->ops->mode_filter) 3904a76b62caSAlan Cox xfer_mask = ap->ops->mode_filter(dev, xfer_mask); 3905c6fd2807SJeff Garzik 39068343f889SRobert Hancock /* Apply cable rule here. Don't apply it early because when 39078343f889SRobert Hancock * we handle hot plug the cable type can itself change. 39088343f889SRobert Hancock * Check this last so that we know if the transfer rate was 39098343f889SRobert Hancock * solely limited by the cable. 39108343f889SRobert Hancock * Unknown or 80 wire cables reported host side are checked 39118343f889SRobert Hancock * drive side as well. Cases where we know a 40wire cable 39128343f889SRobert Hancock * is used safely for 80 are not checked here. 39138343f889SRobert Hancock */ 39148343f889SRobert Hancock if (xfer_mask & (0xF8 << ATA_SHIFT_UDMA)) 39158343f889SRobert Hancock /* UDMA/44 or higher would be available */ 39168343f889SRobert Hancock if((ap->cbl == ATA_CBL_PATA40) || 39178343f889SRobert Hancock (ata_drive_40wire(dev->id) && 39188343f889SRobert Hancock (ap->cbl == ATA_CBL_PATA_UNK || 39198343f889SRobert Hancock ap->cbl == ATA_CBL_PATA80))) { 39208343f889SRobert Hancock ata_dev_printk(dev, KERN_WARNING, 39218343f889SRobert Hancock "limited to UDMA/33 due to 40-wire cable\n"); 39228343f889SRobert Hancock xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA); 39238343f889SRobert Hancock } 39248343f889SRobert Hancock 3925c6fd2807SJeff Garzik ata_unpack_xfermask(xfer_mask, &dev->pio_mask, 3926c6fd2807SJeff Garzik &dev->mwdma_mask, &dev->udma_mask); 3927c6fd2807SJeff Garzik } 3928c6fd2807SJeff Garzik 3929c6fd2807SJeff Garzik /** 3930c6fd2807SJeff Garzik * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command 3931c6fd2807SJeff Garzik * @dev: Device to which command will be sent 3932c6fd2807SJeff Garzik * 3933c6fd2807SJeff Garzik * Issue SET FEATURES - XFER MODE command to device @dev 3934c6fd2807SJeff Garzik * on port @ap. 3935c6fd2807SJeff Garzik * 3936c6fd2807SJeff Garzik * LOCKING: 3937c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 3938c6fd2807SJeff Garzik * 3939c6fd2807SJeff Garzik * RETURNS: 3940c6fd2807SJeff Garzik * 0 on success, AC_ERR_* mask otherwise. 3941c6fd2807SJeff Garzik */ 3942c6fd2807SJeff Garzik 3943c6fd2807SJeff Garzik static unsigned int ata_dev_set_xfermode(struct ata_device *dev) 3944c6fd2807SJeff Garzik { 3945c6fd2807SJeff Garzik struct ata_taskfile tf; 3946c6fd2807SJeff Garzik unsigned int err_mask; 3947c6fd2807SJeff Garzik 3948c6fd2807SJeff Garzik /* set up set-features taskfile */ 3949c6fd2807SJeff Garzik DPRINTK("set features - xfer mode\n"); 3950c6fd2807SJeff Garzik 3951464cf177STejun Heo /* Some controllers and ATAPI devices show flaky interrupt 3952464cf177STejun Heo * behavior after setting xfer mode. Use polling instead. 3953464cf177STejun Heo */ 3954c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 3955c6fd2807SJeff Garzik tf.command = ATA_CMD_SET_FEATURES; 3956c6fd2807SJeff Garzik tf.feature = SETFEATURES_XFER; 3957464cf177STejun Heo tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_POLLING; 3958c6fd2807SJeff Garzik tf.protocol = ATA_PROT_NODATA; 3959c6fd2807SJeff Garzik tf.nsect = dev->xfer_mode; 3960c6fd2807SJeff Garzik 3961c6fd2807SJeff Garzik err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0); 3962c6fd2807SJeff Garzik 3963c6fd2807SJeff Garzik DPRINTK("EXIT, err_mask=%x\n", err_mask); 3964c6fd2807SJeff Garzik return err_mask; 3965c6fd2807SJeff Garzik } 3966c6fd2807SJeff Garzik 3967c6fd2807SJeff Garzik /** 3968c6fd2807SJeff Garzik * ata_dev_init_params - Issue INIT DEV PARAMS command 3969c6fd2807SJeff Garzik * @dev: Device to which command will be sent 3970c6fd2807SJeff Garzik * @heads: Number of heads (taskfile parameter) 3971c6fd2807SJeff Garzik * @sectors: Number of sectors (taskfile parameter) 3972c6fd2807SJeff Garzik * 3973c6fd2807SJeff Garzik * LOCKING: 3974c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3975c6fd2807SJeff Garzik * 3976c6fd2807SJeff Garzik * RETURNS: 3977c6fd2807SJeff Garzik * 0 on success, AC_ERR_* mask otherwise. 3978c6fd2807SJeff Garzik */ 3979c6fd2807SJeff Garzik static unsigned int ata_dev_init_params(struct ata_device *dev, 3980c6fd2807SJeff Garzik u16 heads, u16 sectors) 3981c6fd2807SJeff Garzik { 3982c6fd2807SJeff Garzik struct ata_taskfile tf; 3983c6fd2807SJeff Garzik unsigned int err_mask; 3984c6fd2807SJeff Garzik 3985c6fd2807SJeff Garzik /* Number of sectors per track 1-255. Number of heads 1-16 */ 3986c6fd2807SJeff Garzik if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16) 3987c6fd2807SJeff Garzik return AC_ERR_INVALID; 3988c6fd2807SJeff Garzik 3989c6fd2807SJeff Garzik /* set up init dev params taskfile */ 3990c6fd2807SJeff Garzik DPRINTK("init dev params \n"); 3991c6fd2807SJeff Garzik 3992c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 3993c6fd2807SJeff Garzik tf.command = ATA_CMD_INIT_DEV_PARAMS; 3994c6fd2807SJeff Garzik tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 3995c6fd2807SJeff Garzik tf.protocol = ATA_PROT_NODATA; 3996c6fd2807SJeff Garzik tf.nsect = sectors; 3997c6fd2807SJeff Garzik tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */ 3998c6fd2807SJeff Garzik 3999c6fd2807SJeff Garzik err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0); 400018b2466cSAlan Cox /* A clean abort indicates an original or just out of spec drive 400118b2466cSAlan Cox and we should continue as we issue the setup based on the 400218b2466cSAlan Cox drive reported working geometry */ 400318b2466cSAlan Cox if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED)) 400418b2466cSAlan Cox err_mask = 0; 4005c6fd2807SJeff Garzik 4006c6fd2807SJeff Garzik DPRINTK("EXIT, err_mask=%x\n", err_mask); 4007c6fd2807SJeff Garzik return err_mask; 4008c6fd2807SJeff Garzik } 4009c6fd2807SJeff Garzik 4010c6fd2807SJeff Garzik /** 4011c6fd2807SJeff Garzik * ata_sg_clean - Unmap DMA memory associated with command 4012c6fd2807SJeff Garzik * @qc: Command containing DMA memory to be released 4013c6fd2807SJeff Garzik * 4014c6fd2807SJeff Garzik * Unmap all mapped DMA memory associated with this command. 4015c6fd2807SJeff Garzik * 4016c6fd2807SJeff Garzik * LOCKING: 4017cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4018c6fd2807SJeff Garzik */ 401970e6ad0cSTejun Heo void ata_sg_clean(struct ata_queued_cmd *qc) 4020c6fd2807SJeff Garzik { 4021c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4022c6fd2807SJeff Garzik struct scatterlist *sg = qc->__sg; 4023c6fd2807SJeff Garzik int dir = qc->dma_dir; 4024c6fd2807SJeff Garzik void *pad_buf = NULL; 4025c6fd2807SJeff Garzik 4026c6fd2807SJeff Garzik WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP)); 4027c6fd2807SJeff Garzik WARN_ON(sg == NULL); 4028c6fd2807SJeff Garzik 4029c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_SINGLE) 4030c6fd2807SJeff Garzik WARN_ON(qc->n_elem > 1); 4031c6fd2807SJeff Garzik 4032c6fd2807SJeff Garzik VPRINTK("unmapping %u sg elements\n", qc->n_elem); 4033c6fd2807SJeff Garzik 4034c6fd2807SJeff Garzik /* if we padded the buffer out to 32-bit bound, and data 4035c6fd2807SJeff Garzik * xfer direction is from-device, we must copy from the 4036c6fd2807SJeff Garzik * pad buffer back into the supplied buffer 4037c6fd2807SJeff Garzik */ 4038c6fd2807SJeff Garzik if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE)) 4039c6fd2807SJeff Garzik pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ); 4040c6fd2807SJeff Garzik 4041c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_SG) { 4042c6fd2807SJeff Garzik if (qc->n_elem) 4043c6fd2807SJeff Garzik dma_unmap_sg(ap->dev, sg, qc->n_elem, dir); 4044c6fd2807SJeff Garzik /* restore last sg */ 4045c6fd2807SJeff Garzik sg[qc->orig_n_elem - 1].length += qc->pad_len; 4046c6fd2807SJeff Garzik if (pad_buf) { 4047c6fd2807SJeff Garzik struct scatterlist *psg = &qc->pad_sgent; 4048c6fd2807SJeff Garzik void *addr = kmap_atomic(psg->page, KM_IRQ0); 4049c6fd2807SJeff Garzik memcpy(addr + psg->offset, pad_buf, qc->pad_len); 4050c6fd2807SJeff Garzik kunmap_atomic(addr, KM_IRQ0); 4051c6fd2807SJeff Garzik } 4052c6fd2807SJeff Garzik } else { 4053c6fd2807SJeff Garzik if (qc->n_elem) 4054c6fd2807SJeff Garzik dma_unmap_single(ap->dev, 4055c6fd2807SJeff Garzik sg_dma_address(&sg[0]), sg_dma_len(&sg[0]), 4056c6fd2807SJeff Garzik dir); 4057c6fd2807SJeff Garzik /* restore sg */ 4058c6fd2807SJeff Garzik sg->length += qc->pad_len; 4059c6fd2807SJeff Garzik if (pad_buf) 4060c6fd2807SJeff Garzik memcpy(qc->buf_virt + sg->length - qc->pad_len, 4061c6fd2807SJeff Garzik pad_buf, qc->pad_len); 4062c6fd2807SJeff Garzik } 4063c6fd2807SJeff Garzik 4064c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_DMAMAP; 4065c6fd2807SJeff Garzik qc->__sg = NULL; 4066c6fd2807SJeff Garzik } 4067c6fd2807SJeff Garzik 4068c6fd2807SJeff Garzik /** 4069c6fd2807SJeff Garzik * ata_fill_sg - Fill PCI IDE PRD table 4070c6fd2807SJeff Garzik * @qc: Metadata associated with taskfile to be transferred 4071c6fd2807SJeff Garzik * 4072c6fd2807SJeff Garzik * Fill PCI IDE PRD (scatter-gather) table with segments 4073c6fd2807SJeff Garzik * associated with the current disk command. 4074c6fd2807SJeff Garzik * 4075c6fd2807SJeff Garzik * LOCKING: 4076cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4077c6fd2807SJeff Garzik * 4078c6fd2807SJeff Garzik */ 4079c6fd2807SJeff Garzik static void ata_fill_sg(struct ata_queued_cmd *qc) 4080c6fd2807SJeff Garzik { 4081c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4082c6fd2807SJeff Garzik struct scatterlist *sg; 4083c6fd2807SJeff Garzik unsigned int idx; 4084c6fd2807SJeff Garzik 4085c6fd2807SJeff Garzik WARN_ON(qc->__sg == NULL); 4086c6fd2807SJeff Garzik WARN_ON(qc->n_elem == 0 && qc->pad_len == 0); 4087c6fd2807SJeff Garzik 4088c6fd2807SJeff Garzik idx = 0; 4089c6fd2807SJeff Garzik ata_for_each_sg(sg, qc) { 4090c6fd2807SJeff Garzik u32 addr, offset; 4091c6fd2807SJeff Garzik u32 sg_len, len; 4092c6fd2807SJeff Garzik 4093c6fd2807SJeff Garzik /* determine if physical DMA addr spans 64K boundary. 4094c6fd2807SJeff Garzik * Note h/w doesn't support 64-bit, so we unconditionally 4095c6fd2807SJeff Garzik * truncate dma_addr_t to u32. 4096c6fd2807SJeff Garzik */ 4097c6fd2807SJeff Garzik addr = (u32) sg_dma_address(sg); 4098c6fd2807SJeff Garzik sg_len = sg_dma_len(sg); 4099c6fd2807SJeff Garzik 4100c6fd2807SJeff Garzik while (sg_len) { 4101c6fd2807SJeff Garzik offset = addr & 0xffff; 4102c6fd2807SJeff Garzik len = sg_len; 4103c6fd2807SJeff Garzik if ((offset + sg_len) > 0x10000) 4104c6fd2807SJeff Garzik len = 0x10000 - offset; 4105c6fd2807SJeff Garzik 4106c6fd2807SJeff Garzik ap->prd[idx].addr = cpu_to_le32(addr); 4107c6fd2807SJeff Garzik ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff); 4108c6fd2807SJeff Garzik VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len); 4109c6fd2807SJeff Garzik 4110c6fd2807SJeff Garzik idx++; 4111c6fd2807SJeff Garzik sg_len -= len; 4112c6fd2807SJeff Garzik addr += len; 4113c6fd2807SJeff Garzik } 4114c6fd2807SJeff Garzik } 4115c6fd2807SJeff Garzik 4116c6fd2807SJeff Garzik if (idx) 4117c6fd2807SJeff Garzik ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT); 4118c6fd2807SJeff Garzik } 4119b9a4197eSTejun Heo 4120c6fd2807SJeff Garzik /** 4121d26fc955SAlan Cox * ata_fill_sg_dumb - Fill PCI IDE PRD table 4122d26fc955SAlan Cox * @qc: Metadata associated with taskfile to be transferred 4123d26fc955SAlan Cox * 4124d26fc955SAlan Cox * Fill PCI IDE PRD (scatter-gather) table with segments 4125d26fc955SAlan Cox * associated with the current disk command. Perform the fill 4126d26fc955SAlan Cox * so that we avoid writing any length 64K records for 4127d26fc955SAlan Cox * controllers that don't follow the spec. 4128d26fc955SAlan Cox * 4129d26fc955SAlan Cox * LOCKING: 4130d26fc955SAlan Cox * spin_lock_irqsave(host lock) 4131d26fc955SAlan Cox * 4132d26fc955SAlan Cox */ 4133d26fc955SAlan Cox static void ata_fill_sg_dumb(struct ata_queued_cmd *qc) 4134d26fc955SAlan Cox { 4135d26fc955SAlan Cox struct ata_port *ap = qc->ap; 4136d26fc955SAlan Cox struct scatterlist *sg; 4137d26fc955SAlan Cox unsigned int idx; 4138d26fc955SAlan Cox 4139d26fc955SAlan Cox WARN_ON(qc->__sg == NULL); 4140d26fc955SAlan Cox WARN_ON(qc->n_elem == 0 && qc->pad_len == 0); 4141d26fc955SAlan Cox 4142d26fc955SAlan Cox idx = 0; 4143d26fc955SAlan Cox ata_for_each_sg(sg, qc) { 4144d26fc955SAlan Cox u32 addr, offset; 4145d26fc955SAlan Cox u32 sg_len, len, blen; 4146d26fc955SAlan Cox 4147d26fc955SAlan Cox /* determine if physical DMA addr spans 64K boundary. 4148d26fc955SAlan Cox * Note h/w doesn't support 64-bit, so we unconditionally 4149d26fc955SAlan Cox * truncate dma_addr_t to u32. 4150d26fc955SAlan Cox */ 4151d26fc955SAlan Cox addr = (u32) sg_dma_address(sg); 4152d26fc955SAlan Cox sg_len = sg_dma_len(sg); 4153d26fc955SAlan Cox 4154d26fc955SAlan Cox while (sg_len) { 4155d26fc955SAlan Cox offset = addr & 0xffff; 4156d26fc955SAlan Cox len = sg_len; 4157d26fc955SAlan Cox if ((offset + sg_len) > 0x10000) 4158d26fc955SAlan Cox len = 0x10000 - offset; 4159d26fc955SAlan Cox 4160d26fc955SAlan Cox blen = len & 0xffff; 4161d26fc955SAlan Cox ap->prd[idx].addr = cpu_to_le32(addr); 4162d26fc955SAlan Cox if (blen == 0) { 4163d26fc955SAlan Cox /* Some PATA chipsets like the CS5530 can't 4164d26fc955SAlan Cox cope with 0x0000 meaning 64K as the spec says */ 4165d26fc955SAlan Cox ap->prd[idx].flags_len = cpu_to_le32(0x8000); 4166d26fc955SAlan Cox blen = 0x8000; 4167d26fc955SAlan Cox ap->prd[++idx].addr = cpu_to_le32(addr + 0x8000); 4168d26fc955SAlan Cox } 4169d26fc955SAlan Cox ap->prd[idx].flags_len = cpu_to_le32(blen); 4170d26fc955SAlan Cox VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len); 4171d26fc955SAlan Cox 4172d26fc955SAlan Cox idx++; 4173d26fc955SAlan Cox sg_len -= len; 4174d26fc955SAlan Cox addr += len; 4175d26fc955SAlan Cox } 4176d26fc955SAlan Cox } 4177d26fc955SAlan Cox 4178d26fc955SAlan Cox if (idx) 4179d26fc955SAlan Cox ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT); 4180d26fc955SAlan Cox } 4181d26fc955SAlan Cox 4182d26fc955SAlan Cox /** 4183c6fd2807SJeff Garzik * ata_check_atapi_dma - Check whether ATAPI DMA can be supported 4184c6fd2807SJeff Garzik * @qc: Metadata associated with taskfile to check 4185c6fd2807SJeff Garzik * 4186c6fd2807SJeff Garzik * Allow low-level driver to filter ATA PACKET commands, returning 4187c6fd2807SJeff Garzik * a status indicating whether or not it is OK to use DMA for the 4188c6fd2807SJeff Garzik * supplied PACKET command. 4189c6fd2807SJeff Garzik * 4190c6fd2807SJeff Garzik * LOCKING: 4191cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4192c6fd2807SJeff Garzik * 4193c6fd2807SJeff Garzik * RETURNS: 0 when ATAPI DMA can be used 4194c6fd2807SJeff Garzik * nonzero otherwise 4195c6fd2807SJeff Garzik */ 4196c6fd2807SJeff Garzik int ata_check_atapi_dma(struct ata_queued_cmd *qc) 4197c6fd2807SJeff Garzik { 4198c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4199c6fd2807SJeff Garzik 4200b9a4197eSTejun Heo /* Don't allow DMA if it isn't multiple of 16 bytes. Quite a 4201b9a4197eSTejun Heo * few ATAPI devices choke on such DMA requests. 4202b9a4197eSTejun Heo */ 4203b9a4197eSTejun Heo if (unlikely(qc->nbytes & 15)) 42046f23a31dSAlbert Lee return 1; 42056f23a31dSAlbert Lee 4206c6fd2807SJeff Garzik if (ap->ops->check_atapi_dma) 4207b9a4197eSTejun Heo return ap->ops->check_atapi_dma(qc); 4208c6fd2807SJeff Garzik 4209b9a4197eSTejun Heo return 0; 4210c6fd2807SJeff Garzik } 4211b9a4197eSTejun Heo 4212c6fd2807SJeff Garzik /** 4213c6fd2807SJeff Garzik * ata_qc_prep - Prepare taskfile for submission 4214c6fd2807SJeff Garzik * @qc: Metadata associated with taskfile to be prepared 4215c6fd2807SJeff Garzik * 4216c6fd2807SJeff Garzik * Prepare ATA taskfile for submission. 4217c6fd2807SJeff Garzik * 4218c6fd2807SJeff Garzik * LOCKING: 4219cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4220c6fd2807SJeff Garzik */ 4221c6fd2807SJeff Garzik void ata_qc_prep(struct ata_queued_cmd *qc) 4222c6fd2807SJeff Garzik { 4223c6fd2807SJeff Garzik if (!(qc->flags & ATA_QCFLAG_DMAMAP)) 4224c6fd2807SJeff Garzik return; 4225c6fd2807SJeff Garzik 4226c6fd2807SJeff Garzik ata_fill_sg(qc); 4227c6fd2807SJeff Garzik } 4228c6fd2807SJeff Garzik 4229d26fc955SAlan Cox /** 4230d26fc955SAlan Cox * ata_dumb_qc_prep - Prepare taskfile for submission 4231d26fc955SAlan Cox * @qc: Metadata associated with taskfile to be prepared 4232d26fc955SAlan Cox * 4233d26fc955SAlan Cox * Prepare ATA taskfile for submission. 4234d26fc955SAlan Cox * 4235d26fc955SAlan Cox * LOCKING: 4236d26fc955SAlan Cox * spin_lock_irqsave(host lock) 4237d26fc955SAlan Cox */ 4238d26fc955SAlan Cox void ata_dumb_qc_prep(struct ata_queued_cmd *qc) 4239d26fc955SAlan Cox { 4240d26fc955SAlan Cox if (!(qc->flags & ATA_QCFLAG_DMAMAP)) 4241d26fc955SAlan Cox return; 4242d26fc955SAlan Cox 4243d26fc955SAlan Cox ata_fill_sg_dumb(qc); 4244d26fc955SAlan Cox } 4245d26fc955SAlan Cox 4246c6fd2807SJeff Garzik void ata_noop_qc_prep(struct ata_queued_cmd *qc) { } 4247c6fd2807SJeff Garzik 4248c6fd2807SJeff Garzik /** 4249c6fd2807SJeff Garzik * ata_sg_init_one - Associate command with memory buffer 4250c6fd2807SJeff Garzik * @qc: Command to be associated 4251c6fd2807SJeff Garzik * @buf: Memory buffer 4252c6fd2807SJeff Garzik * @buflen: Length of memory buffer, in bytes. 4253c6fd2807SJeff Garzik * 4254c6fd2807SJeff Garzik * Initialize the data-related elements of queued_cmd @qc 4255c6fd2807SJeff Garzik * to point to a single memory buffer, @buf of byte length @buflen. 4256c6fd2807SJeff Garzik * 4257c6fd2807SJeff Garzik * LOCKING: 4258cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4259c6fd2807SJeff Garzik */ 4260c6fd2807SJeff Garzik 4261c6fd2807SJeff Garzik void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen) 4262c6fd2807SJeff Garzik { 4263c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_SINGLE; 4264c6fd2807SJeff Garzik 4265c6fd2807SJeff Garzik qc->__sg = &qc->sgent; 4266c6fd2807SJeff Garzik qc->n_elem = 1; 4267c6fd2807SJeff Garzik qc->orig_n_elem = 1; 4268c6fd2807SJeff Garzik qc->buf_virt = buf; 4269c6fd2807SJeff Garzik qc->nbytes = buflen; 4270c6fd2807SJeff Garzik 427161c0596cSTejun Heo sg_init_one(&qc->sgent, buf, buflen); 4272c6fd2807SJeff Garzik } 4273c6fd2807SJeff Garzik 4274c6fd2807SJeff Garzik /** 4275c6fd2807SJeff Garzik * ata_sg_init - Associate command with scatter-gather table. 4276c6fd2807SJeff Garzik * @qc: Command to be associated 4277c6fd2807SJeff Garzik * @sg: Scatter-gather table. 4278c6fd2807SJeff Garzik * @n_elem: Number of elements in s/g table. 4279c6fd2807SJeff Garzik * 4280c6fd2807SJeff Garzik * Initialize the data-related elements of queued_cmd @qc 4281c6fd2807SJeff Garzik * to point to a scatter-gather table @sg, containing @n_elem 4282c6fd2807SJeff Garzik * elements. 4283c6fd2807SJeff Garzik * 4284c6fd2807SJeff Garzik * LOCKING: 4285cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4286c6fd2807SJeff Garzik */ 4287c6fd2807SJeff Garzik 4288c6fd2807SJeff Garzik void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg, 4289c6fd2807SJeff Garzik unsigned int n_elem) 4290c6fd2807SJeff Garzik { 4291c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_SG; 4292c6fd2807SJeff Garzik qc->__sg = sg; 4293c6fd2807SJeff Garzik qc->n_elem = n_elem; 4294c6fd2807SJeff Garzik qc->orig_n_elem = n_elem; 4295c6fd2807SJeff Garzik } 4296c6fd2807SJeff Garzik 4297c6fd2807SJeff Garzik /** 4298c6fd2807SJeff Garzik * ata_sg_setup_one - DMA-map the memory buffer associated with a command. 4299c6fd2807SJeff Garzik * @qc: Command with memory buffer to be mapped. 4300c6fd2807SJeff Garzik * 4301c6fd2807SJeff Garzik * DMA-map the memory buffer associated with queued_cmd @qc. 4302c6fd2807SJeff Garzik * 4303c6fd2807SJeff Garzik * LOCKING: 4304cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4305c6fd2807SJeff Garzik * 4306c6fd2807SJeff Garzik * RETURNS: 4307c6fd2807SJeff Garzik * Zero on success, negative on error. 4308c6fd2807SJeff Garzik */ 4309c6fd2807SJeff Garzik 4310c6fd2807SJeff Garzik static int ata_sg_setup_one(struct ata_queued_cmd *qc) 4311c6fd2807SJeff Garzik { 4312c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4313c6fd2807SJeff Garzik int dir = qc->dma_dir; 4314c6fd2807SJeff Garzik struct scatterlist *sg = qc->__sg; 4315c6fd2807SJeff Garzik dma_addr_t dma_address; 4316c6fd2807SJeff Garzik int trim_sg = 0; 4317c6fd2807SJeff Garzik 4318c6fd2807SJeff Garzik /* we must lengthen transfers to end on a 32-bit boundary */ 4319c6fd2807SJeff Garzik qc->pad_len = sg->length & 3; 4320c6fd2807SJeff Garzik if (qc->pad_len) { 4321c6fd2807SJeff Garzik void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ); 4322c6fd2807SJeff Garzik struct scatterlist *psg = &qc->pad_sgent; 4323c6fd2807SJeff Garzik 4324c6fd2807SJeff Garzik WARN_ON(qc->dev->class != ATA_DEV_ATAPI); 4325c6fd2807SJeff Garzik 4326c6fd2807SJeff Garzik memset(pad_buf, 0, ATA_DMA_PAD_SZ); 4327c6fd2807SJeff Garzik 4328c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_WRITE) 4329c6fd2807SJeff Garzik memcpy(pad_buf, qc->buf_virt + sg->length - qc->pad_len, 4330c6fd2807SJeff Garzik qc->pad_len); 4331c6fd2807SJeff Garzik 4332c6fd2807SJeff Garzik sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ); 4333c6fd2807SJeff Garzik sg_dma_len(psg) = ATA_DMA_PAD_SZ; 4334c6fd2807SJeff Garzik /* trim sg */ 4335c6fd2807SJeff Garzik sg->length -= qc->pad_len; 4336c6fd2807SJeff Garzik if (sg->length == 0) 4337c6fd2807SJeff Garzik trim_sg = 1; 4338c6fd2807SJeff Garzik 4339c6fd2807SJeff Garzik DPRINTK("padding done, sg->length=%u pad_len=%u\n", 4340c6fd2807SJeff Garzik sg->length, qc->pad_len); 4341c6fd2807SJeff Garzik } 4342c6fd2807SJeff Garzik 4343c6fd2807SJeff Garzik if (trim_sg) { 4344c6fd2807SJeff Garzik qc->n_elem--; 4345c6fd2807SJeff Garzik goto skip_map; 4346c6fd2807SJeff Garzik } 4347c6fd2807SJeff Garzik 4348c6fd2807SJeff Garzik dma_address = dma_map_single(ap->dev, qc->buf_virt, 4349c6fd2807SJeff Garzik sg->length, dir); 4350c6fd2807SJeff Garzik if (dma_mapping_error(dma_address)) { 4351c6fd2807SJeff Garzik /* restore sg */ 4352c6fd2807SJeff Garzik sg->length += qc->pad_len; 4353c6fd2807SJeff Garzik return -1; 4354c6fd2807SJeff Garzik } 4355c6fd2807SJeff Garzik 4356c6fd2807SJeff Garzik sg_dma_address(sg) = dma_address; 4357c6fd2807SJeff Garzik sg_dma_len(sg) = sg->length; 4358c6fd2807SJeff Garzik 4359c6fd2807SJeff Garzik skip_map: 4360c6fd2807SJeff Garzik DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg), 4361c6fd2807SJeff Garzik qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read"); 4362c6fd2807SJeff Garzik 4363c6fd2807SJeff Garzik return 0; 4364c6fd2807SJeff Garzik } 4365c6fd2807SJeff Garzik 4366c6fd2807SJeff Garzik /** 4367c6fd2807SJeff Garzik * ata_sg_setup - DMA-map the scatter-gather table associated with a command. 4368c6fd2807SJeff Garzik * @qc: Command with scatter-gather table to be mapped. 4369c6fd2807SJeff Garzik * 4370c6fd2807SJeff Garzik * DMA-map the scatter-gather table associated with queued_cmd @qc. 4371c6fd2807SJeff Garzik * 4372c6fd2807SJeff Garzik * LOCKING: 4373cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4374c6fd2807SJeff Garzik * 4375c6fd2807SJeff Garzik * RETURNS: 4376c6fd2807SJeff Garzik * Zero on success, negative on error. 4377c6fd2807SJeff Garzik * 4378c6fd2807SJeff Garzik */ 4379c6fd2807SJeff Garzik 4380c6fd2807SJeff Garzik static int ata_sg_setup(struct ata_queued_cmd *qc) 4381c6fd2807SJeff Garzik { 4382c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4383c6fd2807SJeff Garzik struct scatterlist *sg = qc->__sg; 4384c6fd2807SJeff Garzik struct scatterlist *lsg = &sg[qc->n_elem - 1]; 4385c6fd2807SJeff Garzik int n_elem, pre_n_elem, dir, trim_sg = 0; 4386c6fd2807SJeff Garzik 438744877b4eSTejun Heo VPRINTK("ENTER, ata%u\n", ap->print_id); 4388c6fd2807SJeff Garzik WARN_ON(!(qc->flags & ATA_QCFLAG_SG)); 4389c6fd2807SJeff Garzik 4390c6fd2807SJeff Garzik /* we must lengthen transfers to end on a 32-bit boundary */ 4391c6fd2807SJeff Garzik qc->pad_len = lsg->length & 3; 4392c6fd2807SJeff Garzik if (qc->pad_len) { 4393c6fd2807SJeff Garzik void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ); 4394c6fd2807SJeff Garzik struct scatterlist *psg = &qc->pad_sgent; 4395c6fd2807SJeff Garzik unsigned int offset; 4396c6fd2807SJeff Garzik 4397c6fd2807SJeff Garzik WARN_ON(qc->dev->class != ATA_DEV_ATAPI); 4398c6fd2807SJeff Garzik 4399c6fd2807SJeff Garzik memset(pad_buf, 0, ATA_DMA_PAD_SZ); 4400c6fd2807SJeff Garzik 4401c6fd2807SJeff Garzik /* 4402c6fd2807SJeff Garzik * psg->page/offset are used to copy to-be-written 4403c6fd2807SJeff Garzik * data in this function or read data in ata_sg_clean. 4404c6fd2807SJeff Garzik */ 4405c6fd2807SJeff Garzik offset = lsg->offset + lsg->length - qc->pad_len; 4406c6fd2807SJeff Garzik psg->page = nth_page(lsg->page, offset >> PAGE_SHIFT); 4407c6fd2807SJeff Garzik psg->offset = offset_in_page(offset); 4408c6fd2807SJeff Garzik 4409c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_WRITE) { 4410c6fd2807SJeff Garzik void *addr = kmap_atomic(psg->page, KM_IRQ0); 4411c6fd2807SJeff Garzik memcpy(pad_buf, addr + psg->offset, qc->pad_len); 4412c6fd2807SJeff Garzik kunmap_atomic(addr, KM_IRQ0); 4413c6fd2807SJeff Garzik } 4414c6fd2807SJeff Garzik 4415c6fd2807SJeff Garzik sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ); 4416c6fd2807SJeff Garzik sg_dma_len(psg) = ATA_DMA_PAD_SZ; 4417c6fd2807SJeff Garzik /* trim last sg */ 4418c6fd2807SJeff Garzik lsg->length -= qc->pad_len; 4419c6fd2807SJeff Garzik if (lsg->length == 0) 4420c6fd2807SJeff Garzik trim_sg = 1; 4421c6fd2807SJeff Garzik 4422c6fd2807SJeff Garzik DPRINTK("padding done, sg[%d].length=%u pad_len=%u\n", 4423c6fd2807SJeff Garzik qc->n_elem - 1, lsg->length, qc->pad_len); 4424c6fd2807SJeff Garzik } 4425c6fd2807SJeff Garzik 4426c6fd2807SJeff Garzik pre_n_elem = qc->n_elem; 4427c6fd2807SJeff Garzik if (trim_sg && pre_n_elem) 4428c6fd2807SJeff Garzik pre_n_elem--; 4429c6fd2807SJeff Garzik 4430c6fd2807SJeff Garzik if (!pre_n_elem) { 4431c6fd2807SJeff Garzik n_elem = 0; 4432c6fd2807SJeff Garzik goto skip_map; 4433c6fd2807SJeff Garzik } 4434c6fd2807SJeff Garzik 4435c6fd2807SJeff Garzik dir = qc->dma_dir; 4436c6fd2807SJeff Garzik n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir); 4437c6fd2807SJeff Garzik if (n_elem < 1) { 4438c6fd2807SJeff Garzik /* restore last sg */ 4439c6fd2807SJeff Garzik lsg->length += qc->pad_len; 4440c6fd2807SJeff Garzik return -1; 4441c6fd2807SJeff Garzik } 4442c6fd2807SJeff Garzik 4443c6fd2807SJeff Garzik DPRINTK("%d sg elements mapped\n", n_elem); 4444c6fd2807SJeff Garzik 4445c6fd2807SJeff Garzik skip_map: 4446c6fd2807SJeff Garzik qc->n_elem = n_elem; 4447c6fd2807SJeff Garzik 4448c6fd2807SJeff Garzik return 0; 4449c6fd2807SJeff Garzik } 4450c6fd2807SJeff Garzik 4451c6fd2807SJeff Garzik /** 4452c6fd2807SJeff Garzik * swap_buf_le16 - swap halves of 16-bit words in place 4453c6fd2807SJeff Garzik * @buf: Buffer to swap 4454c6fd2807SJeff Garzik * @buf_words: Number of 16-bit words in buffer. 4455c6fd2807SJeff Garzik * 4456c6fd2807SJeff Garzik * Swap halves of 16-bit words if needed to convert from 4457c6fd2807SJeff Garzik * little-endian byte order to native cpu byte order, or 4458c6fd2807SJeff Garzik * vice-versa. 4459c6fd2807SJeff Garzik * 4460c6fd2807SJeff Garzik * LOCKING: 4461c6fd2807SJeff Garzik * Inherited from caller. 4462c6fd2807SJeff Garzik */ 4463c6fd2807SJeff Garzik void swap_buf_le16(u16 *buf, unsigned int buf_words) 4464c6fd2807SJeff Garzik { 4465c6fd2807SJeff Garzik #ifdef __BIG_ENDIAN 4466c6fd2807SJeff Garzik unsigned int i; 4467c6fd2807SJeff Garzik 4468c6fd2807SJeff Garzik for (i = 0; i < buf_words; i++) 4469c6fd2807SJeff Garzik buf[i] = le16_to_cpu(buf[i]); 4470c6fd2807SJeff Garzik #endif /* __BIG_ENDIAN */ 4471c6fd2807SJeff Garzik } 4472c6fd2807SJeff Garzik 4473c6fd2807SJeff Garzik /** 44740d5ff566STejun Heo * ata_data_xfer - Transfer data by PIO 4475c6fd2807SJeff Garzik * @adev: device to target 4476c6fd2807SJeff Garzik * @buf: data buffer 4477c6fd2807SJeff Garzik * @buflen: buffer length 4478c6fd2807SJeff Garzik * @write_data: read/write 4479c6fd2807SJeff Garzik * 4480c6fd2807SJeff Garzik * Transfer data from/to the device data register by PIO. 4481c6fd2807SJeff Garzik * 4482c6fd2807SJeff Garzik * LOCKING: 4483c6fd2807SJeff Garzik * Inherited from caller. 4484c6fd2807SJeff Garzik */ 44850d5ff566STejun Heo void ata_data_xfer(struct ata_device *adev, unsigned char *buf, 4486c6fd2807SJeff Garzik unsigned int buflen, int write_data) 4487c6fd2807SJeff Garzik { 44889af5c9c9STejun Heo struct ata_port *ap = adev->link->ap; 4489c6fd2807SJeff Garzik unsigned int words = buflen >> 1; 4490c6fd2807SJeff Garzik 4491c6fd2807SJeff Garzik /* Transfer multiple of 2 bytes */ 4492c6fd2807SJeff Garzik if (write_data) 44930d5ff566STejun Heo iowrite16_rep(ap->ioaddr.data_addr, buf, words); 4494c6fd2807SJeff Garzik else 44950d5ff566STejun Heo ioread16_rep(ap->ioaddr.data_addr, buf, words); 4496c6fd2807SJeff Garzik 4497c6fd2807SJeff Garzik /* Transfer trailing 1 byte, if any. */ 4498c6fd2807SJeff Garzik if (unlikely(buflen & 0x01)) { 4499c6fd2807SJeff Garzik u16 align_buf[1] = { 0 }; 4500c6fd2807SJeff Garzik unsigned char *trailing_buf = buf + buflen - 1; 4501c6fd2807SJeff Garzik 4502c6fd2807SJeff Garzik if (write_data) { 4503c6fd2807SJeff Garzik memcpy(align_buf, trailing_buf, 1); 45040d5ff566STejun Heo iowrite16(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr); 4505c6fd2807SJeff Garzik } else { 45060d5ff566STejun Heo align_buf[0] = cpu_to_le16(ioread16(ap->ioaddr.data_addr)); 4507c6fd2807SJeff Garzik memcpy(trailing_buf, align_buf, 1); 4508c6fd2807SJeff Garzik } 4509c6fd2807SJeff Garzik } 4510c6fd2807SJeff Garzik } 4511c6fd2807SJeff Garzik 4512c6fd2807SJeff Garzik /** 45130d5ff566STejun Heo * ata_data_xfer_noirq - Transfer data by PIO 4514c6fd2807SJeff Garzik * @adev: device to target 4515c6fd2807SJeff Garzik * @buf: data buffer 4516c6fd2807SJeff Garzik * @buflen: buffer length 4517c6fd2807SJeff Garzik * @write_data: read/write 4518c6fd2807SJeff Garzik * 4519c6fd2807SJeff Garzik * Transfer data from/to the device data register by PIO. Do the 4520c6fd2807SJeff Garzik * transfer with interrupts disabled. 4521c6fd2807SJeff Garzik * 4522c6fd2807SJeff Garzik * LOCKING: 4523c6fd2807SJeff Garzik * Inherited from caller. 4524c6fd2807SJeff Garzik */ 45250d5ff566STejun Heo void ata_data_xfer_noirq(struct ata_device *adev, unsigned char *buf, 4526c6fd2807SJeff Garzik unsigned int buflen, int write_data) 4527c6fd2807SJeff Garzik { 4528c6fd2807SJeff Garzik unsigned long flags; 4529c6fd2807SJeff Garzik local_irq_save(flags); 45300d5ff566STejun Heo ata_data_xfer(adev, buf, buflen, write_data); 4531c6fd2807SJeff Garzik local_irq_restore(flags); 4532c6fd2807SJeff Garzik } 4533c6fd2807SJeff Garzik 4534c6fd2807SJeff Garzik 4535c6fd2807SJeff Garzik /** 45365a5dbd18SMark Lord * ata_pio_sector - Transfer a sector of data. 4537c6fd2807SJeff Garzik * @qc: Command on going 4538c6fd2807SJeff Garzik * 45395a5dbd18SMark Lord * Transfer qc->sect_size bytes of data from/to the ATA device. 4540c6fd2807SJeff Garzik * 4541c6fd2807SJeff Garzik * LOCKING: 4542c6fd2807SJeff Garzik * Inherited from caller. 4543c6fd2807SJeff Garzik */ 4544c6fd2807SJeff Garzik 4545c6fd2807SJeff Garzik static void ata_pio_sector(struct ata_queued_cmd *qc) 4546c6fd2807SJeff Garzik { 4547c6fd2807SJeff Garzik int do_write = (qc->tf.flags & ATA_TFLAG_WRITE); 4548c6fd2807SJeff Garzik struct scatterlist *sg = qc->__sg; 4549c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4550c6fd2807SJeff Garzik struct page *page; 4551c6fd2807SJeff Garzik unsigned int offset; 4552c6fd2807SJeff Garzik unsigned char *buf; 4553c6fd2807SJeff Garzik 45545a5dbd18SMark Lord if (qc->curbytes == qc->nbytes - qc->sect_size) 4555c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4556c6fd2807SJeff Garzik 4557c6fd2807SJeff Garzik page = sg[qc->cursg].page; 4558726f0785STejun Heo offset = sg[qc->cursg].offset + qc->cursg_ofs; 4559c6fd2807SJeff Garzik 4560c6fd2807SJeff Garzik /* get the current page and offset */ 4561c6fd2807SJeff Garzik page = nth_page(page, (offset >> PAGE_SHIFT)); 4562c6fd2807SJeff Garzik offset %= PAGE_SIZE; 4563c6fd2807SJeff Garzik 4564c6fd2807SJeff Garzik DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read"); 4565c6fd2807SJeff Garzik 4566c6fd2807SJeff Garzik if (PageHighMem(page)) { 4567c6fd2807SJeff Garzik unsigned long flags; 4568c6fd2807SJeff Garzik 4569c6fd2807SJeff Garzik /* FIXME: use a bounce buffer */ 4570c6fd2807SJeff Garzik local_irq_save(flags); 4571c6fd2807SJeff Garzik buf = kmap_atomic(page, KM_IRQ0); 4572c6fd2807SJeff Garzik 4573c6fd2807SJeff Garzik /* do the actual data transfer */ 45745a5dbd18SMark Lord ap->ops->data_xfer(qc->dev, buf + offset, qc->sect_size, do_write); 4575c6fd2807SJeff Garzik 4576c6fd2807SJeff Garzik kunmap_atomic(buf, KM_IRQ0); 4577c6fd2807SJeff Garzik local_irq_restore(flags); 4578c6fd2807SJeff Garzik } else { 4579c6fd2807SJeff Garzik buf = page_address(page); 45805a5dbd18SMark Lord ap->ops->data_xfer(qc->dev, buf + offset, qc->sect_size, do_write); 4581c6fd2807SJeff Garzik } 4582c6fd2807SJeff Garzik 45835a5dbd18SMark Lord qc->curbytes += qc->sect_size; 45845a5dbd18SMark Lord qc->cursg_ofs += qc->sect_size; 4585c6fd2807SJeff Garzik 4586726f0785STejun Heo if (qc->cursg_ofs == (&sg[qc->cursg])->length) { 4587c6fd2807SJeff Garzik qc->cursg++; 4588c6fd2807SJeff Garzik qc->cursg_ofs = 0; 4589c6fd2807SJeff Garzik } 4590c6fd2807SJeff Garzik } 4591c6fd2807SJeff Garzik 4592c6fd2807SJeff Garzik /** 45935a5dbd18SMark Lord * ata_pio_sectors - Transfer one or many sectors. 4594c6fd2807SJeff Garzik * @qc: Command on going 4595c6fd2807SJeff Garzik * 45965a5dbd18SMark Lord * Transfer one or many sectors of data from/to the 4597c6fd2807SJeff Garzik * ATA device for the DRQ request. 4598c6fd2807SJeff Garzik * 4599c6fd2807SJeff Garzik * LOCKING: 4600c6fd2807SJeff Garzik * Inherited from caller. 4601c6fd2807SJeff Garzik */ 4602c6fd2807SJeff Garzik 4603c6fd2807SJeff Garzik static void ata_pio_sectors(struct ata_queued_cmd *qc) 4604c6fd2807SJeff Garzik { 4605c6fd2807SJeff Garzik if (is_multi_taskfile(&qc->tf)) { 4606c6fd2807SJeff Garzik /* READ/WRITE MULTIPLE */ 4607c6fd2807SJeff Garzik unsigned int nsect; 4608c6fd2807SJeff Garzik 4609c6fd2807SJeff Garzik WARN_ON(qc->dev->multi_count == 0); 4610c6fd2807SJeff Garzik 46115a5dbd18SMark Lord nsect = min((qc->nbytes - qc->curbytes) / qc->sect_size, 4612726f0785STejun Heo qc->dev->multi_count); 4613c6fd2807SJeff Garzik while (nsect--) 4614c6fd2807SJeff Garzik ata_pio_sector(qc); 4615c6fd2807SJeff Garzik } else 4616c6fd2807SJeff Garzik ata_pio_sector(qc); 4617c6fd2807SJeff Garzik } 4618c6fd2807SJeff Garzik 4619c6fd2807SJeff Garzik /** 4620c6fd2807SJeff Garzik * atapi_send_cdb - Write CDB bytes to hardware 4621c6fd2807SJeff Garzik * @ap: Port to which ATAPI device is attached. 4622c6fd2807SJeff Garzik * @qc: Taskfile currently active 4623c6fd2807SJeff Garzik * 4624c6fd2807SJeff Garzik * When device has indicated its readiness to accept 4625c6fd2807SJeff Garzik * a CDB, this function is called. Send the CDB. 4626c6fd2807SJeff Garzik * 4627c6fd2807SJeff Garzik * LOCKING: 4628c6fd2807SJeff Garzik * caller. 4629c6fd2807SJeff Garzik */ 4630c6fd2807SJeff Garzik 4631c6fd2807SJeff Garzik static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc) 4632c6fd2807SJeff Garzik { 4633c6fd2807SJeff Garzik /* send SCSI cdb */ 4634c6fd2807SJeff Garzik DPRINTK("send cdb\n"); 4635c6fd2807SJeff Garzik WARN_ON(qc->dev->cdb_len < 12); 4636c6fd2807SJeff Garzik 4637c6fd2807SJeff Garzik ap->ops->data_xfer(qc->dev, qc->cdb, qc->dev->cdb_len, 1); 4638c6fd2807SJeff Garzik ata_altstatus(ap); /* flush */ 4639c6fd2807SJeff Garzik 4640c6fd2807SJeff Garzik switch (qc->tf.protocol) { 4641c6fd2807SJeff Garzik case ATA_PROT_ATAPI: 4642c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST; 4643c6fd2807SJeff Garzik break; 4644c6fd2807SJeff Garzik case ATA_PROT_ATAPI_NODATA: 4645c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4646c6fd2807SJeff Garzik break; 4647c6fd2807SJeff Garzik case ATA_PROT_ATAPI_DMA: 4648c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4649c6fd2807SJeff Garzik /* initiate bmdma */ 4650c6fd2807SJeff Garzik ap->ops->bmdma_start(qc); 4651c6fd2807SJeff Garzik break; 4652c6fd2807SJeff Garzik } 4653c6fd2807SJeff Garzik } 4654c6fd2807SJeff Garzik 4655c6fd2807SJeff Garzik /** 4656c6fd2807SJeff Garzik * __atapi_pio_bytes - Transfer data from/to the ATAPI device. 4657c6fd2807SJeff Garzik * @qc: Command on going 4658c6fd2807SJeff Garzik * @bytes: number of bytes 4659c6fd2807SJeff Garzik * 4660c6fd2807SJeff Garzik * Transfer Transfer data from/to the ATAPI device. 4661c6fd2807SJeff Garzik * 4662c6fd2807SJeff Garzik * LOCKING: 4663c6fd2807SJeff Garzik * Inherited from caller. 4664c6fd2807SJeff Garzik * 4665c6fd2807SJeff Garzik */ 4666c6fd2807SJeff Garzik 4667c6fd2807SJeff Garzik static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes) 4668c6fd2807SJeff Garzik { 4669c6fd2807SJeff Garzik int do_write = (qc->tf.flags & ATA_TFLAG_WRITE); 4670c6fd2807SJeff Garzik struct scatterlist *sg = qc->__sg; 4671c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4672c6fd2807SJeff Garzik struct page *page; 4673c6fd2807SJeff Garzik unsigned char *buf; 4674c6fd2807SJeff Garzik unsigned int offset, count; 4675c6fd2807SJeff Garzik 4676c6fd2807SJeff Garzik if (qc->curbytes + bytes >= qc->nbytes) 4677c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4678c6fd2807SJeff Garzik 4679c6fd2807SJeff Garzik next_sg: 4680c6fd2807SJeff Garzik if (unlikely(qc->cursg >= qc->n_elem)) { 4681c6fd2807SJeff Garzik /* 4682c6fd2807SJeff Garzik * The end of qc->sg is reached and the device expects 4683c6fd2807SJeff Garzik * more data to transfer. In order not to overrun qc->sg 4684c6fd2807SJeff Garzik * and fulfill length specified in the byte count register, 4685c6fd2807SJeff Garzik * - for read case, discard trailing data from the device 4686c6fd2807SJeff Garzik * - for write case, padding zero data to the device 4687c6fd2807SJeff Garzik */ 4688c6fd2807SJeff Garzik u16 pad_buf[1] = { 0 }; 4689c6fd2807SJeff Garzik unsigned int words = bytes >> 1; 4690c6fd2807SJeff Garzik unsigned int i; 4691c6fd2807SJeff Garzik 4692c6fd2807SJeff Garzik if (words) /* warning if bytes > 1 */ 4693c6fd2807SJeff Garzik ata_dev_printk(qc->dev, KERN_WARNING, 4694c6fd2807SJeff Garzik "%u bytes trailing data\n", bytes); 4695c6fd2807SJeff Garzik 4696c6fd2807SJeff Garzik for (i = 0; i < words; i++) 4697c6fd2807SJeff Garzik ap->ops->data_xfer(qc->dev, (unsigned char*)pad_buf, 2, do_write); 4698c6fd2807SJeff Garzik 4699c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4700c6fd2807SJeff Garzik return; 4701c6fd2807SJeff Garzik } 4702c6fd2807SJeff Garzik 4703c6fd2807SJeff Garzik sg = &qc->__sg[qc->cursg]; 4704c6fd2807SJeff Garzik 4705c6fd2807SJeff Garzik page = sg->page; 4706c6fd2807SJeff Garzik offset = sg->offset + qc->cursg_ofs; 4707c6fd2807SJeff Garzik 4708c6fd2807SJeff Garzik /* get the current page and offset */ 4709c6fd2807SJeff Garzik page = nth_page(page, (offset >> PAGE_SHIFT)); 4710c6fd2807SJeff Garzik offset %= PAGE_SIZE; 4711c6fd2807SJeff Garzik 4712c6fd2807SJeff Garzik /* don't overrun current sg */ 4713c6fd2807SJeff Garzik count = min(sg->length - qc->cursg_ofs, bytes); 4714c6fd2807SJeff Garzik 4715c6fd2807SJeff Garzik /* don't cross page boundaries */ 4716c6fd2807SJeff Garzik count = min(count, (unsigned int)PAGE_SIZE - offset); 4717c6fd2807SJeff Garzik 4718c6fd2807SJeff Garzik DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read"); 4719c6fd2807SJeff Garzik 4720c6fd2807SJeff Garzik if (PageHighMem(page)) { 4721c6fd2807SJeff Garzik unsigned long flags; 4722c6fd2807SJeff Garzik 4723c6fd2807SJeff Garzik /* FIXME: use bounce buffer */ 4724c6fd2807SJeff Garzik local_irq_save(flags); 4725c6fd2807SJeff Garzik buf = kmap_atomic(page, KM_IRQ0); 4726c6fd2807SJeff Garzik 4727c6fd2807SJeff Garzik /* do the actual data transfer */ 4728c6fd2807SJeff Garzik ap->ops->data_xfer(qc->dev, buf + offset, count, do_write); 4729c6fd2807SJeff Garzik 4730c6fd2807SJeff Garzik kunmap_atomic(buf, KM_IRQ0); 4731c6fd2807SJeff Garzik local_irq_restore(flags); 4732c6fd2807SJeff Garzik } else { 4733c6fd2807SJeff Garzik buf = page_address(page); 4734c6fd2807SJeff Garzik ap->ops->data_xfer(qc->dev, buf + offset, count, do_write); 4735c6fd2807SJeff Garzik } 4736c6fd2807SJeff Garzik 4737c6fd2807SJeff Garzik bytes -= count; 4738c6fd2807SJeff Garzik qc->curbytes += count; 4739c6fd2807SJeff Garzik qc->cursg_ofs += count; 4740c6fd2807SJeff Garzik 4741c6fd2807SJeff Garzik if (qc->cursg_ofs == sg->length) { 4742c6fd2807SJeff Garzik qc->cursg++; 4743c6fd2807SJeff Garzik qc->cursg_ofs = 0; 4744c6fd2807SJeff Garzik } 4745c6fd2807SJeff Garzik 4746c6fd2807SJeff Garzik if (bytes) 4747c6fd2807SJeff Garzik goto next_sg; 4748c6fd2807SJeff Garzik } 4749c6fd2807SJeff Garzik 4750c6fd2807SJeff Garzik /** 4751c6fd2807SJeff Garzik * atapi_pio_bytes - Transfer data from/to the ATAPI device. 4752c6fd2807SJeff Garzik * @qc: Command on going 4753c6fd2807SJeff Garzik * 4754c6fd2807SJeff Garzik * Transfer Transfer data from/to the ATAPI device. 4755c6fd2807SJeff Garzik * 4756c6fd2807SJeff Garzik * LOCKING: 4757c6fd2807SJeff Garzik * Inherited from caller. 4758c6fd2807SJeff Garzik */ 4759c6fd2807SJeff Garzik 4760c6fd2807SJeff Garzik static void atapi_pio_bytes(struct ata_queued_cmd *qc) 4761c6fd2807SJeff Garzik { 4762c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4763c6fd2807SJeff Garzik struct ata_device *dev = qc->dev; 4764c6fd2807SJeff Garzik unsigned int ireason, bc_lo, bc_hi, bytes; 4765c6fd2807SJeff Garzik int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0; 4766c6fd2807SJeff Garzik 4767c6fd2807SJeff Garzik /* Abuse qc->result_tf for temp storage of intermediate TF 4768c6fd2807SJeff Garzik * here to save some kernel stack usage. 4769c6fd2807SJeff Garzik * For normal completion, qc->result_tf is not relevant. For 4770c6fd2807SJeff Garzik * error, qc->result_tf is later overwritten by ata_qc_complete(). 4771c6fd2807SJeff Garzik * So, the correctness of qc->result_tf is not affected. 4772c6fd2807SJeff Garzik */ 4773c6fd2807SJeff Garzik ap->ops->tf_read(ap, &qc->result_tf); 4774c6fd2807SJeff Garzik ireason = qc->result_tf.nsect; 4775c6fd2807SJeff Garzik bc_lo = qc->result_tf.lbam; 4776c6fd2807SJeff Garzik bc_hi = qc->result_tf.lbah; 4777c6fd2807SJeff Garzik bytes = (bc_hi << 8) | bc_lo; 4778c6fd2807SJeff Garzik 4779c6fd2807SJeff Garzik /* shall be cleared to zero, indicating xfer of data */ 4780c6fd2807SJeff Garzik if (ireason & (1 << 0)) 4781c6fd2807SJeff Garzik goto err_out; 4782c6fd2807SJeff Garzik 4783c6fd2807SJeff Garzik /* make sure transfer direction matches expected */ 4784c6fd2807SJeff Garzik i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0; 4785c6fd2807SJeff Garzik if (do_write != i_write) 4786c6fd2807SJeff Garzik goto err_out; 4787c6fd2807SJeff Garzik 478844877b4eSTejun Heo VPRINTK("ata%u: xfering %d bytes\n", ap->print_id, bytes); 4789c6fd2807SJeff Garzik 4790c6fd2807SJeff Garzik __atapi_pio_bytes(qc, bytes); 4791c6fd2807SJeff Garzik 4792c6fd2807SJeff Garzik return; 4793c6fd2807SJeff Garzik 4794c6fd2807SJeff Garzik err_out: 4795c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "ATAPI check failed\n"); 4796c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HSM; 4797c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 4798c6fd2807SJeff Garzik } 4799c6fd2807SJeff Garzik 4800c6fd2807SJeff Garzik /** 4801c6fd2807SJeff Garzik * ata_hsm_ok_in_wq - Check if the qc can be handled in the workqueue. 4802c6fd2807SJeff Garzik * @ap: the target ata_port 4803c6fd2807SJeff Garzik * @qc: qc on going 4804c6fd2807SJeff Garzik * 4805c6fd2807SJeff Garzik * RETURNS: 4806c6fd2807SJeff Garzik * 1 if ok in workqueue, 0 otherwise. 4807c6fd2807SJeff Garzik */ 4808c6fd2807SJeff Garzik 4809c6fd2807SJeff Garzik static inline int ata_hsm_ok_in_wq(struct ata_port *ap, struct ata_queued_cmd *qc) 4810c6fd2807SJeff Garzik { 4811c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 4812c6fd2807SJeff Garzik return 1; 4813c6fd2807SJeff Garzik 4814c6fd2807SJeff Garzik if (ap->hsm_task_state == HSM_ST_FIRST) { 4815c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_PIO && 4816c6fd2807SJeff Garzik (qc->tf.flags & ATA_TFLAG_WRITE)) 4817c6fd2807SJeff Garzik return 1; 4818c6fd2807SJeff Garzik 4819c6fd2807SJeff Garzik if (is_atapi_taskfile(&qc->tf) && 4820c6fd2807SJeff Garzik !(qc->dev->flags & ATA_DFLAG_CDB_INTR)) 4821c6fd2807SJeff Garzik return 1; 4822c6fd2807SJeff Garzik } 4823c6fd2807SJeff Garzik 4824c6fd2807SJeff Garzik return 0; 4825c6fd2807SJeff Garzik } 4826c6fd2807SJeff Garzik 4827c6fd2807SJeff Garzik /** 4828c6fd2807SJeff Garzik * ata_hsm_qc_complete - finish a qc running on standard HSM 4829c6fd2807SJeff Garzik * @qc: Command to complete 4830c6fd2807SJeff Garzik * @in_wq: 1 if called from workqueue, 0 otherwise 4831c6fd2807SJeff Garzik * 4832c6fd2807SJeff Garzik * Finish @qc which is running on standard HSM. 4833c6fd2807SJeff Garzik * 4834c6fd2807SJeff Garzik * LOCKING: 4835cca3974eSJeff Garzik * If @in_wq is zero, spin_lock_irqsave(host lock). 4836c6fd2807SJeff Garzik * Otherwise, none on entry and grabs host lock. 4837c6fd2807SJeff Garzik */ 4838c6fd2807SJeff Garzik static void ata_hsm_qc_complete(struct ata_queued_cmd *qc, int in_wq) 4839c6fd2807SJeff Garzik { 4840c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4841c6fd2807SJeff Garzik unsigned long flags; 4842c6fd2807SJeff Garzik 4843c6fd2807SJeff Garzik if (ap->ops->error_handler) { 4844c6fd2807SJeff Garzik if (in_wq) { 4845c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 4846c6fd2807SJeff Garzik 4847cca3974eSJeff Garzik /* EH might have kicked in while host lock is 4848cca3974eSJeff Garzik * released. 4849c6fd2807SJeff Garzik */ 4850c6fd2807SJeff Garzik qc = ata_qc_from_tag(ap, qc->tag); 4851c6fd2807SJeff Garzik if (qc) { 4852c6fd2807SJeff Garzik if (likely(!(qc->err_mask & AC_ERR_HSM))) { 485383625006SAkira Iguchi ap->ops->irq_on(ap); 4854c6fd2807SJeff Garzik ata_qc_complete(qc); 4855c6fd2807SJeff Garzik } else 4856c6fd2807SJeff Garzik ata_port_freeze(ap); 4857c6fd2807SJeff Garzik } 4858c6fd2807SJeff Garzik 4859c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 4860c6fd2807SJeff Garzik } else { 4861c6fd2807SJeff Garzik if (likely(!(qc->err_mask & AC_ERR_HSM))) 4862c6fd2807SJeff Garzik ata_qc_complete(qc); 4863c6fd2807SJeff Garzik else 4864c6fd2807SJeff Garzik ata_port_freeze(ap); 4865c6fd2807SJeff Garzik } 4866c6fd2807SJeff Garzik } else { 4867c6fd2807SJeff Garzik if (in_wq) { 4868c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 486983625006SAkira Iguchi ap->ops->irq_on(ap); 4870c6fd2807SJeff Garzik ata_qc_complete(qc); 4871c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 4872c6fd2807SJeff Garzik } else 4873c6fd2807SJeff Garzik ata_qc_complete(qc); 4874c6fd2807SJeff Garzik } 4875c6fd2807SJeff Garzik } 4876c6fd2807SJeff Garzik 4877c6fd2807SJeff Garzik /** 4878c6fd2807SJeff Garzik * ata_hsm_move - move the HSM to the next state. 4879c6fd2807SJeff Garzik * @ap: the target ata_port 4880c6fd2807SJeff Garzik * @qc: qc on going 4881c6fd2807SJeff Garzik * @status: current device status 4882c6fd2807SJeff Garzik * @in_wq: 1 if called from workqueue, 0 otherwise 4883c6fd2807SJeff Garzik * 4884c6fd2807SJeff Garzik * RETURNS: 4885c6fd2807SJeff Garzik * 1 when poll next status needed, 0 otherwise. 4886c6fd2807SJeff Garzik */ 4887c6fd2807SJeff Garzik int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc, 4888c6fd2807SJeff Garzik u8 status, int in_wq) 4889c6fd2807SJeff Garzik { 4890c6fd2807SJeff Garzik unsigned long flags = 0; 4891c6fd2807SJeff Garzik int poll_next; 4892c6fd2807SJeff Garzik 4893c6fd2807SJeff Garzik WARN_ON((qc->flags & ATA_QCFLAG_ACTIVE) == 0); 4894c6fd2807SJeff Garzik 4895c6fd2807SJeff Garzik /* Make sure ata_qc_issue_prot() does not throw things 4896c6fd2807SJeff Garzik * like DMA polling into the workqueue. Notice that 4897c6fd2807SJeff Garzik * in_wq is not equivalent to (qc->tf.flags & ATA_TFLAG_POLLING). 4898c6fd2807SJeff Garzik */ 4899c6fd2807SJeff Garzik WARN_ON(in_wq != ata_hsm_ok_in_wq(ap, qc)); 4900c6fd2807SJeff Garzik 4901c6fd2807SJeff Garzik fsm_start: 4902c6fd2807SJeff Garzik DPRINTK("ata%u: protocol %d task_state %d (dev_stat 0x%X)\n", 490344877b4eSTejun Heo ap->print_id, qc->tf.protocol, ap->hsm_task_state, status); 4904c6fd2807SJeff Garzik 4905c6fd2807SJeff Garzik switch (ap->hsm_task_state) { 4906c6fd2807SJeff Garzik case HSM_ST_FIRST: 4907c6fd2807SJeff Garzik /* Send first data block or PACKET CDB */ 4908c6fd2807SJeff Garzik 4909c6fd2807SJeff Garzik /* If polling, we will stay in the work queue after 4910c6fd2807SJeff Garzik * sending the data. Otherwise, interrupt handler 4911c6fd2807SJeff Garzik * takes over after sending the data. 4912c6fd2807SJeff Garzik */ 4913c6fd2807SJeff Garzik poll_next = (qc->tf.flags & ATA_TFLAG_POLLING); 4914c6fd2807SJeff Garzik 4915c6fd2807SJeff Garzik /* check device status */ 4916c6fd2807SJeff Garzik if (unlikely((status & ATA_DRQ) == 0)) { 4917c6fd2807SJeff Garzik /* handle BSY=0, DRQ=0 as error */ 4918c6fd2807SJeff Garzik if (likely(status & (ATA_ERR | ATA_DF))) 4919c6fd2807SJeff Garzik /* device stops HSM for abort/error */ 4920c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_DEV; 4921c6fd2807SJeff Garzik else 4922c6fd2807SJeff Garzik /* HSM violation. Let EH handle this */ 4923c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HSM; 4924c6fd2807SJeff Garzik 4925c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 4926c6fd2807SJeff Garzik goto fsm_start; 4927c6fd2807SJeff Garzik } 4928c6fd2807SJeff Garzik 4929c6fd2807SJeff Garzik /* Device should not ask for data transfer (DRQ=1) 4930c6fd2807SJeff Garzik * when it finds something wrong. 4931c6fd2807SJeff Garzik * We ignore DRQ here and stop the HSM by 4932c6fd2807SJeff Garzik * changing hsm_task_state to HSM_ST_ERR and 4933c6fd2807SJeff Garzik * let the EH abort the command or reset the device. 4934c6fd2807SJeff Garzik */ 4935c6fd2807SJeff Garzik if (unlikely(status & (ATA_ERR | ATA_DF))) { 493644877b4eSTejun Heo ata_port_printk(ap, KERN_WARNING, "DRQ=1 with device " 493744877b4eSTejun Heo "error, dev_stat 0x%X\n", status); 4938c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HSM; 4939c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 4940c6fd2807SJeff Garzik goto fsm_start; 4941c6fd2807SJeff Garzik } 4942c6fd2807SJeff Garzik 4943c6fd2807SJeff Garzik /* Send the CDB (atapi) or the first data block (ata pio out). 4944c6fd2807SJeff Garzik * During the state transition, interrupt handler shouldn't 4945c6fd2807SJeff Garzik * be invoked before the data transfer is complete and 4946c6fd2807SJeff Garzik * hsm_task_state is changed. Hence, the following locking. 4947c6fd2807SJeff Garzik */ 4948c6fd2807SJeff Garzik if (in_wq) 4949c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 4950c6fd2807SJeff Garzik 4951c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_PIO) { 4952c6fd2807SJeff Garzik /* PIO data out protocol. 4953c6fd2807SJeff Garzik * send first data block. 4954c6fd2807SJeff Garzik */ 4955c6fd2807SJeff Garzik 4956c6fd2807SJeff Garzik /* ata_pio_sectors() might change the state 4957c6fd2807SJeff Garzik * to HSM_ST_LAST. so, the state is changed here 4958c6fd2807SJeff Garzik * before ata_pio_sectors(). 4959c6fd2807SJeff Garzik */ 4960c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST; 4961c6fd2807SJeff Garzik ata_pio_sectors(qc); 4962c6fd2807SJeff Garzik ata_altstatus(ap); /* flush */ 4963c6fd2807SJeff Garzik } else 4964c6fd2807SJeff Garzik /* send CDB */ 4965c6fd2807SJeff Garzik atapi_send_cdb(ap, qc); 4966c6fd2807SJeff Garzik 4967c6fd2807SJeff Garzik if (in_wq) 4968c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 4969c6fd2807SJeff Garzik 4970c6fd2807SJeff Garzik /* if polling, ata_pio_task() handles the rest. 4971c6fd2807SJeff Garzik * otherwise, interrupt handler takes over from here. 4972c6fd2807SJeff Garzik */ 4973c6fd2807SJeff Garzik break; 4974c6fd2807SJeff Garzik 4975c6fd2807SJeff Garzik case HSM_ST: 4976c6fd2807SJeff Garzik /* complete command or read/write the data register */ 4977c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_ATAPI) { 4978c6fd2807SJeff Garzik /* ATAPI PIO protocol */ 4979c6fd2807SJeff Garzik if ((status & ATA_DRQ) == 0) { 4980c6fd2807SJeff Garzik /* No more data to transfer or device error. 4981c6fd2807SJeff Garzik * Device error will be tagged in HSM_ST_LAST. 4982c6fd2807SJeff Garzik */ 4983c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 4984c6fd2807SJeff Garzik goto fsm_start; 4985c6fd2807SJeff Garzik } 4986c6fd2807SJeff Garzik 4987c6fd2807SJeff Garzik /* Device should not ask for data transfer (DRQ=1) 4988c6fd2807SJeff Garzik * when it finds something wrong. 4989c6fd2807SJeff Garzik * We ignore DRQ here and stop the HSM by 4990c6fd2807SJeff Garzik * changing hsm_task_state to HSM_ST_ERR and 4991c6fd2807SJeff Garzik * let the EH abort the command or reset the device. 4992c6fd2807SJeff Garzik */ 4993c6fd2807SJeff Garzik if (unlikely(status & (ATA_ERR | ATA_DF))) { 499444877b4eSTejun Heo ata_port_printk(ap, KERN_WARNING, "DRQ=1 with " 499544877b4eSTejun Heo "device error, dev_stat 0x%X\n", 499644877b4eSTejun Heo status); 4997c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HSM; 4998c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 4999c6fd2807SJeff Garzik goto fsm_start; 5000c6fd2807SJeff Garzik } 5001c6fd2807SJeff Garzik 5002c6fd2807SJeff Garzik atapi_pio_bytes(qc); 5003c6fd2807SJeff Garzik 5004c6fd2807SJeff Garzik if (unlikely(ap->hsm_task_state == HSM_ST_ERR)) 5005c6fd2807SJeff Garzik /* bad ireason reported by device */ 5006c6fd2807SJeff Garzik goto fsm_start; 5007c6fd2807SJeff Garzik 5008c6fd2807SJeff Garzik } else { 5009c6fd2807SJeff Garzik /* ATA PIO protocol */ 5010c6fd2807SJeff Garzik if (unlikely((status & ATA_DRQ) == 0)) { 5011c6fd2807SJeff Garzik /* handle BSY=0, DRQ=0 as error */ 5012c6fd2807SJeff Garzik if (likely(status & (ATA_ERR | ATA_DF))) 5013c6fd2807SJeff Garzik /* device stops HSM for abort/error */ 5014c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_DEV; 5015c6fd2807SJeff Garzik else 501655a8e2c8STejun Heo /* HSM violation. Let EH handle this. 501755a8e2c8STejun Heo * Phantom devices also trigger this 501855a8e2c8STejun Heo * condition. Mark hint. 501955a8e2c8STejun Heo */ 502055a8e2c8STejun Heo qc->err_mask |= AC_ERR_HSM | 502155a8e2c8STejun Heo AC_ERR_NODEV_HINT; 5022c6fd2807SJeff Garzik 5023c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 5024c6fd2807SJeff Garzik goto fsm_start; 5025c6fd2807SJeff Garzik } 5026c6fd2807SJeff Garzik 5027c6fd2807SJeff Garzik /* For PIO reads, some devices may ask for 5028c6fd2807SJeff Garzik * data transfer (DRQ=1) alone with ERR=1. 5029c6fd2807SJeff Garzik * We respect DRQ here and transfer one 5030c6fd2807SJeff Garzik * block of junk data before changing the 5031c6fd2807SJeff Garzik * hsm_task_state to HSM_ST_ERR. 5032c6fd2807SJeff Garzik * 5033c6fd2807SJeff Garzik * For PIO writes, ERR=1 DRQ=1 doesn't make 5034c6fd2807SJeff Garzik * sense since the data block has been 5035c6fd2807SJeff Garzik * transferred to the device. 5036c6fd2807SJeff Garzik */ 5037c6fd2807SJeff Garzik if (unlikely(status & (ATA_ERR | ATA_DF))) { 5038c6fd2807SJeff Garzik /* data might be corrputed */ 5039c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_DEV; 5040c6fd2807SJeff Garzik 5041c6fd2807SJeff Garzik if (!(qc->tf.flags & ATA_TFLAG_WRITE)) { 5042c6fd2807SJeff Garzik ata_pio_sectors(qc); 5043c6fd2807SJeff Garzik ata_altstatus(ap); 5044c6fd2807SJeff Garzik status = ata_wait_idle(ap); 5045c6fd2807SJeff Garzik } 5046c6fd2807SJeff Garzik 5047c6fd2807SJeff Garzik if (status & (ATA_BUSY | ATA_DRQ)) 5048c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HSM; 5049c6fd2807SJeff Garzik 5050c6fd2807SJeff Garzik /* ata_pio_sectors() might change the 5051c6fd2807SJeff Garzik * state to HSM_ST_LAST. so, the state 5052c6fd2807SJeff Garzik * is changed after ata_pio_sectors(). 5053c6fd2807SJeff Garzik */ 5054c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 5055c6fd2807SJeff Garzik goto fsm_start; 5056c6fd2807SJeff Garzik } 5057c6fd2807SJeff Garzik 5058c6fd2807SJeff Garzik ata_pio_sectors(qc); 5059c6fd2807SJeff Garzik 5060c6fd2807SJeff Garzik if (ap->hsm_task_state == HSM_ST_LAST && 5061c6fd2807SJeff Garzik (!(qc->tf.flags & ATA_TFLAG_WRITE))) { 5062c6fd2807SJeff Garzik /* all data read */ 5063c6fd2807SJeff Garzik ata_altstatus(ap); 5064c6fd2807SJeff Garzik status = ata_wait_idle(ap); 5065c6fd2807SJeff Garzik goto fsm_start; 5066c6fd2807SJeff Garzik } 5067c6fd2807SJeff Garzik } 5068c6fd2807SJeff Garzik 5069c6fd2807SJeff Garzik ata_altstatus(ap); /* flush */ 5070c6fd2807SJeff Garzik poll_next = 1; 5071c6fd2807SJeff Garzik break; 5072c6fd2807SJeff Garzik 5073c6fd2807SJeff Garzik case HSM_ST_LAST: 5074c6fd2807SJeff Garzik if (unlikely(!ata_ok(status))) { 5075c6fd2807SJeff Garzik qc->err_mask |= __ac_err_mask(status); 5076c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 5077c6fd2807SJeff Garzik goto fsm_start; 5078c6fd2807SJeff Garzik } 5079c6fd2807SJeff Garzik 5080c6fd2807SJeff Garzik /* no more data to transfer */ 5081c6fd2807SJeff Garzik DPRINTK("ata%u: dev %u command complete, drv_stat 0x%x\n", 508244877b4eSTejun Heo ap->print_id, qc->dev->devno, status); 5083c6fd2807SJeff Garzik 5084c6fd2807SJeff Garzik WARN_ON(qc->err_mask); 5085c6fd2807SJeff Garzik 5086c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_IDLE; 5087c6fd2807SJeff Garzik 5088c6fd2807SJeff Garzik /* complete taskfile transaction */ 5089c6fd2807SJeff Garzik ata_hsm_qc_complete(qc, in_wq); 5090c6fd2807SJeff Garzik 5091c6fd2807SJeff Garzik poll_next = 0; 5092c6fd2807SJeff Garzik break; 5093c6fd2807SJeff Garzik 5094c6fd2807SJeff Garzik case HSM_ST_ERR: 5095c6fd2807SJeff Garzik /* make sure qc->err_mask is available to 5096c6fd2807SJeff Garzik * know what's wrong and recover 5097c6fd2807SJeff Garzik */ 5098c6fd2807SJeff Garzik WARN_ON(qc->err_mask == 0); 5099c6fd2807SJeff Garzik 5100c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_IDLE; 5101c6fd2807SJeff Garzik 5102c6fd2807SJeff Garzik /* complete taskfile transaction */ 5103c6fd2807SJeff Garzik ata_hsm_qc_complete(qc, in_wq); 5104c6fd2807SJeff Garzik 5105c6fd2807SJeff Garzik poll_next = 0; 5106c6fd2807SJeff Garzik break; 5107c6fd2807SJeff Garzik default: 5108c6fd2807SJeff Garzik poll_next = 0; 5109c6fd2807SJeff Garzik BUG(); 5110c6fd2807SJeff Garzik } 5111c6fd2807SJeff Garzik 5112c6fd2807SJeff Garzik return poll_next; 5113c6fd2807SJeff Garzik } 5114c6fd2807SJeff Garzik 511565f27f38SDavid Howells static void ata_pio_task(struct work_struct *work) 5116c6fd2807SJeff Garzik { 511765f27f38SDavid Howells struct ata_port *ap = 511865f27f38SDavid Howells container_of(work, struct ata_port, port_task.work); 511965f27f38SDavid Howells struct ata_queued_cmd *qc = ap->port_task_data; 5120c6fd2807SJeff Garzik u8 status; 5121c6fd2807SJeff Garzik int poll_next; 5122c6fd2807SJeff Garzik 5123c6fd2807SJeff Garzik fsm_start: 5124c6fd2807SJeff Garzik WARN_ON(ap->hsm_task_state == HSM_ST_IDLE); 5125c6fd2807SJeff Garzik 5126c6fd2807SJeff Garzik /* 5127c6fd2807SJeff Garzik * This is purely heuristic. This is a fast path. 5128c6fd2807SJeff Garzik * Sometimes when we enter, BSY will be cleared in 5129c6fd2807SJeff Garzik * a chk-status or two. If not, the drive is probably seeking 5130c6fd2807SJeff Garzik * or something. Snooze for a couple msecs, then 5131c6fd2807SJeff Garzik * chk-status again. If still busy, queue delayed work. 5132c6fd2807SJeff Garzik */ 5133c6fd2807SJeff Garzik status = ata_busy_wait(ap, ATA_BUSY, 5); 5134c6fd2807SJeff Garzik if (status & ATA_BUSY) { 5135c6fd2807SJeff Garzik msleep(2); 5136c6fd2807SJeff Garzik status = ata_busy_wait(ap, ATA_BUSY, 10); 5137c6fd2807SJeff Garzik if (status & ATA_BUSY) { 5138c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, ATA_SHORT_PAUSE); 5139c6fd2807SJeff Garzik return; 5140c6fd2807SJeff Garzik } 5141c6fd2807SJeff Garzik } 5142c6fd2807SJeff Garzik 5143c6fd2807SJeff Garzik /* move the HSM */ 5144c6fd2807SJeff Garzik poll_next = ata_hsm_move(ap, qc, status, 1); 5145c6fd2807SJeff Garzik 5146c6fd2807SJeff Garzik /* another command or interrupt handler 5147c6fd2807SJeff Garzik * may be running at this point. 5148c6fd2807SJeff Garzik */ 5149c6fd2807SJeff Garzik if (poll_next) 5150c6fd2807SJeff Garzik goto fsm_start; 5151c6fd2807SJeff Garzik } 5152c6fd2807SJeff Garzik 5153c6fd2807SJeff Garzik /** 5154c6fd2807SJeff Garzik * ata_qc_new - Request an available ATA command, for queueing 5155c6fd2807SJeff Garzik * @ap: Port associated with device @dev 5156c6fd2807SJeff Garzik * @dev: Device from whom we request an available command structure 5157c6fd2807SJeff Garzik * 5158c6fd2807SJeff Garzik * LOCKING: 5159c6fd2807SJeff Garzik * None. 5160c6fd2807SJeff Garzik */ 5161c6fd2807SJeff Garzik 5162c6fd2807SJeff Garzik static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap) 5163c6fd2807SJeff Garzik { 5164c6fd2807SJeff Garzik struct ata_queued_cmd *qc = NULL; 5165c6fd2807SJeff Garzik unsigned int i; 5166c6fd2807SJeff Garzik 5167c6fd2807SJeff Garzik /* no command while frozen */ 5168c6fd2807SJeff Garzik if (unlikely(ap->pflags & ATA_PFLAG_FROZEN)) 5169c6fd2807SJeff Garzik return NULL; 5170c6fd2807SJeff Garzik 5171c6fd2807SJeff Garzik /* the last tag is reserved for internal command. */ 5172c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_QUEUE - 1; i++) 5173c6fd2807SJeff Garzik if (!test_and_set_bit(i, &ap->qc_allocated)) { 5174c6fd2807SJeff Garzik qc = __ata_qc_from_tag(ap, i); 5175c6fd2807SJeff Garzik break; 5176c6fd2807SJeff Garzik } 5177c6fd2807SJeff Garzik 5178c6fd2807SJeff Garzik if (qc) 5179c6fd2807SJeff Garzik qc->tag = i; 5180c6fd2807SJeff Garzik 5181c6fd2807SJeff Garzik return qc; 5182c6fd2807SJeff Garzik } 5183c6fd2807SJeff Garzik 5184c6fd2807SJeff Garzik /** 5185c6fd2807SJeff Garzik * ata_qc_new_init - Request an available ATA command, and initialize it 5186c6fd2807SJeff Garzik * @dev: Device from whom we request an available command structure 5187c6fd2807SJeff Garzik * 5188c6fd2807SJeff Garzik * LOCKING: 5189c6fd2807SJeff Garzik * None. 5190c6fd2807SJeff Garzik */ 5191c6fd2807SJeff Garzik 5192c6fd2807SJeff Garzik struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev) 5193c6fd2807SJeff Garzik { 51949af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 5195c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 5196c6fd2807SJeff Garzik 5197c6fd2807SJeff Garzik qc = ata_qc_new(ap); 5198c6fd2807SJeff Garzik if (qc) { 5199c6fd2807SJeff Garzik qc->scsicmd = NULL; 5200c6fd2807SJeff Garzik qc->ap = ap; 5201c6fd2807SJeff Garzik qc->dev = dev; 5202c6fd2807SJeff Garzik 5203c6fd2807SJeff Garzik ata_qc_reinit(qc); 5204c6fd2807SJeff Garzik } 5205c6fd2807SJeff Garzik 5206c6fd2807SJeff Garzik return qc; 5207c6fd2807SJeff Garzik } 5208c6fd2807SJeff Garzik 5209c6fd2807SJeff Garzik /** 5210c6fd2807SJeff Garzik * ata_qc_free - free unused ata_queued_cmd 5211c6fd2807SJeff Garzik * @qc: Command to complete 5212c6fd2807SJeff Garzik * 5213c6fd2807SJeff Garzik * Designed to free unused ata_queued_cmd object 5214c6fd2807SJeff Garzik * in case something prevents using it. 5215c6fd2807SJeff Garzik * 5216c6fd2807SJeff Garzik * LOCKING: 5217cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 5218c6fd2807SJeff Garzik */ 5219c6fd2807SJeff Garzik void ata_qc_free(struct ata_queued_cmd *qc) 5220c6fd2807SJeff Garzik { 5221c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 5222c6fd2807SJeff Garzik unsigned int tag; 5223c6fd2807SJeff Garzik 5224c6fd2807SJeff Garzik WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */ 5225c6fd2807SJeff Garzik 5226c6fd2807SJeff Garzik qc->flags = 0; 5227c6fd2807SJeff Garzik tag = qc->tag; 5228c6fd2807SJeff Garzik if (likely(ata_tag_valid(tag))) { 5229c6fd2807SJeff Garzik qc->tag = ATA_TAG_POISON; 5230c6fd2807SJeff Garzik clear_bit(tag, &ap->qc_allocated); 5231c6fd2807SJeff Garzik } 5232c6fd2807SJeff Garzik } 5233c6fd2807SJeff Garzik 5234c6fd2807SJeff Garzik void __ata_qc_complete(struct ata_queued_cmd *qc) 5235c6fd2807SJeff Garzik { 5236c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 52379af5c9c9STejun Heo struct ata_link *link = qc->dev->link; 5238c6fd2807SJeff Garzik 5239c6fd2807SJeff Garzik WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */ 5240c6fd2807SJeff Garzik WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE)); 5241c6fd2807SJeff Garzik 5242c6fd2807SJeff Garzik if (likely(qc->flags & ATA_QCFLAG_DMAMAP)) 5243c6fd2807SJeff Garzik ata_sg_clean(qc); 5244c6fd2807SJeff Garzik 5245c6fd2807SJeff Garzik /* command should be marked inactive atomically with qc completion */ 5246c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_NCQ) 52479af5c9c9STejun Heo link->sactive &= ~(1 << qc->tag); 5248c6fd2807SJeff Garzik else 52499af5c9c9STejun Heo link->active_tag = ATA_TAG_POISON; 5250c6fd2807SJeff Garzik 5251c6fd2807SJeff Garzik /* atapi: mark qc as inactive to prevent the interrupt handler 5252c6fd2807SJeff Garzik * from completing the command twice later, before the error handler 5253c6fd2807SJeff Garzik * is called. (when rc != 0 and atapi request sense is needed) 5254c6fd2807SJeff Garzik */ 5255c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_ACTIVE; 5256c6fd2807SJeff Garzik ap->qc_active &= ~(1 << qc->tag); 5257c6fd2807SJeff Garzik 5258c6fd2807SJeff Garzik /* call completion callback */ 5259c6fd2807SJeff Garzik qc->complete_fn(qc); 5260c6fd2807SJeff Garzik } 5261c6fd2807SJeff Garzik 526239599a53STejun Heo static void fill_result_tf(struct ata_queued_cmd *qc) 526339599a53STejun Heo { 526439599a53STejun Heo struct ata_port *ap = qc->ap; 526539599a53STejun Heo 526639599a53STejun Heo qc->result_tf.flags = qc->tf.flags; 52674742d54fSMark Lord ap->ops->tf_read(ap, &qc->result_tf); 526839599a53STejun Heo } 526939599a53STejun Heo 5270c6fd2807SJeff Garzik /** 5271c6fd2807SJeff Garzik * ata_qc_complete - Complete an active ATA command 5272c6fd2807SJeff Garzik * @qc: Command to complete 5273c6fd2807SJeff Garzik * @err_mask: ATA Status register contents 5274c6fd2807SJeff Garzik * 5275c6fd2807SJeff Garzik * Indicate to the mid and upper layers that an ATA 5276c6fd2807SJeff Garzik * command has completed, with either an ok or not-ok status. 5277c6fd2807SJeff Garzik * 5278c6fd2807SJeff Garzik * LOCKING: 5279cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 5280c6fd2807SJeff Garzik */ 5281c6fd2807SJeff Garzik void ata_qc_complete(struct ata_queued_cmd *qc) 5282c6fd2807SJeff Garzik { 5283c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 5284c6fd2807SJeff Garzik 5285c6fd2807SJeff Garzik /* XXX: New EH and old EH use different mechanisms to 5286c6fd2807SJeff Garzik * synchronize EH with regular execution path. 5287c6fd2807SJeff Garzik * 5288c6fd2807SJeff Garzik * In new EH, a failed qc is marked with ATA_QCFLAG_FAILED. 5289c6fd2807SJeff Garzik * Normal execution path is responsible for not accessing a 5290c6fd2807SJeff Garzik * failed qc. libata core enforces the rule by returning NULL 5291c6fd2807SJeff Garzik * from ata_qc_from_tag() for failed qcs. 5292c6fd2807SJeff Garzik * 5293c6fd2807SJeff Garzik * Old EH depends on ata_qc_complete() nullifying completion 5294c6fd2807SJeff Garzik * requests if ATA_QCFLAG_EH_SCHEDULED is set. Old EH does 5295c6fd2807SJeff Garzik * not synchronize with interrupt handler. Only PIO task is 5296c6fd2807SJeff Garzik * taken care of. 5297c6fd2807SJeff Garzik */ 5298c6fd2807SJeff Garzik if (ap->ops->error_handler) { 5299c6fd2807SJeff Garzik WARN_ON(ap->pflags & ATA_PFLAG_FROZEN); 5300c6fd2807SJeff Garzik 5301c6fd2807SJeff Garzik if (unlikely(qc->err_mask)) 5302c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_FAILED; 5303c6fd2807SJeff Garzik 5304c6fd2807SJeff Garzik if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) { 5305c6fd2807SJeff Garzik if (!ata_tag_internal(qc->tag)) { 5306c6fd2807SJeff Garzik /* always fill result TF for failed qc */ 530739599a53STejun Heo fill_result_tf(qc); 5308c6fd2807SJeff Garzik ata_qc_schedule_eh(qc); 5309c6fd2807SJeff Garzik return; 5310c6fd2807SJeff Garzik } 5311c6fd2807SJeff Garzik } 5312c6fd2807SJeff Garzik 5313c6fd2807SJeff Garzik /* read result TF if requested */ 5314c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_RESULT_TF) 531539599a53STejun Heo fill_result_tf(qc); 5316c6fd2807SJeff Garzik 5317c6fd2807SJeff Garzik __ata_qc_complete(qc); 5318c6fd2807SJeff Garzik } else { 5319c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_EH_SCHEDULED) 5320c6fd2807SJeff Garzik return; 5321c6fd2807SJeff Garzik 5322c6fd2807SJeff Garzik /* read result TF if failed or requested */ 5323c6fd2807SJeff Garzik if (qc->err_mask || qc->flags & ATA_QCFLAG_RESULT_TF) 532439599a53STejun Heo fill_result_tf(qc); 5325c6fd2807SJeff Garzik 5326c6fd2807SJeff Garzik __ata_qc_complete(qc); 5327c6fd2807SJeff Garzik } 5328c6fd2807SJeff Garzik } 5329c6fd2807SJeff Garzik 5330c6fd2807SJeff Garzik /** 5331c6fd2807SJeff Garzik * ata_qc_complete_multiple - Complete multiple qcs successfully 5332c6fd2807SJeff Garzik * @ap: port in question 5333c6fd2807SJeff Garzik * @qc_active: new qc_active mask 5334c6fd2807SJeff Garzik * @finish_qc: LLDD callback invoked before completing a qc 5335c6fd2807SJeff Garzik * 5336c6fd2807SJeff Garzik * Complete in-flight commands. This functions is meant to be 5337c6fd2807SJeff Garzik * called from low-level driver's interrupt routine to complete 5338c6fd2807SJeff Garzik * requests normally. ap->qc_active and @qc_active is compared 5339c6fd2807SJeff Garzik * and commands are completed accordingly. 5340c6fd2807SJeff Garzik * 5341c6fd2807SJeff Garzik * LOCKING: 5342cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 5343c6fd2807SJeff Garzik * 5344c6fd2807SJeff Garzik * RETURNS: 5345c6fd2807SJeff Garzik * Number of completed commands on success, -errno otherwise. 5346c6fd2807SJeff Garzik */ 5347c6fd2807SJeff Garzik int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active, 5348c6fd2807SJeff Garzik void (*finish_qc)(struct ata_queued_cmd *)) 5349c6fd2807SJeff Garzik { 5350c6fd2807SJeff Garzik int nr_done = 0; 5351c6fd2807SJeff Garzik u32 done_mask; 5352c6fd2807SJeff Garzik int i; 5353c6fd2807SJeff Garzik 5354c6fd2807SJeff Garzik done_mask = ap->qc_active ^ qc_active; 5355c6fd2807SJeff Garzik 5356c6fd2807SJeff Garzik if (unlikely(done_mask & qc_active)) { 5357c6fd2807SJeff Garzik ata_port_printk(ap, KERN_ERR, "illegal qc_active transition " 5358c6fd2807SJeff Garzik "(%08x->%08x)\n", ap->qc_active, qc_active); 5359c6fd2807SJeff Garzik return -EINVAL; 5360c6fd2807SJeff Garzik } 5361c6fd2807SJeff Garzik 5362c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_QUEUE; i++) { 5363c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 5364c6fd2807SJeff Garzik 5365c6fd2807SJeff Garzik if (!(done_mask & (1 << i))) 5366c6fd2807SJeff Garzik continue; 5367c6fd2807SJeff Garzik 5368c6fd2807SJeff Garzik if ((qc = ata_qc_from_tag(ap, i))) { 5369c6fd2807SJeff Garzik if (finish_qc) 5370c6fd2807SJeff Garzik finish_qc(qc); 5371c6fd2807SJeff Garzik ata_qc_complete(qc); 5372c6fd2807SJeff Garzik nr_done++; 5373c6fd2807SJeff Garzik } 5374c6fd2807SJeff Garzik } 5375c6fd2807SJeff Garzik 5376c6fd2807SJeff Garzik return nr_done; 5377c6fd2807SJeff Garzik } 5378c6fd2807SJeff Garzik 5379c6fd2807SJeff Garzik static inline int ata_should_dma_map(struct ata_queued_cmd *qc) 5380c6fd2807SJeff Garzik { 5381c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 5382c6fd2807SJeff Garzik 5383c6fd2807SJeff Garzik switch (qc->tf.protocol) { 5384c6fd2807SJeff Garzik case ATA_PROT_NCQ: 5385c6fd2807SJeff Garzik case ATA_PROT_DMA: 5386c6fd2807SJeff Garzik case ATA_PROT_ATAPI_DMA: 5387c6fd2807SJeff Garzik return 1; 5388c6fd2807SJeff Garzik 5389c6fd2807SJeff Garzik case ATA_PROT_ATAPI: 5390c6fd2807SJeff Garzik case ATA_PROT_PIO: 5391c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_PIO_DMA) 5392c6fd2807SJeff Garzik return 1; 5393c6fd2807SJeff Garzik 5394c6fd2807SJeff Garzik /* fall through */ 5395c6fd2807SJeff Garzik 5396c6fd2807SJeff Garzik default: 5397c6fd2807SJeff Garzik return 0; 5398c6fd2807SJeff Garzik } 5399c6fd2807SJeff Garzik 5400c6fd2807SJeff Garzik /* never reached */ 5401c6fd2807SJeff Garzik } 5402c6fd2807SJeff Garzik 5403c6fd2807SJeff Garzik /** 5404c6fd2807SJeff Garzik * ata_qc_issue - issue taskfile to device 5405c6fd2807SJeff Garzik * @qc: command to issue to device 5406c6fd2807SJeff Garzik * 5407c6fd2807SJeff Garzik * Prepare an ATA command to submission to device. 5408c6fd2807SJeff Garzik * This includes mapping the data into a DMA-able 5409c6fd2807SJeff Garzik * area, filling in the S/G table, and finally 5410c6fd2807SJeff Garzik * writing the taskfile to hardware, starting the command. 5411c6fd2807SJeff Garzik * 5412c6fd2807SJeff Garzik * LOCKING: 5413cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 5414c6fd2807SJeff Garzik */ 5415c6fd2807SJeff Garzik void ata_qc_issue(struct ata_queued_cmd *qc) 5416c6fd2807SJeff Garzik { 5417c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 54189af5c9c9STejun Heo struct ata_link *link = qc->dev->link; 5419c6fd2807SJeff Garzik 5420c6fd2807SJeff Garzik /* Make sure only one non-NCQ command is outstanding. The 5421c6fd2807SJeff Garzik * check is skipped for old EH because it reuses active qc to 5422c6fd2807SJeff Garzik * request ATAPI sense. 5423c6fd2807SJeff Garzik */ 54249af5c9c9STejun Heo WARN_ON(ap->ops->error_handler && ata_tag_valid(link->active_tag)); 5425c6fd2807SJeff Garzik 5426c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_NCQ) { 54279af5c9c9STejun Heo WARN_ON(link->sactive & (1 << qc->tag)); 54289af5c9c9STejun Heo link->sactive |= 1 << qc->tag; 5429c6fd2807SJeff Garzik } else { 54309af5c9c9STejun Heo WARN_ON(link->sactive); 54319af5c9c9STejun Heo link->active_tag = qc->tag; 5432c6fd2807SJeff Garzik } 5433c6fd2807SJeff Garzik 5434c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_ACTIVE; 5435c6fd2807SJeff Garzik ap->qc_active |= 1 << qc->tag; 5436c6fd2807SJeff Garzik 5437c6fd2807SJeff Garzik if (ata_should_dma_map(qc)) { 5438c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_SG) { 5439c6fd2807SJeff Garzik if (ata_sg_setup(qc)) 5440c6fd2807SJeff Garzik goto sg_err; 5441c6fd2807SJeff Garzik } else if (qc->flags & ATA_QCFLAG_SINGLE) { 5442c6fd2807SJeff Garzik if (ata_sg_setup_one(qc)) 5443c6fd2807SJeff Garzik goto sg_err; 5444c6fd2807SJeff Garzik } 5445c6fd2807SJeff Garzik } else { 5446c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_DMAMAP; 5447c6fd2807SJeff Garzik } 5448c6fd2807SJeff Garzik 5449c6fd2807SJeff Garzik ap->ops->qc_prep(qc); 5450c6fd2807SJeff Garzik 5451c6fd2807SJeff Garzik qc->err_mask |= ap->ops->qc_issue(qc); 5452c6fd2807SJeff Garzik if (unlikely(qc->err_mask)) 5453c6fd2807SJeff Garzik goto err; 5454c6fd2807SJeff Garzik return; 5455c6fd2807SJeff Garzik 5456c6fd2807SJeff Garzik sg_err: 5457c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_DMAMAP; 5458c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_SYSTEM; 5459c6fd2807SJeff Garzik err: 5460c6fd2807SJeff Garzik ata_qc_complete(qc); 5461c6fd2807SJeff Garzik } 5462c6fd2807SJeff Garzik 5463c6fd2807SJeff Garzik /** 5464c6fd2807SJeff Garzik * ata_qc_issue_prot - issue taskfile to device in proto-dependent manner 5465c6fd2807SJeff Garzik * @qc: command to issue to device 5466c6fd2807SJeff Garzik * 5467c6fd2807SJeff Garzik * Using various libata functions and hooks, this function 5468c6fd2807SJeff Garzik * starts an ATA command. ATA commands are grouped into 5469c6fd2807SJeff Garzik * classes called "protocols", and issuing each type of protocol 5470c6fd2807SJeff Garzik * is slightly different. 5471c6fd2807SJeff Garzik * 5472c6fd2807SJeff Garzik * May be used as the qc_issue() entry in ata_port_operations. 5473c6fd2807SJeff Garzik * 5474c6fd2807SJeff Garzik * LOCKING: 5475cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 5476c6fd2807SJeff Garzik * 5477c6fd2807SJeff Garzik * RETURNS: 5478c6fd2807SJeff Garzik * Zero on success, AC_ERR_* mask on failure 5479c6fd2807SJeff Garzik */ 5480c6fd2807SJeff Garzik 5481c6fd2807SJeff Garzik unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc) 5482c6fd2807SJeff Garzik { 5483c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 5484c6fd2807SJeff Garzik 5485c6fd2807SJeff Garzik /* Use polling pio if the LLD doesn't handle 5486c6fd2807SJeff Garzik * interrupt driven pio and atapi CDB interrupt. 5487c6fd2807SJeff Garzik */ 5488c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_PIO_POLLING) { 5489c6fd2807SJeff Garzik switch (qc->tf.protocol) { 5490c6fd2807SJeff Garzik case ATA_PROT_PIO: 5491e3472cbeSAlbert Lee case ATA_PROT_NODATA: 5492c6fd2807SJeff Garzik case ATA_PROT_ATAPI: 5493c6fd2807SJeff Garzik case ATA_PROT_ATAPI_NODATA: 5494c6fd2807SJeff Garzik qc->tf.flags |= ATA_TFLAG_POLLING; 5495c6fd2807SJeff Garzik break; 5496c6fd2807SJeff Garzik case ATA_PROT_ATAPI_DMA: 5497c6fd2807SJeff Garzik if (qc->dev->flags & ATA_DFLAG_CDB_INTR) 5498c6fd2807SJeff Garzik /* see ata_dma_blacklisted() */ 5499c6fd2807SJeff Garzik BUG(); 5500c6fd2807SJeff Garzik break; 5501c6fd2807SJeff Garzik default: 5502c6fd2807SJeff Garzik break; 5503c6fd2807SJeff Garzik } 5504c6fd2807SJeff Garzik } 5505c6fd2807SJeff Garzik 5506c6fd2807SJeff Garzik /* select the device */ 5507c6fd2807SJeff Garzik ata_dev_select(ap, qc->dev->devno, 1, 0); 5508c6fd2807SJeff Garzik 5509c6fd2807SJeff Garzik /* start the command */ 5510c6fd2807SJeff Garzik switch (qc->tf.protocol) { 5511c6fd2807SJeff Garzik case ATA_PROT_NODATA: 5512c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 5513c6fd2807SJeff Garzik ata_qc_set_polling(qc); 5514c6fd2807SJeff Garzik 5515c6fd2807SJeff Garzik ata_tf_to_host(ap, &qc->tf); 5516c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 5517c6fd2807SJeff Garzik 5518c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 5519c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, 0); 5520c6fd2807SJeff Garzik 5521c6fd2807SJeff Garzik break; 5522c6fd2807SJeff Garzik 5523c6fd2807SJeff Garzik case ATA_PROT_DMA: 5524c6fd2807SJeff Garzik WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING); 5525c6fd2807SJeff Garzik 5526c6fd2807SJeff Garzik ap->ops->tf_load(ap, &qc->tf); /* load tf registers */ 5527c6fd2807SJeff Garzik ap->ops->bmdma_setup(qc); /* set up bmdma */ 5528c6fd2807SJeff Garzik ap->ops->bmdma_start(qc); /* initiate bmdma */ 5529c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_LAST; 5530c6fd2807SJeff Garzik break; 5531c6fd2807SJeff Garzik 5532c6fd2807SJeff Garzik case ATA_PROT_PIO: 5533c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 5534c6fd2807SJeff Garzik ata_qc_set_polling(qc); 5535c6fd2807SJeff Garzik 5536c6fd2807SJeff Garzik ata_tf_to_host(ap, &qc->tf); 5537c6fd2807SJeff Garzik 5538c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_WRITE) { 5539c6fd2807SJeff Garzik /* PIO data out protocol */ 5540c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_FIRST; 5541c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, 0); 5542c6fd2807SJeff Garzik 5543c6fd2807SJeff Garzik /* always send first data block using 5544c6fd2807SJeff Garzik * the ata_pio_task() codepath. 5545c6fd2807SJeff Garzik */ 5546c6fd2807SJeff Garzik } else { 5547c6fd2807SJeff Garzik /* PIO data in protocol */ 5548c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST; 5549c6fd2807SJeff Garzik 5550c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 5551c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, 0); 5552c6fd2807SJeff Garzik 5553c6fd2807SJeff Garzik /* if polling, ata_pio_task() handles the rest. 5554c6fd2807SJeff Garzik * otherwise, interrupt handler takes over from here. 5555c6fd2807SJeff Garzik */ 5556c6fd2807SJeff Garzik } 5557c6fd2807SJeff Garzik 5558c6fd2807SJeff Garzik break; 5559c6fd2807SJeff Garzik 5560c6fd2807SJeff Garzik case ATA_PROT_ATAPI: 5561c6fd2807SJeff Garzik case ATA_PROT_ATAPI_NODATA: 5562c6fd2807SJeff Garzik if (qc->tf.flags & ATA_TFLAG_POLLING) 5563c6fd2807SJeff Garzik ata_qc_set_polling(qc); 5564c6fd2807SJeff Garzik 5565c6fd2807SJeff Garzik ata_tf_to_host(ap, &qc->tf); 5566c6fd2807SJeff Garzik 5567c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_FIRST; 5568c6fd2807SJeff Garzik 5569c6fd2807SJeff Garzik /* send cdb by polling if no cdb interrupt */ 5570c6fd2807SJeff Garzik if ((!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) || 5571c6fd2807SJeff Garzik (qc->tf.flags & ATA_TFLAG_POLLING)) 5572c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, 0); 5573c6fd2807SJeff Garzik break; 5574c6fd2807SJeff Garzik 5575c6fd2807SJeff Garzik case ATA_PROT_ATAPI_DMA: 5576c6fd2807SJeff Garzik WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING); 5577c6fd2807SJeff Garzik 5578c6fd2807SJeff Garzik ap->ops->tf_load(ap, &qc->tf); /* load tf registers */ 5579c6fd2807SJeff Garzik ap->ops->bmdma_setup(qc); /* set up bmdma */ 5580c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_FIRST; 5581c6fd2807SJeff Garzik 5582c6fd2807SJeff Garzik /* send cdb by polling if no cdb interrupt */ 5583c6fd2807SJeff Garzik if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) 5584c6fd2807SJeff Garzik ata_port_queue_task(ap, ata_pio_task, qc, 0); 5585c6fd2807SJeff Garzik break; 5586c6fd2807SJeff Garzik 5587c6fd2807SJeff Garzik default: 5588c6fd2807SJeff Garzik WARN_ON(1); 5589c6fd2807SJeff Garzik return AC_ERR_SYSTEM; 5590c6fd2807SJeff Garzik } 5591c6fd2807SJeff Garzik 5592c6fd2807SJeff Garzik return 0; 5593c6fd2807SJeff Garzik } 5594c6fd2807SJeff Garzik 5595c6fd2807SJeff Garzik /** 5596c6fd2807SJeff Garzik * ata_host_intr - Handle host interrupt for given (port, task) 5597c6fd2807SJeff Garzik * @ap: Port on which interrupt arrived (possibly...) 5598c6fd2807SJeff Garzik * @qc: Taskfile currently active in engine 5599c6fd2807SJeff Garzik * 5600c6fd2807SJeff Garzik * Handle host interrupt for given queued command. Currently, 5601c6fd2807SJeff Garzik * only DMA interrupts are handled. All other commands are 5602c6fd2807SJeff Garzik * handled via polling with interrupts disabled (nIEN bit). 5603c6fd2807SJeff Garzik * 5604c6fd2807SJeff Garzik * LOCKING: 5605cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 5606c6fd2807SJeff Garzik * 5607c6fd2807SJeff Garzik * RETURNS: 5608c6fd2807SJeff Garzik * One if interrupt was handled, zero if not (shared irq). 5609c6fd2807SJeff Garzik */ 5610c6fd2807SJeff Garzik 5611c6fd2807SJeff Garzik inline unsigned int ata_host_intr (struct ata_port *ap, 5612c6fd2807SJeff Garzik struct ata_queued_cmd *qc) 5613c6fd2807SJeff Garzik { 56149af5c9c9STejun Heo struct ata_eh_info *ehi = &ap->link.eh_info; 5615c6fd2807SJeff Garzik u8 status, host_stat = 0; 5616c6fd2807SJeff Garzik 5617c6fd2807SJeff Garzik VPRINTK("ata%u: protocol %d task_state %d\n", 561844877b4eSTejun Heo ap->print_id, qc->tf.protocol, ap->hsm_task_state); 5619c6fd2807SJeff Garzik 5620c6fd2807SJeff Garzik /* Check whether we are expecting interrupt in this state */ 5621c6fd2807SJeff Garzik switch (ap->hsm_task_state) { 5622c6fd2807SJeff Garzik case HSM_ST_FIRST: 5623c6fd2807SJeff Garzik /* Some pre-ATAPI-4 devices assert INTRQ 5624c6fd2807SJeff Garzik * at this state when ready to receive CDB. 5625c6fd2807SJeff Garzik */ 5626c6fd2807SJeff Garzik 5627c6fd2807SJeff Garzik /* Check the ATA_DFLAG_CDB_INTR flag is enough here. 5628c6fd2807SJeff Garzik * The flag was turned on only for atapi devices. 5629c6fd2807SJeff Garzik * No need to check is_atapi_taskfile(&qc->tf) again. 5630c6fd2807SJeff Garzik */ 5631c6fd2807SJeff Garzik if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) 5632c6fd2807SJeff Garzik goto idle_irq; 5633c6fd2807SJeff Garzik break; 5634c6fd2807SJeff Garzik case HSM_ST_LAST: 5635c6fd2807SJeff Garzik if (qc->tf.protocol == ATA_PROT_DMA || 5636c6fd2807SJeff Garzik qc->tf.protocol == ATA_PROT_ATAPI_DMA) { 5637c6fd2807SJeff Garzik /* check status of DMA engine */ 5638c6fd2807SJeff Garzik host_stat = ap->ops->bmdma_status(ap); 563944877b4eSTejun Heo VPRINTK("ata%u: host_stat 0x%X\n", 564044877b4eSTejun Heo ap->print_id, host_stat); 5641c6fd2807SJeff Garzik 5642c6fd2807SJeff Garzik /* if it's not our irq... */ 5643c6fd2807SJeff Garzik if (!(host_stat & ATA_DMA_INTR)) 5644c6fd2807SJeff Garzik goto idle_irq; 5645c6fd2807SJeff Garzik 5646c6fd2807SJeff Garzik /* before we do anything else, clear DMA-Start bit */ 5647c6fd2807SJeff Garzik ap->ops->bmdma_stop(qc); 5648c6fd2807SJeff Garzik 5649c6fd2807SJeff Garzik if (unlikely(host_stat & ATA_DMA_ERR)) { 5650c6fd2807SJeff Garzik /* error when transfering data to/from memory */ 5651c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_HOST_BUS; 5652c6fd2807SJeff Garzik ap->hsm_task_state = HSM_ST_ERR; 5653c6fd2807SJeff Garzik } 5654c6fd2807SJeff Garzik } 5655c6fd2807SJeff Garzik break; 5656c6fd2807SJeff Garzik case HSM_ST: 5657c6fd2807SJeff Garzik break; 5658c6fd2807SJeff Garzik default: 5659c6fd2807SJeff Garzik goto idle_irq; 5660c6fd2807SJeff Garzik } 5661c6fd2807SJeff Garzik 5662c6fd2807SJeff Garzik /* check altstatus */ 5663c6fd2807SJeff Garzik status = ata_altstatus(ap); 5664c6fd2807SJeff Garzik if (status & ATA_BUSY) 5665c6fd2807SJeff Garzik goto idle_irq; 5666c6fd2807SJeff Garzik 5667c6fd2807SJeff Garzik /* check main status, clearing INTRQ */ 5668c6fd2807SJeff Garzik status = ata_chk_status(ap); 5669c6fd2807SJeff Garzik if (unlikely(status & ATA_BUSY)) 5670c6fd2807SJeff Garzik goto idle_irq; 5671c6fd2807SJeff Garzik 5672c6fd2807SJeff Garzik /* ack bmdma irq events */ 5673c6fd2807SJeff Garzik ap->ops->irq_clear(ap); 5674c6fd2807SJeff Garzik 5675c6fd2807SJeff Garzik ata_hsm_move(ap, qc, status, 0); 5676ea54763fSTejun Heo 5677ea54763fSTejun Heo if (unlikely(qc->err_mask) && (qc->tf.protocol == ATA_PROT_DMA || 5678ea54763fSTejun Heo qc->tf.protocol == ATA_PROT_ATAPI_DMA)) 5679ea54763fSTejun Heo ata_ehi_push_desc(ehi, "BMDMA stat 0x%x", host_stat); 5680ea54763fSTejun Heo 5681c6fd2807SJeff Garzik return 1; /* irq handled */ 5682c6fd2807SJeff Garzik 5683c6fd2807SJeff Garzik idle_irq: 5684c6fd2807SJeff Garzik ap->stats.idle_irq++; 5685c6fd2807SJeff Garzik 5686c6fd2807SJeff Garzik #ifdef ATA_IRQ_TRAP 5687c6fd2807SJeff Garzik if ((ap->stats.idle_irq % 1000) == 0) { 568883625006SAkira Iguchi ap->ops->irq_ack(ap, 0); /* debug trap */ 5689c6fd2807SJeff Garzik ata_port_printk(ap, KERN_WARNING, "irq trap\n"); 5690c6fd2807SJeff Garzik return 1; 5691c6fd2807SJeff Garzik } 5692c6fd2807SJeff Garzik #endif 5693c6fd2807SJeff Garzik return 0; /* irq not handled */ 5694c6fd2807SJeff Garzik } 5695c6fd2807SJeff Garzik 5696c6fd2807SJeff Garzik /** 5697c6fd2807SJeff Garzik * ata_interrupt - Default ATA host interrupt handler 5698c6fd2807SJeff Garzik * @irq: irq line (unused) 5699cca3974eSJeff Garzik * @dev_instance: pointer to our ata_host information structure 5700c6fd2807SJeff Garzik * 5701c6fd2807SJeff Garzik * Default interrupt handler for PCI IDE devices. Calls 5702c6fd2807SJeff Garzik * ata_host_intr() for each port that is not disabled. 5703c6fd2807SJeff Garzik * 5704c6fd2807SJeff Garzik * LOCKING: 5705cca3974eSJeff Garzik * Obtains host lock during operation. 5706c6fd2807SJeff Garzik * 5707c6fd2807SJeff Garzik * RETURNS: 5708c6fd2807SJeff Garzik * IRQ_NONE or IRQ_HANDLED. 5709c6fd2807SJeff Garzik */ 5710c6fd2807SJeff Garzik 57117d12e780SDavid Howells irqreturn_t ata_interrupt (int irq, void *dev_instance) 5712c6fd2807SJeff Garzik { 5713cca3974eSJeff Garzik struct ata_host *host = dev_instance; 5714c6fd2807SJeff Garzik unsigned int i; 5715c6fd2807SJeff Garzik unsigned int handled = 0; 5716c6fd2807SJeff Garzik unsigned long flags; 5717c6fd2807SJeff Garzik 5718c6fd2807SJeff Garzik /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */ 5719cca3974eSJeff Garzik spin_lock_irqsave(&host->lock, flags); 5720c6fd2807SJeff Garzik 5721cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 5722c6fd2807SJeff Garzik struct ata_port *ap; 5723c6fd2807SJeff Garzik 5724cca3974eSJeff Garzik ap = host->ports[i]; 5725c6fd2807SJeff Garzik if (ap && 5726c6fd2807SJeff Garzik !(ap->flags & ATA_FLAG_DISABLED)) { 5727c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 5728c6fd2807SJeff Garzik 57299af5c9c9STejun Heo qc = ata_qc_from_tag(ap, ap->link.active_tag); 5730c6fd2807SJeff Garzik if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) && 5731c6fd2807SJeff Garzik (qc->flags & ATA_QCFLAG_ACTIVE)) 5732c6fd2807SJeff Garzik handled |= ata_host_intr(ap, qc); 5733c6fd2807SJeff Garzik } 5734c6fd2807SJeff Garzik } 5735c6fd2807SJeff Garzik 5736cca3974eSJeff Garzik spin_unlock_irqrestore(&host->lock, flags); 5737c6fd2807SJeff Garzik 5738c6fd2807SJeff Garzik return IRQ_RETVAL(handled); 5739c6fd2807SJeff Garzik } 5740c6fd2807SJeff Garzik 5741c6fd2807SJeff Garzik /** 5742c6fd2807SJeff Garzik * sata_scr_valid - test whether SCRs are accessible 5743936fd732STejun Heo * @link: ATA link to test SCR accessibility for 5744c6fd2807SJeff Garzik * 5745936fd732STejun Heo * Test whether SCRs are accessible for @link. 5746c6fd2807SJeff Garzik * 5747c6fd2807SJeff Garzik * LOCKING: 5748c6fd2807SJeff Garzik * None. 5749c6fd2807SJeff Garzik * 5750c6fd2807SJeff Garzik * RETURNS: 5751c6fd2807SJeff Garzik * 1 if SCRs are accessible, 0 otherwise. 5752c6fd2807SJeff Garzik */ 5753936fd732STejun Heo int sata_scr_valid(struct ata_link *link) 5754c6fd2807SJeff Garzik { 5755936fd732STejun Heo struct ata_port *ap = link->ap; 5756936fd732STejun Heo 5757a16abc0bSTejun Heo return (ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read; 5758c6fd2807SJeff Garzik } 5759c6fd2807SJeff Garzik 5760c6fd2807SJeff Garzik /** 5761c6fd2807SJeff Garzik * sata_scr_read - read SCR register of the specified port 5762936fd732STejun Heo * @link: ATA link to read SCR for 5763c6fd2807SJeff Garzik * @reg: SCR to read 5764c6fd2807SJeff Garzik * @val: Place to store read value 5765c6fd2807SJeff Garzik * 5766936fd732STejun Heo * Read SCR register @reg of @link into *@val. This function is 5767c6fd2807SJeff Garzik * guaranteed to succeed if the cable type of the port is SATA 5768c6fd2807SJeff Garzik * and the port implements ->scr_read. 5769c6fd2807SJeff Garzik * 5770c6fd2807SJeff Garzik * LOCKING: 5771c6fd2807SJeff Garzik * None. 5772c6fd2807SJeff Garzik * 5773c6fd2807SJeff Garzik * RETURNS: 5774c6fd2807SJeff Garzik * 0 on success, negative errno on failure. 5775c6fd2807SJeff Garzik */ 5776936fd732STejun Heo int sata_scr_read(struct ata_link *link, int reg, u32 *val) 5777c6fd2807SJeff Garzik { 5778936fd732STejun Heo struct ata_port *ap = link->ap; 5779936fd732STejun Heo 5780936fd732STejun Heo if (sata_scr_valid(link)) 5781da3dbb17STejun Heo return ap->ops->scr_read(ap, reg, val); 5782c6fd2807SJeff Garzik return -EOPNOTSUPP; 5783c6fd2807SJeff Garzik } 5784c6fd2807SJeff Garzik 5785c6fd2807SJeff Garzik /** 5786c6fd2807SJeff Garzik * sata_scr_write - write SCR register of the specified port 5787936fd732STejun Heo * @link: ATA link to write SCR for 5788c6fd2807SJeff Garzik * @reg: SCR to write 5789c6fd2807SJeff Garzik * @val: value to write 5790c6fd2807SJeff Garzik * 5791936fd732STejun Heo * Write @val to SCR register @reg of @link. This function is 5792c6fd2807SJeff Garzik * guaranteed to succeed if the cable type of the port is SATA 5793c6fd2807SJeff Garzik * and the port implements ->scr_read. 5794c6fd2807SJeff Garzik * 5795c6fd2807SJeff Garzik * LOCKING: 5796c6fd2807SJeff Garzik * None. 5797c6fd2807SJeff Garzik * 5798c6fd2807SJeff Garzik * RETURNS: 5799c6fd2807SJeff Garzik * 0 on success, negative errno on failure. 5800c6fd2807SJeff Garzik */ 5801936fd732STejun Heo int sata_scr_write(struct ata_link *link, int reg, u32 val) 5802c6fd2807SJeff Garzik { 5803936fd732STejun Heo struct ata_port *ap = link->ap; 5804936fd732STejun Heo 5805936fd732STejun Heo if (sata_scr_valid(link)) 5806da3dbb17STejun Heo return ap->ops->scr_write(ap, reg, val); 5807c6fd2807SJeff Garzik return -EOPNOTSUPP; 5808c6fd2807SJeff Garzik } 5809c6fd2807SJeff Garzik 5810c6fd2807SJeff Garzik /** 5811c6fd2807SJeff Garzik * sata_scr_write_flush - write SCR register of the specified port and flush 5812936fd732STejun Heo * @link: ATA link to write SCR for 5813c6fd2807SJeff Garzik * @reg: SCR to write 5814c6fd2807SJeff Garzik * @val: value to write 5815c6fd2807SJeff Garzik * 5816c6fd2807SJeff Garzik * This function is identical to sata_scr_write() except that this 5817c6fd2807SJeff Garzik * function performs flush after writing to the register. 5818c6fd2807SJeff Garzik * 5819c6fd2807SJeff Garzik * LOCKING: 5820c6fd2807SJeff Garzik * None. 5821c6fd2807SJeff Garzik * 5822c6fd2807SJeff Garzik * RETURNS: 5823c6fd2807SJeff Garzik * 0 on success, negative errno on failure. 5824c6fd2807SJeff Garzik */ 5825936fd732STejun Heo int sata_scr_write_flush(struct ata_link *link, int reg, u32 val) 5826c6fd2807SJeff Garzik { 5827936fd732STejun Heo struct ata_port *ap = link->ap; 5828da3dbb17STejun Heo int rc; 5829da3dbb17STejun Heo 5830936fd732STejun Heo if (sata_scr_valid(link)) { 5831da3dbb17STejun Heo rc = ap->ops->scr_write(ap, reg, val); 5832da3dbb17STejun Heo if (rc == 0) 5833da3dbb17STejun Heo rc = ap->ops->scr_read(ap, reg, &val); 5834da3dbb17STejun Heo return rc; 5835c6fd2807SJeff Garzik } 5836c6fd2807SJeff Garzik return -EOPNOTSUPP; 5837c6fd2807SJeff Garzik } 5838c6fd2807SJeff Garzik 5839c6fd2807SJeff Garzik /** 5840936fd732STejun Heo * ata_link_online - test whether the given link is online 5841936fd732STejun Heo * @link: ATA link to test 5842c6fd2807SJeff Garzik * 5843936fd732STejun Heo * Test whether @link is online. Note that this function returns 5844936fd732STejun Heo * 0 if online status of @link cannot be obtained, so 5845936fd732STejun Heo * ata_link_online(link) != !ata_link_offline(link). 5846c6fd2807SJeff Garzik * 5847c6fd2807SJeff Garzik * LOCKING: 5848c6fd2807SJeff Garzik * None. 5849c6fd2807SJeff Garzik * 5850c6fd2807SJeff Garzik * RETURNS: 5851c6fd2807SJeff Garzik * 1 if the port online status is available and online. 5852c6fd2807SJeff Garzik */ 5853936fd732STejun Heo int ata_link_online(struct ata_link *link) 5854c6fd2807SJeff Garzik { 5855c6fd2807SJeff Garzik u32 sstatus; 5856c6fd2807SJeff Garzik 5857936fd732STejun Heo if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 && 5858936fd732STejun Heo (sstatus & 0xf) == 0x3) 5859c6fd2807SJeff Garzik return 1; 5860c6fd2807SJeff Garzik return 0; 5861c6fd2807SJeff Garzik } 5862c6fd2807SJeff Garzik 5863c6fd2807SJeff Garzik /** 5864936fd732STejun Heo * ata_link_offline - test whether the given link is offline 5865936fd732STejun Heo * @link: ATA link to test 5866c6fd2807SJeff Garzik * 5867936fd732STejun Heo * Test whether @link is offline. Note that this function 5868936fd732STejun Heo * returns 0 if offline status of @link cannot be obtained, so 5869936fd732STejun Heo * ata_link_online(link) != !ata_link_offline(link). 5870c6fd2807SJeff Garzik * 5871c6fd2807SJeff Garzik * LOCKING: 5872c6fd2807SJeff Garzik * None. 5873c6fd2807SJeff Garzik * 5874c6fd2807SJeff Garzik * RETURNS: 5875c6fd2807SJeff Garzik * 1 if the port offline status is available and offline. 5876c6fd2807SJeff Garzik */ 5877936fd732STejun Heo int ata_link_offline(struct ata_link *link) 5878c6fd2807SJeff Garzik { 5879c6fd2807SJeff Garzik u32 sstatus; 5880c6fd2807SJeff Garzik 5881936fd732STejun Heo if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 && 5882936fd732STejun Heo (sstatus & 0xf) != 0x3) 5883c6fd2807SJeff Garzik return 1; 5884c6fd2807SJeff Garzik return 0; 5885c6fd2807SJeff Garzik } 5886c6fd2807SJeff Garzik 5887c6fd2807SJeff Garzik int ata_flush_cache(struct ata_device *dev) 5888c6fd2807SJeff Garzik { 5889c6fd2807SJeff Garzik unsigned int err_mask; 5890c6fd2807SJeff Garzik u8 cmd; 5891c6fd2807SJeff Garzik 5892c6fd2807SJeff Garzik if (!ata_try_flush_cache(dev)) 5893c6fd2807SJeff Garzik return 0; 5894c6fd2807SJeff Garzik 58956fc49adbSTejun Heo if (dev->flags & ATA_DFLAG_FLUSH_EXT) 5896c6fd2807SJeff Garzik cmd = ATA_CMD_FLUSH_EXT; 5897c6fd2807SJeff Garzik else 5898c6fd2807SJeff Garzik cmd = ATA_CMD_FLUSH; 5899c6fd2807SJeff Garzik 5900c6fd2807SJeff Garzik err_mask = ata_do_simple_cmd(dev, cmd); 5901c6fd2807SJeff Garzik if (err_mask) { 5902c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_ERR, "failed to flush cache\n"); 5903c6fd2807SJeff Garzik return -EIO; 5904c6fd2807SJeff Garzik } 5905c6fd2807SJeff Garzik 5906c6fd2807SJeff Garzik return 0; 5907c6fd2807SJeff Garzik } 5908c6fd2807SJeff Garzik 59096ffa01d8STejun Heo #ifdef CONFIG_PM 5910cca3974eSJeff Garzik static int ata_host_request_pm(struct ata_host *host, pm_message_t mesg, 5911cca3974eSJeff Garzik unsigned int action, unsigned int ehi_flags, 5912cca3974eSJeff Garzik int wait) 5913c6fd2807SJeff Garzik { 5914c6fd2807SJeff Garzik unsigned long flags; 5915c6fd2807SJeff Garzik int i, rc; 5916c6fd2807SJeff Garzik 5917cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 5918cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 5919e3667ebfSTejun Heo struct ata_link *link; 5920c6fd2807SJeff Garzik 5921c6fd2807SJeff Garzik /* Previous resume operation might still be in 5922c6fd2807SJeff Garzik * progress. Wait for PM_PENDING to clear. 5923c6fd2807SJeff Garzik */ 5924c6fd2807SJeff Garzik if (ap->pflags & ATA_PFLAG_PM_PENDING) { 5925c6fd2807SJeff Garzik ata_port_wait_eh(ap); 5926c6fd2807SJeff Garzik WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING); 5927c6fd2807SJeff Garzik } 5928c6fd2807SJeff Garzik 5929c6fd2807SJeff Garzik /* request PM ops to EH */ 5930c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 5931c6fd2807SJeff Garzik 5932c6fd2807SJeff Garzik ap->pm_mesg = mesg; 5933c6fd2807SJeff Garzik if (wait) { 5934c6fd2807SJeff Garzik rc = 0; 5935c6fd2807SJeff Garzik ap->pm_result = &rc; 5936c6fd2807SJeff Garzik } 5937c6fd2807SJeff Garzik 5938c6fd2807SJeff Garzik ap->pflags |= ATA_PFLAG_PM_PENDING; 5939e3667ebfSTejun Heo __ata_port_for_each_link(link, ap) { 5940e3667ebfSTejun Heo link->eh_info.action |= action; 5941e3667ebfSTejun Heo link->eh_info.flags |= ehi_flags; 5942e3667ebfSTejun Heo } 5943c6fd2807SJeff Garzik 5944c6fd2807SJeff Garzik ata_port_schedule_eh(ap); 5945c6fd2807SJeff Garzik 5946c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5947c6fd2807SJeff Garzik 5948c6fd2807SJeff Garzik /* wait and check result */ 5949c6fd2807SJeff Garzik if (wait) { 5950c6fd2807SJeff Garzik ata_port_wait_eh(ap); 5951c6fd2807SJeff Garzik WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING); 5952c6fd2807SJeff Garzik if (rc) 5953c6fd2807SJeff Garzik return rc; 5954c6fd2807SJeff Garzik } 5955c6fd2807SJeff Garzik } 5956c6fd2807SJeff Garzik 5957c6fd2807SJeff Garzik return 0; 5958c6fd2807SJeff Garzik } 5959c6fd2807SJeff Garzik 5960c6fd2807SJeff Garzik /** 5961cca3974eSJeff Garzik * ata_host_suspend - suspend host 5962cca3974eSJeff Garzik * @host: host to suspend 5963c6fd2807SJeff Garzik * @mesg: PM message 5964c6fd2807SJeff Garzik * 5965cca3974eSJeff Garzik * Suspend @host. Actual operation is performed by EH. This 5966c6fd2807SJeff Garzik * function requests EH to perform PM operations and waits for EH 5967c6fd2807SJeff Garzik * to finish. 5968c6fd2807SJeff Garzik * 5969c6fd2807SJeff Garzik * LOCKING: 5970c6fd2807SJeff Garzik * Kernel thread context (may sleep). 5971c6fd2807SJeff Garzik * 5972c6fd2807SJeff Garzik * RETURNS: 5973c6fd2807SJeff Garzik * 0 on success, -errno on failure. 5974c6fd2807SJeff Garzik */ 5975cca3974eSJeff Garzik int ata_host_suspend(struct ata_host *host, pm_message_t mesg) 5976c6fd2807SJeff Garzik { 59779666f400STejun Heo int rc; 5978c6fd2807SJeff Garzik 5979cca3974eSJeff Garzik rc = ata_host_request_pm(host, mesg, 0, ATA_EHI_QUIET, 1); 59809666f400STejun Heo if (rc == 0) 5981cca3974eSJeff Garzik host->dev->power.power_state = mesg; 5982c6fd2807SJeff Garzik return rc; 5983c6fd2807SJeff Garzik } 5984c6fd2807SJeff Garzik 5985c6fd2807SJeff Garzik /** 5986cca3974eSJeff Garzik * ata_host_resume - resume host 5987cca3974eSJeff Garzik * @host: host to resume 5988c6fd2807SJeff Garzik * 5989cca3974eSJeff Garzik * Resume @host. Actual operation is performed by EH. This 5990c6fd2807SJeff Garzik * function requests EH to perform PM operations and returns. 5991c6fd2807SJeff Garzik * Note that all resume operations are performed parallely. 5992c6fd2807SJeff Garzik * 5993c6fd2807SJeff Garzik * LOCKING: 5994c6fd2807SJeff Garzik * Kernel thread context (may sleep). 5995c6fd2807SJeff Garzik */ 5996cca3974eSJeff Garzik void ata_host_resume(struct ata_host *host) 5997c6fd2807SJeff Garzik { 5998cca3974eSJeff Garzik ata_host_request_pm(host, PMSG_ON, ATA_EH_SOFTRESET, 5999c6fd2807SJeff Garzik ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET, 0); 6000cca3974eSJeff Garzik host->dev->power.power_state = PMSG_ON; 6001c6fd2807SJeff Garzik } 60026ffa01d8STejun Heo #endif 6003c6fd2807SJeff Garzik 6004c6fd2807SJeff Garzik /** 6005c6fd2807SJeff Garzik * ata_port_start - Set port up for dma. 6006c6fd2807SJeff Garzik * @ap: Port to initialize 6007c6fd2807SJeff Garzik * 6008c6fd2807SJeff Garzik * Called just after data structures for each port are 6009c6fd2807SJeff Garzik * initialized. Allocates space for PRD table. 6010c6fd2807SJeff Garzik * 6011c6fd2807SJeff Garzik * May be used as the port_start() entry in ata_port_operations. 6012c6fd2807SJeff Garzik * 6013c6fd2807SJeff Garzik * LOCKING: 6014c6fd2807SJeff Garzik * Inherited from caller. 6015c6fd2807SJeff Garzik */ 6016c6fd2807SJeff Garzik int ata_port_start(struct ata_port *ap) 6017c6fd2807SJeff Garzik { 6018c6fd2807SJeff Garzik struct device *dev = ap->dev; 6019c6fd2807SJeff Garzik int rc; 6020c6fd2807SJeff Garzik 6021f0d36efdSTejun Heo ap->prd = dmam_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, 6022f0d36efdSTejun Heo GFP_KERNEL); 6023c6fd2807SJeff Garzik if (!ap->prd) 6024c6fd2807SJeff Garzik return -ENOMEM; 6025c6fd2807SJeff Garzik 6026c6fd2807SJeff Garzik rc = ata_pad_alloc(ap, dev); 6027f0d36efdSTejun Heo if (rc) 6028c6fd2807SJeff Garzik return rc; 6029c6fd2807SJeff Garzik 6030f0d36efdSTejun Heo DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, 6031f0d36efdSTejun Heo (unsigned long long)ap->prd_dma); 6032c6fd2807SJeff Garzik return 0; 6033c6fd2807SJeff Garzik } 6034c6fd2807SJeff Garzik 6035c6fd2807SJeff Garzik /** 6036c6fd2807SJeff Garzik * ata_dev_init - Initialize an ata_device structure 6037c6fd2807SJeff Garzik * @dev: Device structure to initialize 6038c6fd2807SJeff Garzik * 6039c6fd2807SJeff Garzik * Initialize @dev in preparation for probing. 6040c6fd2807SJeff Garzik * 6041c6fd2807SJeff Garzik * LOCKING: 6042c6fd2807SJeff Garzik * Inherited from caller. 6043c6fd2807SJeff Garzik */ 6044c6fd2807SJeff Garzik void ata_dev_init(struct ata_device *dev) 6045c6fd2807SJeff Garzik { 60469af5c9c9STejun Heo struct ata_link *link = dev->link; 60479af5c9c9STejun Heo struct ata_port *ap = link->ap; 6048c6fd2807SJeff Garzik unsigned long flags; 6049c6fd2807SJeff Garzik 6050c6fd2807SJeff Garzik /* SATA spd limit is bound to the first device */ 60519af5c9c9STejun Heo link->sata_spd_limit = link->hw_sata_spd_limit; 60529af5c9c9STejun Heo link->sata_spd = 0; 6053c6fd2807SJeff Garzik 6054c6fd2807SJeff Garzik /* High bits of dev->flags are used to record warm plug 6055c6fd2807SJeff Garzik * requests which occur asynchronously. Synchronize using 6056cca3974eSJeff Garzik * host lock. 6057c6fd2807SJeff Garzik */ 6058c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 6059c6fd2807SJeff Garzik dev->flags &= ~ATA_DFLAG_INIT_MASK; 60603dcc323fSTejun Heo dev->horkage = 0; 6061c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 6062c6fd2807SJeff Garzik 6063c6fd2807SJeff Garzik memset((void *)dev + ATA_DEVICE_CLEAR_OFFSET, 0, 6064c6fd2807SJeff Garzik sizeof(*dev) - ATA_DEVICE_CLEAR_OFFSET); 6065c6fd2807SJeff Garzik dev->pio_mask = UINT_MAX; 6066c6fd2807SJeff Garzik dev->mwdma_mask = UINT_MAX; 6067c6fd2807SJeff Garzik dev->udma_mask = UINT_MAX; 6068c6fd2807SJeff Garzik } 6069c6fd2807SJeff Garzik 6070c6fd2807SJeff Garzik /** 60714fb37a25STejun Heo * ata_link_init - Initialize an ata_link structure 60724fb37a25STejun Heo * @ap: ATA port link is attached to 60734fb37a25STejun Heo * @link: Link structure to initialize 60748989805dSTejun Heo * @pmp: Port multiplier port number 60754fb37a25STejun Heo * 60764fb37a25STejun Heo * Initialize @link. 60774fb37a25STejun Heo * 60784fb37a25STejun Heo * LOCKING: 60794fb37a25STejun Heo * Kernel thread context (may sleep) 60804fb37a25STejun Heo */ 60818989805dSTejun Heo static void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp) 60824fb37a25STejun Heo { 60834fb37a25STejun Heo int i; 60844fb37a25STejun Heo 60854fb37a25STejun Heo /* clear everything except for devices */ 60864fb37a25STejun Heo memset(link, 0, offsetof(struct ata_link, device[0])); 60874fb37a25STejun Heo 60884fb37a25STejun Heo link->ap = ap; 60898989805dSTejun Heo link->pmp = pmp; 60904fb37a25STejun Heo link->active_tag = ATA_TAG_POISON; 60914fb37a25STejun Heo link->hw_sata_spd_limit = UINT_MAX; 60924fb37a25STejun Heo 60934fb37a25STejun Heo /* can't use iterator, ap isn't initialized yet */ 60944fb37a25STejun Heo for (i = 0; i < ATA_MAX_DEVICES; i++) { 60954fb37a25STejun Heo struct ata_device *dev = &link->device[i]; 60964fb37a25STejun Heo 60974fb37a25STejun Heo dev->link = link; 60984fb37a25STejun Heo dev->devno = dev - link->device; 60994fb37a25STejun Heo ata_dev_init(dev); 61004fb37a25STejun Heo } 61014fb37a25STejun Heo } 61024fb37a25STejun Heo 61034fb37a25STejun Heo /** 61044fb37a25STejun Heo * sata_link_init_spd - Initialize link->sata_spd_limit 61054fb37a25STejun Heo * @link: Link to configure sata_spd_limit for 61064fb37a25STejun Heo * 61074fb37a25STejun Heo * Initialize @link->[hw_]sata_spd_limit to the currently 61084fb37a25STejun Heo * configured value. 61094fb37a25STejun Heo * 61104fb37a25STejun Heo * LOCKING: 61114fb37a25STejun Heo * Kernel thread context (may sleep). 61124fb37a25STejun Heo * 61134fb37a25STejun Heo * RETURNS: 61144fb37a25STejun Heo * 0 on success, -errno on failure. 61154fb37a25STejun Heo */ 61164fb37a25STejun Heo static int sata_link_init_spd(struct ata_link *link) 61174fb37a25STejun Heo { 61184fb37a25STejun Heo u32 scontrol, spd; 61194fb37a25STejun Heo int rc; 61204fb37a25STejun Heo 61214fb37a25STejun Heo rc = sata_scr_read(link, SCR_CONTROL, &scontrol); 61224fb37a25STejun Heo if (rc) 61234fb37a25STejun Heo return rc; 61244fb37a25STejun Heo 61254fb37a25STejun Heo spd = (scontrol >> 4) & 0xf; 61264fb37a25STejun Heo if (spd) 61274fb37a25STejun Heo link->hw_sata_spd_limit &= (1 << spd) - 1; 61284fb37a25STejun Heo 61294fb37a25STejun Heo link->sata_spd_limit = link->hw_sata_spd_limit; 61304fb37a25STejun Heo 61314fb37a25STejun Heo return 0; 61324fb37a25STejun Heo } 61334fb37a25STejun Heo 61344fb37a25STejun Heo /** 6135f3187195STejun Heo * ata_port_alloc - allocate and initialize basic ATA port resources 6136f3187195STejun Heo * @host: ATA host this allocated port belongs to 6137c6fd2807SJeff Garzik * 6138f3187195STejun Heo * Allocate and initialize basic ATA port resources. 6139f3187195STejun Heo * 6140f3187195STejun Heo * RETURNS: 6141f3187195STejun Heo * Allocate ATA port on success, NULL on failure. 6142c6fd2807SJeff Garzik * 6143c6fd2807SJeff Garzik * LOCKING: 6144f3187195STejun Heo * Inherited from calling layer (may sleep). 6145c6fd2807SJeff Garzik */ 6146f3187195STejun Heo struct ata_port *ata_port_alloc(struct ata_host *host) 6147c6fd2807SJeff Garzik { 6148f3187195STejun Heo struct ata_port *ap; 6149c6fd2807SJeff Garzik 6150f3187195STejun Heo DPRINTK("ENTER\n"); 6151f3187195STejun Heo 6152f3187195STejun Heo ap = kzalloc(sizeof(*ap), GFP_KERNEL); 6153f3187195STejun Heo if (!ap) 6154f3187195STejun Heo return NULL; 6155f3187195STejun Heo 6156f4d6d004STejun Heo ap->pflags |= ATA_PFLAG_INITIALIZING; 6157cca3974eSJeff Garzik ap->lock = &host->lock; 6158c6fd2807SJeff Garzik ap->flags = ATA_FLAG_DISABLED; 6159f3187195STejun Heo ap->print_id = -1; 6160c6fd2807SJeff Garzik ap->ctl = ATA_DEVCTL_OBS; 6161cca3974eSJeff Garzik ap->host = host; 6162f3187195STejun Heo ap->dev = host->dev; 6163c6fd2807SJeff Garzik ap->last_ctl = 0xFF; 6164c6fd2807SJeff Garzik 6165c6fd2807SJeff Garzik #if defined(ATA_VERBOSE_DEBUG) 6166c6fd2807SJeff Garzik /* turn on all debugging levels */ 6167c6fd2807SJeff Garzik ap->msg_enable = 0x00FF; 6168c6fd2807SJeff Garzik #elif defined(ATA_DEBUG) 6169c6fd2807SJeff Garzik ap->msg_enable = ATA_MSG_DRV | ATA_MSG_INFO | ATA_MSG_CTL | ATA_MSG_WARN | ATA_MSG_ERR; 6170c6fd2807SJeff Garzik #else 6171c6fd2807SJeff Garzik ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR | ATA_MSG_WARN; 6172c6fd2807SJeff Garzik #endif 6173c6fd2807SJeff Garzik 617465f27f38SDavid Howells INIT_DELAYED_WORK(&ap->port_task, NULL); 617565f27f38SDavid Howells INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug); 617665f27f38SDavid Howells INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan); 6177c6fd2807SJeff Garzik INIT_LIST_HEAD(&ap->eh_done_q); 6178c6fd2807SJeff Garzik init_waitqueue_head(&ap->eh_wait_q); 61795ddf24c5STejun Heo init_timer_deferrable(&ap->fastdrain_timer); 61805ddf24c5STejun Heo ap->fastdrain_timer.function = ata_eh_fastdrain_timerfn; 61815ddf24c5STejun Heo ap->fastdrain_timer.data = (unsigned long)ap; 6182c6fd2807SJeff Garzik 6183c6fd2807SJeff Garzik ap->cbl = ATA_CBL_NONE; 6184c6fd2807SJeff Garzik 61858989805dSTejun Heo ata_link_init(ap, &ap->link, 0); 6186c6fd2807SJeff Garzik 6187c6fd2807SJeff Garzik #ifdef ATA_IRQ_TRAP 6188c6fd2807SJeff Garzik ap->stats.unhandled_irq = 1; 6189c6fd2807SJeff Garzik ap->stats.idle_irq = 1; 6190c6fd2807SJeff Garzik #endif 6191c6fd2807SJeff Garzik return ap; 6192c6fd2807SJeff Garzik } 6193c6fd2807SJeff Garzik 6194f0d36efdSTejun Heo static void ata_host_release(struct device *gendev, void *res) 6195f0d36efdSTejun Heo { 6196f0d36efdSTejun Heo struct ata_host *host = dev_get_drvdata(gendev); 6197f0d36efdSTejun Heo int i; 6198f0d36efdSTejun Heo 6199f0d36efdSTejun Heo for (i = 0; i < host->n_ports; i++) { 6200f0d36efdSTejun Heo struct ata_port *ap = host->ports[i]; 6201f0d36efdSTejun Heo 6202ecef7253STejun Heo if (!ap) 6203ecef7253STejun Heo continue; 6204ecef7253STejun Heo 6205ecef7253STejun Heo if ((host->flags & ATA_HOST_STARTED) && ap->ops->port_stop) 6206f0d36efdSTejun Heo ap->ops->port_stop(ap); 6207f0d36efdSTejun Heo } 6208f0d36efdSTejun Heo 6209ecef7253STejun Heo if ((host->flags & ATA_HOST_STARTED) && host->ops->host_stop) 6210f0d36efdSTejun Heo host->ops->host_stop(host); 62111aa56ccaSTejun Heo 62121aa506e4STejun Heo for (i = 0; i < host->n_ports; i++) { 62131aa506e4STejun Heo struct ata_port *ap = host->ports[i]; 62141aa506e4STejun Heo 62154911487aSTejun Heo if (!ap) 62164911487aSTejun Heo continue; 62174911487aSTejun Heo 62184911487aSTejun Heo if (ap->scsi_host) 62191aa506e4STejun Heo scsi_host_put(ap->scsi_host); 62201aa506e4STejun Heo 62214911487aSTejun Heo kfree(ap); 62221aa506e4STejun Heo host->ports[i] = NULL; 62231aa506e4STejun Heo } 62241aa506e4STejun Heo 62251aa56ccaSTejun Heo dev_set_drvdata(gendev, NULL); 6226f0d36efdSTejun Heo } 6227f0d36efdSTejun Heo 6228c6fd2807SJeff Garzik /** 6229f3187195STejun Heo * ata_host_alloc - allocate and init basic ATA host resources 6230f3187195STejun Heo * @dev: generic device this host is associated with 6231f3187195STejun Heo * @max_ports: maximum number of ATA ports associated with this host 6232f3187195STejun Heo * 6233f3187195STejun Heo * Allocate and initialize basic ATA host resources. LLD calls 6234f3187195STejun Heo * this function to allocate a host, initializes it fully and 6235f3187195STejun Heo * attaches it using ata_host_register(). 6236f3187195STejun Heo * 6237f3187195STejun Heo * @max_ports ports are allocated and host->n_ports is 6238f3187195STejun Heo * initialized to @max_ports. The caller is allowed to decrease 6239f3187195STejun Heo * host->n_ports before calling ata_host_register(). The unused 6240f3187195STejun Heo * ports will be automatically freed on registration. 6241f3187195STejun Heo * 6242f3187195STejun Heo * RETURNS: 6243f3187195STejun Heo * Allocate ATA host on success, NULL on failure. 6244f3187195STejun Heo * 6245f3187195STejun Heo * LOCKING: 6246f3187195STejun Heo * Inherited from calling layer (may sleep). 6247f3187195STejun Heo */ 6248f3187195STejun Heo struct ata_host *ata_host_alloc(struct device *dev, int max_ports) 6249f3187195STejun Heo { 6250f3187195STejun Heo struct ata_host *host; 6251f3187195STejun Heo size_t sz; 6252f3187195STejun Heo int i; 6253f3187195STejun Heo 6254f3187195STejun Heo DPRINTK("ENTER\n"); 6255f3187195STejun Heo 6256f3187195STejun Heo if (!devres_open_group(dev, NULL, GFP_KERNEL)) 6257f3187195STejun Heo return NULL; 6258f3187195STejun Heo 6259f3187195STejun Heo /* alloc a container for our list of ATA ports (buses) */ 6260f3187195STejun Heo sz = sizeof(struct ata_host) + (max_ports + 1) * sizeof(void *); 6261f3187195STejun Heo /* alloc a container for our list of ATA ports (buses) */ 6262f3187195STejun Heo host = devres_alloc(ata_host_release, sz, GFP_KERNEL); 6263f3187195STejun Heo if (!host) 6264f3187195STejun Heo goto err_out; 6265f3187195STejun Heo 6266f3187195STejun Heo devres_add(dev, host); 6267f3187195STejun Heo dev_set_drvdata(dev, host); 6268f3187195STejun Heo 6269f3187195STejun Heo spin_lock_init(&host->lock); 6270f3187195STejun Heo host->dev = dev; 6271f3187195STejun Heo host->n_ports = max_ports; 6272f3187195STejun Heo 6273f3187195STejun Heo /* allocate ports bound to this host */ 6274f3187195STejun Heo for (i = 0; i < max_ports; i++) { 6275f3187195STejun Heo struct ata_port *ap; 6276f3187195STejun Heo 6277f3187195STejun Heo ap = ata_port_alloc(host); 6278f3187195STejun Heo if (!ap) 6279f3187195STejun Heo goto err_out; 6280f3187195STejun Heo 6281f3187195STejun Heo ap->port_no = i; 6282f3187195STejun Heo host->ports[i] = ap; 6283f3187195STejun Heo } 6284f3187195STejun Heo 6285f3187195STejun Heo devres_remove_group(dev, NULL); 6286f3187195STejun Heo return host; 6287f3187195STejun Heo 6288f3187195STejun Heo err_out: 6289f3187195STejun Heo devres_release_group(dev, NULL); 6290f3187195STejun Heo return NULL; 6291f3187195STejun Heo } 6292f3187195STejun Heo 6293f3187195STejun Heo /** 6294f5cda257STejun Heo * ata_host_alloc_pinfo - alloc host and init with port_info array 6295f5cda257STejun Heo * @dev: generic device this host is associated with 6296f5cda257STejun Heo * @ppi: array of ATA port_info to initialize host with 6297f5cda257STejun Heo * @n_ports: number of ATA ports attached to this host 6298f5cda257STejun Heo * 6299f5cda257STejun Heo * Allocate ATA host and initialize with info from @ppi. If NULL 6300f5cda257STejun Heo * terminated, @ppi may contain fewer entries than @n_ports. The 6301f5cda257STejun Heo * last entry will be used for the remaining ports. 6302f5cda257STejun Heo * 6303f5cda257STejun Heo * RETURNS: 6304f5cda257STejun Heo * Allocate ATA host on success, NULL on failure. 6305f5cda257STejun Heo * 6306f5cda257STejun Heo * LOCKING: 6307f5cda257STejun Heo * Inherited from calling layer (may sleep). 6308f5cda257STejun Heo */ 6309f5cda257STejun Heo struct ata_host *ata_host_alloc_pinfo(struct device *dev, 6310f5cda257STejun Heo const struct ata_port_info * const * ppi, 6311f5cda257STejun Heo int n_ports) 6312f5cda257STejun Heo { 6313f5cda257STejun Heo const struct ata_port_info *pi; 6314f5cda257STejun Heo struct ata_host *host; 6315f5cda257STejun Heo int i, j; 6316f5cda257STejun Heo 6317f5cda257STejun Heo host = ata_host_alloc(dev, n_ports); 6318f5cda257STejun Heo if (!host) 6319f5cda257STejun Heo return NULL; 6320f5cda257STejun Heo 6321f5cda257STejun Heo for (i = 0, j = 0, pi = NULL; i < host->n_ports; i++) { 6322f5cda257STejun Heo struct ata_port *ap = host->ports[i]; 6323f5cda257STejun Heo 6324f5cda257STejun Heo if (ppi[j]) 6325f5cda257STejun Heo pi = ppi[j++]; 6326f5cda257STejun Heo 6327f5cda257STejun Heo ap->pio_mask = pi->pio_mask; 6328f5cda257STejun Heo ap->mwdma_mask = pi->mwdma_mask; 6329f5cda257STejun Heo ap->udma_mask = pi->udma_mask; 6330f5cda257STejun Heo ap->flags |= pi->flags; 63310c88758bSTejun Heo ap->link.flags |= pi->link_flags; 6332f5cda257STejun Heo ap->ops = pi->port_ops; 6333f5cda257STejun Heo 6334f5cda257STejun Heo if (!host->ops && (pi->port_ops != &ata_dummy_port_ops)) 6335f5cda257STejun Heo host->ops = pi->port_ops; 6336f5cda257STejun Heo if (!host->private_data && pi->private_data) 6337f5cda257STejun Heo host->private_data = pi->private_data; 6338f5cda257STejun Heo } 6339f5cda257STejun Heo 6340f5cda257STejun Heo return host; 6341f5cda257STejun Heo } 6342f5cda257STejun Heo 6343f5cda257STejun Heo /** 6344ecef7253STejun Heo * ata_host_start - start and freeze ports of an ATA host 6345ecef7253STejun Heo * @host: ATA host to start ports for 6346ecef7253STejun Heo * 6347ecef7253STejun Heo * Start and then freeze ports of @host. Started status is 6348ecef7253STejun Heo * recorded in host->flags, so this function can be called 6349ecef7253STejun Heo * multiple times. Ports are guaranteed to get started only 6350f3187195STejun Heo * once. If host->ops isn't initialized yet, its set to the 6351f3187195STejun Heo * first non-dummy port ops. 6352ecef7253STejun Heo * 6353ecef7253STejun Heo * LOCKING: 6354ecef7253STejun Heo * Inherited from calling layer (may sleep). 6355ecef7253STejun Heo * 6356ecef7253STejun Heo * RETURNS: 6357ecef7253STejun Heo * 0 if all ports are started successfully, -errno otherwise. 6358ecef7253STejun Heo */ 6359ecef7253STejun Heo int ata_host_start(struct ata_host *host) 6360ecef7253STejun Heo { 6361ecef7253STejun Heo int i, rc; 6362ecef7253STejun Heo 6363ecef7253STejun Heo if (host->flags & ATA_HOST_STARTED) 6364ecef7253STejun Heo return 0; 6365ecef7253STejun Heo 6366ecef7253STejun Heo for (i = 0; i < host->n_ports; i++) { 6367ecef7253STejun Heo struct ata_port *ap = host->ports[i]; 6368ecef7253STejun Heo 6369f3187195STejun Heo if (!host->ops && !ata_port_is_dummy(ap)) 6370f3187195STejun Heo host->ops = ap->ops; 6371f3187195STejun Heo 6372ecef7253STejun Heo if (ap->ops->port_start) { 6373ecef7253STejun Heo rc = ap->ops->port_start(ap); 6374ecef7253STejun Heo if (rc) { 6375ecef7253STejun Heo ata_port_printk(ap, KERN_ERR, "failed to " 6376ecef7253STejun Heo "start port (errno=%d)\n", rc); 6377ecef7253STejun Heo goto err_out; 6378ecef7253STejun Heo } 6379ecef7253STejun Heo } 6380ecef7253STejun Heo 6381ecef7253STejun Heo ata_eh_freeze_port(ap); 6382ecef7253STejun Heo } 6383ecef7253STejun Heo 6384ecef7253STejun Heo host->flags |= ATA_HOST_STARTED; 6385ecef7253STejun Heo return 0; 6386ecef7253STejun Heo 6387ecef7253STejun Heo err_out: 6388ecef7253STejun Heo while (--i >= 0) { 6389ecef7253STejun Heo struct ata_port *ap = host->ports[i]; 6390ecef7253STejun Heo 6391ecef7253STejun Heo if (ap->ops->port_stop) 6392ecef7253STejun Heo ap->ops->port_stop(ap); 6393ecef7253STejun Heo } 6394ecef7253STejun Heo return rc; 6395ecef7253STejun Heo } 6396ecef7253STejun Heo 6397ecef7253STejun Heo /** 6398cca3974eSJeff Garzik * ata_sas_host_init - Initialize a host struct 6399cca3974eSJeff Garzik * @host: host to initialize 6400cca3974eSJeff Garzik * @dev: device host is attached to 6401cca3974eSJeff Garzik * @flags: host flags 6402c6fd2807SJeff Garzik * @ops: port_ops 6403c6fd2807SJeff Garzik * 6404c6fd2807SJeff Garzik * LOCKING: 6405c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 6406c6fd2807SJeff Garzik * 6407c6fd2807SJeff Garzik */ 6408f3187195STejun Heo /* KILLME - the only user left is ipr */ 6409cca3974eSJeff Garzik void ata_host_init(struct ata_host *host, struct device *dev, 6410cca3974eSJeff Garzik unsigned long flags, const struct ata_port_operations *ops) 6411c6fd2807SJeff Garzik { 6412cca3974eSJeff Garzik spin_lock_init(&host->lock); 6413cca3974eSJeff Garzik host->dev = dev; 6414cca3974eSJeff Garzik host->flags = flags; 6415cca3974eSJeff Garzik host->ops = ops; 6416c6fd2807SJeff Garzik } 6417c6fd2807SJeff Garzik 6418c6fd2807SJeff Garzik /** 6419f3187195STejun Heo * ata_host_register - register initialized ATA host 6420f3187195STejun Heo * @host: ATA host to register 6421f3187195STejun Heo * @sht: template for SCSI host 6422c6fd2807SJeff Garzik * 6423f3187195STejun Heo * Register initialized ATA host. @host is allocated using 6424f3187195STejun Heo * ata_host_alloc() and fully initialized by LLD. This function 6425f3187195STejun Heo * starts ports, registers @host with ATA and SCSI layers and 6426f3187195STejun Heo * probe registered devices. 6427c6fd2807SJeff Garzik * 6428c6fd2807SJeff Garzik * LOCKING: 6429f3187195STejun Heo * Inherited from calling layer (may sleep). 6430c6fd2807SJeff Garzik * 6431c6fd2807SJeff Garzik * RETURNS: 6432f3187195STejun Heo * 0 on success, -errno otherwise. 6433c6fd2807SJeff Garzik */ 6434f3187195STejun Heo int ata_host_register(struct ata_host *host, struct scsi_host_template *sht) 6435c6fd2807SJeff Garzik { 6436f3187195STejun Heo int i, rc; 6437c6fd2807SJeff Garzik 6438f3187195STejun Heo /* host must have been started */ 6439f3187195STejun Heo if (!(host->flags & ATA_HOST_STARTED)) { 6440f3187195STejun Heo dev_printk(KERN_ERR, host->dev, 6441f3187195STejun Heo "BUG: trying to register unstarted host\n"); 6442f3187195STejun Heo WARN_ON(1); 6443f3187195STejun Heo return -EINVAL; 644402f076aaSAlan Cox } 6445f0d36efdSTejun Heo 6446f3187195STejun Heo /* Blow away unused ports. This happens when LLD can't 6447f3187195STejun Heo * determine the exact number of ports to allocate at 6448f3187195STejun Heo * allocation time. 6449f3187195STejun Heo */ 6450f3187195STejun Heo for (i = host->n_ports; host->ports[i]; i++) 6451f3187195STejun Heo kfree(host->ports[i]); 6452f0d36efdSTejun Heo 6453f3187195STejun Heo /* give ports names and add SCSI hosts */ 6454f3187195STejun Heo for (i = 0; i < host->n_ports; i++) 6455f3187195STejun Heo host->ports[i]->print_id = ata_print_id++; 6456c6fd2807SJeff Garzik 6457f3187195STejun Heo rc = ata_scsi_add_hosts(host, sht); 6458ecef7253STejun Heo if (rc) 6459f3187195STejun Heo return rc; 6460ecef7253STejun Heo 6461fafbae87STejun Heo /* associate with ACPI nodes */ 6462fafbae87STejun Heo ata_acpi_associate(host); 6463fafbae87STejun Heo 6464f3187195STejun Heo /* set cable, sata_spd_limit and report */ 6465cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 6466cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 6467f3187195STejun Heo int irq_line; 6468f3187195STejun Heo unsigned long xfer_mask; 6469f3187195STejun Heo 6470f3187195STejun Heo /* set SATA cable type if still unset */ 6471f3187195STejun Heo if (ap->cbl == ATA_CBL_NONE && (ap->flags & ATA_FLAG_SATA)) 6472f3187195STejun Heo ap->cbl = ATA_CBL_SATA; 6473c6fd2807SJeff Garzik 6474c6fd2807SJeff Garzik /* init sata_spd_limit to the current value */ 64754fb37a25STejun Heo sata_link_init_spd(&ap->link); 6476c6fd2807SJeff Garzik 6477f3187195STejun Heo /* report the secondary IRQ for second channel legacy */ 6478f3187195STejun Heo irq_line = host->irq; 6479f3187195STejun Heo if (i == 1 && host->irq2) 6480f3187195STejun Heo irq_line = host->irq2; 6481f3187195STejun Heo 6482f3187195STejun Heo xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask, 6483f3187195STejun Heo ap->udma_mask); 6484f3187195STejun Heo 6485f3187195STejun Heo /* print per-port info to dmesg */ 6486f3187195STejun Heo if (!ata_port_is_dummy(ap)) 6487f3187195STejun Heo ata_port_printk(ap, KERN_INFO, "%cATA max %s cmd 0x%p " 6488f3187195STejun Heo "ctl 0x%p bmdma 0x%p irq %d\n", 6489a16abc0bSTejun Heo (ap->flags & ATA_FLAG_SATA) ? 'S' : 'P', 6490f3187195STejun Heo ata_mode_string(xfer_mask), 6491f3187195STejun Heo ap->ioaddr.cmd_addr, 6492f3187195STejun Heo ap->ioaddr.ctl_addr, 6493f3187195STejun Heo ap->ioaddr.bmdma_addr, 6494f3187195STejun Heo irq_line); 6495f3187195STejun Heo else 6496f3187195STejun Heo ata_port_printk(ap, KERN_INFO, "DUMMY\n"); 6497c6fd2807SJeff Garzik } 6498c6fd2807SJeff Garzik 6499f3187195STejun Heo /* perform each probe synchronously */ 6500f3187195STejun Heo DPRINTK("probe begin\n"); 6501f3187195STejun Heo for (i = 0; i < host->n_ports; i++) { 6502f3187195STejun Heo struct ata_port *ap = host->ports[i]; 6503f3187195STejun Heo int rc; 6504f3187195STejun Heo 6505f3187195STejun Heo /* probe */ 6506c6fd2807SJeff Garzik if (ap->ops->error_handler) { 65079af5c9c9STejun Heo struct ata_eh_info *ehi = &ap->link.eh_info; 6508c6fd2807SJeff Garzik unsigned long flags; 6509c6fd2807SJeff Garzik 6510c6fd2807SJeff Garzik ata_port_probe(ap); 6511c6fd2807SJeff Garzik 6512c6fd2807SJeff Garzik /* kick EH for boot probing */ 6513c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 6514c6fd2807SJeff Garzik 6515f58229f8STejun Heo ehi->probe_mask = 6516f58229f8STejun Heo (1 << ata_link_max_devices(&ap->link)) - 1; 6517c6fd2807SJeff Garzik ehi->action |= ATA_EH_SOFTRESET; 6518c6fd2807SJeff Garzik ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET; 6519c6fd2807SJeff Garzik 6520f4d6d004STejun Heo ap->pflags &= ~ATA_PFLAG_INITIALIZING; 6521c6fd2807SJeff Garzik ap->pflags |= ATA_PFLAG_LOADING; 6522c6fd2807SJeff Garzik ata_port_schedule_eh(ap); 6523c6fd2807SJeff Garzik 6524c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 6525c6fd2807SJeff Garzik 6526c6fd2807SJeff Garzik /* wait for EH to finish */ 6527c6fd2807SJeff Garzik ata_port_wait_eh(ap); 6528c6fd2807SJeff Garzik } else { 652944877b4eSTejun Heo DPRINTK("ata%u: bus probe begin\n", ap->print_id); 6530c6fd2807SJeff Garzik rc = ata_bus_probe(ap); 653144877b4eSTejun Heo DPRINTK("ata%u: bus probe end\n", ap->print_id); 6532c6fd2807SJeff Garzik 6533c6fd2807SJeff Garzik if (rc) { 6534c6fd2807SJeff Garzik /* FIXME: do something useful here? 6535c6fd2807SJeff Garzik * Current libata behavior will 6536c6fd2807SJeff Garzik * tear down everything when 6537c6fd2807SJeff Garzik * the module is removed 6538c6fd2807SJeff Garzik * or the h/w is unplugged. 6539c6fd2807SJeff Garzik */ 6540c6fd2807SJeff Garzik } 6541c6fd2807SJeff Garzik } 6542c6fd2807SJeff Garzik } 6543c6fd2807SJeff Garzik 6544c6fd2807SJeff Garzik /* probes are done, now scan each port's disk(s) */ 6545c6fd2807SJeff Garzik DPRINTK("host probe begin\n"); 6546cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 6547cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 6548c6fd2807SJeff Garzik 65491ae46317STejun Heo ata_scsi_scan_host(ap, 1); 6550c6fd2807SJeff Garzik } 6551c6fd2807SJeff Garzik 6552f3187195STejun Heo return 0; 6553f3187195STejun Heo } 6554f3187195STejun Heo 6555f3187195STejun Heo /** 6556f5cda257STejun Heo * ata_host_activate - start host, request IRQ and register it 6557f5cda257STejun Heo * @host: target ATA host 6558f5cda257STejun Heo * @irq: IRQ to request 6559f5cda257STejun Heo * @irq_handler: irq_handler used when requesting IRQ 6560f5cda257STejun Heo * @irq_flags: irq_flags used when requesting IRQ 6561f5cda257STejun Heo * @sht: scsi_host_template to use when registering the host 6562f5cda257STejun Heo * 6563f5cda257STejun Heo * After allocating an ATA host and initializing it, most libata 6564f5cda257STejun Heo * LLDs perform three steps to activate the host - start host, 6565f5cda257STejun Heo * request IRQ and register it. This helper takes necessasry 6566f5cda257STejun Heo * arguments and performs the three steps in one go. 6567f5cda257STejun Heo * 6568f5cda257STejun Heo * LOCKING: 6569f5cda257STejun Heo * Inherited from calling layer (may sleep). 6570f5cda257STejun Heo * 6571f5cda257STejun Heo * RETURNS: 6572f5cda257STejun Heo * 0 on success, -errno otherwise. 6573f5cda257STejun Heo */ 6574f5cda257STejun Heo int ata_host_activate(struct ata_host *host, int irq, 6575f5cda257STejun Heo irq_handler_t irq_handler, unsigned long irq_flags, 6576f5cda257STejun Heo struct scsi_host_template *sht) 6577f5cda257STejun Heo { 6578f5cda257STejun Heo int rc; 6579f5cda257STejun Heo 6580f5cda257STejun Heo rc = ata_host_start(host); 6581f5cda257STejun Heo if (rc) 6582f5cda257STejun Heo return rc; 6583f5cda257STejun Heo 6584f5cda257STejun Heo rc = devm_request_irq(host->dev, irq, irq_handler, irq_flags, 6585f5cda257STejun Heo dev_driver_string(host->dev), host); 6586f5cda257STejun Heo if (rc) 6587f5cda257STejun Heo return rc; 6588f5cda257STejun Heo 65894031826bSTejun Heo /* Used to print device info at probe */ 65904031826bSTejun Heo host->irq = irq; 65914031826bSTejun Heo 6592f5cda257STejun Heo rc = ata_host_register(host, sht); 6593f5cda257STejun Heo /* if failed, just free the IRQ and leave ports alone */ 6594f5cda257STejun Heo if (rc) 6595f5cda257STejun Heo devm_free_irq(host->dev, irq, host); 6596f5cda257STejun Heo 6597f5cda257STejun Heo return rc; 6598f5cda257STejun Heo } 6599f5cda257STejun Heo 6600f5cda257STejun Heo /** 6601c6fd2807SJeff Garzik * ata_port_detach - Detach ATA port in prepration of device removal 6602c6fd2807SJeff Garzik * @ap: ATA port to be detached 6603c6fd2807SJeff Garzik * 6604c6fd2807SJeff Garzik * Detach all ATA devices and the associated SCSI devices of @ap; 6605c6fd2807SJeff Garzik * then, remove the associated SCSI host. @ap is guaranteed to 6606c6fd2807SJeff Garzik * be quiescent on return from this function. 6607c6fd2807SJeff Garzik * 6608c6fd2807SJeff Garzik * LOCKING: 6609c6fd2807SJeff Garzik * Kernel thread context (may sleep). 6610c6fd2807SJeff Garzik */ 6611c6fd2807SJeff Garzik void ata_port_detach(struct ata_port *ap) 6612c6fd2807SJeff Garzik { 6613c6fd2807SJeff Garzik unsigned long flags; 661441bda9c9STejun Heo struct ata_link *link; 6615f58229f8STejun Heo struct ata_device *dev; 6616c6fd2807SJeff Garzik 6617c6fd2807SJeff Garzik if (!ap->ops->error_handler) 6618c6fd2807SJeff Garzik goto skip_eh; 6619c6fd2807SJeff Garzik 6620c6fd2807SJeff Garzik /* tell EH we're leaving & flush EH */ 6621c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 6622c6fd2807SJeff Garzik ap->pflags |= ATA_PFLAG_UNLOADING; 6623c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 6624c6fd2807SJeff Garzik 6625c6fd2807SJeff Garzik ata_port_wait_eh(ap); 6626c6fd2807SJeff Garzik 6627c6fd2807SJeff Garzik /* EH is now guaranteed to see UNLOADING, so no new device 6628c6fd2807SJeff Garzik * will be attached. Disable all existing devices. 6629c6fd2807SJeff Garzik */ 6630c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 6631c6fd2807SJeff Garzik 663241bda9c9STejun Heo ata_port_for_each_link(link, ap) { 663341bda9c9STejun Heo ata_link_for_each_dev(dev, link) 6634f58229f8STejun Heo ata_dev_disable(dev); 663541bda9c9STejun Heo } 6636c6fd2807SJeff Garzik 6637c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 6638c6fd2807SJeff Garzik 6639c6fd2807SJeff Garzik /* Final freeze & EH. All in-flight commands are aborted. EH 6640c6fd2807SJeff Garzik * will be skipped and retrials will be terminated with bad 6641c6fd2807SJeff Garzik * target. 6642c6fd2807SJeff Garzik */ 6643c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 6644c6fd2807SJeff Garzik ata_port_freeze(ap); /* won't be thawed */ 6645c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 6646c6fd2807SJeff Garzik 6647c6fd2807SJeff Garzik ata_port_wait_eh(ap); 664845a66c1cSOleg Nesterov cancel_rearming_delayed_work(&ap->hotplug_task); 6649c6fd2807SJeff Garzik 6650c6fd2807SJeff Garzik skip_eh: 6651c6fd2807SJeff Garzik /* remove the associated SCSI host */ 6652cca3974eSJeff Garzik scsi_remove_host(ap->scsi_host); 6653c6fd2807SJeff Garzik } 6654c6fd2807SJeff Garzik 6655c6fd2807SJeff Garzik /** 66560529c159STejun Heo * ata_host_detach - Detach all ports of an ATA host 66570529c159STejun Heo * @host: Host to detach 66580529c159STejun Heo * 66590529c159STejun Heo * Detach all ports of @host. 66600529c159STejun Heo * 66610529c159STejun Heo * LOCKING: 66620529c159STejun Heo * Kernel thread context (may sleep). 66630529c159STejun Heo */ 66640529c159STejun Heo void ata_host_detach(struct ata_host *host) 66650529c159STejun Heo { 66660529c159STejun Heo int i; 66670529c159STejun Heo 66680529c159STejun Heo for (i = 0; i < host->n_ports; i++) 66690529c159STejun Heo ata_port_detach(host->ports[i]); 66700529c159STejun Heo } 66710529c159STejun Heo 6672c6fd2807SJeff Garzik /** 6673c6fd2807SJeff Garzik * ata_std_ports - initialize ioaddr with standard port offsets. 6674c6fd2807SJeff Garzik * @ioaddr: IO address structure to be initialized 6675c6fd2807SJeff Garzik * 6676c6fd2807SJeff Garzik * Utility function which initializes data_addr, error_addr, 6677c6fd2807SJeff Garzik * feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr, 6678c6fd2807SJeff Garzik * device_addr, status_addr, and command_addr to standard offsets 6679c6fd2807SJeff Garzik * relative to cmd_addr. 6680c6fd2807SJeff Garzik * 6681c6fd2807SJeff Garzik * Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr. 6682c6fd2807SJeff Garzik */ 6683c6fd2807SJeff Garzik 6684c6fd2807SJeff Garzik void ata_std_ports(struct ata_ioports *ioaddr) 6685c6fd2807SJeff Garzik { 6686c6fd2807SJeff Garzik ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA; 6687c6fd2807SJeff Garzik ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR; 6688c6fd2807SJeff Garzik ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE; 6689c6fd2807SJeff Garzik ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT; 6690c6fd2807SJeff Garzik ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL; 6691c6fd2807SJeff Garzik ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM; 6692c6fd2807SJeff Garzik ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH; 6693c6fd2807SJeff Garzik ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE; 6694c6fd2807SJeff Garzik ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS; 6695c6fd2807SJeff Garzik ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD; 6696c6fd2807SJeff Garzik } 6697c6fd2807SJeff Garzik 6698c6fd2807SJeff Garzik 6699c6fd2807SJeff Garzik #ifdef CONFIG_PCI 6700c6fd2807SJeff Garzik 6701c6fd2807SJeff Garzik /** 6702c6fd2807SJeff Garzik * ata_pci_remove_one - PCI layer callback for device removal 6703c6fd2807SJeff Garzik * @pdev: PCI device that was removed 6704c6fd2807SJeff Garzik * 6705b878ca5dSTejun Heo * PCI layer indicates to libata via this hook that hot-unplug or 6706b878ca5dSTejun Heo * module unload event has occurred. Detach all ports. Resource 6707b878ca5dSTejun Heo * release is handled via devres. 6708c6fd2807SJeff Garzik * 6709c6fd2807SJeff Garzik * LOCKING: 6710c6fd2807SJeff Garzik * Inherited from PCI layer (may sleep). 6711c6fd2807SJeff Garzik */ 6712c6fd2807SJeff Garzik void ata_pci_remove_one(struct pci_dev *pdev) 6713c6fd2807SJeff Garzik { 6714c6fd2807SJeff Garzik struct device *dev = pci_dev_to_dev(pdev); 6715cca3974eSJeff Garzik struct ata_host *host = dev_get_drvdata(dev); 6716c6fd2807SJeff Garzik 6717f0d36efdSTejun Heo ata_host_detach(host); 6718c6fd2807SJeff Garzik } 6719c6fd2807SJeff Garzik 6720c6fd2807SJeff Garzik /* move to PCI subsystem */ 6721c6fd2807SJeff Garzik int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits) 6722c6fd2807SJeff Garzik { 6723c6fd2807SJeff Garzik unsigned long tmp = 0; 6724c6fd2807SJeff Garzik 6725c6fd2807SJeff Garzik switch (bits->width) { 6726c6fd2807SJeff Garzik case 1: { 6727c6fd2807SJeff Garzik u8 tmp8 = 0; 6728c6fd2807SJeff Garzik pci_read_config_byte(pdev, bits->reg, &tmp8); 6729c6fd2807SJeff Garzik tmp = tmp8; 6730c6fd2807SJeff Garzik break; 6731c6fd2807SJeff Garzik } 6732c6fd2807SJeff Garzik case 2: { 6733c6fd2807SJeff Garzik u16 tmp16 = 0; 6734c6fd2807SJeff Garzik pci_read_config_word(pdev, bits->reg, &tmp16); 6735c6fd2807SJeff Garzik tmp = tmp16; 6736c6fd2807SJeff Garzik break; 6737c6fd2807SJeff Garzik } 6738c6fd2807SJeff Garzik case 4: { 6739c6fd2807SJeff Garzik u32 tmp32 = 0; 6740c6fd2807SJeff Garzik pci_read_config_dword(pdev, bits->reg, &tmp32); 6741c6fd2807SJeff Garzik tmp = tmp32; 6742c6fd2807SJeff Garzik break; 6743c6fd2807SJeff Garzik } 6744c6fd2807SJeff Garzik 6745c6fd2807SJeff Garzik default: 6746c6fd2807SJeff Garzik return -EINVAL; 6747c6fd2807SJeff Garzik } 6748c6fd2807SJeff Garzik 6749c6fd2807SJeff Garzik tmp &= bits->mask; 6750c6fd2807SJeff Garzik 6751c6fd2807SJeff Garzik return (tmp == bits->val) ? 1 : 0; 6752c6fd2807SJeff Garzik } 6753c6fd2807SJeff Garzik 67546ffa01d8STejun Heo #ifdef CONFIG_PM 6755c6fd2807SJeff Garzik void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg) 6756c6fd2807SJeff Garzik { 6757c6fd2807SJeff Garzik pci_save_state(pdev); 6758c6fd2807SJeff Garzik pci_disable_device(pdev); 67594c90d971STejun Heo 67604c90d971STejun Heo if (mesg.event == PM_EVENT_SUSPEND) 6761c6fd2807SJeff Garzik pci_set_power_state(pdev, PCI_D3hot); 6762c6fd2807SJeff Garzik } 6763c6fd2807SJeff Garzik 6764553c4aa6STejun Heo int ata_pci_device_do_resume(struct pci_dev *pdev) 6765c6fd2807SJeff Garzik { 6766553c4aa6STejun Heo int rc; 6767553c4aa6STejun Heo 6768c6fd2807SJeff Garzik pci_set_power_state(pdev, PCI_D0); 6769c6fd2807SJeff Garzik pci_restore_state(pdev); 6770553c4aa6STejun Heo 6771f0d36efdSTejun Heo rc = pcim_enable_device(pdev); 6772553c4aa6STejun Heo if (rc) { 6773553c4aa6STejun Heo dev_printk(KERN_ERR, &pdev->dev, 6774553c4aa6STejun Heo "failed to enable device after resume (%d)\n", rc); 6775553c4aa6STejun Heo return rc; 6776553c4aa6STejun Heo } 6777553c4aa6STejun Heo 6778c6fd2807SJeff Garzik pci_set_master(pdev); 6779553c4aa6STejun Heo return 0; 6780c6fd2807SJeff Garzik } 6781c6fd2807SJeff Garzik 6782c6fd2807SJeff Garzik int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg) 6783c6fd2807SJeff Garzik { 6784cca3974eSJeff Garzik struct ata_host *host = dev_get_drvdata(&pdev->dev); 6785c6fd2807SJeff Garzik int rc = 0; 6786c6fd2807SJeff Garzik 6787cca3974eSJeff Garzik rc = ata_host_suspend(host, mesg); 6788c6fd2807SJeff Garzik if (rc) 6789c6fd2807SJeff Garzik return rc; 6790c6fd2807SJeff Garzik 6791c6fd2807SJeff Garzik ata_pci_device_do_suspend(pdev, mesg); 6792c6fd2807SJeff Garzik 6793c6fd2807SJeff Garzik return 0; 6794c6fd2807SJeff Garzik } 6795c6fd2807SJeff Garzik 6796c6fd2807SJeff Garzik int ata_pci_device_resume(struct pci_dev *pdev) 6797c6fd2807SJeff Garzik { 6798cca3974eSJeff Garzik struct ata_host *host = dev_get_drvdata(&pdev->dev); 6799553c4aa6STejun Heo int rc; 6800c6fd2807SJeff Garzik 6801553c4aa6STejun Heo rc = ata_pci_device_do_resume(pdev); 6802553c4aa6STejun Heo if (rc == 0) 6803cca3974eSJeff Garzik ata_host_resume(host); 6804553c4aa6STejun Heo return rc; 6805c6fd2807SJeff Garzik } 68066ffa01d8STejun Heo #endif /* CONFIG_PM */ 68076ffa01d8STejun Heo 6808c6fd2807SJeff Garzik #endif /* CONFIG_PCI */ 6809c6fd2807SJeff Garzik 6810c6fd2807SJeff Garzik 6811c6fd2807SJeff Garzik static int __init ata_init(void) 6812c6fd2807SJeff Garzik { 6813c6fd2807SJeff Garzik ata_probe_timeout *= HZ; 6814c6fd2807SJeff Garzik ata_wq = create_workqueue("ata"); 6815c6fd2807SJeff Garzik if (!ata_wq) 6816c6fd2807SJeff Garzik return -ENOMEM; 6817c6fd2807SJeff Garzik 6818c6fd2807SJeff Garzik ata_aux_wq = create_singlethread_workqueue("ata_aux"); 6819c6fd2807SJeff Garzik if (!ata_aux_wq) { 6820c6fd2807SJeff Garzik destroy_workqueue(ata_wq); 6821c6fd2807SJeff Garzik return -ENOMEM; 6822c6fd2807SJeff Garzik } 6823c6fd2807SJeff Garzik 6824c6fd2807SJeff Garzik printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n"); 6825c6fd2807SJeff Garzik return 0; 6826c6fd2807SJeff Garzik } 6827c6fd2807SJeff Garzik 6828c6fd2807SJeff Garzik static void __exit ata_exit(void) 6829c6fd2807SJeff Garzik { 6830c6fd2807SJeff Garzik destroy_workqueue(ata_wq); 6831c6fd2807SJeff Garzik destroy_workqueue(ata_aux_wq); 6832c6fd2807SJeff Garzik } 6833c6fd2807SJeff Garzik 6834a4625085SBrian King subsys_initcall(ata_init); 6835c6fd2807SJeff Garzik module_exit(ata_exit); 6836c6fd2807SJeff Garzik 6837c6fd2807SJeff Garzik static unsigned long ratelimit_time; 6838c6fd2807SJeff Garzik static DEFINE_SPINLOCK(ata_ratelimit_lock); 6839c6fd2807SJeff Garzik 6840c6fd2807SJeff Garzik int ata_ratelimit(void) 6841c6fd2807SJeff Garzik { 6842c6fd2807SJeff Garzik int rc; 6843c6fd2807SJeff Garzik unsigned long flags; 6844c6fd2807SJeff Garzik 6845c6fd2807SJeff Garzik spin_lock_irqsave(&ata_ratelimit_lock, flags); 6846c6fd2807SJeff Garzik 6847c6fd2807SJeff Garzik if (time_after(jiffies, ratelimit_time)) { 6848c6fd2807SJeff Garzik rc = 1; 6849c6fd2807SJeff Garzik ratelimit_time = jiffies + (HZ/5); 6850c6fd2807SJeff Garzik } else 6851c6fd2807SJeff Garzik rc = 0; 6852c6fd2807SJeff Garzik 6853c6fd2807SJeff Garzik spin_unlock_irqrestore(&ata_ratelimit_lock, flags); 6854c6fd2807SJeff Garzik 6855c6fd2807SJeff Garzik return rc; 6856c6fd2807SJeff Garzik } 6857c6fd2807SJeff Garzik 6858c6fd2807SJeff Garzik /** 6859c6fd2807SJeff Garzik * ata_wait_register - wait until register value changes 6860c6fd2807SJeff Garzik * @reg: IO-mapped register 6861c6fd2807SJeff Garzik * @mask: Mask to apply to read register value 6862c6fd2807SJeff Garzik * @val: Wait condition 6863c6fd2807SJeff Garzik * @interval_msec: polling interval in milliseconds 6864c6fd2807SJeff Garzik * @timeout_msec: timeout in milliseconds 6865c6fd2807SJeff Garzik * 6866c6fd2807SJeff Garzik * Waiting for some bits of register to change is a common 6867c6fd2807SJeff Garzik * operation for ATA controllers. This function reads 32bit LE 6868c6fd2807SJeff Garzik * IO-mapped register @reg and tests for the following condition. 6869c6fd2807SJeff Garzik * 6870c6fd2807SJeff Garzik * (*@reg & mask) != val 6871c6fd2807SJeff Garzik * 6872c6fd2807SJeff Garzik * If the condition is met, it returns; otherwise, the process is 6873c6fd2807SJeff Garzik * repeated after @interval_msec until timeout. 6874c6fd2807SJeff Garzik * 6875c6fd2807SJeff Garzik * LOCKING: 6876c6fd2807SJeff Garzik * Kernel thread context (may sleep) 6877c6fd2807SJeff Garzik * 6878c6fd2807SJeff Garzik * RETURNS: 6879c6fd2807SJeff Garzik * The final register value. 6880c6fd2807SJeff Garzik */ 6881c6fd2807SJeff Garzik u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val, 6882c6fd2807SJeff Garzik unsigned long interval_msec, 6883c6fd2807SJeff Garzik unsigned long timeout_msec) 6884c6fd2807SJeff Garzik { 6885c6fd2807SJeff Garzik unsigned long timeout; 6886c6fd2807SJeff Garzik u32 tmp; 6887c6fd2807SJeff Garzik 6888c6fd2807SJeff Garzik tmp = ioread32(reg); 6889c6fd2807SJeff Garzik 6890c6fd2807SJeff Garzik /* Calculate timeout _after_ the first read to make sure 6891c6fd2807SJeff Garzik * preceding writes reach the controller before starting to 6892c6fd2807SJeff Garzik * eat away the timeout. 6893c6fd2807SJeff Garzik */ 6894c6fd2807SJeff Garzik timeout = jiffies + (timeout_msec * HZ) / 1000; 6895c6fd2807SJeff Garzik 6896c6fd2807SJeff Garzik while ((tmp & mask) == val && time_before(jiffies, timeout)) { 6897c6fd2807SJeff Garzik msleep(interval_msec); 6898c6fd2807SJeff Garzik tmp = ioread32(reg); 6899c6fd2807SJeff Garzik } 6900c6fd2807SJeff Garzik 6901c6fd2807SJeff Garzik return tmp; 6902c6fd2807SJeff Garzik } 6903c6fd2807SJeff Garzik 6904c6fd2807SJeff Garzik /* 6905c6fd2807SJeff Garzik * Dummy port_ops 6906c6fd2807SJeff Garzik */ 6907c6fd2807SJeff Garzik static void ata_dummy_noret(struct ata_port *ap) { } 6908c6fd2807SJeff Garzik static int ata_dummy_ret0(struct ata_port *ap) { return 0; } 6909c6fd2807SJeff Garzik static void ata_dummy_qc_noret(struct ata_queued_cmd *qc) { } 6910c6fd2807SJeff Garzik 6911c6fd2807SJeff Garzik static u8 ata_dummy_check_status(struct ata_port *ap) 6912c6fd2807SJeff Garzik { 6913c6fd2807SJeff Garzik return ATA_DRDY; 6914c6fd2807SJeff Garzik } 6915c6fd2807SJeff Garzik 6916c6fd2807SJeff Garzik static unsigned int ata_dummy_qc_issue(struct ata_queued_cmd *qc) 6917c6fd2807SJeff Garzik { 6918c6fd2807SJeff Garzik return AC_ERR_SYSTEM; 6919c6fd2807SJeff Garzik } 6920c6fd2807SJeff Garzik 6921c6fd2807SJeff Garzik const struct ata_port_operations ata_dummy_port_ops = { 6922c6fd2807SJeff Garzik .port_disable = ata_port_disable, 6923c6fd2807SJeff Garzik .check_status = ata_dummy_check_status, 6924c6fd2807SJeff Garzik .check_altstatus = ata_dummy_check_status, 6925c6fd2807SJeff Garzik .dev_select = ata_noop_dev_select, 6926c6fd2807SJeff Garzik .qc_prep = ata_noop_qc_prep, 6927c6fd2807SJeff Garzik .qc_issue = ata_dummy_qc_issue, 6928c6fd2807SJeff Garzik .freeze = ata_dummy_noret, 6929c6fd2807SJeff Garzik .thaw = ata_dummy_noret, 6930c6fd2807SJeff Garzik .error_handler = ata_dummy_noret, 6931c6fd2807SJeff Garzik .post_internal_cmd = ata_dummy_qc_noret, 6932c6fd2807SJeff Garzik .irq_clear = ata_dummy_noret, 6933c6fd2807SJeff Garzik .port_start = ata_dummy_ret0, 6934c6fd2807SJeff Garzik .port_stop = ata_dummy_noret, 6935c6fd2807SJeff Garzik }; 6936c6fd2807SJeff Garzik 693721b0ad4fSTejun Heo const struct ata_port_info ata_dummy_port_info = { 693821b0ad4fSTejun Heo .port_ops = &ata_dummy_port_ops, 693921b0ad4fSTejun Heo }; 694021b0ad4fSTejun Heo 6941c6fd2807SJeff Garzik /* 6942c6fd2807SJeff Garzik * libata is essentially a library of internal helper functions for 6943c6fd2807SJeff Garzik * low-level ATA host controller drivers. As such, the API/ABI is 6944c6fd2807SJeff Garzik * likely to change as new drivers are added and updated. 6945c6fd2807SJeff Garzik * Do not depend on ABI/API stability. 6946c6fd2807SJeff Garzik */ 6947c6fd2807SJeff Garzik 6948c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_deb_timing_normal); 6949c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_deb_timing_hotplug); 6950c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_deb_timing_long); 6951c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_dummy_port_ops); 695221b0ad4fSTejun Heo EXPORT_SYMBOL_GPL(ata_dummy_port_info); 6953c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_bios_param); 6954c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_ports); 6955cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_init); 6956f3187195STejun Heo EXPORT_SYMBOL_GPL(ata_host_alloc); 6957f5cda257STejun Heo EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo); 6958ecef7253STejun Heo EXPORT_SYMBOL_GPL(ata_host_start); 6959f3187195STejun Heo EXPORT_SYMBOL_GPL(ata_host_register); 6960f5cda257STejun Heo EXPORT_SYMBOL_GPL(ata_host_activate); 69610529c159STejun Heo EXPORT_SYMBOL_GPL(ata_host_detach); 6962c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_sg_init); 6963c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_sg_init_one); 6964c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_hsm_move); 6965c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_complete); 6966c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_complete_multiple); 6967c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_issue_prot); 6968c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_load); 6969c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_read); 6970c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_noop_dev_select); 6971c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_dev_select); 697243727fbcSJeff Garzik EXPORT_SYMBOL_GPL(sata_print_link_status); 6973c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_to_fis); 6974c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_from_fis); 6975c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_check_status); 6976c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_altstatus); 6977c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_exec_command); 6978c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_start); 6979d92e74d3SAlan Cox EXPORT_SYMBOL_GPL(ata_sff_port_start); 6980c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_interrupt); 698104351821SAlan EXPORT_SYMBOL_GPL(ata_do_set_mode); 69820d5ff566STejun Heo EXPORT_SYMBOL_GPL(ata_data_xfer); 69830d5ff566STejun Heo EXPORT_SYMBOL_GPL(ata_data_xfer_noirq); 6984c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_prep); 6985d26fc955SAlan Cox EXPORT_SYMBOL_GPL(ata_dumb_qc_prep); 6986c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_noop_qc_prep); 6987c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_setup); 6988c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_start); 6989c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear); 6990c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_status); 6991c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_stop); 6992c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_freeze); 6993c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_thaw); 6994c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_drive_eh); 6995c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_error_handler); 6996c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bmdma_post_internal_cmd); 6997c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_probe); 699810305f0fSAlan EXPORT_SYMBOL_GPL(ata_dev_disable); 6999c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_set_spd); 7000936fd732STejun Heo EXPORT_SYMBOL_GPL(sata_link_debounce); 7001936fd732STejun Heo EXPORT_SYMBOL_GPL(sata_link_resume); 7002c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_phy_reset); 7003c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(__sata_phy_reset); 7004c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_bus_reset); 7005c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_prereset); 7006c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_softreset); 7007cc0680a5STejun Heo EXPORT_SYMBOL_GPL(sata_link_hardreset); 7008c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_std_hardreset); 7009c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_postreset); 7010c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_dev_classify); 7011c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_dev_pair); 7012c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_disable); 7013c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_ratelimit); 7014c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_wait_register); 7015c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_busy_sleep); 7016d4b2bab4STejun Heo EXPORT_SYMBOL_GPL(ata_wait_ready); 7017c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_queue_task); 7018c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_ioctl); 7019c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_queuecmd); 7020c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_slave_config); 7021c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_slave_destroy); 7022c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth); 7023c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_host_intr); 7024c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_valid); 7025c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_read); 7026c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_write); 7027c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_write_flush); 7028936fd732STejun Heo EXPORT_SYMBOL_GPL(ata_link_online); 7029936fd732STejun Heo EXPORT_SYMBOL_GPL(ata_link_offline); 70306ffa01d8STejun Heo #ifdef CONFIG_PM 7031cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_suspend); 7032cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_resume); 70336ffa01d8STejun Heo #endif /* CONFIG_PM */ 7034c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_id_string); 7035c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_id_c_string); 703610305f0fSAlan EXPORT_SYMBOL_GPL(ata_id_to_dma_mode); 7037c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_simulate); 7038c6fd2807SJeff Garzik 7039c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pio_need_iordy); 7040c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_timing_compute); 7041c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_timing_merge); 7042c6fd2807SJeff Garzik 7043c6fd2807SJeff Garzik #ifdef CONFIG_PCI 7044c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(pci_test_config_bits); 7045d583bc18STejun Heo EXPORT_SYMBOL_GPL(ata_pci_init_sff_host); 70461626aeb8STejun Heo EXPORT_SYMBOL_GPL(ata_pci_init_bmdma); 7047d583bc18STejun Heo EXPORT_SYMBOL_GPL(ata_pci_prepare_sff_host); 7048c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_init_one); 7049c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_remove_one); 70506ffa01d8STejun Heo #ifdef CONFIG_PM 7051c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_do_suspend); 7052c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_do_resume); 7053c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_suspend); 7054c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_resume); 70556ffa01d8STejun Heo #endif /* CONFIG_PM */ 7056c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_default_filter); 7057c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_clear_simplex); 7058c6fd2807SJeff Garzik #endif /* CONFIG_PCI */ 7059c6fd2807SJeff Garzik 7060b64bbc39STejun Heo EXPORT_SYMBOL_GPL(__ata_ehi_push_desc); 7061b64bbc39STejun Heo EXPORT_SYMBOL_GPL(ata_ehi_push_desc); 7062b64bbc39STejun Heo EXPORT_SYMBOL_GPL(ata_ehi_clear_desc); 7063c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eng_timeout); 7064c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_schedule_eh); 7065dbd82616STejun Heo EXPORT_SYMBOL_GPL(ata_link_abort); 7066c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_abort); 7067c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_freeze); 7068c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_freeze_port); 7069c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_thaw_port); 7070c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_qc_complete); 7071c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_qc_retry); 7072c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_do_eh); 707383625006SAkira Iguchi EXPORT_SYMBOL_GPL(ata_irq_on); 707483625006SAkira Iguchi EXPORT_SYMBOL_GPL(ata_dummy_irq_on); 707583625006SAkira Iguchi EXPORT_SYMBOL_GPL(ata_irq_ack); 707683625006SAkira Iguchi EXPORT_SYMBOL_GPL(ata_dummy_irq_ack); 7077a619f981SAkira Iguchi EXPORT_SYMBOL_GPL(ata_dev_try_classify); 7078be0d18dfSAlan Cox 7079be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_40wire); 7080be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_80wire); 7081be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_unknown); 7082be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_sata); 7083