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 * 3392c52c52SAlan Cox * Standards documents from: 3492c52c52SAlan Cox * http://www.t13.org (ATA standards, PCI DMA IDE spec) 3592c52c52SAlan Cox * http://www.t10.org (SCSI MMC - for ATAPI MMC) 3692c52c52SAlan Cox * http://www.sata-io.org (SATA) 3792c52c52SAlan Cox * http://www.compactflash.org (CF) 3892c52c52SAlan Cox * http://www.qic.org (QIC157 - Tape and DSC) 3992c52c52SAlan Cox * http://www.ce-ata.org (CE-ATA: not supported) 4092c52c52SAlan Cox * 41c6fd2807SJeff Garzik */ 42c6fd2807SJeff Garzik 43c6fd2807SJeff Garzik #include <linux/kernel.h> 44c6fd2807SJeff Garzik #include <linux/module.h> 45c6fd2807SJeff Garzik #include <linux/pci.h> 46c6fd2807SJeff Garzik #include <linux/init.h> 47c6fd2807SJeff Garzik #include <linux/list.h> 48c6fd2807SJeff Garzik #include <linux/mm.h> 49c6fd2807SJeff Garzik #include <linux/spinlock.h> 50c6fd2807SJeff Garzik #include <linux/blkdev.h> 51c6fd2807SJeff Garzik #include <linux/delay.h> 52c6fd2807SJeff Garzik #include <linux/timer.h> 53c6fd2807SJeff Garzik #include <linux/interrupt.h> 54c6fd2807SJeff Garzik #include <linux/completion.h> 55c6fd2807SJeff Garzik #include <linux/suspend.h> 56c6fd2807SJeff Garzik #include <linux/workqueue.h> 57c6fd2807SJeff Garzik #include <linux/scatterlist.h> 582dcb407eSJeff Garzik #include <linux/io.h> 5979318057SArjan van de Ven #include <linux/async.h> 60e18086d6SMark Lord #include <linux/log2.h> 61c6fd2807SJeff Garzik #include <scsi/scsi.h> 62c6fd2807SJeff Garzik #include <scsi/scsi_cmnd.h> 63c6fd2807SJeff Garzik #include <scsi/scsi_host.h> 64c6fd2807SJeff Garzik #include <linux/libata.h> 65c6fd2807SJeff Garzik #include <asm/byteorder.h> 66140b5e59STejun Heo #include <linux/cdrom.h> 67c6fd2807SJeff Garzik 68c6fd2807SJeff Garzik #include "libata.h" 69c6fd2807SJeff Garzik 70fda0efc5SJeff Garzik 71c6fd2807SJeff Garzik /* debounce timing parameters in msecs { interval, duration, timeout } */ 72c6fd2807SJeff Garzik const unsigned long sata_deb_timing_normal[] = { 5, 100, 2000 }; 73c6fd2807SJeff Garzik const unsigned long sata_deb_timing_hotplug[] = { 25, 500, 2000 }; 74c6fd2807SJeff Garzik const unsigned long sata_deb_timing_long[] = { 100, 2000, 5000 }; 75c6fd2807SJeff Garzik 76029cfd6bSTejun Heo const struct ata_port_operations ata_base_port_ops = { 770aa1113dSTejun Heo .prereset = ata_std_prereset, 78203c75b8STejun Heo .postreset = ata_std_postreset, 79a1efdabaSTejun Heo .error_handler = ata_std_error_handler, 80029cfd6bSTejun Heo }; 81029cfd6bSTejun Heo 82029cfd6bSTejun Heo const struct ata_port_operations sata_port_ops = { 83029cfd6bSTejun Heo .inherits = &ata_base_port_ops, 84029cfd6bSTejun Heo 85029cfd6bSTejun Heo .qc_defer = ata_std_qc_defer, 8657c9efdfSTejun Heo .hardreset = sata_std_hardreset, 87029cfd6bSTejun Heo }; 88029cfd6bSTejun Heo 89c6fd2807SJeff Garzik static unsigned int ata_dev_init_params(struct ata_device *dev, 90c6fd2807SJeff Garzik u16 heads, u16 sectors); 91c6fd2807SJeff Garzik static unsigned int ata_dev_set_xfermode(struct ata_device *dev); 92218f3d30SJeff Garzik static unsigned int ata_dev_set_feature(struct ata_device *dev, 93218f3d30SJeff Garzik u8 enable, u8 feature); 94c6fd2807SJeff Garzik static void ata_dev_xfermask(struct ata_device *dev); 9575683fe7STejun Heo static unsigned long ata_dev_blacklisted(const struct ata_device *dev); 96c6fd2807SJeff Garzik 97f3187195STejun Heo unsigned int ata_print_id = 1; 98c6fd2807SJeff Garzik static struct workqueue_struct *ata_wq; 99c6fd2807SJeff Garzik 100c6fd2807SJeff Garzik struct workqueue_struct *ata_aux_wq; 101c6fd2807SJeff Garzik 10233267325STejun Heo struct ata_force_param { 10333267325STejun Heo const char *name; 10433267325STejun Heo unsigned int cbl; 10533267325STejun Heo int spd_limit; 10633267325STejun Heo unsigned long xfer_mask; 10733267325STejun Heo unsigned int horkage_on; 10833267325STejun Heo unsigned int horkage_off; 10905944bdfSTejun Heo unsigned int lflags; 11033267325STejun Heo }; 11133267325STejun Heo 11233267325STejun Heo struct ata_force_ent { 11333267325STejun Heo int port; 11433267325STejun Heo int device; 11533267325STejun Heo struct ata_force_param param; 11633267325STejun Heo }; 11733267325STejun Heo 11833267325STejun Heo static struct ata_force_ent *ata_force_tbl; 11933267325STejun Heo static int ata_force_tbl_size; 12033267325STejun Heo 12133267325STejun Heo static char ata_force_param_buf[PAGE_SIZE] __initdata; 1227afb4222STejun Heo /* param_buf is thrown away after initialization, disallow read */ 1237afb4222STejun Heo module_param_string(force, ata_force_param_buf, sizeof(ata_force_param_buf), 0); 12433267325STejun Heo MODULE_PARM_DESC(force, "Force ATA configurations including cable type, link speed and transfer mode (see Documentation/kernel-parameters.txt for details)"); 12533267325STejun Heo 1262486fa56STejun Heo static int atapi_enabled = 1; 127c6fd2807SJeff Garzik module_param(atapi_enabled, int, 0444); 128c6fd2807SJeff Garzik MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)"); 129c6fd2807SJeff Garzik 130c5c61bdaSAdrian Bunk static int atapi_dmadir = 0; 131c6fd2807SJeff Garzik module_param(atapi_dmadir, int, 0444); 132c6fd2807SJeff Garzik MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)"); 133c6fd2807SJeff Garzik 134baf4fdfaSMark Lord int atapi_passthru16 = 1; 135baf4fdfaSMark Lord module_param(atapi_passthru16, int, 0444); 136baf4fdfaSMark Lord MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices; on by default (0=off, 1=on)"); 137baf4fdfaSMark Lord 138c6fd2807SJeff Garzik int libata_fua = 0; 139c6fd2807SJeff Garzik module_param_named(fua, libata_fua, int, 0444); 140c6fd2807SJeff Garzik MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)"); 141c6fd2807SJeff Garzik 1422dcb407eSJeff Garzik static int ata_ignore_hpa; 1431e999736SAlan Cox module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644); 1441e999736SAlan Cox MODULE_PARM_DESC(ignore_hpa, "Ignore HPA limit (0=keep BIOS limits, 1=ignore limits, using full disk)"); 1451e999736SAlan Cox 146b3a70601SAlan Cox static int libata_dma_mask = ATA_DMA_MASK_ATA|ATA_DMA_MASK_ATAPI|ATA_DMA_MASK_CFA; 147b3a70601SAlan Cox module_param_named(dma, libata_dma_mask, int, 0444); 148b3a70601SAlan Cox MODULE_PARM_DESC(dma, "DMA enable/disable (0x1==ATA, 0x2==ATAPI, 0x4==CF)"); 149b3a70601SAlan Cox 15087fbc5a0STejun Heo static int ata_probe_timeout; 151c6fd2807SJeff Garzik module_param(ata_probe_timeout, int, 0444); 152c6fd2807SJeff Garzik MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)"); 153c6fd2807SJeff Garzik 1546ebe9d86SJeff Garzik int libata_noacpi = 0; 155d7d0dad6SJeff Garzik module_param_named(noacpi, libata_noacpi, int, 0444); 1566ebe9d86SJeff Garzik MODULE_PARM_DESC(noacpi, "Disables the use of ACPI in probe/suspend/resume when set"); 15711ef697bSKristen Carlson Accardi 158ae8d4ee7SAlan Cox int libata_allow_tpm = 0; 159ae8d4ee7SAlan Cox module_param_named(allow_tpm, libata_allow_tpm, int, 0444); 160ae8d4ee7SAlan Cox MODULE_PARM_DESC(allow_tpm, "Permit the use of TPM commands"); 161ae8d4ee7SAlan Cox 162c6fd2807SJeff Garzik MODULE_AUTHOR("Jeff Garzik"); 163c6fd2807SJeff Garzik MODULE_DESCRIPTION("Library module for ATA devices"); 164c6fd2807SJeff Garzik MODULE_LICENSE("GPL"); 165c6fd2807SJeff Garzik MODULE_VERSION(DRV_VERSION); 166c6fd2807SJeff Garzik 167c6fd2807SJeff Garzik 1689913ff8aSTejun Heo static bool ata_sstatus_online(u32 sstatus) 1699913ff8aSTejun Heo { 1709913ff8aSTejun Heo return (sstatus & 0xf) == 0x3; 1719913ff8aSTejun Heo } 1729913ff8aSTejun Heo 1731eca4365STejun Heo /** 1741eca4365STejun Heo * ata_link_next - link iteration helper 1751eca4365STejun Heo * @link: the previous link, NULL to start 1761eca4365STejun Heo * @ap: ATA port containing links to iterate 1771eca4365STejun Heo * @mode: iteration mode, one of ATA_LITER_* 178aadffb68STejun Heo * 179aadffb68STejun Heo * LOCKING: 180aadffb68STejun Heo * Host lock or EH context. 1811eca4365STejun Heo * 1821eca4365STejun Heo * RETURNS: 1831eca4365STejun Heo * Pointer to the next link. 184aadffb68STejun Heo */ 1851eca4365STejun Heo struct ata_link *ata_link_next(struct ata_link *link, struct ata_port *ap, 1861eca4365STejun Heo enum ata_link_iter_mode mode) 187aadffb68STejun Heo { 1881eca4365STejun Heo BUG_ON(mode != ATA_LITER_EDGE && 1891eca4365STejun Heo mode != ATA_LITER_PMP_FIRST && mode != ATA_LITER_HOST_FIRST); 1901eca4365STejun Heo 191aadffb68STejun Heo /* NULL link indicates start of iteration */ 1921eca4365STejun Heo if (!link) 1931eca4365STejun Heo switch (mode) { 1941eca4365STejun Heo case ATA_LITER_EDGE: 1951eca4365STejun Heo case ATA_LITER_PMP_FIRST: 1961eca4365STejun Heo if (sata_pmp_attached(ap)) 197aadffb68STejun Heo return ap->pmp_link; 1981eca4365STejun Heo /* fall through */ 1991eca4365STejun Heo case ATA_LITER_HOST_FIRST: 200aadffb68STejun Heo return &ap->link; 201aadffb68STejun Heo } 202aadffb68STejun Heo 2031eca4365STejun Heo /* we just iterated over the host link, what's next? */ 2041eca4365STejun Heo if (link == &ap->link) 2051eca4365STejun Heo switch (mode) { 2061eca4365STejun Heo case ATA_LITER_HOST_FIRST: 2071eca4365STejun Heo if (sata_pmp_attached(ap)) 208aadffb68STejun Heo return ap->pmp_link; 2091eca4365STejun Heo /* fall through */ 2101eca4365STejun Heo case ATA_LITER_PMP_FIRST: 2111eca4365STejun Heo if (unlikely(ap->slave_link)) 2121eca4365STejun Heo return ap->slave_link; 2131eca4365STejun Heo /* fall through */ 2141eca4365STejun Heo case ATA_LITER_EDGE: 2151eca4365STejun Heo return NULL; 216aadffb68STejun Heo } 217aadffb68STejun Heo 218b1c72916STejun Heo /* slave_link excludes PMP */ 219b1c72916STejun Heo if (unlikely(link == ap->slave_link)) 220b1c72916STejun Heo return NULL; 221b1c72916STejun Heo 2221eca4365STejun Heo /* we were over a PMP link */ 223aadffb68STejun Heo if (++link < ap->pmp_link + ap->nr_pmp_links) 224aadffb68STejun Heo return link; 2251eca4365STejun Heo 2261eca4365STejun Heo if (mode == ATA_LITER_PMP_FIRST) 2271eca4365STejun Heo return &ap->link; 2281eca4365STejun Heo 229aadffb68STejun Heo return NULL; 230aadffb68STejun Heo } 231aadffb68STejun Heo 232c6fd2807SJeff Garzik /** 2331eca4365STejun Heo * ata_dev_next - device iteration helper 2341eca4365STejun Heo * @dev: the previous device, NULL to start 2351eca4365STejun Heo * @link: ATA link containing devices to iterate 2361eca4365STejun Heo * @mode: iteration mode, one of ATA_DITER_* 2371eca4365STejun Heo * 2381eca4365STejun Heo * LOCKING: 2391eca4365STejun Heo * Host lock or EH context. 2401eca4365STejun Heo * 2411eca4365STejun Heo * RETURNS: 2421eca4365STejun Heo * Pointer to the next device. 2431eca4365STejun Heo */ 2441eca4365STejun Heo struct ata_device *ata_dev_next(struct ata_device *dev, struct ata_link *link, 2451eca4365STejun Heo enum ata_dev_iter_mode mode) 2461eca4365STejun Heo { 2471eca4365STejun Heo BUG_ON(mode != ATA_DITER_ENABLED && mode != ATA_DITER_ENABLED_REVERSE && 2481eca4365STejun Heo mode != ATA_DITER_ALL && mode != ATA_DITER_ALL_REVERSE); 2491eca4365STejun Heo 2501eca4365STejun Heo /* NULL dev indicates start of iteration */ 2511eca4365STejun Heo if (!dev) 2521eca4365STejun Heo switch (mode) { 2531eca4365STejun Heo case ATA_DITER_ENABLED: 2541eca4365STejun Heo case ATA_DITER_ALL: 2551eca4365STejun Heo dev = link->device; 2561eca4365STejun Heo goto check; 2571eca4365STejun Heo case ATA_DITER_ENABLED_REVERSE: 2581eca4365STejun Heo case ATA_DITER_ALL_REVERSE: 2591eca4365STejun Heo dev = link->device + ata_link_max_devices(link) - 1; 2601eca4365STejun Heo goto check; 2611eca4365STejun Heo } 2621eca4365STejun Heo 2631eca4365STejun Heo next: 2641eca4365STejun Heo /* move to the next one */ 2651eca4365STejun Heo switch (mode) { 2661eca4365STejun Heo case ATA_DITER_ENABLED: 2671eca4365STejun Heo case ATA_DITER_ALL: 2681eca4365STejun Heo if (++dev < link->device + ata_link_max_devices(link)) 2691eca4365STejun Heo goto check; 2701eca4365STejun Heo return NULL; 2711eca4365STejun Heo case ATA_DITER_ENABLED_REVERSE: 2721eca4365STejun Heo case ATA_DITER_ALL_REVERSE: 2731eca4365STejun Heo if (--dev >= link->device) 2741eca4365STejun Heo goto check; 2751eca4365STejun Heo return NULL; 2761eca4365STejun Heo } 2771eca4365STejun Heo 2781eca4365STejun Heo check: 2791eca4365STejun Heo if ((mode == ATA_DITER_ENABLED || mode == ATA_DITER_ENABLED_REVERSE) && 2801eca4365STejun Heo !ata_dev_enabled(dev)) 2811eca4365STejun Heo goto next; 2821eca4365STejun Heo return dev; 2831eca4365STejun Heo } 2841eca4365STejun Heo 2851eca4365STejun Heo /** 286b1c72916STejun Heo * ata_dev_phys_link - find physical link for a device 287b1c72916STejun Heo * @dev: ATA device to look up physical link for 288b1c72916STejun Heo * 289b1c72916STejun Heo * Look up physical link which @dev is attached to. Note that 290b1c72916STejun Heo * this is different from @dev->link only when @dev is on slave 291b1c72916STejun Heo * link. For all other cases, it's the same as @dev->link. 292b1c72916STejun Heo * 293b1c72916STejun Heo * LOCKING: 294b1c72916STejun Heo * Don't care. 295b1c72916STejun Heo * 296b1c72916STejun Heo * RETURNS: 297b1c72916STejun Heo * Pointer to the found physical link. 298b1c72916STejun Heo */ 299b1c72916STejun Heo struct ata_link *ata_dev_phys_link(struct ata_device *dev) 300b1c72916STejun Heo { 301b1c72916STejun Heo struct ata_port *ap = dev->link->ap; 302b1c72916STejun Heo 303b1c72916STejun Heo if (!ap->slave_link) 304b1c72916STejun Heo return dev->link; 305b1c72916STejun Heo if (!dev->devno) 306b1c72916STejun Heo return &ap->link; 307b1c72916STejun Heo return ap->slave_link; 308b1c72916STejun Heo } 309b1c72916STejun Heo 310b1c72916STejun Heo /** 31133267325STejun Heo * ata_force_cbl - force cable type according to libata.force 3124cdfa1b3SRandy Dunlap * @ap: ATA port of interest 31333267325STejun Heo * 31433267325STejun Heo * Force cable type according to libata.force and whine about it. 31533267325STejun Heo * The last entry which has matching port number is used, so it 31633267325STejun Heo * can be specified as part of device force parameters. For 31733267325STejun Heo * example, both "a:40c,1.00:udma4" and "1.00:40c,udma4" have the 31833267325STejun Heo * same effect. 31933267325STejun Heo * 32033267325STejun Heo * LOCKING: 32133267325STejun Heo * EH context. 32233267325STejun Heo */ 32333267325STejun Heo void ata_force_cbl(struct ata_port *ap) 32433267325STejun Heo { 32533267325STejun Heo int i; 32633267325STejun Heo 32733267325STejun Heo for (i = ata_force_tbl_size - 1; i >= 0; i--) { 32833267325STejun Heo const struct ata_force_ent *fe = &ata_force_tbl[i]; 32933267325STejun Heo 33033267325STejun Heo if (fe->port != -1 && fe->port != ap->print_id) 33133267325STejun Heo continue; 33233267325STejun Heo 33333267325STejun Heo if (fe->param.cbl == ATA_CBL_NONE) 33433267325STejun Heo continue; 33533267325STejun Heo 33633267325STejun Heo ap->cbl = fe->param.cbl; 33733267325STejun Heo ata_port_printk(ap, KERN_NOTICE, 33833267325STejun Heo "FORCE: cable set to %s\n", fe->param.name); 33933267325STejun Heo return; 34033267325STejun Heo } 34133267325STejun Heo } 34233267325STejun Heo 34333267325STejun Heo /** 34405944bdfSTejun Heo * ata_force_link_limits - force link limits according to libata.force 34533267325STejun Heo * @link: ATA link of interest 34633267325STejun Heo * 34705944bdfSTejun Heo * Force link flags and SATA spd limit according to libata.force 34805944bdfSTejun Heo * and whine about it. When only the port part is specified 34905944bdfSTejun Heo * (e.g. 1:), the limit applies to all links connected to both 35005944bdfSTejun Heo * the host link and all fan-out ports connected via PMP. If the 35105944bdfSTejun Heo * device part is specified as 0 (e.g. 1.00:), it specifies the 35205944bdfSTejun Heo * first fan-out link not the host link. Device number 15 always 353b1c72916STejun Heo * points to the host link whether PMP is attached or not. If the 354b1c72916STejun Heo * controller has slave link, device number 16 points to it. 35533267325STejun Heo * 35633267325STejun Heo * LOCKING: 35733267325STejun Heo * EH context. 35833267325STejun Heo */ 35905944bdfSTejun Heo static void ata_force_link_limits(struct ata_link *link) 36033267325STejun Heo { 36105944bdfSTejun Heo bool did_spd = false; 362b1c72916STejun Heo int linkno = link->pmp; 363b1c72916STejun Heo int i; 36433267325STejun Heo 36533267325STejun Heo if (ata_is_host_link(link)) 366b1c72916STejun Heo linkno += 15; 36733267325STejun Heo 36833267325STejun Heo for (i = ata_force_tbl_size - 1; i >= 0; i--) { 36933267325STejun Heo const struct ata_force_ent *fe = &ata_force_tbl[i]; 37033267325STejun Heo 37133267325STejun Heo if (fe->port != -1 && fe->port != link->ap->print_id) 37233267325STejun Heo continue; 37333267325STejun Heo 37433267325STejun Heo if (fe->device != -1 && fe->device != linkno) 37533267325STejun Heo continue; 37633267325STejun Heo 37705944bdfSTejun Heo /* only honor the first spd limit */ 37805944bdfSTejun Heo if (!did_spd && fe->param.spd_limit) { 37933267325STejun Heo link->hw_sata_spd_limit = (1 << fe->param.spd_limit) - 1; 38033267325STejun Heo ata_link_printk(link, KERN_NOTICE, 38105944bdfSTejun Heo "FORCE: PHY spd limit set to %s\n", 38205944bdfSTejun Heo fe->param.name); 38305944bdfSTejun Heo did_spd = true; 38405944bdfSTejun Heo } 38505944bdfSTejun Heo 38605944bdfSTejun Heo /* let lflags stack */ 38705944bdfSTejun Heo if (fe->param.lflags) { 38805944bdfSTejun Heo link->flags |= fe->param.lflags; 38905944bdfSTejun Heo ata_link_printk(link, KERN_NOTICE, 39005944bdfSTejun Heo "FORCE: link flag 0x%x forced -> 0x%x\n", 39105944bdfSTejun Heo fe->param.lflags, link->flags); 39205944bdfSTejun Heo } 39333267325STejun Heo } 39433267325STejun Heo } 39533267325STejun Heo 39633267325STejun Heo /** 39733267325STejun Heo * ata_force_xfermask - force xfermask according to libata.force 39833267325STejun Heo * @dev: ATA device of interest 39933267325STejun Heo * 40033267325STejun Heo * Force xfer_mask according to libata.force and whine about it. 40133267325STejun Heo * For consistency with link selection, device number 15 selects 40233267325STejun Heo * the first device connected to the host link. 40333267325STejun Heo * 40433267325STejun Heo * LOCKING: 40533267325STejun Heo * EH context. 40633267325STejun Heo */ 40733267325STejun Heo static void ata_force_xfermask(struct ata_device *dev) 40833267325STejun Heo { 40933267325STejun Heo int devno = dev->link->pmp + dev->devno; 41033267325STejun Heo int alt_devno = devno; 41133267325STejun Heo int i; 41233267325STejun Heo 413b1c72916STejun Heo /* allow n.15/16 for devices attached to host port */ 414b1c72916STejun Heo if (ata_is_host_link(dev->link)) 415b1c72916STejun Heo alt_devno += 15; 41633267325STejun Heo 41733267325STejun Heo for (i = ata_force_tbl_size - 1; i >= 0; i--) { 41833267325STejun Heo const struct ata_force_ent *fe = &ata_force_tbl[i]; 41933267325STejun Heo unsigned long pio_mask, mwdma_mask, udma_mask; 42033267325STejun Heo 42133267325STejun Heo if (fe->port != -1 && fe->port != dev->link->ap->print_id) 42233267325STejun Heo continue; 42333267325STejun Heo 42433267325STejun Heo if (fe->device != -1 && fe->device != devno && 42533267325STejun Heo fe->device != alt_devno) 42633267325STejun Heo continue; 42733267325STejun Heo 42833267325STejun Heo if (!fe->param.xfer_mask) 42933267325STejun Heo continue; 43033267325STejun Heo 43133267325STejun Heo ata_unpack_xfermask(fe->param.xfer_mask, 43233267325STejun Heo &pio_mask, &mwdma_mask, &udma_mask); 43333267325STejun Heo if (udma_mask) 43433267325STejun Heo dev->udma_mask = udma_mask; 43533267325STejun Heo else if (mwdma_mask) { 43633267325STejun Heo dev->udma_mask = 0; 43733267325STejun Heo dev->mwdma_mask = mwdma_mask; 43833267325STejun Heo } else { 43933267325STejun Heo dev->udma_mask = 0; 44033267325STejun Heo dev->mwdma_mask = 0; 44133267325STejun Heo dev->pio_mask = pio_mask; 44233267325STejun Heo } 44333267325STejun Heo 44433267325STejun Heo ata_dev_printk(dev, KERN_NOTICE, 44533267325STejun Heo "FORCE: xfer_mask set to %s\n", fe->param.name); 44633267325STejun Heo return; 44733267325STejun Heo } 44833267325STejun Heo } 44933267325STejun Heo 45033267325STejun Heo /** 45133267325STejun Heo * ata_force_horkage - force horkage according to libata.force 45233267325STejun Heo * @dev: ATA device of interest 45333267325STejun Heo * 45433267325STejun Heo * Force horkage according to libata.force and whine about it. 45533267325STejun Heo * For consistency with link selection, device number 15 selects 45633267325STejun Heo * the first device connected to the host link. 45733267325STejun Heo * 45833267325STejun Heo * LOCKING: 45933267325STejun Heo * EH context. 46033267325STejun Heo */ 46133267325STejun Heo static void ata_force_horkage(struct ata_device *dev) 46233267325STejun Heo { 46333267325STejun Heo int devno = dev->link->pmp + dev->devno; 46433267325STejun Heo int alt_devno = devno; 46533267325STejun Heo int i; 46633267325STejun Heo 467b1c72916STejun Heo /* allow n.15/16 for devices attached to host port */ 468b1c72916STejun Heo if (ata_is_host_link(dev->link)) 469b1c72916STejun Heo alt_devno += 15; 47033267325STejun Heo 47133267325STejun Heo for (i = 0; i < ata_force_tbl_size; i++) { 47233267325STejun Heo const struct ata_force_ent *fe = &ata_force_tbl[i]; 47333267325STejun Heo 47433267325STejun Heo if (fe->port != -1 && fe->port != dev->link->ap->print_id) 47533267325STejun Heo continue; 47633267325STejun Heo 47733267325STejun Heo if (fe->device != -1 && fe->device != devno && 47833267325STejun Heo fe->device != alt_devno) 47933267325STejun Heo continue; 48033267325STejun Heo 48133267325STejun Heo if (!(~dev->horkage & fe->param.horkage_on) && 48233267325STejun Heo !(dev->horkage & fe->param.horkage_off)) 48333267325STejun Heo continue; 48433267325STejun Heo 48533267325STejun Heo dev->horkage |= fe->param.horkage_on; 48633267325STejun Heo dev->horkage &= ~fe->param.horkage_off; 48733267325STejun Heo 48833267325STejun Heo ata_dev_printk(dev, KERN_NOTICE, 48933267325STejun Heo "FORCE: horkage modified (%s)\n", fe->param.name); 49033267325STejun Heo } 49133267325STejun Heo } 49233267325STejun Heo 49333267325STejun Heo /** 494436d34b3STejun Heo * atapi_cmd_type - Determine ATAPI command type from SCSI opcode 495436d34b3STejun Heo * @opcode: SCSI opcode 496436d34b3STejun Heo * 497436d34b3STejun Heo * Determine ATAPI command type from @opcode. 498436d34b3STejun Heo * 499436d34b3STejun Heo * LOCKING: 500436d34b3STejun Heo * None. 501436d34b3STejun Heo * 502436d34b3STejun Heo * RETURNS: 503436d34b3STejun Heo * ATAPI_{READ|WRITE|READ_CD|PASS_THRU|MISC} 504436d34b3STejun Heo */ 505436d34b3STejun Heo int atapi_cmd_type(u8 opcode) 506436d34b3STejun Heo { 507436d34b3STejun Heo switch (opcode) { 508436d34b3STejun Heo case GPCMD_READ_10: 509436d34b3STejun Heo case GPCMD_READ_12: 510436d34b3STejun Heo return ATAPI_READ; 511436d34b3STejun Heo 512436d34b3STejun Heo case GPCMD_WRITE_10: 513436d34b3STejun Heo case GPCMD_WRITE_12: 514436d34b3STejun Heo case GPCMD_WRITE_AND_VERIFY_10: 515436d34b3STejun Heo return ATAPI_WRITE; 516436d34b3STejun Heo 517436d34b3STejun Heo case GPCMD_READ_CD: 518436d34b3STejun Heo case GPCMD_READ_CD_MSF: 519436d34b3STejun Heo return ATAPI_READ_CD; 520436d34b3STejun Heo 521e52dcc48STejun Heo case ATA_16: 522e52dcc48STejun Heo case ATA_12: 523e52dcc48STejun Heo if (atapi_passthru16) 524e52dcc48STejun Heo return ATAPI_PASS_THRU; 525e52dcc48STejun Heo /* fall thru */ 526436d34b3STejun Heo default: 527436d34b3STejun Heo return ATAPI_MISC; 528436d34b3STejun Heo } 529436d34b3STejun Heo } 530436d34b3STejun Heo 531436d34b3STejun Heo /** 532c6fd2807SJeff Garzik * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure 533c6fd2807SJeff Garzik * @tf: Taskfile to convert 534c6fd2807SJeff Garzik * @pmp: Port multiplier port 5359977126cSTejun Heo * @is_cmd: This FIS is for command 5369977126cSTejun Heo * @fis: Buffer into which data will output 537c6fd2807SJeff Garzik * 538c6fd2807SJeff Garzik * Converts a standard ATA taskfile to a Serial ATA 539c6fd2807SJeff Garzik * FIS structure (Register - Host to Device). 540c6fd2807SJeff Garzik * 541c6fd2807SJeff Garzik * LOCKING: 542c6fd2807SJeff Garzik * Inherited from caller. 543c6fd2807SJeff Garzik */ 5449977126cSTejun Heo void ata_tf_to_fis(const struct ata_taskfile *tf, u8 pmp, int is_cmd, u8 *fis) 545c6fd2807SJeff Garzik { 546c6fd2807SJeff Garzik fis[0] = 0x27; /* Register - Host to Device FIS */ 5479977126cSTejun Heo fis[1] = pmp & 0xf; /* Port multiplier number*/ 5489977126cSTejun Heo if (is_cmd) 5499977126cSTejun Heo fis[1] |= (1 << 7); /* bit 7 indicates Command FIS */ 5509977126cSTejun Heo 551c6fd2807SJeff Garzik fis[2] = tf->command; 552c6fd2807SJeff Garzik fis[3] = tf->feature; 553c6fd2807SJeff Garzik 554c6fd2807SJeff Garzik fis[4] = tf->lbal; 555c6fd2807SJeff Garzik fis[5] = tf->lbam; 556c6fd2807SJeff Garzik fis[6] = tf->lbah; 557c6fd2807SJeff Garzik fis[7] = tf->device; 558c6fd2807SJeff Garzik 559c6fd2807SJeff Garzik fis[8] = tf->hob_lbal; 560c6fd2807SJeff Garzik fis[9] = tf->hob_lbam; 561c6fd2807SJeff Garzik fis[10] = tf->hob_lbah; 562c6fd2807SJeff Garzik fis[11] = tf->hob_feature; 563c6fd2807SJeff Garzik 564c6fd2807SJeff Garzik fis[12] = tf->nsect; 565c6fd2807SJeff Garzik fis[13] = tf->hob_nsect; 566c6fd2807SJeff Garzik fis[14] = 0; 567c6fd2807SJeff Garzik fis[15] = tf->ctl; 568c6fd2807SJeff Garzik 569c6fd2807SJeff Garzik fis[16] = 0; 570c6fd2807SJeff Garzik fis[17] = 0; 571c6fd2807SJeff Garzik fis[18] = 0; 572c6fd2807SJeff Garzik fis[19] = 0; 573c6fd2807SJeff Garzik } 574c6fd2807SJeff Garzik 575c6fd2807SJeff Garzik /** 576c6fd2807SJeff Garzik * ata_tf_from_fis - Convert SATA FIS to ATA taskfile 577c6fd2807SJeff Garzik * @fis: Buffer from which data will be input 578c6fd2807SJeff Garzik * @tf: Taskfile to output 579c6fd2807SJeff Garzik * 580c6fd2807SJeff Garzik * Converts a serial ATA FIS structure to a standard ATA taskfile. 581c6fd2807SJeff Garzik * 582c6fd2807SJeff Garzik * LOCKING: 583c6fd2807SJeff Garzik * Inherited from caller. 584c6fd2807SJeff Garzik */ 585c6fd2807SJeff Garzik 586c6fd2807SJeff Garzik void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf) 587c6fd2807SJeff Garzik { 588c6fd2807SJeff Garzik tf->command = fis[2]; /* status */ 589c6fd2807SJeff Garzik tf->feature = fis[3]; /* error */ 590c6fd2807SJeff Garzik 591c6fd2807SJeff Garzik tf->lbal = fis[4]; 592c6fd2807SJeff Garzik tf->lbam = fis[5]; 593c6fd2807SJeff Garzik tf->lbah = fis[6]; 594c6fd2807SJeff Garzik tf->device = fis[7]; 595c6fd2807SJeff Garzik 596c6fd2807SJeff Garzik tf->hob_lbal = fis[8]; 597c6fd2807SJeff Garzik tf->hob_lbam = fis[9]; 598c6fd2807SJeff Garzik tf->hob_lbah = fis[10]; 599c6fd2807SJeff Garzik 600c6fd2807SJeff Garzik tf->nsect = fis[12]; 601c6fd2807SJeff Garzik tf->hob_nsect = fis[13]; 602c6fd2807SJeff Garzik } 603c6fd2807SJeff Garzik 604c6fd2807SJeff Garzik static const u8 ata_rw_cmds[] = { 605c6fd2807SJeff Garzik /* pio multi */ 606c6fd2807SJeff Garzik ATA_CMD_READ_MULTI, 607c6fd2807SJeff Garzik ATA_CMD_WRITE_MULTI, 608c6fd2807SJeff Garzik ATA_CMD_READ_MULTI_EXT, 609c6fd2807SJeff Garzik ATA_CMD_WRITE_MULTI_EXT, 610c6fd2807SJeff Garzik 0, 611c6fd2807SJeff Garzik 0, 612c6fd2807SJeff Garzik 0, 613c6fd2807SJeff Garzik ATA_CMD_WRITE_MULTI_FUA_EXT, 614c6fd2807SJeff Garzik /* pio */ 615c6fd2807SJeff Garzik ATA_CMD_PIO_READ, 616c6fd2807SJeff Garzik ATA_CMD_PIO_WRITE, 617c6fd2807SJeff Garzik ATA_CMD_PIO_READ_EXT, 618c6fd2807SJeff Garzik ATA_CMD_PIO_WRITE_EXT, 619c6fd2807SJeff Garzik 0, 620c6fd2807SJeff Garzik 0, 621c6fd2807SJeff Garzik 0, 622c6fd2807SJeff Garzik 0, 623c6fd2807SJeff Garzik /* dma */ 624c6fd2807SJeff Garzik ATA_CMD_READ, 625c6fd2807SJeff Garzik ATA_CMD_WRITE, 626c6fd2807SJeff Garzik ATA_CMD_READ_EXT, 627c6fd2807SJeff Garzik ATA_CMD_WRITE_EXT, 628c6fd2807SJeff Garzik 0, 629c6fd2807SJeff Garzik 0, 630c6fd2807SJeff Garzik 0, 631c6fd2807SJeff Garzik ATA_CMD_WRITE_FUA_EXT 632c6fd2807SJeff Garzik }; 633c6fd2807SJeff Garzik 634c6fd2807SJeff Garzik /** 635c6fd2807SJeff Garzik * ata_rwcmd_protocol - set taskfile r/w commands and protocol 636bd056d7eSTejun Heo * @tf: command to examine and configure 637bd056d7eSTejun Heo * @dev: device tf belongs to 638c6fd2807SJeff Garzik * 639c6fd2807SJeff Garzik * Examine the device configuration and tf->flags to calculate 640c6fd2807SJeff Garzik * the proper read/write commands and protocol to use. 641c6fd2807SJeff Garzik * 642c6fd2807SJeff Garzik * LOCKING: 643c6fd2807SJeff Garzik * caller. 644c6fd2807SJeff Garzik */ 645bd056d7eSTejun Heo static int ata_rwcmd_protocol(struct ata_taskfile *tf, struct ata_device *dev) 646c6fd2807SJeff Garzik { 647c6fd2807SJeff Garzik u8 cmd; 648c6fd2807SJeff Garzik 649c6fd2807SJeff Garzik int index, fua, lba48, write; 650c6fd2807SJeff Garzik 651c6fd2807SJeff Garzik fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0; 652c6fd2807SJeff Garzik lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0; 653c6fd2807SJeff Garzik write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0; 654c6fd2807SJeff Garzik 655c6fd2807SJeff Garzik if (dev->flags & ATA_DFLAG_PIO) { 656c6fd2807SJeff Garzik tf->protocol = ATA_PROT_PIO; 657c6fd2807SJeff Garzik index = dev->multi_count ? 0 : 8; 6589af5c9c9STejun Heo } else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) { 659c6fd2807SJeff Garzik /* Unable to use DMA due to host limitation */ 660c6fd2807SJeff Garzik tf->protocol = ATA_PROT_PIO; 661c6fd2807SJeff Garzik index = dev->multi_count ? 0 : 8; 662c6fd2807SJeff Garzik } else { 663c6fd2807SJeff Garzik tf->protocol = ATA_PROT_DMA; 664c6fd2807SJeff Garzik index = 16; 665c6fd2807SJeff Garzik } 666c6fd2807SJeff Garzik 667c6fd2807SJeff Garzik cmd = ata_rw_cmds[index + fua + lba48 + write]; 668c6fd2807SJeff Garzik if (cmd) { 669c6fd2807SJeff Garzik tf->command = cmd; 670c6fd2807SJeff Garzik return 0; 671c6fd2807SJeff Garzik } 672c6fd2807SJeff Garzik return -1; 673c6fd2807SJeff Garzik } 674c6fd2807SJeff Garzik 675c6fd2807SJeff Garzik /** 67635b649feSTejun Heo * ata_tf_read_block - Read block address from ATA taskfile 67735b649feSTejun Heo * @tf: ATA taskfile of interest 67835b649feSTejun Heo * @dev: ATA device @tf belongs to 67935b649feSTejun Heo * 68035b649feSTejun Heo * LOCKING: 68135b649feSTejun Heo * None. 68235b649feSTejun Heo * 68335b649feSTejun Heo * Read block address from @tf. This function can handle all 68435b649feSTejun Heo * three address formats - LBA, LBA48 and CHS. tf->protocol and 68535b649feSTejun Heo * flags select the address format to use. 68635b649feSTejun Heo * 68735b649feSTejun Heo * RETURNS: 68835b649feSTejun Heo * Block address read from @tf. 68935b649feSTejun Heo */ 69035b649feSTejun Heo u64 ata_tf_read_block(struct ata_taskfile *tf, struct ata_device *dev) 69135b649feSTejun Heo { 69235b649feSTejun Heo u64 block = 0; 69335b649feSTejun Heo 69435b649feSTejun Heo if (tf->flags & ATA_TFLAG_LBA) { 69535b649feSTejun Heo if (tf->flags & ATA_TFLAG_LBA48) { 69635b649feSTejun Heo block |= (u64)tf->hob_lbah << 40; 69735b649feSTejun Heo block |= (u64)tf->hob_lbam << 32; 69844901a96SRoland Dreier block |= (u64)tf->hob_lbal << 24; 69935b649feSTejun Heo } else 70035b649feSTejun Heo block |= (tf->device & 0xf) << 24; 70135b649feSTejun Heo 70235b649feSTejun Heo block |= tf->lbah << 16; 70335b649feSTejun Heo block |= tf->lbam << 8; 70435b649feSTejun Heo block |= tf->lbal; 70535b649feSTejun Heo } else { 70635b649feSTejun Heo u32 cyl, head, sect; 70735b649feSTejun Heo 70835b649feSTejun Heo cyl = tf->lbam | (tf->lbah << 8); 70935b649feSTejun Heo head = tf->device & 0xf; 71035b649feSTejun Heo sect = tf->lbal; 71135b649feSTejun Heo 71235b649feSTejun Heo block = (cyl * dev->heads + head) * dev->sectors + sect; 71335b649feSTejun Heo } 71435b649feSTejun Heo 71535b649feSTejun Heo return block; 71635b649feSTejun Heo } 71735b649feSTejun Heo 71835b649feSTejun Heo /** 719bd056d7eSTejun Heo * ata_build_rw_tf - Build ATA taskfile for given read/write request 720bd056d7eSTejun Heo * @tf: Target ATA taskfile 721bd056d7eSTejun Heo * @dev: ATA device @tf belongs to 722bd056d7eSTejun Heo * @block: Block address 723bd056d7eSTejun Heo * @n_block: Number of blocks 724bd056d7eSTejun Heo * @tf_flags: RW/FUA etc... 725bd056d7eSTejun Heo * @tag: tag 726bd056d7eSTejun Heo * 727bd056d7eSTejun Heo * LOCKING: 728bd056d7eSTejun Heo * None. 729bd056d7eSTejun Heo * 730bd056d7eSTejun Heo * Build ATA taskfile @tf for read/write request described by 731bd056d7eSTejun Heo * @block, @n_block, @tf_flags and @tag on @dev. 732bd056d7eSTejun Heo * 733bd056d7eSTejun Heo * RETURNS: 734bd056d7eSTejun Heo * 735bd056d7eSTejun Heo * 0 on success, -ERANGE if the request is too large for @dev, 736bd056d7eSTejun Heo * -EINVAL if the request is invalid. 737bd056d7eSTejun Heo */ 738bd056d7eSTejun Heo int ata_build_rw_tf(struct ata_taskfile *tf, struct ata_device *dev, 739bd056d7eSTejun Heo u64 block, u32 n_block, unsigned int tf_flags, 740bd056d7eSTejun Heo unsigned int tag) 741bd056d7eSTejun Heo { 742bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 743bd056d7eSTejun Heo tf->flags |= tf_flags; 744bd056d7eSTejun Heo 7456d1245bfSTejun Heo if (ata_ncq_enabled(dev) && likely(tag != ATA_TAG_INTERNAL)) { 746bd056d7eSTejun Heo /* yay, NCQ */ 747bd056d7eSTejun Heo if (!lba_48_ok(block, n_block)) 748bd056d7eSTejun Heo return -ERANGE; 749bd056d7eSTejun Heo 750bd056d7eSTejun Heo tf->protocol = ATA_PROT_NCQ; 751bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48; 752bd056d7eSTejun Heo 753bd056d7eSTejun Heo if (tf->flags & ATA_TFLAG_WRITE) 754bd056d7eSTejun Heo tf->command = ATA_CMD_FPDMA_WRITE; 755bd056d7eSTejun Heo else 756bd056d7eSTejun Heo tf->command = ATA_CMD_FPDMA_READ; 757bd056d7eSTejun Heo 758bd056d7eSTejun Heo tf->nsect = tag << 3; 759bd056d7eSTejun Heo tf->hob_feature = (n_block >> 8) & 0xff; 760bd056d7eSTejun Heo tf->feature = n_block & 0xff; 761bd056d7eSTejun Heo 762bd056d7eSTejun Heo tf->hob_lbah = (block >> 40) & 0xff; 763bd056d7eSTejun Heo tf->hob_lbam = (block >> 32) & 0xff; 764bd056d7eSTejun Heo tf->hob_lbal = (block >> 24) & 0xff; 765bd056d7eSTejun Heo tf->lbah = (block >> 16) & 0xff; 766bd056d7eSTejun Heo tf->lbam = (block >> 8) & 0xff; 767bd056d7eSTejun Heo tf->lbal = block & 0xff; 768bd056d7eSTejun Heo 769bd056d7eSTejun Heo tf->device = 1 << 6; 770bd056d7eSTejun Heo if (tf->flags & ATA_TFLAG_FUA) 771bd056d7eSTejun Heo tf->device |= 1 << 7; 772bd056d7eSTejun Heo } else if (dev->flags & ATA_DFLAG_LBA) { 773bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_LBA; 774bd056d7eSTejun Heo 775bd056d7eSTejun Heo if (lba_28_ok(block, n_block)) { 776bd056d7eSTejun Heo /* use LBA28 */ 777bd056d7eSTejun Heo tf->device |= (block >> 24) & 0xf; 778bd056d7eSTejun Heo } else if (lba_48_ok(block, n_block)) { 779bd056d7eSTejun Heo if (!(dev->flags & ATA_DFLAG_LBA48)) 780bd056d7eSTejun Heo return -ERANGE; 781bd056d7eSTejun Heo 782bd056d7eSTejun Heo /* use LBA48 */ 783bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_LBA48; 784bd056d7eSTejun Heo 785bd056d7eSTejun Heo tf->hob_nsect = (n_block >> 8) & 0xff; 786bd056d7eSTejun Heo 787bd056d7eSTejun Heo tf->hob_lbah = (block >> 40) & 0xff; 788bd056d7eSTejun Heo tf->hob_lbam = (block >> 32) & 0xff; 789bd056d7eSTejun Heo tf->hob_lbal = (block >> 24) & 0xff; 790bd056d7eSTejun Heo } else 791bd056d7eSTejun Heo /* request too large even for LBA48 */ 792bd056d7eSTejun Heo return -ERANGE; 793bd056d7eSTejun Heo 794bd056d7eSTejun Heo if (unlikely(ata_rwcmd_protocol(tf, dev) < 0)) 795bd056d7eSTejun Heo return -EINVAL; 796bd056d7eSTejun Heo 797bd056d7eSTejun Heo tf->nsect = n_block & 0xff; 798bd056d7eSTejun Heo 799bd056d7eSTejun Heo tf->lbah = (block >> 16) & 0xff; 800bd056d7eSTejun Heo tf->lbam = (block >> 8) & 0xff; 801bd056d7eSTejun Heo tf->lbal = block & 0xff; 802bd056d7eSTejun Heo 803bd056d7eSTejun Heo tf->device |= ATA_LBA; 804bd056d7eSTejun Heo } else { 805bd056d7eSTejun Heo /* CHS */ 806bd056d7eSTejun Heo u32 sect, head, cyl, track; 807bd056d7eSTejun Heo 808bd056d7eSTejun Heo /* The request -may- be too large for CHS addressing. */ 809bd056d7eSTejun Heo if (!lba_28_ok(block, n_block)) 810bd056d7eSTejun Heo return -ERANGE; 811bd056d7eSTejun Heo 812bd056d7eSTejun Heo if (unlikely(ata_rwcmd_protocol(tf, dev) < 0)) 813bd056d7eSTejun Heo return -EINVAL; 814bd056d7eSTejun Heo 815bd056d7eSTejun Heo /* Convert LBA to CHS */ 816bd056d7eSTejun Heo track = (u32)block / dev->sectors; 817bd056d7eSTejun Heo cyl = track / dev->heads; 818bd056d7eSTejun Heo head = track % dev->heads; 819bd056d7eSTejun Heo sect = (u32)block % dev->sectors + 1; 820bd056d7eSTejun Heo 821bd056d7eSTejun Heo DPRINTK("block %u track %u cyl %u head %u sect %u\n", 822bd056d7eSTejun Heo (u32)block, track, cyl, head, sect); 823bd056d7eSTejun Heo 824bd056d7eSTejun Heo /* Check whether the converted CHS can fit. 825bd056d7eSTejun Heo Cylinder: 0-65535 826bd056d7eSTejun Heo Head: 0-15 827bd056d7eSTejun Heo Sector: 1-255*/ 828bd056d7eSTejun Heo if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect)) 829bd056d7eSTejun Heo return -ERANGE; 830bd056d7eSTejun Heo 831bd056d7eSTejun Heo tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */ 832bd056d7eSTejun Heo tf->lbal = sect; 833bd056d7eSTejun Heo tf->lbam = cyl; 834bd056d7eSTejun Heo tf->lbah = cyl >> 8; 835bd056d7eSTejun Heo tf->device |= head; 836bd056d7eSTejun Heo } 837bd056d7eSTejun Heo 838bd056d7eSTejun Heo return 0; 839bd056d7eSTejun Heo } 840bd056d7eSTejun Heo 841bd056d7eSTejun Heo /** 842c6fd2807SJeff Garzik * ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask 843c6fd2807SJeff Garzik * @pio_mask: pio_mask 844c6fd2807SJeff Garzik * @mwdma_mask: mwdma_mask 845c6fd2807SJeff Garzik * @udma_mask: udma_mask 846c6fd2807SJeff Garzik * 847c6fd2807SJeff Garzik * Pack @pio_mask, @mwdma_mask and @udma_mask into a single 848c6fd2807SJeff Garzik * unsigned int xfer_mask. 849c6fd2807SJeff Garzik * 850c6fd2807SJeff Garzik * LOCKING: 851c6fd2807SJeff Garzik * None. 852c6fd2807SJeff Garzik * 853c6fd2807SJeff Garzik * RETURNS: 854c6fd2807SJeff Garzik * Packed xfer_mask. 855c6fd2807SJeff Garzik */ 8567dc951aeSTejun Heo unsigned long ata_pack_xfermask(unsigned long pio_mask, 8577dc951aeSTejun Heo unsigned long mwdma_mask, 8587dc951aeSTejun Heo unsigned long udma_mask) 859c6fd2807SJeff Garzik { 860c6fd2807SJeff Garzik return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) | 861c6fd2807SJeff Garzik ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) | 862c6fd2807SJeff Garzik ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA); 863c6fd2807SJeff Garzik } 864c6fd2807SJeff Garzik 865c6fd2807SJeff Garzik /** 866c6fd2807SJeff Garzik * ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks 867c6fd2807SJeff Garzik * @xfer_mask: xfer_mask to unpack 868c6fd2807SJeff Garzik * @pio_mask: resulting pio_mask 869c6fd2807SJeff Garzik * @mwdma_mask: resulting mwdma_mask 870c6fd2807SJeff Garzik * @udma_mask: resulting udma_mask 871c6fd2807SJeff Garzik * 872c6fd2807SJeff Garzik * Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask. 873c6fd2807SJeff Garzik * Any NULL distination masks will be ignored. 874c6fd2807SJeff Garzik */ 8757dc951aeSTejun Heo void ata_unpack_xfermask(unsigned long xfer_mask, unsigned long *pio_mask, 8767dc951aeSTejun Heo unsigned long *mwdma_mask, unsigned long *udma_mask) 877c6fd2807SJeff Garzik { 878c6fd2807SJeff Garzik if (pio_mask) 879c6fd2807SJeff Garzik *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO; 880c6fd2807SJeff Garzik if (mwdma_mask) 881c6fd2807SJeff Garzik *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA; 882c6fd2807SJeff Garzik if (udma_mask) 883c6fd2807SJeff Garzik *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA; 884c6fd2807SJeff Garzik } 885c6fd2807SJeff Garzik 886c6fd2807SJeff Garzik static const struct ata_xfer_ent { 887c6fd2807SJeff Garzik int shift, bits; 888c6fd2807SJeff Garzik u8 base; 889c6fd2807SJeff Garzik } ata_xfer_tbl[] = { 89070cd071eSTejun Heo { ATA_SHIFT_PIO, ATA_NR_PIO_MODES, XFER_PIO_0 }, 89170cd071eSTejun Heo { ATA_SHIFT_MWDMA, ATA_NR_MWDMA_MODES, XFER_MW_DMA_0 }, 89270cd071eSTejun Heo { ATA_SHIFT_UDMA, ATA_NR_UDMA_MODES, XFER_UDMA_0 }, 893c6fd2807SJeff Garzik { -1, }, 894c6fd2807SJeff Garzik }; 895c6fd2807SJeff Garzik 896c6fd2807SJeff Garzik /** 897c6fd2807SJeff Garzik * ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask 898c6fd2807SJeff Garzik * @xfer_mask: xfer_mask of interest 899c6fd2807SJeff Garzik * 900c6fd2807SJeff Garzik * Return matching XFER_* value for @xfer_mask. Only the highest 901c6fd2807SJeff Garzik * bit of @xfer_mask is considered. 902c6fd2807SJeff Garzik * 903c6fd2807SJeff Garzik * LOCKING: 904c6fd2807SJeff Garzik * None. 905c6fd2807SJeff Garzik * 906c6fd2807SJeff Garzik * RETURNS: 90770cd071eSTejun Heo * Matching XFER_* value, 0xff if no match found. 908c6fd2807SJeff Garzik */ 9097dc951aeSTejun Heo u8 ata_xfer_mask2mode(unsigned long xfer_mask) 910c6fd2807SJeff Garzik { 911c6fd2807SJeff Garzik int highbit = fls(xfer_mask) - 1; 912c6fd2807SJeff Garzik const struct ata_xfer_ent *ent; 913c6fd2807SJeff Garzik 914c6fd2807SJeff Garzik for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 915c6fd2807SJeff Garzik if (highbit >= ent->shift && highbit < ent->shift + ent->bits) 916c6fd2807SJeff Garzik return ent->base + highbit - ent->shift; 91770cd071eSTejun Heo return 0xff; 918c6fd2807SJeff Garzik } 919c6fd2807SJeff Garzik 920c6fd2807SJeff Garzik /** 921c6fd2807SJeff Garzik * ata_xfer_mode2mask - Find matching xfer_mask for XFER_* 922c6fd2807SJeff Garzik * @xfer_mode: XFER_* of interest 923c6fd2807SJeff Garzik * 924c6fd2807SJeff Garzik * Return matching xfer_mask for @xfer_mode. 925c6fd2807SJeff Garzik * 926c6fd2807SJeff Garzik * LOCKING: 927c6fd2807SJeff Garzik * None. 928c6fd2807SJeff Garzik * 929c6fd2807SJeff Garzik * RETURNS: 930c6fd2807SJeff Garzik * Matching xfer_mask, 0 if no match found. 931c6fd2807SJeff Garzik */ 9327dc951aeSTejun Heo unsigned long ata_xfer_mode2mask(u8 xfer_mode) 933c6fd2807SJeff Garzik { 934c6fd2807SJeff Garzik const struct ata_xfer_ent *ent; 935c6fd2807SJeff Garzik 936c6fd2807SJeff Garzik for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 937c6fd2807SJeff Garzik if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits) 93870cd071eSTejun Heo return ((2 << (ent->shift + xfer_mode - ent->base)) - 1) 93970cd071eSTejun Heo & ~((1 << ent->shift) - 1); 940c6fd2807SJeff Garzik return 0; 941c6fd2807SJeff Garzik } 942c6fd2807SJeff Garzik 943c6fd2807SJeff Garzik /** 944c6fd2807SJeff Garzik * ata_xfer_mode2shift - Find matching xfer_shift for XFER_* 945c6fd2807SJeff Garzik * @xfer_mode: XFER_* of interest 946c6fd2807SJeff Garzik * 947c6fd2807SJeff Garzik * Return matching xfer_shift for @xfer_mode. 948c6fd2807SJeff Garzik * 949c6fd2807SJeff Garzik * LOCKING: 950c6fd2807SJeff Garzik * None. 951c6fd2807SJeff Garzik * 952c6fd2807SJeff Garzik * RETURNS: 953c6fd2807SJeff Garzik * Matching xfer_shift, -1 if no match found. 954c6fd2807SJeff Garzik */ 9557dc951aeSTejun Heo int ata_xfer_mode2shift(unsigned long xfer_mode) 956c6fd2807SJeff Garzik { 957c6fd2807SJeff Garzik const struct ata_xfer_ent *ent; 958c6fd2807SJeff Garzik 959c6fd2807SJeff Garzik for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 960c6fd2807SJeff Garzik if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits) 961c6fd2807SJeff Garzik return ent->shift; 962c6fd2807SJeff Garzik return -1; 963c6fd2807SJeff Garzik } 964c6fd2807SJeff Garzik 965c6fd2807SJeff Garzik /** 966c6fd2807SJeff Garzik * ata_mode_string - convert xfer_mask to string 967c6fd2807SJeff Garzik * @xfer_mask: mask of bits supported; only highest bit counts. 968c6fd2807SJeff Garzik * 969c6fd2807SJeff Garzik * Determine string which represents the highest speed 970c6fd2807SJeff Garzik * (highest bit in @modemask). 971c6fd2807SJeff Garzik * 972c6fd2807SJeff Garzik * LOCKING: 973c6fd2807SJeff Garzik * None. 974c6fd2807SJeff Garzik * 975c6fd2807SJeff Garzik * RETURNS: 976c6fd2807SJeff Garzik * Constant C string representing highest speed listed in 977c6fd2807SJeff Garzik * @mode_mask, or the constant C string "<n/a>". 978c6fd2807SJeff Garzik */ 9797dc951aeSTejun Heo const char *ata_mode_string(unsigned long xfer_mask) 980c6fd2807SJeff Garzik { 981c6fd2807SJeff Garzik static const char * const xfer_mode_str[] = { 982c6fd2807SJeff Garzik "PIO0", 983c6fd2807SJeff Garzik "PIO1", 984c6fd2807SJeff Garzik "PIO2", 985c6fd2807SJeff Garzik "PIO3", 986c6fd2807SJeff Garzik "PIO4", 987b352e57dSAlan Cox "PIO5", 988b352e57dSAlan Cox "PIO6", 989c6fd2807SJeff Garzik "MWDMA0", 990c6fd2807SJeff Garzik "MWDMA1", 991c6fd2807SJeff Garzik "MWDMA2", 992b352e57dSAlan Cox "MWDMA3", 993b352e57dSAlan Cox "MWDMA4", 994c6fd2807SJeff Garzik "UDMA/16", 995c6fd2807SJeff Garzik "UDMA/25", 996c6fd2807SJeff Garzik "UDMA/33", 997c6fd2807SJeff Garzik "UDMA/44", 998c6fd2807SJeff Garzik "UDMA/66", 999c6fd2807SJeff Garzik "UDMA/100", 1000c6fd2807SJeff Garzik "UDMA/133", 1001c6fd2807SJeff Garzik "UDMA7", 1002c6fd2807SJeff Garzik }; 1003c6fd2807SJeff Garzik int highbit; 1004c6fd2807SJeff Garzik 1005c6fd2807SJeff Garzik highbit = fls(xfer_mask) - 1; 1006c6fd2807SJeff Garzik if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str)) 1007c6fd2807SJeff Garzik return xfer_mode_str[highbit]; 1008c6fd2807SJeff Garzik return "<n/a>"; 1009c6fd2807SJeff Garzik } 1010c6fd2807SJeff Garzik 1011c6fd2807SJeff Garzik static const char *sata_spd_string(unsigned int spd) 1012c6fd2807SJeff Garzik { 1013c6fd2807SJeff Garzik static const char * const spd_str[] = { 1014c6fd2807SJeff Garzik "1.5 Gbps", 1015c6fd2807SJeff Garzik "3.0 Gbps", 10168522ee25SShane Huang "6.0 Gbps", 1017c6fd2807SJeff Garzik }; 1018c6fd2807SJeff Garzik 1019c6fd2807SJeff Garzik if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str)) 1020c6fd2807SJeff Garzik return "<unknown>"; 1021c6fd2807SJeff Garzik return spd_str[spd - 1]; 1022c6fd2807SJeff Garzik } 1023c6fd2807SJeff Garzik 1024ca77329fSKristen Carlson Accardi static int ata_dev_set_dipm(struct ata_device *dev, enum link_pm policy) 1025ca77329fSKristen Carlson Accardi { 1026ca77329fSKristen Carlson Accardi struct ata_link *link = dev->link; 1027ca77329fSKristen Carlson Accardi struct ata_port *ap = link->ap; 1028ca77329fSKristen Carlson Accardi u32 scontrol; 1029ca77329fSKristen Carlson Accardi unsigned int err_mask; 1030ca77329fSKristen Carlson Accardi int rc; 1031ca77329fSKristen Carlson Accardi 1032ca77329fSKristen Carlson Accardi /* 1033ca77329fSKristen Carlson Accardi * disallow DIPM for drivers which haven't set 1034ca77329fSKristen Carlson Accardi * ATA_FLAG_IPM. This is because when DIPM is enabled, 1035ca77329fSKristen Carlson Accardi * phy ready will be set in the interrupt status on 1036ca77329fSKristen Carlson Accardi * state changes, which will cause some drivers to 1037ca77329fSKristen Carlson Accardi * think there are errors - additionally drivers will 1038ca77329fSKristen Carlson Accardi * need to disable hot plug. 1039ca77329fSKristen Carlson Accardi */ 1040ca77329fSKristen Carlson Accardi if (!(ap->flags & ATA_FLAG_IPM) || !ata_dev_enabled(dev)) { 1041ca77329fSKristen Carlson Accardi ap->pm_policy = NOT_AVAILABLE; 1042ca77329fSKristen Carlson Accardi return -EINVAL; 1043ca77329fSKristen Carlson Accardi } 1044ca77329fSKristen Carlson Accardi 1045ca77329fSKristen Carlson Accardi /* 1046ca77329fSKristen Carlson Accardi * For DIPM, we will only enable it for the 1047ca77329fSKristen Carlson Accardi * min_power setting. 1048ca77329fSKristen Carlson Accardi * 1049ca77329fSKristen Carlson Accardi * Why? Because Disks are too stupid to know that 1050ca77329fSKristen Carlson Accardi * If the host rejects a request to go to SLUMBER 1051ca77329fSKristen Carlson Accardi * they should retry at PARTIAL, and instead it 1052ca77329fSKristen Carlson Accardi * just would give up. So, for medium_power to 1053ca77329fSKristen Carlson Accardi * work at all, we need to only allow HIPM. 1054ca77329fSKristen Carlson Accardi */ 1055ca77329fSKristen Carlson Accardi rc = sata_scr_read(link, SCR_CONTROL, &scontrol); 1056ca77329fSKristen Carlson Accardi if (rc) 1057ca77329fSKristen Carlson Accardi return rc; 1058ca77329fSKristen Carlson Accardi 1059ca77329fSKristen Carlson Accardi switch (policy) { 1060ca77329fSKristen Carlson Accardi case MIN_POWER: 1061ca77329fSKristen Carlson Accardi /* no restrictions on IPM transitions */ 1062ca77329fSKristen Carlson Accardi scontrol &= ~(0x3 << 8); 1063ca77329fSKristen Carlson Accardi rc = sata_scr_write(link, SCR_CONTROL, scontrol); 1064ca77329fSKristen Carlson Accardi if (rc) 1065ca77329fSKristen Carlson Accardi return rc; 1066ca77329fSKristen Carlson Accardi 1067ca77329fSKristen Carlson Accardi /* enable DIPM */ 1068ca77329fSKristen Carlson Accardi if (dev->flags & ATA_DFLAG_DIPM) 1069ca77329fSKristen Carlson Accardi err_mask = ata_dev_set_feature(dev, 1070ca77329fSKristen Carlson Accardi SETFEATURES_SATA_ENABLE, SATA_DIPM); 1071ca77329fSKristen Carlson Accardi break; 1072ca77329fSKristen Carlson Accardi case MEDIUM_POWER: 1073ca77329fSKristen Carlson Accardi /* allow IPM to PARTIAL */ 1074ca77329fSKristen Carlson Accardi scontrol &= ~(0x1 << 8); 1075ca77329fSKristen Carlson Accardi scontrol |= (0x2 << 8); 1076ca77329fSKristen Carlson Accardi rc = sata_scr_write(link, SCR_CONTROL, scontrol); 1077ca77329fSKristen Carlson Accardi if (rc) 1078ca77329fSKristen Carlson Accardi return rc; 1079ca77329fSKristen Carlson Accardi 1080f5456b63SKristen Carlson Accardi /* 1081f5456b63SKristen Carlson Accardi * we don't have to disable DIPM since IPM flags 1082f5456b63SKristen Carlson Accardi * disallow transitions to SLUMBER, which effectively 1083f5456b63SKristen Carlson Accardi * disable DIPM if it does not support PARTIAL 1084f5456b63SKristen Carlson Accardi */ 1085ca77329fSKristen Carlson Accardi break; 1086ca77329fSKristen Carlson Accardi case NOT_AVAILABLE: 1087ca77329fSKristen Carlson Accardi case MAX_PERFORMANCE: 1088ca77329fSKristen Carlson Accardi /* disable all IPM transitions */ 1089ca77329fSKristen Carlson Accardi scontrol |= (0x3 << 8); 1090ca77329fSKristen Carlson Accardi rc = sata_scr_write(link, SCR_CONTROL, scontrol); 1091ca77329fSKristen Carlson Accardi if (rc) 1092ca77329fSKristen Carlson Accardi return rc; 1093ca77329fSKristen Carlson Accardi 1094f5456b63SKristen Carlson Accardi /* 1095f5456b63SKristen Carlson Accardi * we don't have to disable DIPM since IPM flags 1096f5456b63SKristen Carlson Accardi * disallow all transitions which effectively 1097f5456b63SKristen Carlson Accardi * disable DIPM anyway. 1098f5456b63SKristen Carlson Accardi */ 1099ca77329fSKristen Carlson Accardi break; 1100ca77329fSKristen Carlson Accardi } 1101ca77329fSKristen Carlson Accardi 1102ca77329fSKristen Carlson Accardi /* FIXME: handle SET FEATURES failure */ 1103ca77329fSKristen Carlson Accardi (void) err_mask; 1104ca77329fSKristen Carlson Accardi 1105ca77329fSKristen Carlson Accardi return 0; 1106ca77329fSKristen Carlson Accardi } 1107ca77329fSKristen Carlson Accardi 1108ca77329fSKristen Carlson Accardi /** 1109ca77329fSKristen Carlson Accardi * ata_dev_enable_pm - enable SATA interface power management 111048166fd9SStephen Hemminger * @dev: device to enable power management 111148166fd9SStephen Hemminger * @policy: the link power management policy 1112ca77329fSKristen Carlson Accardi * 1113ca77329fSKristen Carlson Accardi * Enable SATA Interface power management. This will enable 1114ca77329fSKristen Carlson Accardi * Device Interface Power Management (DIPM) for min_power 1115ca77329fSKristen Carlson Accardi * policy, and then call driver specific callbacks for 1116ca77329fSKristen Carlson Accardi * enabling Host Initiated Power management. 1117ca77329fSKristen Carlson Accardi * 1118ca77329fSKristen Carlson Accardi * Locking: Caller. 1119ca77329fSKristen Carlson Accardi * Returns: -EINVAL if IPM is not supported, 0 otherwise. 1120ca77329fSKristen Carlson Accardi */ 1121ca77329fSKristen Carlson Accardi void ata_dev_enable_pm(struct ata_device *dev, enum link_pm policy) 1122ca77329fSKristen Carlson Accardi { 1123ca77329fSKristen Carlson Accardi int rc = 0; 1124ca77329fSKristen Carlson Accardi struct ata_port *ap = dev->link->ap; 1125ca77329fSKristen Carlson Accardi 1126ca77329fSKristen Carlson Accardi /* set HIPM first, then DIPM */ 1127ca77329fSKristen Carlson Accardi if (ap->ops->enable_pm) 1128ca77329fSKristen Carlson Accardi rc = ap->ops->enable_pm(ap, policy); 1129ca77329fSKristen Carlson Accardi if (rc) 1130ca77329fSKristen Carlson Accardi goto enable_pm_out; 1131ca77329fSKristen Carlson Accardi rc = ata_dev_set_dipm(dev, policy); 1132ca77329fSKristen Carlson Accardi 1133ca77329fSKristen Carlson Accardi enable_pm_out: 1134ca77329fSKristen Carlson Accardi if (rc) 1135ca77329fSKristen Carlson Accardi ap->pm_policy = MAX_PERFORMANCE; 1136ca77329fSKristen Carlson Accardi else 1137ca77329fSKristen Carlson Accardi ap->pm_policy = policy; 1138ca77329fSKristen Carlson Accardi return /* rc */; /* hopefully we can use 'rc' eventually */ 1139ca77329fSKristen Carlson Accardi } 1140ca77329fSKristen Carlson Accardi 11411992a5edSStephen Rothwell #ifdef CONFIG_PM 1142ca77329fSKristen Carlson Accardi /** 1143ca77329fSKristen Carlson Accardi * ata_dev_disable_pm - disable SATA interface power management 114448166fd9SStephen Hemminger * @dev: device to disable power management 1145ca77329fSKristen Carlson Accardi * 1146ca77329fSKristen Carlson Accardi * Disable SATA Interface power management. This will disable 1147ca77329fSKristen Carlson Accardi * Device Interface Power Management (DIPM) without changing 1148ca77329fSKristen Carlson Accardi * policy, call driver specific callbacks for disabling Host 1149ca77329fSKristen Carlson Accardi * Initiated Power management. 1150ca77329fSKristen Carlson Accardi * 1151ca77329fSKristen Carlson Accardi * Locking: Caller. 1152ca77329fSKristen Carlson Accardi * Returns: void 1153ca77329fSKristen Carlson Accardi */ 1154ca77329fSKristen Carlson Accardi static void ata_dev_disable_pm(struct ata_device *dev) 1155ca77329fSKristen Carlson Accardi { 1156ca77329fSKristen Carlson Accardi struct ata_port *ap = dev->link->ap; 1157ca77329fSKristen Carlson Accardi 1158ca77329fSKristen Carlson Accardi ata_dev_set_dipm(dev, MAX_PERFORMANCE); 1159ca77329fSKristen Carlson Accardi if (ap->ops->disable_pm) 1160ca77329fSKristen Carlson Accardi ap->ops->disable_pm(ap); 1161ca77329fSKristen Carlson Accardi } 11621992a5edSStephen Rothwell #endif /* CONFIG_PM */ 1163ca77329fSKristen Carlson Accardi 1164ca77329fSKristen Carlson Accardi void ata_lpm_schedule(struct ata_port *ap, enum link_pm policy) 1165ca77329fSKristen Carlson Accardi { 1166ca77329fSKristen Carlson Accardi ap->pm_policy = policy; 11673ec25ebdSTejun Heo ap->link.eh_info.action |= ATA_EH_LPM; 1168ca77329fSKristen Carlson Accardi ap->link.eh_info.flags |= ATA_EHI_NO_AUTOPSY; 1169ca77329fSKristen Carlson Accardi ata_port_schedule_eh(ap); 1170ca77329fSKristen Carlson Accardi } 1171ca77329fSKristen Carlson Accardi 11721992a5edSStephen Rothwell #ifdef CONFIG_PM 1173ca77329fSKristen Carlson Accardi static void ata_lpm_enable(struct ata_host *host) 1174ca77329fSKristen Carlson Accardi { 1175ca77329fSKristen Carlson Accardi struct ata_link *link; 1176ca77329fSKristen Carlson Accardi struct ata_port *ap; 1177ca77329fSKristen Carlson Accardi struct ata_device *dev; 1178ca77329fSKristen Carlson Accardi int i; 1179ca77329fSKristen Carlson Accardi 1180ca77329fSKristen Carlson Accardi for (i = 0; i < host->n_ports; i++) { 1181ca77329fSKristen Carlson Accardi ap = host->ports[i]; 11821eca4365STejun Heo ata_for_each_link(link, ap, EDGE) { 11831eca4365STejun Heo ata_for_each_dev(dev, link, ALL) 1184ca77329fSKristen Carlson Accardi ata_dev_disable_pm(dev); 1185ca77329fSKristen Carlson Accardi } 1186ca77329fSKristen Carlson Accardi } 1187ca77329fSKristen Carlson Accardi } 1188ca77329fSKristen Carlson Accardi 1189ca77329fSKristen Carlson Accardi static void ata_lpm_disable(struct ata_host *host) 1190ca77329fSKristen Carlson Accardi { 1191ca77329fSKristen Carlson Accardi int i; 1192ca77329fSKristen Carlson Accardi 1193ca77329fSKristen Carlson Accardi for (i = 0; i < host->n_ports; i++) { 1194ca77329fSKristen Carlson Accardi struct ata_port *ap = host->ports[i]; 1195ca77329fSKristen Carlson Accardi ata_lpm_schedule(ap, ap->pm_policy); 1196ca77329fSKristen Carlson Accardi } 1197ca77329fSKristen Carlson Accardi } 11981992a5edSStephen Rothwell #endif /* CONFIG_PM */ 1199ca77329fSKristen Carlson Accardi 1200c6fd2807SJeff Garzik /** 1201c6fd2807SJeff Garzik * ata_dev_classify - determine device type based on ATA-spec signature 1202c6fd2807SJeff Garzik * @tf: ATA taskfile register set for device to be identified 1203c6fd2807SJeff Garzik * 1204c6fd2807SJeff Garzik * Determine from taskfile register contents whether a device is 1205c6fd2807SJeff Garzik * ATA or ATAPI, as per "Signature and persistence" section 1206c6fd2807SJeff Garzik * of ATA/PI spec (volume 1, sect 5.14). 1207c6fd2807SJeff Garzik * 1208c6fd2807SJeff Garzik * LOCKING: 1209c6fd2807SJeff Garzik * None. 1210c6fd2807SJeff Garzik * 1211c6fd2807SJeff Garzik * RETURNS: 1212633273a3STejun Heo * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, %ATA_DEV_PMP or 1213633273a3STejun Heo * %ATA_DEV_UNKNOWN the event of failure. 1214c6fd2807SJeff Garzik */ 1215c6fd2807SJeff Garzik unsigned int ata_dev_classify(const struct ata_taskfile *tf) 1216c6fd2807SJeff Garzik { 1217c6fd2807SJeff Garzik /* Apple's open source Darwin code hints that some devices only 1218c6fd2807SJeff Garzik * put a proper signature into the LBA mid/high registers, 1219c6fd2807SJeff Garzik * So, we only check those. It's sufficient for uniqueness. 1220633273a3STejun Heo * 1221633273a3STejun Heo * ATA/ATAPI-7 (d1532v1r1: Feb. 19, 2003) specified separate 1222633273a3STejun Heo * signatures for ATA and ATAPI devices attached on SerialATA, 1223633273a3STejun Heo * 0x3c/0xc3 and 0x69/0x96 respectively. However, SerialATA 1224633273a3STejun Heo * spec has never mentioned about using different signatures 1225633273a3STejun Heo * for ATA/ATAPI devices. Then, Serial ATA II: Port 1226633273a3STejun Heo * Multiplier specification began to use 0x69/0x96 to identify 1227633273a3STejun Heo * port multpliers and 0x3c/0xc3 to identify SEMB device. 1228633273a3STejun Heo * ATA/ATAPI-7 dropped descriptions about 0x3c/0xc3 and 1229633273a3STejun Heo * 0x69/0x96 shortly and described them as reserved for 1230633273a3STejun Heo * SerialATA. 1231633273a3STejun Heo * 1232633273a3STejun Heo * We follow the current spec and consider that 0x69/0x96 1233633273a3STejun Heo * identifies a port multiplier and 0x3c/0xc3 a SEMB device. 123479b42babSTejun Heo * Unfortunately, WDC WD1600JS-62MHB5 (a hard drive) reports 123579b42babSTejun Heo * SEMB signature. This is worked around in 123679b42babSTejun Heo * ata_dev_read_id(). 1237c6fd2807SJeff Garzik */ 1238633273a3STejun Heo if ((tf->lbam == 0) && (tf->lbah == 0)) { 1239c6fd2807SJeff Garzik DPRINTK("found ATA device by sig\n"); 1240c6fd2807SJeff Garzik return ATA_DEV_ATA; 1241c6fd2807SJeff Garzik } 1242c6fd2807SJeff Garzik 1243633273a3STejun Heo if ((tf->lbam == 0x14) && (tf->lbah == 0xeb)) { 1244c6fd2807SJeff Garzik DPRINTK("found ATAPI device by sig\n"); 1245c6fd2807SJeff Garzik return ATA_DEV_ATAPI; 1246c6fd2807SJeff Garzik } 1247c6fd2807SJeff Garzik 1248633273a3STejun Heo if ((tf->lbam == 0x69) && (tf->lbah == 0x96)) { 1249633273a3STejun Heo DPRINTK("found PMP device by sig\n"); 1250633273a3STejun Heo return ATA_DEV_PMP; 1251633273a3STejun Heo } 1252633273a3STejun Heo 1253633273a3STejun Heo if ((tf->lbam == 0x3c) && (tf->lbah == 0xc3)) { 125479b42babSTejun Heo DPRINTK("found SEMB device by sig (could be ATA device)\n"); 125579b42babSTejun Heo return ATA_DEV_SEMB; 1256633273a3STejun Heo } 1257633273a3STejun Heo 1258c6fd2807SJeff Garzik DPRINTK("unknown device\n"); 1259c6fd2807SJeff Garzik return ATA_DEV_UNKNOWN; 1260c6fd2807SJeff Garzik } 1261c6fd2807SJeff Garzik 1262c6fd2807SJeff Garzik /** 1263c6fd2807SJeff Garzik * ata_id_string - Convert IDENTIFY DEVICE page into string 1264c6fd2807SJeff Garzik * @id: IDENTIFY DEVICE results we will examine 1265c6fd2807SJeff Garzik * @s: string into which data is output 1266c6fd2807SJeff Garzik * @ofs: offset into identify device page 1267c6fd2807SJeff Garzik * @len: length of string to return. must be an even number. 1268c6fd2807SJeff Garzik * 1269c6fd2807SJeff Garzik * The strings in the IDENTIFY DEVICE page are broken up into 1270c6fd2807SJeff Garzik * 16-bit chunks. Run through the string, and output each 1271c6fd2807SJeff Garzik * 8-bit chunk linearly, regardless of platform. 1272c6fd2807SJeff Garzik * 1273c6fd2807SJeff Garzik * LOCKING: 1274c6fd2807SJeff Garzik * caller. 1275c6fd2807SJeff Garzik */ 1276c6fd2807SJeff Garzik 1277c6fd2807SJeff Garzik void ata_id_string(const u16 *id, unsigned char *s, 1278c6fd2807SJeff Garzik unsigned int ofs, unsigned int len) 1279c6fd2807SJeff Garzik { 1280c6fd2807SJeff Garzik unsigned int c; 1281c6fd2807SJeff Garzik 1282963e4975SAlan Cox BUG_ON(len & 1); 1283963e4975SAlan Cox 1284c6fd2807SJeff Garzik while (len > 0) { 1285c6fd2807SJeff Garzik c = id[ofs] >> 8; 1286c6fd2807SJeff Garzik *s = c; 1287c6fd2807SJeff Garzik s++; 1288c6fd2807SJeff Garzik 1289c6fd2807SJeff Garzik c = id[ofs] & 0xff; 1290c6fd2807SJeff Garzik *s = c; 1291c6fd2807SJeff Garzik s++; 1292c6fd2807SJeff Garzik 1293c6fd2807SJeff Garzik ofs++; 1294c6fd2807SJeff Garzik len -= 2; 1295c6fd2807SJeff Garzik } 1296c6fd2807SJeff Garzik } 1297c6fd2807SJeff Garzik 1298c6fd2807SJeff Garzik /** 1299c6fd2807SJeff Garzik * ata_id_c_string - Convert IDENTIFY DEVICE page into C string 1300c6fd2807SJeff Garzik * @id: IDENTIFY DEVICE results we will examine 1301c6fd2807SJeff Garzik * @s: string into which data is output 1302c6fd2807SJeff Garzik * @ofs: offset into identify device page 1303c6fd2807SJeff Garzik * @len: length of string to return. must be an odd number. 1304c6fd2807SJeff Garzik * 1305c6fd2807SJeff Garzik * This function is identical to ata_id_string except that it 1306c6fd2807SJeff Garzik * trims trailing spaces and terminates the resulting string with 1307c6fd2807SJeff Garzik * null. @len must be actual maximum length (even number) + 1. 1308c6fd2807SJeff Garzik * 1309c6fd2807SJeff Garzik * LOCKING: 1310c6fd2807SJeff Garzik * caller. 1311c6fd2807SJeff Garzik */ 1312c6fd2807SJeff Garzik void ata_id_c_string(const u16 *id, unsigned char *s, 1313c6fd2807SJeff Garzik unsigned int ofs, unsigned int len) 1314c6fd2807SJeff Garzik { 1315c6fd2807SJeff Garzik unsigned char *p; 1316c6fd2807SJeff Garzik 1317c6fd2807SJeff Garzik ata_id_string(id, s, ofs, len - 1); 1318c6fd2807SJeff Garzik 1319c6fd2807SJeff Garzik p = s + strnlen(s, len - 1); 1320c6fd2807SJeff Garzik while (p > s && p[-1] == ' ') 1321c6fd2807SJeff Garzik p--; 1322c6fd2807SJeff Garzik *p = '\0'; 1323c6fd2807SJeff Garzik } 1324c6fd2807SJeff Garzik 1325db6f8759STejun Heo static u64 ata_id_n_sectors(const u16 *id) 1326db6f8759STejun Heo { 1327db6f8759STejun Heo if (ata_id_has_lba(id)) { 1328db6f8759STejun Heo if (ata_id_has_lba48(id)) 1329968e594aSRobert Hancock return ata_id_u64(id, ATA_ID_LBA_CAPACITY_2); 1330db6f8759STejun Heo else 1331968e594aSRobert Hancock return ata_id_u32(id, ATA_ID_LBA_CAPACITY); 1332db6f8759STejun Heo } else { 1333db6f8759STejun Heo if (ata_id_current_chs_valid(id)) 1334968e594aSRobert Hancock return id[ATA_ID_CUR_CYLS] * id[ATA_ID_CUR_HEADS] * 1335968e594aSRobert Hancock id[ATA_ID_CUR_SECTORS]; 1336db6f8759STejun Heo else 1337968e594aSRobert Hancock return id[ATA_ID_CYLS] * id[ATA_ID_HEADS] * 1338968e594aSRobert Hancock id[ATA_ID_SECTORS]; 1339db6f8759STejun Heo } 1340db6f8759STejun Heo } 1341db6f8759STejun Heo 1342a5987e0aSTejun Heo u64 ata_tf_to_lba48(const struct ata_taskfile *tf) 13431e999736SAlan Cox { 13441e999736SAlan Cox u64 sectors = 0; 13451e999736SAlan Cox 13461e999736SAlan Cox sectors |= ((u64)(tf->hob_lbah & 0xff)) << 40; 13471e999736SAlan Cox sectors |= ((u64)(tf->hob_lbam & 0xff)) << 32; 1348ba14a9c2SRoland Dreier sectors |= ((u64)(tf->hob_lbal & 0xff)) << 24; 13491e999736SAlan Cox sectors |= (tf->lbah & 0xff) << 16; 13501e999736SAlan Cox sectors |= (tf->lbam & 0xff) << 8; 13511e999736SAlan Cox sectors |= (tf->lbal & 0xff); 13521e999736SAlan Cox 1353a5987e0aSTejun Heo return sectors; 13541e999736SAlan Cox } 13551e999736SAlan Cox 1356a5987e0aSTejun Heo u64 ata_tf_to_lba(const struct ata_taskfile *tf) 13571e999736SAlan Cox { 13581e999736SAlan Cox u64 sectors = 0; 13591e999736SAlan Cox 13601e999736SAlan Cox sectors |= (tf->device & 0x0f) << 24; 13611e999736SAlan Cox sectors |= (tf->lbah & 0xff) << 16; 13621e999736SAlan Cox sectors |= (tf->lbam & 0xff) << 8; 13631e999736SAlan Cox sectors |= (tf->lbal & 0xff); 13641e999736SAlan Cox 1365a5987e0aSTejun Heo return sectors; 13661e999736SAlan Cox } 13671e999736SAlan Cox 13681e999736SAlan Cox /** 1369c728a914STejun Heo * ata_read_native_max_address - Read native max address 1370c728a914STejun Heo * @dev: target device 1371c728a914STejun Heo * @max_sectors: out parameter for the result native max address 13721e999736SAlan Cox * 1373c728a914STejun Heo * Perform an LBA48 or LBA28 native size query upon the device in 1374c728a914STejun Heo * question. 1375c728a914STejun Heo * 1376c728a914STejun Heo * RETURNS: 1377c728a914STejun Heo * 0 on success, -EACCES if command is aborted by the drive. 1378c728a914STejun Heo * -EIO on other errors. 13791e999736SAlan Cox */ 1380c728a914STejun Heo static int ata_read_native_max_address(struct ata_device *dev, u64 *max_sectors) 13811e999736SAlan Cox { 1382c728a914STejun Heo unsigned int err_mask; 13831e999736SAlan Cox struct ata_taskfile tf; 1384c728a914STejun Heo int lba48 = ata_id_has_lba48(dev->id); 13851e999736SAlan Cox 13861e999736SAlan Cox ata_tf_init(dev, &tf); 13871e999736SAlan Cox 1388c728a914STejun Heo /* always clear all address registers */ 13891e999736SAlan Cox tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR; 1390c728a914STejun Heo 1391c728a914STejun Heo if (lba48) { 1392c728a914STejun Heo tf.command = ATA_CMD_READ_NATIVE_MAX_EXT; 1393c728a914STejun Heo tf.flags |= ATA_TFLAG_LBA48; 1394c728a914STejun Heo } else 1395c728a914STejun Heo tf.command = ATA_CMD_READ_NATIVE_MAX; 1396c728a914STejun Heo 13971e999736SAlan Cox tf.protocol |= ATA_PROT_NODATA; 1398c728a914STejun Heo tf.device |= ATA_LBA; 13991e999736SAlan Cox 14002b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 1401c728a914STejun Heo if (err_mask) { 1402c728a914STejun Heo ata_dev_printk(dev, KERN_WARNING, "failed to read native " 1403c728a914STejun Heo "max address (err_mask=0x%x)\n", err_mask); 1404c728a914STejun Heo if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED)) 1405c728a914STejun Heo return -EACCES; 1406c728a914STejun Heo return -EIO; 1407c728a914STejun Heo } 1408c728a914STejun Heo 1409c728a914STejun Heo if (lba48) 1410a5987e0aSTejun Heo *max_sectors = ata_tf_to_lba48(&tf) + 1; 1411c728a914STejun Heo else 1412a5987e0aSTejun Heo *max_sectors = ata_tf_to_lba(&tf) + 1; 141393328e11SAlan Cox if (dev->horkage & ATA_HORKAGE_HPA_SIZE) 141493328e11SAlan Cox (*max_sectors)--; 14151e999736SAlan Cox return 0; 14161e999736SAlan Cox } 14171e999736SAlan Cox 14181e999736SAlan Cox /** 1419c728a914STejun Heo * ata_set_max_sectors - Set max sectors 1420c728a914STejun Heo * @dev: target device 14216b38d1d1SRandy Dunlap * @new_sectors: new max sectors value to set for the device 14221e999736SAlan Cox * 1423c728a914STejun Heo * Set max sectors of @dev to @new_sectors. 1424c728a914STejun Heo * 1425c728a914STejun Heo * RETURNS: 1426c728a914STejun Heo * 0 on success, -EACCES if command is aborted or denied (due to 1427c728a914STejun Heo * previous non-volatile SET_MAX) by the drive. -EIO on other 1428c728a914STejun Heo * errors. 14291e999736SAlan Cox */ 143005027adcSTejun Heo static int ata_set_max_sectors(struct ata_device *dev, u64 new_sectors) 14311e999736SAlan Cox { 1432c728a914STejun Heo unsigned int err_mask; 14331e999736SAlan Cox struct ata_taskfile tf; 1434c728a914STejun Heo int lba48 = ata_id_has_lba48(dev->id); 14351e999736SAlan Cox 14361e999736SAlan Cox new_sectors--; 14371e999736SAlan Cox 14381e999736SAlan Cox ata_tf_init(dev, &tf); 14391e999736SAlan Cox 1440c728a914STejun Heo tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR; 14411e999736SAlan Cox 1442c728a914STejun Heo if (lba48) { 1443c728a914STejun Heo tf.command = ATA_CMD_SET_MAX_EXT; 1444c728a914STejun Heo tf.flags |= ATA_TFLAG_LBA48; 14451e999736SAlan Cox 14461e999736SAlan Cox tf.hob_lbal = (new_sectors >> 24) & 0xff; 14471e999736SAlan Cox tf.hob_lbam = (new_sectors >> 32) & 0xff; 14481e999736SAlan Cox tf.hob_lbah = (new_sectors >> 40) & 0xff; 14491e582ba4STejun Heo } else { 14501e999736SAlan Cox tf.command = ATA_CMD_SET_MAX; 1451c728a914STejun Heo 14521e582ba4STejun Heo tf.device |= (new_sectors >> 24) & 0xf; 14531e582ba4STejun Heo } 14541e582ba4STejun Heo 14551e999736SAlan Cox tf.protocol |= ATA_PROT_NODATA; 1456c728a914STejun Heo tf.device |= ATA_LBA; 14571e999736SAlan Cox 14581e999736SAlan Cox tf.lbal = (new_sectors >> 0) & 0xff; 14591e999736SAlan Cox tf.lbam = (new_sectors >> 8) & 0xff; 14601e999736SAlan Cox tf.lbah = (new_sectors >> 16) & 0xff; 14611e999736SAlan Cox 14622b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 1463c728a914STejun Heo if (err_mask) { 1464c728a914STejun Heo ata_dev_printk(dev, KERN_WARNING, "failed to set " 1465c728a914STejun Heo "max address (err_mask=0x%x)\n", err_mask); 1466c728a914STejun Heo if (err_mask == AC_ERR_DEV && 1467c728a914STejun Heo (tf.feature & (ATA_ABORTED | ATA_IDNF))) 1468c728a914STejun Heo return -EACCES; 1469c728a914STejun Heo return -EIO; 1470c728a914STejun Heo } 1471c728a914STejun Heo 14721e999736SAlan Cox return 0; 14731e999736SAlan Cox } 14741e999736SAlan Cox 14751e999736SAlan Cox /** 14761e999736SAlan Cox * ata_hpa_resize - Resize a device with an HPA set 14771e999736SAlan Cox * @dev: Device to resize 14781e999736SAlan Cox * 14791e999736SAlan Cox * Read the size of an LBA28 or LBA48 disk with HPA features and resize 14801e999736SAlan Cox * it if required to the full size of the media. The caller must check 14811e999736SAlan Cox * the drive has the HPA feature set enabled. 148205027adcSTejun Heo * 148305027adcSTejun Heo * RETURNS: 148405027adcSTejun Heo * 0 on success, -errno on failure. 14851e999736SAlan Cox */ 148605027adcSTejun Heo static int ata_hpa_resize(struct ata_device *dev) 14871e999736SAlan Cox { 148805027adcSTejun Heo struct ata_eh_context *ehc = &dev->link->eh_context; 148905027adcSTejun Heo int print_info = ehc->i.flags & ATA_EHI_PRINTINFO; 149005027adcSTejun Heo u64 sectors = ata_id_n_sectors(dev->id); 149105027adcSTejun Heo u64 native_sectors; 1492c728a914STejun Heo int rc; 14931e999736SAlan Cox 149405027adcSTejun Heo /* do we need to do it? */ 149505027adcSTejun Heo if (dev->class != ATA_DEV_ATA || 149605027adcSTejun Heo !ata_id_has_lba(dev->id) || !ata_id_hpa_enabled(dev->id) || 149705027adcSTejun Heo (dev->horkage & ATA_HORKAGE_BROKEN_HPA)) 1498c728a914STejun Heo return 0; 14991e999736SAlan Cox 150005027adcSTejun Heo /* read native max address */ 150105027adcSTejun Heo rc = ata_read_native_max_address(dev, &native_sectors); 150205027adcSTejun Heo if (rc) { 1503dda7aba1STejun Heo /* If device aborted the command or HPA isn't going to 1504dda7aba1STejun Heo * be unlocked, skip HPA resizing. 150505027adcSTejun Heo */ 1506dda7aba1STejun Heo if (rc == -EACCES || !ata_ignore_hpa) { 150705027adcSTejun Heo ata_dev_printk(dev, KERN_WARNING, "HPA support seems " 1508dda7aba1STejun Heo "broken, skipping HPA handling\n"); 150905027adcSTejun Heo dev->horkage |= ATA_HORKAGE_BROKEN_HPA; 151005027adcSTejun Heo 151105027adcSTejun Heo /* we can continue if device aborted the command */ 151205027adcSTejun Heo if (rc == -EACCES) 151305027adcSTejun Heo rc = 0; 151405027adcSTejun Heo } 151505027adcSTejun Heo 151605027adcSTejun Heo return rc; 151705027adcSTejun Heo } 151805027adcSTejun Heo 151905027adcSTejun Heo /* nothing to do? */ 152005027adcSTejun Heo if (native_sectors <= sectors || !ata_ignore_hpa) { 152105027adcSTejun Heo if (!print_info || native_sectors == sectors) 152205027adcSTejun Heo return 0; 152305027adcSTejun Heo 152405027adcSTejun Heo if (native_sectors > sectors) 15251e999736SAlan Cox ata_dev_printk(dev, KERN_INFO, 152605027adcSTejun Heo "HPA detected: current %llu, native %llu\n", 152705027adcSTejun Heo (unsigned long long)sectors, 152805027adcSTejun Heo (unsigned long long)native_sectors); 152905027adcSTejun Heo else if (native_sectors < sectors) 153005027adcSTejun Heo ata_dev_printk(dev, KERN_WARNING, 153105027adcSTejun Heo "native sectors (%llu) is smaller than " 153205027adcSTejun Heo "sectors (%llu)\n", 153305027adcSTejun Heo (unsigned long long)native_sectors, 153405027adcSTejun Heo (unsigned long long)sectors); 153505027adcSTejun Heo return 0; 15361e999736SAlan Cox } 153737301a55STejun Heo 153805027adcSTejun Heo /* let's unlock HPA */ 153905027adcSTejun Heo rc = ata_set_max_sectors(dev, native_sectors); 154005027adcSTejun Heo if (rc == -EACCES) { 154105027adcSTejun Heo /* if device aborted the command, skip HPA resizing */ 154205027adcSTejun Heo ata_dev_printk(dev, KERN_WARNING, "device aborted resize " 154305027adcSTejun Heo "(%llu -> %llu), skipping HPA handling\n", 154405027adcSTejun Heo (unsigned long long)sectors, 154505027adcSTejun Heo (unsigned long long)native_sectors); 154605027adcSTejun Heo dev->horkage |= ATA_HORKAGE_BROKEN_HPA; 154705027adcSTejun Heo return 0; 154805027adcSTejun Heo } else if (rc) 154905027adcSTejun Heo return rc; 155005027adcSTejun Heo 155105027adcSTejun Heo /* re-read IDENTIFY data */ 155205027adcSTejun Heo rc = ata_dev_reread_id(dev, 0); 155305027adcSTejun Heo if (rc) { 155405027adcSTejun Heo ata_dev_printk(dev, KERN_ERR, "failed to re-read IDENTIFY " 155505027adcSTejun Heo "data after HPA resizing\n"); 155605027adcSTejun Heo return rc; 155705027adcSTejun Heo } 155805027adcSTejun Heo 155905027adcSTejun Heo if (print_info) { 156005027adcSTejun Heo u64 new_sectors = ata_id_n_sectors(dev->id); 156105027adcSTejun Heo ata_dev_printk(dev, KERN_INFO, 156205027adcSTejun Heo "HPA unlocked: %llu -> %llu, native %llu\n", 156305027adcSTejun Heo (unsigned long long)sectors, 156405027adcSTejun Heo (unsigned long long)new_sectors, 156505027adcSTejun Heo (unsigned long long)native_sectors); 156605027adcSTejun Heo } 156705027adcSTejun Heo 156805027adcSTejun Heo return 0; 15691e999736SAlan Cox } 15701e999736SAlan Cox 1571c6fd2807SJeff Garzik /** 1572c6fd2807SJeff Garzik * ata_dump_id - IDENTIFY DEVICE info debugging output 1573c6fd2807SJeff Garzik * @id: IDENTIFY DEVICE page to dump 1574c6fd2807SJeff Garzik * 1575c6fd2807SJeff Garzik * Dump selected 16-bit words from the given IDENTIFY DEVICE 1576c6fd2807SJeff Garzik * page. 1577c6fd2807SJeff Garzik * 1578c6fd2807SJeff Garzik * LOCKING: 1579c6fd2807SJeff Garzik * caller. 1580c6fd2807SJeff Garzik */ 1581c6fd2807SJeff Garzik 1582c6fd2807SJeff Garzik static inline void ata_dump_id(const u16 *id) 1583c6fd2807SJeff Garzik { 1584c6fd2807SJeff Garzik DPRINTK("49==0x%04x " 1585c6fd2807SJeff Garzik "53==0x%04x " 1586c6fd2807SJeff Garzik "63==0x%04x " 1587c6fd2807SJeff Garzik "64==0x%04x " 1588c6fd2807SJeff Garzik "75==0x%04x \n", 1589c6fd2807SJeff Garzik id[49], 1590c6fd2807SJeff Garzik id[53], 1591c6fd2807SJeff Garzik id[63], 1592c6fd2807SJeff Garzik id[64], 1593c6fd2807SJeff Garzik id[75]); 1594c6fd2807SJeff Garzik DPRINTK("80==0x%04x " 1595c6fd2807SJeff Garzik "81==0x%04x " 1596c6fd2807SJeff Garzik "82==0x%04x " 1597c6fd2807SJeff Garzik "83==0x%04x " 1598c6fd2807SJeff Garzik "84==0x%04x \n", 1599c6fd2807SJeff Garzik id[80], 1600c6fd2807SJeff Garzik id[81], 1601c6fd2807SJeff Garzik id[82], 1602c6fd2807SJeff Garzik id[83], 1603c6fd2807SJeff Garzik id[84]); 1604c6fd2807SJeff Garzik DPRINTK("88==0x%04x " 1605c6fd2807SJeff Garzik "93==0x%04x\n", 1606c6fd2807SJeff Garzik id[88], 1607c6fd2807SJeff Garzik id[93]); 1608c6fd2807SJeff Garzik } 1609c6fd2807SJeff Garzik 1610c6fd2807SJeff Garzik /** 1611c6fd2807SJeff Garzik * ata_id_xfermask - Compute xfermask from the given IDENTIFY data 1612c6fd2807SJeff Garzik * @id: IDENTIFY data to compute xfer mask from 1613c6fd2807SJeff Garzik * 1614c6fd2807SJeff Garzik * Compute the xfermask for this device. This is not as trivial 1615c6fd2807SJeff Garzik * as it seems if we must consider early devices correctly. 1616c6fd2807SJeff Garzik * 1617c6fd2807SJeff Garzik * FIXME: pre IDE drive timing (do we care ?). 1618c6fd2807SJeff Garzik * 1619c6fd2807SJeff Garzik * LOCKING: 1620c6fd2807SJeff Garzik * None. 1621c6fd2807SJeff Garzik * 1622c6fd2807SJeff Garzik * RETURNS: 1623c6fd2807SJeff Garzik * Computed xfermask 1624c6fd2807SJeff Garzik */ 16257dc951aeSTejun Heo unsigned long ata_id_xfermask(const u16 *id) 1626c6fd2807SJeff Garzik { 16277dc951aeSTejun Heo unsigned long pio_mask, mwdma_mask, udma_mask; 1628c6fd2807SJeff Garzik 1629c6fd2807SJeff Garzik /* Usual case. Word 53 indicates word 64 is valid */ 1630c6fd2807SJeff Garzik if (id[ATA_ID_FIELD_VALID] & (1 << 1)) { 1631c6fd2807SJeff Garzik pio_mask = id[ATA_ID_PIO_MODES] & 0x03; 1632c6fd2807SJeff Garzik pio_mask <<= 3; 1633c6fd2807SJeff Garzik pio_mask |= 0x7; 1634c6fd2807SJeff Garzik } else { 1635c6fd2807SJeff Garzik /* If word 64 isn't valid then Word 51 high byte holds 1636c6fd2807SJeff Garzik * the PIO timing number for the maximum. Turn it into 1637c6fd2807SJeff Garzik * a mask. 1638c6fd2807SJeff Garzik */ 16397a0f1c8aSLennert Buytenhek u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF; 164046767aebSAlan Cox if (mode < 5) /* Valid PIO range */ 164146767aebSAlan Cox pio_mask = (2 << mode) - 1; 164246767aebSAlan Cox else 164346767aebSAlan Cox pio_mask = 1; 1644c6fd2807SJeff Garzik 1645c6fd2807SJeff Garzik /* But wait.. there's more. Design your standards by 1646c6fd2807SJeff Garzik * committee and you too can get a free iordy field to 1647c6fd2807SJeff Garzik * process. However its the speeds not the modes that 1648c6fd2807SJeff Garzik * are supported... Note drivers using the timing API 1649c6fd2807SJeff Garzik * will get this right anyway 1650c6fd2807SJeff Garzik */ 1651c6fd2807SJeff Garzik } 1652c6fd2807SJeff Garzik 1653c6fd2807SJeff Garzik mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07; 1654c6fd2807SJeff Garzik 1655b352e57dSAlan Cox if (ata_id_is_cfa(id)) { 1656b352e57dSAlan Cox /* 1657b352e57dSAlan Cox * Process compact flash extended modes 1658b352e57dSAlan Cox */ 165962afe5d7SSergei Shtylyov int pio = (id[ATA_ID_CFA_MODES] >> 0) & 0x7; 166062afe5d7SSergei Shtylyov int dma = (id[ATA_ID_CFA_MODES] >> 3) & 0x7; 1661b352e57dSAlan Cox 1662b352e57dSAlan Cox if (pio) 1663b352e57dSAlan Cox pio_mask |= (1 << 5); 1664b352e57dSAlan Cox if (pio > 1) 1665b352e57dSAlan Cox pio_mask |= (1 << 6); 1666b352e57dSAlan Cox if (dma) 1667b352e57dSAlan Cox mwdma_mask |= (1 << 3); 1668b352e57dSAlan Cox if (dma > 1) 1669b352e57dSAlan Cox mwdma_mask |= (1 << 4); 1670b352e57dSAlan Cox } 1671b352e57dSAlan Cox 1672c6fd2807SJeff Garzik udma_mask = 0; 1673c6fd2807SJeff Garzik if (id[ATA_ID_FIELD_VALID] & (1 << 2)) 1674c6fd2807SJeff Garzik udma_mask = id[ATA_ID_UDMA_MODES] & 0xff; 1675c6fd2807SJeff Garzik 1676c6fd2807SJeff Garzik return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask); 1677c6fd2807SJeff Garzik } 1678c6fd2807SJeff Garzik 1679c6fd2807SJeff Garzik /** 1680442eacc3SJeff Garzik * ata_pio_queue_task - Queue port_task 1681c6fd2807SJeff Garzik * @ap: The ata_port to queue port_task for 168265f27f38SDavid Howells * @data: data for @fn to use 1683341c2c95STejun Heo * @delay: delay time in msecs for workqueue function 1684c6fd2807SJeff Garzik * 1685c6fd2807SJeff Garzik * Schedule @fn(@data) for execution after @delay jiffies using 1686c6fd2807SJeff Garzik * port_task. There is one port_task per port and it's the 1687c6fd2807SJeff Garzik * user(low level driver)'s responsibility to make sure that only 1688c6fd2807SJeff Garzik * one task is active at any given time. 1689c6fd2807SJeff Garzik * 1690c6fd2807SJeff Garzik * libata core layer takes care of synchronization between 1691442eacc3SJeff Garzik * port_task and EH. ata_pio_queue_task() may be ignored for EH 1692c6fd2807SJeff Garzik * synchronization. 1693c6fd2807SJeff Garzik * 1694c6fd2807SJeff Garzik * LOCKING: 1695c6fd2807SJeff Garzik * Inherited from caller. 1696c6fd2807SJeff Garzik */ 1697624d5c51STejun Heo void ata_pio_queue_task(struct ata_port *ap, void *data, unsigned long delay) 1698c6fd2807SJeff Garzik { 169965f27f38SDavid Howells ap->port_task_data = data; 1700c6fd2807SJeff Garzik 170145a66c1cSOleg Nesterov /* may fail if ata_port_flush_task() in progress */ 1702341c2c95STejun Heo queue_delayed_work(ata_wq, &ap->port_task, msecs_to_jiffies(delay)); 1703c6fd2807SJeff Garzik } 1704c6fd2807SJeff Garzik 1705c6fd2807SJeff Garzik /** 1706c6fd2807SJeff Garzik * ata_port_flush_task - Flush port_task 1707c6fd2807SJeff Garzik * @ap: The ata_port to flush port_task for 1708c6fd2807SJeff Garzik * 1709c6fd2807SJeff Garzik * After this function completes, port_task is guranteed not to 1710c6fd2807SJeff Garzik * be running or scheduled. 1711c6fd2807SJeff Garzik * 1712c6fd2807SJeff Garzik * LOCKING: 1713c6fd2807SJeff Garzik * Kernel thread context (may sleep) 1714c6fd2807SJeff Garzik */ 1715c6fd2807SJeff Garzik void ata_port_flush_task(struct ata_port *ap) 1716c6fd2807SJeff Garzik { 1717c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 1718c6fd2807SJeff Garzik 171945a66c1cSOleg Nesterov cancel_rearming_delayed_work(&ap->port_task); 1720c6fd2807SJeff Garzik 1721c6fd2807SJeff Garzik if (ata_msg_ctl(ap)) 17227f5e4e8dSHarvey Harrison ata_port_printk(ap, KERN_DEBUG, "%s: EXIT\n", __func__); 1723c6fd2807SJeff Garzik } 1724c6fd2807SJeff Garzik 17257102d230SAdrian Bunk static void ata_qc_complete_internal(struct ata_queued_cmd *qc) 1726c6fd2807SJeff Garzik { 1727c6fd2807SJeff Garzik struct completion *waiting = qc->private_data; 1728c6fd2807SJeff Garzik 1729c6fd2807SJeff Garzik complete(waiting); 1730c6fd2807SJeff Garzik } 1731c6fd2807SJeff Garzik 1732c6fd2807SJeff Garzik /** 17332432697bSTejun Heo * ata_exec_internal_sg - execute libata internal command 1734c6fd2807SJeff Garzik * @dev: Device to which the command is sent 1735c6fd2807SJeff Garzik * @tf: Taskfile registers for the command and the result 1736c6fd2807SJeff Garzik * @cdb: CDB for packet command 1737c6fd2807SJeff Garzik * @dma_dir: Data tranfer direction of the command 17385c1ad8b3SRandy Dunlap * @sgl: sg list for the data buffer of the command 17392432697bSTejun Heo * @n_elem: Number of sg entries 17402b789108STejun Heo * @timeout: Timeout in msecs (0 for default) 1741c6fd2807SJeff Garzik * 1742c6fd2807SJeff Garzik * Executes libata internal command with timeout. @tf contains 1743c6fd2807SJeff Garzik * command on entry and result on return. Timeout and error 1744c6fd2807SJeff Garzik * conditions are reported via return value. No recovery action 1745c6fd2807SJeff Garzik * is taken after a command times out. It's caller's duty to 1746c6fd2807SJeff Garzik * clean up after timeout. 1747c6fd2807SJeff Garzik * 1748c6fd2807SJeff Garzik * LOCKING: 1749c6fd2807SJeff Garzik * None. Should be called with kernel context, might sleep. 1750c6fd2807SJeff Garzik * 1751c6fd2807SJeff Garzik * RETURNS: 1752c6fd2807SJeff Garzik * Zero on success, AC_ERR_* mask on failure 1753c6fd2807SJeff Garzik */ 17542432697bSTejun Heo unsigned ata_exec_internal_sg(struct ata_device *dev, 1755c6fd2807SJeff Garzik struct ata_taskfile *tf, const u8 *cdb, 175687260216SJens Axboe int dma_dir, struct scatterlist *sgl, 17572b789108STejun Heo unsigned int n_elem, unsigned long timeout) 1758c6fd2807SJeff Garzik { 17599af5c9c9STejun Heo struct ata_link *link = dev->link; 17609af5c9c9STejun Heo struct ata_port *ap = link->ap; 1761c6fd2807SJeff Garzik u8 command = tf->command; 176287fbc5a0STejun Heo int auto_timeout = 0; 1763c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 1764c6fd2807SJeff Garzik unsigned int tag, preempted_tag; 1765c6fd2807SJeff Garzik u32 preempted_sactive, preempted_qc_active; 1766da917d69STejun Heo int preempted_nr_active_links; 1767c6fd2807SJeff Garzik DECLARE_COMPLETION_ONSTACK(wait); 1768c6fd2807SJeff Garzik unsigned long flags; 1769c6fd2807SJeff Garzik unsigned int err_mask; 1770c6fd2807SJeff Garzik int rc; 1771c6fd2807SJeff Garzik 1772c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1773c6fd2807SJeff Garzik 1774c6fd2807SJeff Garzik /* no internal command while frozen */ 1775c6fd2807SJeff Garzik if (ap->pflags & ATA_PFLAG_FROZEN) { 1776c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1777c6fd2807SJeff Garzik return AC_ERR_SYSTEM; 1778c6fd2807SJeff Garzik } 1779c6fd2807SJeff Garzik 1780c6fd2807SJeff Garzik /* initialize internal qc */ 1781c6fd2807SJeff Garzik 1782c6fd2807SJeff Garzik /* XXX: Tag 0 is used for drivers with legacy EH as some 1783c6fd2807SJeff Garzik * drivers choke if any other tag is given. This breaks 1784c6fd2807SJeff Garzik * ata_tag_internal() test for those drivers. Don't use new 1785c6fd2807SJeff Garzik * EH stuff without converting to it. 1786c6fd2807SJeff Garzik */ 1787c6fd2807SJeff Garzik if (ap->ops->error_handler) 1788c6fd2807SJeff Garzik tag = ATA_TAG_INTERNAL; 1789c6fd2807SJeff Garzik else 1790c6fd2807SJeff Garzik tag = 0; 1791c6fd2807SJeff Garzik 17928a8bc223STejun Heo if (test_and_set_bit(tag, &ap->qc_allocated)) 17938a8bc223STejun Heo BUG(); 1794c6fd2807SJeff Garzik qc = __ata_qc_from_tag(ap, tag); 1795c6fd2807SJeff Garzik 1796c6fd2807SJeff Garzik qc->tag = tag; 1797c6fd2807SJeff Garzik qc->scsicmd = NULL; 1798c6fd2807SJeff Garzik qc->ap = ap; 1799c6fd2807SJeff Garzik qc->dev = dev; 1800c6fd2807SJeff Garzik ata_qc_reinit(qc); 1801c6fd2807SJeff Garzik 18029af5c9c9STejun Heo preempted_tag = link->active_tag; 18039af5c9c9STejun Heo preempted_sactive = link->sactive; 1804c6fd2807SJeff Garzik preempted_qc_active = ap->qc_active; 1805da917d69STejun Heo preempted_nr_active_links = ap->nr_active_links; 18069af5c9c9STejun Heo link->active_tag = ATA_TAG_POISON; 18079af5c9c9STejun Heo link->sactive = 0; 1808c6fd2807SJeff Garzik ap->qc_active = 0; 1809da917d69STejun Heo ap->nr_active_links = 0; 1810c6fd2807SJeff Garzik 1811c6fd2807SJeff Garzik /* prepare & issue qc */ 1812c6fd2807SJeff Garzik qc->tf = *tf; 1813c6fd2807SJeff Garzik if (cdb) 1814c6fd2807SJeff Garzik memcpy(qc->cdb, cdb, ATAPI_CDB_LEN); 1815c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_RESULT_TF; 1816c6fd2807SJeff Garzik qc->dma_dir = dma_dir; 1817c6fd2807SJeff Garzik if (dma_dir != DMA_NONE) { 18182432697bSTejun Heo unsigned int i, buflen = 0; 181987260216SJens Axboe struct scatterlist *sg; 18202432697bSTejun Heo 182187260216SJens Axboe for_each_sg(sgl, sg, n_elem, i) 182287260216SJens Axboe buflen += sg->length; 18232432697bSTejun Heo 182487260216SJens Axboe ata_sg_init(qc, sgl, n_elem); 182549c80429SBrian King qc->nbytes = buflen; 1826c6fd2807SJeff Garzik } 1827c6fd2807SJeff Garzik 1828c6fd2807SJeff Garzik qc->private_data = &wait; 1829c6fd2807SJeff Garzik qc->complete_fn = ata_qc_complete_internal; 1830c6fd2807SJeff Garzik 1831c6fd2807SJeff Garzik ata_qc_issue(qc); 1832c6fd2807SJeff Garzik 1833c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1834c6fd2807SJeff Garzik 183587fbc5a0STejun Heo if (!timeout) { 183687fbc5a0STejun Heo if (ata_probe_timeout) 1837341c2c95STejun Heo timeout = ata_probe_timeout * 1000; 183887fbc5a0STejun Heo else { 183987fbc5a0STejun Heo timeout = ata_internal_cmd_timeout(dev, command); 184087fbc5a0STejun Heo auto_timeout = 1; 184187fbc5a0STejun Heo } 184287fbc5a0STejun Heo } 18432b789108STejun Heo 18442b789108STejun Heo rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout)); 1845c6fd2807SJeff Garzik 1846c6fd2807SJeff Garzik ata_port_flush_task(ap); 1847c6fd2807SJeff Garzik 1848c6fd2807SJeff Garzik if (!rc) { 1849c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1850c6fd2807SJeff Garzik 1851c6fd2807SJeff Garzik /* We're racing with irq here. If we lose, the 1852c6fd2807SJeff Garzik * following test prevents us from completing the qc 1853c6fd2807SJeff Garzik * twice. If we win, the port is frozen and will be 1854c6fd2807SJeff Garzik * cleaned up by ->post_internal_cmd(). 1855c6fd2807SJeff Garzik */ 1856c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_ACTIVE) { 1857c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_TIMEOUT; 1858c6fd2807SJeff Garzik 1859c6fd2807SJeff Garzik if (ap->ops->error_handler) 1860c6fd2807SJeff Garzik ata_port_freeze(ap); 1861c6fd2807SJeff Garzik else 1862c6fd2807SJeff Garzik ata_qc_complete(qc); 1863c6fd2807SJeff Garzik 1864c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 1865c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 1866c6fd2807SJeff Garzik "qc timeout (cmd 0x%x)\n", command); 1867c6fd2807SJeff Garzik } 1868c6fd2807SJeff Garzik 1869c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1870c6fd2807SJeff Garzik } 1871c6fd2807SJeff Garzik 1872c6fd2807SJeff Garzik /* do post_internal_cmd */ 1873c6fd2807SJeff Garzik if (ap->ops->post_internal_cmd) 1874c6fd2807SJeff Garzik ap->ops->post_internal_cmd(qc); 1875c6fd2807SJeff Garzik 1876a51d644aSTejun Heo /* perform minimal error analysis */ 1877a51d644aSTejun Heo if (qc->flags & ATA_QCFLAG_FAILED) { 1878a51d644aSTejun Heo if (qc->result_tf.command & (ATA_ERR | ATA_DF)) 1879a51d644aSTejun Heo qc->err_mask |= AC_ERR_DEV; 1880a51d644aSTejun Heo 1881a51d644aSTejun Heo if (!qc->err_mask) 1882c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_OTHER; 1883a51d644aSTejun Heo 1884a51d644aSTejun Heo if (qc->err_mask & ~AC_ERR_OTHER) 1885a51d644aSTejun Heo qc->err_mask &= ~AC_ERR_OTHER; 1886c6fd2807SJeff Garzik } 1887c6fd2807SJeff Garzik 1888c6fd2807SJeff Garzik /* finish up */ 1889c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1890c6fd2807SJeff Garzik 1891c6fd2807SJeff Garzik *tf = qc->result_tf; 1892c6fd2807SJeff Garzik err_mask = qc->err_mask; 1893c6fd2807SJeff Garzik 1894c6fd2807SJeff Garzik ata_qc_free(qc); 18959af5c9c9STejun Heo link->active_tag = preempted_tag; 18969af5c9c9STejun Heo link->sactive = preempted_sactive; 1897c6fd2807SJeff Garzik ap->qc_active = preempted_qc_active; 1898da917d69STejun Heo ap->nr_active_links = preempted_nr_active_links; 1899c6fd2807SJeff Garzik 1900c6fd2807SJeff Garzik /* XXX - Some LLDDs (sata_mv) disable port on command failure. 1901c6fd2807SJeff Garzik * Until those drivers are fixed, we detect the condition 1902c6fd2807SJeff Garzik * here, fail the command with AC_ERR_SYSTEM and reenable the 1903c6fd2807SJeff Garzik * port. 1904c6fd2807SJeff Garzik * 1905c6fd2807SJeff Garzik * Note that this doesn't change any behavior as internal 1906c6fd2807SJeff Garzik * command failure results in disabling the device in the 1907c6fd2807SJeff Garzik * higher layer for LLDDs without new reset/EH callbacks. 1908c6fd2807SJeff Garzik * 1909c6fd2807SJeff Garzik * Kill the following code as soon as those drivers are fixed. 1910c6fd2807SJeff Garzik */ 1911c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_DISABLED) { 1912c6fd2807SJeff Garzik err_mask |= AC_ERR_SYSTEM; 1913c6fd2807SJeff Garzik ata_port_probe(ap); 1914c6fd2807SJeff Garzik } 1915c6fd2807SJeff Garzik 1916c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1917c6fd2807SJeff Garzik 191887fbc5a0STejun Heo if ((err_mask & AC_ERR_TIMEOUT) && auto_timeout) 191987fbc5a0STejun Heo ata_internal_cmd_timed_out(dev, command); 192087fbc5a0STejun Heo 1921c6fd2807SJeff Garzik return err_mask; 1922c6fd2807SJeff Garzik } 1923c6fd2807SJeff Garzik 1924c6fd2807SJeff Garzik /** 192533480a0eSTejun Heo * ata_exec_internal - execute libata internal command 19262432697bSTejun Heo * @dev: Device to which the command is sent 19272432697bSTejun Heo * @tf: Taskfile registers for the command and the result 19282432697bSTejun Heo * @cdb: CDB for packet command 19292432697bSTejun Heo * @dma_dir: Data tranfer direction of the command 19302432697bSTejun Heo * @buf: Data buffer of the command 19312432697bSTejun Heo * @buflen: Length of data buffer 19322b789108STejun Heo * @timeout: Timeout in msecs (0 for default) 19332432697bSTejun Heo * 19342432697bSTejun Heo * Wrapper around ata_exec_internal_sg() which takes simple 19352432697bSTejun Heo * buffer instead of sg list. 19362432697bSTejun Heo * 19372432697bSTejun Heo * LOCKING: 19382432697bSTejun Heo * None. Should be called with kernel context, might sleep. 19392432697bSTejun Heo * 19402432697bSTejun Heo * RETURNS: 19412432697bSTejun Heo * Zero on success, AC_ERR_* mask on failure 19422432697bSTejun Heo */ 19432432697bSTejun Heo unsigned ata_exec_internal(struct ata_device *dev, 19442432697bSTejun Heo struct ata_taskfile *tf, const u8 *cdb, 19452b789108STejun Heo int dma_dir, void *buf, unsigned int buflen, 19462b789108STejun Heo unsigned long timeout) 19472432697bSTejun Heo { 194833480a0eSTejun Heo struct scatterlist *psg = NULL, sg; 194933480a0eSTejun Heo unsigned int n_elem = 0; 19502432697bSTejun Heo 195133480a0eSTejun Heo if (dma_dir != DMA_NONE) { 195233480a0eSTejun Heo WARN_ON(!buf); 19532432697bSTejun Heo sg_init_one(&sg, buf, buflen); 195433480a0eSTejun Heo psg = &sg; 195533480a0eSTejun Heo n_elem++; 195633480a0eSTejun Heo } 19572432697bSTejun Heo 19582b789108STejun Heo return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem, 19592b789108STejun Heo timeout); 19602432697bSTejun Heo } 19612432697bSTejun Heo 19622432697bSTejun Heo /** 1963c6fd2807SJeff Garzik * ata_do_simple_cmd - execute simple internal command 1964c6fd2807SJeff Garzik * @dev: Device to which the command is sent 1965c6fd2807SJeff Garzik * @cmd: Opcode to execute 1966c6fd2807SJeff Garzik * 1967c6fd2807SJeff Garzik * Execute a 'simple' command, that only consists of the opcode 1968c6fd2807SJeff Garzik * 'cmd' itself, without filling any other registers 1969c6fd2807SJeff Garzik * 1970c6fd2807SJeff Garzik * LOCKING: 1971c6fd2807SJeff Garzik * Kernel thread context (may sleep). 1972c6fd2807SJeff Garzik * 1973c6fd2807SJeff Garzik * RETURNS: 1974c6fd2807SJeff Garzik * Zero on success, AC_ERR_* mask on failure 1975c6fd2807SJeff Garzik */ 1976c6fd2807SJeff Garzik unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd) 1977c6fd2807SJeff Garzik { 1978c6fd2807SJeff Garzik struct ata_taskfile tf; 1979c6fd2807SJeff Garzik 1980c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 1981c6fd2807SJeff Garzik 1982c6fd2807SJeff Garzik tf.command = cmd; 1983c6fd2807SJeff Garzik tf.flags |= ATA_TFLAG_DEVICE; 1984c6fd2807SJeff Garzik tf.protocol = ATA_PROT_NODATA; 1985c6fd2807SJeff Garzik 19862b789108STejun Heo return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 1987c6fd2807SJeff Garzik } 1988c6fd2807SJeff Garzik 1989c6fd2807SJeff Garzik /** 1990c6fd2807SJeff Garzik * ata_pio_need_iordy - check if iordy needed 1991c6fd2807SJeff Garzik * @adev: ATA device 1992c6fd2807SJeff Garzik * 1993c6fd2807SJeff Garzik * Check if the current speed of the device requires IORDY. Used 1994c6fd2807SJeff Garzik * by various controllers for chip configuration. 1995c6fd2807SJeff Garzik */ 1996c6fd2807SJeff Garzik 1997c6fd2807SJeff Garzik unsigned int ata_pio_need_iordy(const struct ata_device *adev) 1998c6fd2807SJeff Garzik { 1999432729f0SAlan Cox /* Controller doesn't support IORDY. Probably a pointless check 2000432729f0SAlan Cox as the caller should know this */ 20019af5c9c9STejun Heo if (adev->link->ap->flags & ATA_FLAG_NO_IORDY) 2002c6fd2807SJeff Garzik return 0; 20035c18c4d2SDavid Daney /* CF spec. r4.1 Table 22 says no iordy on PIO5 and PIO6. */ 20045c18c4d2SDavid Daney if (ata_id_is_cfa(adev->id) 20055c18c4d2SDavid Daney && (adev->pio_mode == XFER_PIO_5 || adev->pio_mode == XFER_PIO_6)) 20065c18c4d2SDavid Daney return 0; 2007432729f0SAlan Cox /* PIO3 and higher it is mandatory */ 2008432729f0SAlan Cox if (adev->pio_mode > XFER_PIO_2) 2009c6fd2807SJeff Garzik return 1; 2010432729f0SAlan Cox /* We turn it on when possible */ 2011432729f0SAlan Cox if (ata_id_has_iordy(adev->id)) 2012432729f0SAlan Cox return 1; 2013432729f0SAlan Cox return 0; 2014432729f0SAlan Cox } 2015c6fd2807SJeff Garzik 2016432729f0SAlan Cox /** 2017432729f0SAlan Cox * ata_pio_mask_no_iordy - Return the non IORDY mask 2018432729f0SAlan Cox * @adev: ATA device 2019432729f0SAlan Cox * 2020432729f0SAlan Cox * Compute the highest mode possible if we are not using iordy. Return 2021432729f0SAlan Cox * -1 if no iordy mode is available. 2022432729f0SAlan Cox */ 2023432729f0SAlan Cox 2024432729f0SAlan Cox static u32 ata_pio_mask_no_iordy(const struct ata_device *adev) 2025432729f0SAlan Cox { 2026c6fd2807SJeff Garzik /* If we have no drive specific rule, then PIO 2 is non IORDY */ 2027c6fd2807SJeff Garzik if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */ 2028432729f0SAlan Cox u16 pio = adev->id[ATA_ID_EIDE_PIO]; 2029c6fd2807SJeff Garzik /* Is the speed faster than the drive allows non IORDY ? */ 2030c6fd2807SJeff Garzik if (pio) { 2031c6fd2807SJeff Garzik /* This is cycle times not frequency - watch the logic! */ 2032c6fd2807SJeff Garzik if (pio > 240) /* PIO2 is 240nS per cycle */ 2033432729f0SAlan Cox return 3 << ATA_SHIFT_PIO; 2034432729f0SAlan Cox return 7 << ATA_SHIFT_PIO; 2035c6fd2807SJeff Garzik } 2036c6fd2807SJeff Garzik } 2037432729f0SAlan Cox return 3 << ATA_SHIFT_PIO; 2038c6fd2807SJeff Garzik } 2039c6fd2807SJeff Garzik 2040c6fd2807SJeff Garzik /** 2041963e4975SAlan Cox * ata_do_dev_read_id - default ID read method 2042963e4975SAlan Cox * @dev: device 2043963e4975SAlan Cox * @tf: proposed taskfile 2044963e4975SAlan Cox * @id: data buffer 2045963e4975SAlan Cox * 2046963e4975SAlan Cox * Issue the identify taskfile and hand back the buffer containing 2047963e4975SAlan Cox * identify data. For some RAID controllers and for pre ATA devices 2048963e4975SAlan Cox * this function is wrapped or replaced by the driver 2049963e4975SAlan Cox */ 2050963e4975SAlan Cox unsigned int ata_do_dev_read_id(struct ata_device *dev, 2051963e4975SAlan Cox struct ata_taskfile *tf, u16 *id) 2052963e4975SAlan Cox { 2053963e4975SAlan Cox return ata_exec_internal(dev, tf, NULL, DMA_FROM_DEVICE, 2054963e4975SAlan Cox id, sizeof(id[0]) * ATA_ID_WORDS, 0); 2055963e4975SAlan Cox } 2056963e4975SAlan Cox 2057963e4975SAlan Cox /** 2058c6fd2807SJeff Garzik * ata_dev_read_id - Read ID data from the specified device 2059c6fd2807SJeff Garzik * @dev: target device 2060c6fd2807SJeff Garzik * @p_class: pointer to class of the target device (may be changed) 2061bff04647STejun Heo * @flags: ATA_READID_* flags 2062c6fd2807SJeff Garzik * @id: buffer to read IDENTIFY data into 2063c6fd2807SJeff Garzik * 2064c6fd2807SJeff Garzik * Read ID data from the specified device. ATA_CMD_ID_ATA is 2065c6fd2807SJeff Garzik * performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI 2066c6fd2807SJeff Garzik * devices. This function also issues ATA_CMD_INIT_DEV_PARAMS 2067c6fd2807SJeff Garzik * for pre-ATA4 drives. 2068c6fd2807SJeff Garzik * 206950a99018SAlan Cox * FIXME: ATA_CMD_ID_ATA is optional for early drives and right 207050a99018SAlan Cox * now we abort if we hit that case. 207150a99018SAlan Cox * 2072c6fd2807SJeff Garzik * LOCKING: 2073c6fd2807SJeff Garzik * Kernel thread context (may sleep) 2074c6fd2807SJeff Garzik * 2075c6fd2807SJeff Garzik * RETURNS: 2076c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 2077c6fd2807SJeff Garzik */ 2078c6fd2807SJeff Garzik int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class, 2079bff04647STejun Heo unsigned int flags, u16 *id) 2080c6fd2807SJeff Garzik { 20819af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 2082c6fd2807SJeff Garzik unsigned int class = *p_class; 2083c6fd2807SJeff Garzik struct ata_taskfile tf; 2084c6fd2807SJeff Garzik unsigned int err_mask = 0; 2085c6fd2807SJeff Garzik const char *reason; 208679b42babSTejun Heo bool is_semb = class == ATA_DEV_SEMB; 208754936f8bSTejun Heo int may_fallback = 1, tried_spinup = 0; 2088c6fd2807SJeff Garzik int rc; 2089c6fd2807SJeff Garzik 2090c6fd2807SJeff Garzik if (ata_msg_ctl(ap)) 20917f5e4e8dSHarvey Harrison ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __func__); 2092c6fd2807SJeff Garzik 2093c6fd2807SJeff Garzik retry: 2094c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 2095c6fd2807SJeff Garzik 2096c6fd2807SJeff Garzik switch (class) { 209779b42babSTejun Heo case ATA_DEV_SEMB: 209879b42babSTejun Heo class = ATA_DEV_ATA; /* some hard drives report SEMB sig */ 2099c6fd2807SJeff Garzik case ATA_DEV_ATA: 2100c6fd2807SJeff Garzik tf.command = ATA_CMD_ID_ATA; 2101c6fd2807SJeff Garzik break; 2102c6fd2807SJeff Garzik case ATA_DEV_ATAPI: 2103c6fd2807SJeff Garzik tf.command = ATA_CMD_ID_ATAPI; 2104c6fd2807SJeff Garzik break; 2105c6fd2807SJeff Garzik default: 2106c6fd2807SJeff Garzik rc = -ENODEV; 2107c6fd2807SJeff Garzik reason = "unsupported class"; 2108c6fd2807SJeff Garzik goto err_out; 2109c6fd2807SJeff Garzik } 2110c6fd2807SJeff Garzik 2111c6fd2807SJeff Garzik tf.protocol = ATA_PROT_PIO; 211281afe893STejun Heo 211381afe893STejun Heo /* Some devices choke if TF registers contain garbage. Make 211481afe893STejun Heo * sure those are properly initialized. 211581afe893STejun Heo */ 211681afe893STejun Heo tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 211781afe893STejun Heo 211881afe893STejun Heo /* Device presence detection is unreliable on some 211981afe893STejun Heo * controllers. Always poll IDENTIFY if available. 212081afe893STejun Heo */ 212181afe893STejun Heo tf.flags |= ATA_TFLAG_POLLING; 2122c6fd2807SJeff Garzik 2123963e4975SAlan Cox if (ap->ops->read_id) 2124963e4975SAlan Cox err_mask = ap->ops->read_id(dev, &tf, id); 2125963e4975SAlan Cox else 2126963e4975SAlan Cox err_mask = ata_do_dev_read_id(dev, &tf, id); 2127963e4975SAlan Cox 2128c6fd2807SJeff Garzik if (err_mask) { 2129800b3996STejun Heo if (err_mask & AC_ERR_NODEV_HINT) { 21301ffc151fSTejun Heo ata_dev_printk(dev, KERN_DEBUG, 21311ffc151fSTejun Heo "NODEV after polling detection\n"); 213255a8e2c8STejun Heo return -ENOENT; 213355a8e2c8STejun Heo } 213455a8e2c8STejun Heo 213579b42babSTejun Heo if (is_semb) { 213679b42babSTejun Heo ata_dev_printk(dev, KERN_INFO, "IDENTIFY failed on " 213779b42babSTejun Heo "device w/ SEMB sig, disabled\n"); 213879b42babSTejun Heo /* SEMB is not supported yet */ 213979b42babSTejun Heo *p_class = ATA_DEV_SEMB_UNSUP; 214079b42babSTejun Heo return 0; 214179b42babSTejun Heo } 214279b42babSTejun Heo 21431ffc151fSTejun Heo if ((err_mask == AC_ERR_DEV) && (tf.feature & ATA_ABORTED)) { 21441ffc151fSTejun Heo /* Device or controller might have reported 21451ffc151fSTejun Heo * the wrong device class. Give a shot at the 21461ffc151fSTejun Heo * other IDENTIFY if the current one is 21471ffc151fSTejun Heo * aborted by the device. 214854936f8bSTejun Heo */ 21491ffc151fSTejun Heo if (may_fallback) { 215054936f8bSTejun Heo may_fallback = 0; 215154936f8bSTejun Heo 215254936f8bSTejun Heo if (class == ATA_DEV_ATA) 215354936f8bSTejun Heo class = ATA_DEV_ATAPI; 215454936f8bSTejun Heo else 215554936f8bSTejun Heo class = ATA_DEV_ATA; 215654936f8bSTejun Heo goto retry; 215754936f8bSTejun Heo } 215854936f8bSTejun Heo 21591ffc151fSTejun Heo /* Control reaches here iff the device aborted 21601ffc151fSTejun Heo * both flavors of IDENTIFYs which happens 21611ffc151fSTejun Heo * sometimes with phantom devices. 21621ffc151fSTejun Heo */ 21631ffc151fSTejun Heo ata_dev_printk(dev, KERN_DEBUG, 21641ffc151fSTejun Heo "both IDENTIFYs aborted, assuming NODEV\n"); 21651ffc151fSTejun Heo return -ENOENT; 21661ffc151fSTejun Heo } 21671ffc151fSTejun Heo 2168c6fd2807SJeff Garzik rc = -EIO; 2169c6fd2807SJeff Garzik reason = "I/O error"; 2170c6fd2807SJeff Garzik goto err_out; 2171c6fd2807SJeff Garzik } 2172c6fd2807SJeff Garzik 217354936f8bSTejun Heo /* Falling back doesn't make sense if ID data was read 217454936f8bSTejun Heo * successfully at least once. 217554936f8bSTejun Heo */ 217654936f8bSTejun Heo may_fallback = 0; 217754936f8bSTejun Heo 2178c6fd2807SJeff Garzik swap_buf_le16(id, ATA_ID_WORDS); 2179c6fd2807SJeff Garzik 2180c6fd2807SJeff Garzik /* sanity check */ 2181c6fd2807SJeff Garzik rc = -EINVAL; 21826070068bSAlan Cox reason = "device reports invalid type"; 21834a3381feSJeff Garzik 21844a3381feSJeff Garzik if (class == ATA_DEV_ATA) { 21854a3381feSJeff Garzik if (!ata_id_is_ata(id) && !ata_id_is_cfa(id)) 21864a3381feSJeff Garzik goto err_out; 21874a3381feSJeff Garzik } else { 21884a3381feSJeff Garzik if (ata_id_is_ata(id)) 2189c6fd2807SJeff Garzik goto err_out; 2190c6fd2807SJeff Garzik } 2191c6fd2807SJeff Garzik 2192169439c2SMark Lord if (!tried_spinup && (id[2] == 0x37c8 || id[2] == 0x738c)) { 2193169439c2SMark Lord tried_spinup = 1; 2194169439c2SMark Lord /* 2195169439c2SMark Lord * Drive powered-up in standby mode, and requires a specific 2196169439c2SMark Lord * SET_FEATURES spin-up subcommand before it will accept 2197169439c2SMark Lord * anything other than the original IDENTIFY command. 2198169439c2SMark Lord */ 2199218f3d30SJeff Garzik err_mask = ata_dev_set_feature(dev, SETFEATURES_SPINUP, 0); 2200fb0582f9SRyan Power if (err_mask && id[2] != 0x738c) { 2201169439c2SMark Lord rc = -EIO; 2202169439c2SMark Lord reason = "SPINUP failed"; 2203169439c2SMark Lord goto err_out; 2204169439c2SMark Lord } 2205169439c2SMark Lord /* 2206169439c2SMark Lord * If the drive initially returned incomplete IDENTIFY info, 2207169439c2SMark Lord * we now must reissue the IDENTIFY command. 2208169439c2SMark Lord */ 2209169439c2SMark Lord if (id[2] == 0x37c8) 2210169439c2SMark Lord goto retry; 2211169439c2SMark Lord } 2212169439c2SMark Lord 2213bff04647STejun Heo if ((flags & ATA_READID_POSTRESET) && class == ATA_DEV_ATA) { 2214c6fd2807SJeff Garzik /* 2215c6fd2807SJeff Garzik * The exact sequence expected by certain pre-ATA4 drives is: 2216c6fd2807SJeff Garzik * SRST RESET 221750a99018SAlan Cox * IDENTIFY (optional in early ATA) 221850a99018SAlan Cox * INITIALIZE DEVICE PARAMETERS (later IDE and ATA) 2219c6fd2807SJeff Garzik * anything else.. 2220c6fd2807SJeff Garzik * Some drives were very specific about that exact sequence. 222150a99018SAlan Cox * 222250a99018SAlan Cox * Note that ATA4 says lba is mandatory so the second check 222350a99018SAlan Cox * shoud never trigger. 2224c6fd2807SJeff Garzik */ 2225c6fd2807SJeff Garzik if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) { 2226c6fd2807SJeff Garzik err_mask = ata_dev_init_params(dev, id[3], id[6]); 2227c6fd2807SJeff Garzik if (err_mask) { 2228c6fd2807SJeff Garzik rc = -EIO; 2229c6fd2807SJeff Garzik reason = "INIT_DEV_PARAMS failed"; 2230c6fd2807SJeff Garzik goto err_out; 2231c6fd2807SJeff Garzik } 2232c6fd2807SJeff Garzik 2233c6fd2807SJeff Garzik /* current CHS translation info (id[53-58]) might be 2234c6fd2807SJeff Garzik * changed. reread the identify device info. 2235c6fd2807SJeff Garzik */ 2236bff04647STejun Heo flags &= ~ATA_READID_POSTRESET; 2237c6fd2807SJeff Garzik goto retry; 2238c6fd2807SJeff Garzik } 2239c6fd2807SJeff Garzik } 2240c6fd2807SJeff Garzik 2241c6fd2807SJeff Garzik *p_class = class; 2242c6fd2807SJeff Garzik 2243c6fd2807SJeff Garzik return 0; 2244c6fd2807SJeff Garzik 2245c6fd2807SJeff Garzik err_out: 2246c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 2247c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "failed to IDENTIFY " 2248c6fd2807SJeff Garzik "(%s, err_mask=0x%x)\n", reason, err_mask); 2249c6fd2807SJeff Garzik return rc; 2250c6fd2807SJeff Garzik } 2251c6fd2807SJeff Garzik 22529062712fSTejun Heo static int ata_do_link_spd_horkage(struct ata_device *dev) 22539062712fSTejun Heo { 22549062712fSTejun Heo struct ata_link *plink = ata_dev_phys_link(dev); 22559062712fSTejun Heo u32 target, target_limit; 22569062712fSTejun Heo 22579062712fSTejun Heo if (!sata_scr_valid(plink)) 22589062712fSTejun Heo return 0; 22599062712fSTejun Heo 22609062712fSTejun Heo if (dev->horkage & ATA_HORKAGE_1_5_GBPS) 22619062712fSTejun Heo target = 1; 22629062712fSTejun Heo else 22639062712fSTejun Heo return 0; 22649062712fSTejun Heo 22659062712fSTejun Heo target_limit = (1 << target) - 1; 22669062712fSTejun Heo 22679062712fSTejun Heo /* if already on stricter limit, no need to push further */ 22689062712fSTejun Heo if (plink->sata_spd_limit <= target_limit) 22699062712fSTejun Heo return 0; 22709062712fSTejun Heo 22719062712fSTejun Heo plink->sata_spd_limit = target_limit; 22729062712fSTejun Heo 22739062712fSTejun Heo /* Request another EH round by returning -EAGAIN if link is 22749062712fSTejun Heo * going faster than the target speed. Forward progress is 22759062712fSTejun Heo * guaranteed by setting sata_spd_limit to target_limit above. 22769062712fSTejun Heo */ 22779062712fSTejun Heo if (plink->sata_spd > target) { 22789062712fSTejun Heo ata_dev_printk(dev, KERN_INFO, 22799062712fSTejun Heo "applying link speed limit horkage to %s\n", 22809062712fSTejun Heo sata_spd_string(target)); 22819062712fSTejun Heo return -EAGAIN; 22829062712fSTejun Heo } 22839062712fSTejun Heo return 0; 22849062712fSTejun Heo } 22859062712fSTejun Heo 2286c6fd2807SJeff Garzik static inline u8 ata_dev_knobble(struct ata_device *dev) 2287c6fd2807SJeff Garzik { 22889af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 22899ce8e307SJens Axboe 22909ce8e307SJens Axboe if (ata_dev_blacklisted(dev) & ATA_HORKAGE_BRIDGE_OK) 22919ce8e307SJens Axboe return 0; 22929ce8e307SJens Axboe 22939af5c9c9STejun Heo return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id))); 2294c6fd2807SJeff Garzik } 2295c6fd2807SJeff Garzik 2296c6fd2807SJeff Garzik static void ata_dev_config_ncq(struct ata_device *dev, 2297c6fd2807SJeff Garzik char *desc, size_t desc_sz) 2298c6fd2807SJeff Garzik { 22999af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 2300c6fd2807SJeff Garzik int hdepth = 0, ddepth = ata_id_queue_depth(dev->id); 2301c6fd2807SJeff Garzik 2302c6fd2807SJeff Garzik if (!ata_id_has_ncq(dev->id)) { 2303c6fd2807SJeff Garzik desc[0] = '\0'; 2304c6fd2807SJeff Garzik return; 2305c6fd2807SJeff Garzik } 230675683fe7STejun Heo if (dev->horkage & ATA_HORKAGE_NONCQ) { 23076919a0a6SAlan Cox snprintf(desc, desc_sz, "NCQ (not used)"); 23086919a0a6SAlan Cox return; 23096919a0a6SAlan Cox } 2310c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_NCQ) { 2311cca3974eSJeff Garzik hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE - 1); 2312c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_NCQ; 2313c6fd2807SJeff Garzik } 2314c6fd2807SJeff Garzik 2315c6fd2807SJeff Garzik if (hdepth >= ddepth) 2316c6fd2807SJeff Garzik snprintf(desc, desc_sz, "NCQ (depth %d)", ddepth); 2317c6fd2807SJeff Garzik else 2318c6fd2807SJeff Garzik snprintf(desc, desc_sz, "NCQ (depth %d/%d)", hdepth, ddepth); 2319c6fd2807SJeff Garzik } 2320c6fd2807SJeff Garzik 2321c6fd2807SJeff Garzik /** 2322c6fd2807SJeff Garzik * ata_dev_configure - Configure the specified ATA/ATAPI device 2323c6fd2807SJeff Garzik * @dev: Target device to configure 2324c6fd2807SJeff Garzik * 2325c6fd2807SJeff Garzik * Configure @dev according to @dev->id. Generic and low-level 2326c6fd2807SJeff Garzik * driver specific fixups are also applied. 2327c6fd2807SJeff Garzik * 2328c6fd2807SJeff Garzik * LOCKING: 2329c6fd2807SJeff Garzik * Kernel thread context (may sleep) 2330c6fd2807SJeff Garzik * 2331c6fd2807SJeff Garzik * RETURNS: 2332c6fd2807SJeff Garzik * 0 on success, -errno otherwise 2333c6fd2807SJeff Garzik */ 2334efdaedc4STejun Heo int ata_dev_configure(struct ata_device *dev) 2335c6fd2807SJeff Garzik { 23369af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 23379af5c9c9STejun Heo struct ata_eh_context *ehc = &dev->link->eh_context; 23386746544cSTejun Heo int print_info = ehc->i.flags & ATA_EHI_PRINTINFO; 2339c6fd2807SJeff Garzik const u16 *id = dev->id; 23407dc951aeSTejun Heo unsigned long xfer_mask; 2341b352e57dSAlan Cox char revbuf[7]; /* XYZ-99\0 */ 23423f64f565SEric D. Mudama char fwrevbuf[ATA_ID_FW_REV_LEN+1]; 23433f64f565SEric D. Mudama char modelbuf[ATA_ID_PROD_LEN+1]; 2344c6fd2807SJeff Garzik int rc; 2345c6fd2807SJeff Garzik 2346c6fd2807SJeff Garzik if (!ata_dev_enabled(dev) && ata_msg_info(ap)) { 234744877b4eSTejun Heo ata_dev_printk(dev, KERN_INFO, "%s: ENTER/EXIT -- nodev\n", 23487f5e4e8dSHarvey Harrison __func__); 2349c6fd2807SJeff Garzik return 0; 2350c6fd2807SJeff Garzik } 2351c6fd2807SJeff Garzik 2352c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 23537f5e4e8dSHarvey Harrison ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __func__); 2354c6fd2807SJeff Garzik 235575683fe7STejun Heo /* set horkage */ 235675683fe7STejun Heo dev->horkage |= ata_dev_blacklisted(dev); 235733267325STejun Heo ata_force_horkage(dev); 235875683fe7STejun Heo 235950af2fa1STejun Heo if (dev->horkage & ATA_HORKAGE_DISABLE) { 236050af2fa1STejun Heo ata_dev_printk(dev, KERN_INFO, 236150af2fa1STejun Heo "unsupported device, disabling\n"); 236250af2fa1STejun Heo ata_dev_disable(dev); 236350af2fa1STejun Heo return 0; 236450af2fa1STejun Heo } 236550af2fa1STejun Heo 23662486fa56STejun Heo if ((!atapi_enabled || (ap->flags & ATA_FLAG_NO_ATAPI)) && 23672486fa56STejun Heo dev->class == ATA_DEV_ATAPI) { 23682486fa56STejun Heo ata_dev_printk(dev, KERN_WARNING, 23692486fa56STejun Heo "WARNING: ATAPI is %s, device ignored.\n", 23702486fa56STejun Heo atapi_enabled ? "not supported with this driver" 23712486fa56STejun Heo : "disabled"); 23722486fa56STejun Heo ata_dev_disable(dev); 23732486fa56STejun Heo return 0; 23742486fa56STejun Heo } 23752486fa56STejun Heo 23769062712fSTejun Heo rc = ata_do_link_spd_horkage(dev); 23779062712fSTejun Heo if (rc) 23789062712fSTejun Heo return rc; 23799062712fSTejun Heo 23806746544cSTejun Heo /* let ACPI work its magic */ 23816746544cSTejun Heo rc = ata_acpi_on_devcfg(dev); 23826746544cSTejun Heo if (rc) 23836746544cSTejun Heo return rc; 238408573a86SKristen Carlson Accardi 238505027adcSTejun Heo /* massage HPA, do it early as it might change IDENTIFY data */ 238605027adcSTejun Heo rc = ata_hpa_resize(dev); 238705027adcSTejun Heo if (rc) 238805027adcSTejun Heo return rc; 238905027adcSTejun Heo 2390c6fd2807SJeff Garzik /* print device capabilities */ 2391c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 2392c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_DEBUG, 2393c6fd2807SJeff Garzik "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x " 2394c6fd2807SJeff Garzik "85:%04x 86:%04x 87:%04x 88:%04x\n", 23957f5e4e8dSHarvey Harrison __func__, 2396c6fd2807SJeff Garzik id[49], id[82], id[83], id[84], 2397c6fd2807SJeff Garzik id[85], id[86], id[87], id[88]); 2398c6fd2807SJeff Garzik 2399c6fd2807SJeff Garzik /* initialize to-be-configured parameters */ 2400c6fd2807SJeff Garzik dev->flags &= ~ATA_DFLAG_CFG_MASK; 2401c6fd2807SJeff Garzik dev->max_sectors = 0; 2402c6fd2807SJeff Garzik dev->cdb_len = 0; 2403c6fd2807SJeff Garzik dev->n_sectors = 0; 2404c6fd2807SJeff Garzik dev->cylinders = 0; 2405c6fd2807SJeff Garzik dev->heads = 0; 2406c6fd2807SJeff Garzik dev->sectors = 0; 2407e18086d6SMark Lord dev->multi_count = 0; 2408c6fd2807SJeff Garzik 2409c6fd2807SJeff Garzik /* 2410c6fd2807SJeff Garzik * common ATA, ATAPI feature tests 2411c6fd2807SJeff Garzik */ 2412c6fd2807SJeff Garzik 2413c6fd2807SJeff Garzik /* find max transfer mode; for printk only */ 2414c6fd2807SJeff Garzik xfer_mask = ata_id_xfermask(id); 2415c6fd2807SJeff Garzik 2416c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 2417c6fd2807SJeff Garzik ata_dump_id(id); 2418c6fd2807SJeff Garzik 2419ef143d57SAlbert Lee /* SCSI only uses 4-char revisions, dump full 8 chars from ATA */ 2420ef143d57SAlbert Lee ata_id_c_string(dev->id, fwrevbuf, ATA_ID_FW_REV, 2421ef143d57SAlbert Lee sizeof(fwrevbuf)); 2422ef143d57SAlbert Lee 2423ef143d57SAlbert Lee ata_id_c_string(dev->id, modelbuf, ATA_ID_PROD, 2424ef143d57SAlbert Lee sizeof(modelbuf)); 2425ef143d57SAlbert Lee 2426c6fd2807SJeff Garzik /* ATA-specific feature tests */ 2427c6fd2807SJeff Garzik if (dev->class == ATA_DEV_ATA) { 2428b352e57dSAlan Cox if (ata_id_is_cfa(id)) { 242962afe5d7SSergei Shtylyov /* CPRM may make this media unusable */ 243062afe5d7SSergei Shtylyov if (id[ATA_ID_CFA_KEY_MGMT] & 1) 243144877b4eSTejun Heo ata_dev_printk(dev, KERN_WARNING, 243244877b4eSTejun Heo "supports DRM functions and may " 243344877b4eSTejun Heo "not be fully accessable.\n"); 2434b352e57dSAlan Cox snprintf(revbuf, 7, "CFA"); 2435ae8d4ee7SAlan Cox } else { 2436b352e57dSAlan Cox snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id)); 2437ae8d4ee7SAlan Cox /* Warn the user if the device has TPM extensions */ 2438ae8d4ee7SAlan Cox if (ata_id_has_tpm(id)) 2439ae8d4ee7SAlan Cox ata_dev_printk(dev, KERN_WARNING, 2440ae8d4ee7SAlan Cox "supports DRM functions and may " 2441ae8d4ee7SAlan Cox "not be fully accessable.\n"); 2442ae8d4ee7SAlan Cox } 2443b352e57dSAlan Cox 2444c6fd2807SJeff Garzik dev->n_sectors = ata_id_n_sectors(id); 2445c6fd2807SJeff Garzik 2446e18086d6SMark Lord /* get current R/W Multiple count setting */ 2447e18086d6SMark Lord if ((dev->id[47] >> 8) == 0x80 && (dev->id[59] & 0x100)) { 2448e18086d6SMark Lord unsigned int max = dev->id[47] & 0xff; 2449e18086d6SMark Lord unsigned int cnt = dev->id[59] & 0xff; 2450e18086d6SMark Lord /* only recognize/allow powers of two here */ 2451e18086d6SMark Lord if (is_power_of_2(max) && is_power_of_2(cnt)) 2452e18086d6SMark Lord if (cnt <= max) 2453e18086d6SMark Lord dev->multi_count = cnt; 2454e18086d6SMark Lord } 24553f64f565SEric D. Mudama 2456c6fd2807SJeff Garzik if (ata_id_has_lba(id)) { 2457c6fd2807SJeff Garzik const char *lba_desc; 2458c6fd2807SJeff Garzik char ncq_desc[20]; 2459c6fd2807SJeff Garzik 2460c6fd2807SJeff Garzik lba_desc = "LBA"; 2461c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_LBA; 2462c6fd2807SJeff Garzik if (ata_id_has_lba48(id)) { 2463c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_LBA48; 2464c6fd2807SJeff Garzik lba_desc = "LBA48"; 24656fc49adbSTejun Heo 24666fc49adbSTejun Heo if (dev->n_sectors >= (1UL << 28) && 24676fc49adbSTejun Heo ata_id_has_flush_ext(id)) 24686fc49adbSTejun Heo dev->flags |= ATA_DFLAG_FLUSH_EXT; 2469c6fd2807SJeff Garzik } 2470c6fd2807SJeff Garzik 2471c6fd2807SJeff Garzik /* config NCQ */ 2472c6fd2807SJeff Garzik ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc)); 2473c6fd2807SJeff Garzik 2474c6fd2807SJeff Garzik /* print device info to dmesg */ 24753f64f565SEric D. Mudama if (ata_msg_drv(ap) && print_info) { 24763f64f565SEric D. Mudama ata_dev_printk(dev, KERN_INFO, 24773f64f565SEric D. Mudama "%s: %s, %s, max %s\n", 24783f64f565SEric D. Mudama revbuf, modelbuf, fwrevbuf, 24793f64f565SEric D. Mudama ata_mode_string(xfer_mask)); 24803f64f565SEric D. Mudama ata_dev_printk(dev, KERN_INFO, 24813f64f565SEric D. Mudama "%Lu sectors, multi %u: %s %s\n", 2482c6fd2807SJeff Garzik (unsigned long long)dev->n_sectors, 24833f64f565SEric D. Mudama dev->multi_count, lba_desc, ncq_desc); 24843f64f565SEric D. Mudama } 2485c6fd2807SJeff Garzik } else { 2486c6fd2807SJeff Garzik /* CHS */ 2487c6fd2807SJeff Garzik 2488c6fd2807SJeff Garzik /* Default translation */ 2489c6fd2807SJeff Garzik dev->cylinders = id[1]; 2490c6fd2807SJeff Garzik dev->heads = id[3]; 2491c6fd2807SJeff Garzik dev->sectors = id[6]; 2492c6fd2807SJeff Garzik 2493c6fd2807SJeff Garzik if (ata_id_current_chs_valid(id)) { 2494c6fd2807SJeff Garzik /* Current CHS translation is valid. */ 2495c6fd2807SJeff Garzik dev->cylinders = id[54]; 2496c6fd2807SJeff Garzik dev->heads = id[55]; 2497c6fd2807SJeff Garzik dev->sectors = id[56]; 2498c6fd2807SJeff Garzik } 2499c6fd2807SJeff Garzik 2500c6fd2807SJeff Garzik /* print device info to dmesg */ 25013f64f565SEric D. Mudama if (ata_msg_drv(ap) && print_info) { 2502c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, 25033f64f565SEric D. Mudama "%s: %s, %s, max %s\n", 25043f64f565SEric D. Mudama revbuf, modelbuf, fwrevbuf, 25053f64f565SEric D. Mudama ata_mode_string(xfer_mask)); 25063f64f565SEric D. Mudama ata_dev_printk(dev, KERN_INFO, 25073f64f565SEric D. Mudama "%Lu sectors, multi %u, CHS %u/%u/%u\n", 25083f64f565SEric D. Mudama (unsigned long long)dev->n_sectors, 25093f64f565SEric D. Mudama dev->multi_count, dev->cylinders, 25103f64f565SEric D. Mudama dev->heads, dev->sectors); 25113f64f565SEric D. Mudama } 2512c6fd2807SJeff Garzik } 2513c6fd2807SJeff Garzik 2514c6fd2807SJeff Garzik dev->cdb_len = 16; 2515c6fd2807SJeff Garzik } 2516c6fd2807SJeff Garzik 2517c6fd2807SJeff Garzik /* ATAPI-specific feature tests */ 2518c6fd2807SJeff Garzik else if (dev->class == ATA_DEV_ATAPI) { 2519854c73a2STejun Heo const char *cdb_intr_string = ""; 2520854c73a2STejun Heo const char *atapi_an_string = ""; 252191163006STejun Heo const char *dma_dir_string = ""; 25227d77b247STejun Heo u32 sntf; 2523c6fd2807SJeff Garzik 2524c6fd2807SJeff Garzik rc = atapi_cdb_len(id); 2525c6fd2807SJeff Garzik if ((rc < 12) || (rc > ATAPI_CDB_LEN)) { 2526c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 2527c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 2528c6fd2807SJeff Garzik "unsupported CDB len\n"); 2529c6fd2807SJeff Garzik rc = -EINVAL; 2530c6fd2807SJeff Garzik goto err_out_nosup; 2531c6fd2807SJeff Garzik } 2532c6fd2807SJeff Garzik dev->cdb_len = (unsigned int) rc; 2533c6fd2807SJeff Garzik 25347d77b247STejun Heo /* Enable ATAPI AN if both the host and device have 25357d77b247STejun Heo * the support. If PMP is attached, SNTF is required 25367d77b247STejun Heo * to enable ATAPI AN to discern between PHY status 25377d77b247STejun Heo * changed notifications and ATAPI ANs. 25389f45cbd3SKristen Carlson Accardi */ 25397d77b247STejun Heo if ((ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) && 2540071f44b1STejun Heo (!sata_pmp_attached(ap) || 25417d77b247STejun Heo sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) { 2542854c73a2STejun Heo unsigned int err_mask; 2543854c73a2STejun Heo 25449f45cbd3SKristen Carlson Accardi /* issue SET feature command to turn this on */ 2545218f3d30SJeff Garzik err_mask = ata_dev_set_feature(dev, 2546218f3d30SJeff Garzik SETFEATURES_SATA_ENABLE, SATA_AN); 2547854c73a2STejun Heo if (err_mask) 25489f45cbd3SKristen Carlson Accardi ata_dev_printk(dev, KERN_ERR, 2549854c73a2STejun Heo "failed to enable ATAPI AN " 2550854c73a2STejun Heo "(err_mask=0x%x)\n", err_mask); 2551854c73a2STejun Heo else { 25529f45cbd3SKristen Carlson Accardi dev->flags |= ATA_DFLAG_AN; 2553854c73a2STejun Heo atapi_an_string = ", ATAPI AN"; 2554854c73a2STejun Heo } 25559f45cbd3SKristen Carlson Accardi } 25569f45cbd3SKristen Carlson Accardi 2557c6fd2807SJeff Garzik if (ata_id_cdb_intr(dev->id)) { 2558c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_CDB_INTR; 2559c6fd2807SJeff Garzik cdb_intr_string = ", CDB intr"; 2560c6fd2807SJeff Garzik } 2561c6fd2807SJeff Garzik 256291163006STejun Heo if (atapi_dmadir || atapi_id_dmadir(dev->id)) { 256391163006STejun Heo dev->flags |= ATA_DFLAG_DMADIR; 256491163006STejun Heo dma_dir_string = ", DMADIR"; 256591163006STejun Heo } 256691163006STejun Heo 2567c6fd2807SJeff Garzik /* print device info to dmesg */ 2568c6fd2807SJeff Garzik if (ata_msg_drv(ap) && print_info) 2569ef143d57SAlbert Lee ata_dev_printk(dev, KERN_INFO, 257091163006STejun Heo "ATAPI: %s, %s, max %s%s%s%s\n", 2571ef143d57SAlbert Lee modelbuf, fwrevbuf, 2572c6fd2807SJeff Garzik ata_mode_string(xfer_mask), 257391163006STejun Heo cdb_intr_string, atapi_an_string, 257491163006STejun Heo dma_dir_string); 2575c6fd2807SJeff Garzik } 2576c6fd2807SJeff Garzik 2577914ed354STejun Heo /* determine max_sectors */ 2578914ed354STejun Heo dev->max_sectors = ATA_MAX_SECTORS; 2579914ed354STejun Heo if (dev->flags & ATA_DFLAG_LBA48) 2580914ed354STejun Heo dev->max_sectors = ATA_MAX_SECTORS_LBA48; 2581914ed354STejun Heo 2582ca77329fSKristen Carlson Accardi if (!(dev->horkage & ATA_HORKAGE_IPM)) { 2583ca77329fSKristen Carlson Accardi if (ata_id_has_hipm(dev->id)) 2584ca77329fSKristen Carlson Accardi dev->flags |= ATA_DFLAG_HIPM; 2585ca77329fSKristen Carlson Accardi if (ata_id_has_dipm(dev->id)) 2586ca77329fSKristen Carlson Accardi dev->flags |= ATA_DFLAG_DIPM; 2587ca77329fSKristen Carlson Accardi } 2588ca77329fSKristen Carlson Accardi 2589c5038fc0SAlan Cox /* Limit PATA drive on SATA cable bridge transfers to udma5, 2590c5038fc0SAlan Cox 200 sectors */ 2591c6fd2807SJeff Garzik if (ata_dev_knobble(dev)) { 2592c6fd2807SJeff Garzik if (ata_msg_drv(ap) && print_info) 2593c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, 2594c6fd2807SJeff Garzik "applying bridge limits\n"); 2595c6fd2807SJeff Garzik dev->udma_mask &= ATA_UDMA5; 2596c6fd2807SJeff Garzik dev->max_sectors = ATA_MAX_SECTORS; 2597c6fd2807SJeff Garzik } 2598c6fd2807SJeff Garzik 2599f8d8e579STony Battersby if ((dev->class == ATA_DEV_ATAPI) && 2600f442cd86SAlbert Lee (atapi_command_packet_set(id) == TYPE_TAPE)) { 2601f8d8e579STony Battersby dev->max_sectors = ATA_MAX_SECTORS_TAPE; 2602f442cd86SAlbert Lee dev->horkage |= ATA_HORKAGE_STUCK_ERR; 2603f442cd86SAlbert Lee } 2604f8d8e579STony Battersby 260575683fe7STejun Heo if (dev->horkage & ATA_HORKAGE_MAX_SEC_128) 260603ec52deSTejun Heo dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128, 260703ec52deSTejun Heo dev->max_sectors); 260818d6e9d5SAlbert Lee 2609ca77329fSKristen Carlson Accardi if (ata_dev_blacklisted(dev) & ATA_HORKAGE_IPM) { 2610ca77329fSKristen Carlson Accardi dev->horkage |= ATA_HORKAGE_IPM; 2611ca77329fSKristen Carlson Accardi 2612ca77329fSKristen Carlson Accardi /* reset link pm_policy for this port to no pm */ 2613ca77329fSKristen Carlson Accardi ap->pm_policy = MAX_PERFORMANCE; 2614ca77329fSKristen Carlson Accardi } 2615ca77329fSKristen Carlson Accardi 2616c6fd2807SJeff Garzik if (ap->ops->dev_config) 2617cd0d3bbcSAlan ap->ops->dev_config(dev); 2618c6fd2807SJeff Garzik 2619c5038fc0SAlan Cox if (dev->horkage & ATA_HORKAGE_DIAGNOSTIC) { 2620c5038fc0SAlan Cox /* Let the user know. We don't want to disallow opens for 2621c5038fc0SAlan Cox rescue purposes, or in case the vendor is just a blithering 2622c5038fc0SAlan Cox idiot. Do this after the dev_config call as some controllers 2623c5038fc0SAlan Cox with buggy firmware may want to avoid reporting false device 2624c5038fc0SAlan Cox bugs */ 2625c5038fc0SAlan Cox 2626c5038fc0SAlan Cox if (print_info) { 2627c5038fc0SAlan Cox ata_dev_printk(dev, KERN_WARNING, 2628c5038fc0SAlan Cox "Drive reports diagnostics failure. This may indicate a drive\n"); 2629c5038fc0SAlan Cox ata_dev_printk(dev, KERN_WARNING, 2630c5038fc0SAlan Cox "fault or invalid emulation. Contact drive vendor for information.\n"); 2631c5038fc0SAlan Cox } 2632c5038fc0SAlan Cox } 2633c5038fc0SAlan Cox 2634ac70a964STejun Heo if ((dev->horkage & ATA_HORKAGE_FIRMWARE_WARN) && print_info) { 2635ac70a964STejun Heo ata_dev_printk(dev, KERN_WARNING, "WARNING: device requires " 2636ac70a964STejun Heo "firmware update to be fully functional.\n"); 2637ac70a964STejun Heo ata_dev_printk(dev, KERN_WARNING, " contact the vendor " 2638ac70a964STejun Heo "or visit http://ata.wiki.kernel.org.\n"); 2639ac70a964STejun Heo } 2640ac70a964STejun Heo 2641c6fd2807SJeff Garzik return 0; 2642c6fd2807SJeff Garzik 2643c6fd2807SJeff Garzik err_out_nosup: 2644c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 2645c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_DEBUG, 26467f5e4e8dSHarvey Harrison "%s: EXIT, err\n", __func__); 2647c6fd2807SJeff Garzik return rc; 2648c6fd2807SJeff Garzik } 2649c6fd2807SJeff Garzik 2650c6fd2807SJeff Garzik /** 26512e41e8e6SAlan Cox * ata_cable_40wire - return 40 wire cable type 2652be0d18dfSAlan Cox * @ap: port 2653be0d18dfSAlan Cox * 26542e41e8e6SAlan Cox * Helper method for drivers which want to hardwire 40 wire cable 2655be0d18dfSAlan Cox * detection. 2656be0d18dfSAlan Cox */ 2657be0d18dfSAlan Cox 2658be0d18dfSAlan Cox int ata_cable_40wire(struct ata_port *ap) 2659be0d18dfSAlan Cox { 2660be0d18dfSAlan Cox return ATA_CBL_PATA40; 2661be0d18dfSAlan Cox } 2662be0d18dfSAlan Cox 2663be0d18dfSAlan Cox /** 26642e41e8e6SAlan Cox * ata_cable_80wire - return 80 wire cable type 2665be0d18dfSAlan Cox * @ap: port 2666be0d18dfSAlan Cox * 26672e41e8e6SAlan Cox * Helper method for drivers which want to hardwire 80 wire cable 2668be0d18dfSAlan Cox * detection. 2669be0d18dfSAlan Cox */ 2670be0d18dfSAlan Cox 2671be0d18dfSAlan Cox int ata_cable_80wire(struct ata_port *ap) 2672be0d18dfSAlan Cox { 2673be0d18dfSAlan Cox return ATA_CBL_PATA80; 2674be0d18dfSAlan Cox } 2675be0d18dfSAlan Cox 2676be0d18dfSAlan Cox /** 2677be0d18dfSAlan Cox * ata_cable_unknown - return unknown PATA cable. 2678be0d18dfSAlan Cox * @ap: port 2679be0d18dfSAlan Cox * 2680be0d18dfSAlan Cox * Helper method for drivers which have no PATA cable detection. 2681be0d18dfSAlan Cox */ 2682be0d18dfSAlan Cox 2683be0d18dfSAlan Cox int ata_cable_unknown(struct ata_port *ap) 2684be0d18dfSAlan Cox { 2685be0d18dfSAlan Cox return ATA_CBL_PATA_UNK; 2686be0d18dfSAlan Cox } 2687be0d18dfSAlan Cox 2688be0d18dfSAlan Cox /** 2689c88f90c3STejun Heo * ata_cable_ignore - return ignored PATA cable. 2690c88f90c3STejun Heo * @ap: port 2691c88f90c3STejun Heo * 2692c88f90c3STejun Heo * Helper method for drivers which don't use cable type to limit 2693c88f90c3STejun Heo * transfer mode. 2694c88f90c3STejun Heo */ 2695c88f90c3STejun Heo int ata_cable_ignore(struct ata_port *ap) 2696c88f90c3STejun Heo { 2697c88f90c3STejun Heo return ATA_CBL_PATA_IGN; 2698c88f90c3STejun Heo } 2699c88f90c3STejun Heo 2700c88f90c3STejun Heo /** 2701be0d18dfSAlan Cox * ata_cable_sata - return SATA cable type 2702be0d18dfSAlan Cox * @ap: port 2703be0d18dfSAlan Cox * 2704be0d18dfSAlan Cox * Helper method for drivers which have SATA cables 2705be0d18dfSAlan Cox */ 2706be0d18dfSAlan Cox 2707be0d18dfSAlan Cox int ata_cable_sata(struct ata_port *ap) 2708be0d18dfSAlan Cox { 2709be0d18dfSAlan Cox return ATA_CBL_SATA; 2710be0d18dfSAlan Cox } 2711be0d18dfSAlan Cox 2712be0d18dfSAlan Cox /** 2713c6fd2807SJeff Garzik * ata_bus_probe - Reset and probe ATA bus 2714c6fd2807SJeff Garzik * @ap: Bus to probe 2715c6fd2807SJeff Garzik * 2716c6fd2807SJeff Garzik * Master ATA bus probing function. Initiates a hardware-dependent 2717c6fd2807SJeff Garzik * bus reset, then attempts to identify any devices found on 2718c6fd2807SJeff Garzik * the bus. 2719c6fd2807SJeff Garzik * 2720c6fd2807SJeff Garzik * LOCKING: 2721c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 2722c6fd2807SJeff Garzik * 2723c6fd2807SJeff Garzik * RETURNS: 2724c6fd2807SJeff Garzik * Zero on success, negative errno otherwise. 2725c6fd2807SJeff Garzik */ 2726c6fd2807SJeff Garzik 2727c6fd2807SJeff Garzik int ata_bus_probe(struct ata_port *ap) 2728c6fd2807SJeff Garzik { 2729c6fd2807SJeff Garzik unsigned int classes[ATA_MAX_DEVICES]; 2730c6fd2807SJeff Garzik int tries[ATA_MAX_DEVICES]; 2731f58229f8STejun Heo int rc; 2732c6fd2807SJeff Garzik struct ata_device *dev; 2733c6fd2807SJeff Garzik 2734c6fd2807SJeff Garzik ata_port_probe(ap); 2735c6fd2807SJeff Garzik 27361eca4365STejun Heo ata_for_each_dev(dev, &ap->link, ALL) 2737f58229f8STejun Heo tries[dev->devno] = ATA_PROBE_MAX_TRIES; 2738c6fd2807SJeff Garzik 2739c6fd2807SJeff Garzik retry: 27401eca4365STejun Heo ata_for_each_dev(dev, &ap->link, ALL) { 2741cdeab114STejun Heo /* If we issue an SRST then an ATA drive (not ATAPI) 2742cdeab114STejun Heo * may change configuration and be in PIO0 timing. If 2743cdeab114STejun Heo * we do a hard reset (or are coming from power on) 2744cdeab114STejun Heo * this is true for ATA or ATAPI. Until we've set a 2745cdeab114STejun Heo * suitable controller mode we should not touch the 2746cdeab114STejun Heo * bus as we may be talking too fast. 2747cdeab114STejun Heo */ 2748cdeab114STejun Heo dev->pio_mode = XFER_PIO_0; 2749cdeab114STejun Heo 2750cdeab114STejun Heo /* If the controller has a pio mode setup function 2751cdeab114STejun Heo * then use it to set the chipset to rights. Don't 2752cdeab114STejun Heo * touch the DMA setup as that will be dealt with when 2753cdeab114STejun Heo * configuring devices. 2754cdeab114STejun Heo */ 2755cdeab114STejun Heo if (ap->ops->set_piomode) 2756cdeab114STejun Heo ap->ops->set_piomode(ap, dev); 2757cdeab114STejun Heo } 2758cdeab114STejun Heo 2759c6fd2807SJeff Garzik /* reset and determine device classes */ 2760c6fd2807SJeff Garzik ap->ops->phy_reset(ap); 2761c6fd2807SJeff Garzik 27621eca4365STejun Heo ata_for_each_dev(dev, &ap->link, ALL) { 2763c6fd2807SJeff Garzik if (!(ap->flags & ATA_FLAG_DISABLED) && 2764c6fd2807SJeff Garzik dev->class != ATA_DEV_UNKNOWN) 2765c6fd2807SJeff Garzik classes[dev->devno] = dev->class; 2766c6fd2807SJeff Garzik else 2767c6fd2807SJeff Garzik classes[dev->devno] = ATA_DEV_NONE; 2768c6fd2807SJeff Garzik 2769c6fd2807SJeff Garzik dev->class = ATA_DEV_UNKNOWN; 2770c6fd2807SJeff Garzik } 2771c6fd2807SJeff Garzik 2772c6fd2807SJeff Garzik ata_port_probe(ap); 2773c6fd2807SJeff Garzik 2774f31f0cc2SJeff Garzik /* read IDENTIFY page and configure devices. We have to do the identify 2775f31f0cc2SJeff Garzik specific sequence bass-ackwards so that PDIAG- is released by 2776f31f0cc2SJeff Garzik the slave device */ 2777f31f0cc2SJeff Garzik 27781eca4365STejun Heo ata_for_each_dev(dev, &ap->link, ALL_REVERSE) { 2779f58229f8STejun Heo if (tries[dev->devno]) 2780f58229f8STejun Heo dev->class = classes[dev->devno]; 2781c6fd2807SJeff Garzik 2782c6fd2807SJeff Garzik if (!ata_dev_enabled(dev)) 2783c6fd2807SJeff Garzik continue; 2784c6fd2807SJeff Garzik 2785bff04647STejun Heo rc = ata_dev_read_id(dev, &dev->class, ATA_READID_POSTRESET, 2786bff04647STejun Heo dev->id); 2787c6fd2807SJeff Garzik if (rc) 2788c6fd2807SJeff Garzik goto fail; 2789f31f0cc2SJeff Garzik } 2790f31f0cc2SJeff Garzik 2791be0d18dfSAlan Cox /* Now ask for the cable type as PDIAG- should have been released */ 2792be0d18dfSAlan Cox if (ap->ops->cable_detect) 2793be0d18dfSAlan Cox ap->cbl = ap->ops->cable_detect(ap); 2794be0d18dfSAlan Cox 27951eca4365STejun Heo /* We may have SATA bridge glue hiding here irrespective of 27961eca4365STejun Heo * the reported cable types and sensed types. When SATA 27971eca4365STejun Heo * drives indicate we have a bridge, we don't know which end 27981eca4365STejun Heo * of the link the bridge is which is a problem. 27991eca4365STejun Heo */ 28001eca4365STejun Heo ata_for_each_dev(dev, &ap->link, ENABLED) 2801614fe29bSAlan Cox if (ata_id_is_sata(dev->id)) 2802614fe29bSAlan Cox ap->cbl = ATA_CBL_SATA; 2803614fe29bSAlan Cox 2804f31f0cc2SJeff Garzik /* After the identify sequence we can now set up the devices. We do 2805f31f0cc2SJeff Garzik this in the normal order so that the user doesn't get confused */ 2806f31f0cc2SJeff Garzik 28071eca4365STejun Heo ata_for_each_dev(dev, &ap->link, ENABLED) { 28089af5c9c9STejun Heo ap->link.eh_context.i.flags |= ATA_EHI_PRINTINFO; 2809efdaedc4STejun Heo rc = ata_dev_configure(dev); 28109af5c9c9STejun Heo ap->link.eh_context.i.flags &= ~ATA_EHI_PRINTINFO; 2811c6fd2807SJeff Garzik if (rc) 2812c6fd2807SJeff Garzik goto fail; 2813c6fd2807SJeff Garzik } 2814c6fd2807SJeff Garzik 2815c6fd2807SJeff Garzik /* configure transfer mode */ 28160260731fSTejun Heo rc = ata_set_mode(&ap->link, &dev); 28174ae72a1eSTejun Heo if (rc) 2818c6fd2807SJeff Garzik goto fail; 2819c6fd2807SJeff Garzik 28201eca4365STejun Heo ata_for_each_dev(dev, &ap->link, ENABLED) 2821c6fd2807SJeff Garzik return 0; 2822c6fd2807SJeff Garzik 2823c6fd2807SJeff Garzik /* no device present, disable port */ 2824c6fd2807SJeff Garzik ata_port_disable(ap); 2825c6fd2807SJeff Garzik return -ENODEV; 2826c6fd2807SJeff Garzik 2827c6fd2807SJeff Garzik fail: 28284ae72a1eSTejun Heo tries[dev->devno]--; 28294ae72a1eSTejun Heo 2830c6fd2807SJeff Garzik switch (rc) { 2831c6fd2807SJeff Garzik case -EINVAL: 28324ae72a1eSTejun Heo /* eeek, something went very wrong, give up */ 2833c6fd2807SJeff Garzik tries[dev->devno] = 0; 2834c6fd2807SJeff Garzik break; 28354ae72a1eSTejun Heo 28364ae72a1eSTejun Heo case -ENODEV: 28374ae72a1eSTejun Heo /* give it just one more chance */ 28384ae72a1eSTejun Heo tries[dev->devno] = min(tries[dev->devno], 1); 2839c6fd2807SJeff Garzik case -EIO: 28404ae72a1eSTejun Heo if (tries[dev->devno] == 1) { 28414ae72a1eSTejun Heo /* This is the last chance, better to slow 28424ae72a1eSTejun Heo * down than lose it. 28434ae72a1eSTejun Heo */ 2844a07d499bSTejun Heo sata_down_spd_limit(&ap->link, 0); 28454ae72a1eSTejun Heo ata_down_xfermask_limit(dev, ATA_DNXFER_PIO); 28464ae72a1eSTejun Heo } 2847c6fd2807SJeff Garzik } 2848c6fd2807SJeff Garzik 28494ae72a1eSTejun Heo if (!tries[dev->devno]) 2850c6fd2807SJeff Garzik ata_dev_disable(dev); 2851c6fd2807SJeff Garzik 2852c6fd2807SJeff Garzik goto retry; 2853c6fd2807SJeff Garzik } 2854c6fd2807SJeff Garzik 2855c6fd2807SJeff Garzik /** 2856c6fd2807SJeff Garzik * ata_port_probe - Mark port as enabled 2857c6fd2807SJeff Garzik * @ap: Port for which we indicate enablement 2858c6fd2807SJeff Garzik * 2859c6fd2807SJeff Garzik * Modify @ap data structure such that the system 2860c6fd2807SJeff Garzik * thinks that the entire port is enabled. 2861c6fd2807SJeff Garzik * 2862cca3974eSJeff Garzik * LOCKING: host lock, or some other form of 2863c6fd2807SJeff Garzik * serialization. 2864c6fd2807SJeff Garzik */ 2865c6fd2807SJeff Garzik 2866c6fd2807SJeff Garzik void ata_port_probe(struct ata_port *ap) 2867c6fd2807SJeff Garzik { 2868c6fd2807SJeff Garzik ap->flags &= ~ATA_FLAG_DISABLED; 2869c6fd2807SJeff Garzik } 2870c6fd2807SJeff Garzik 2871c6fd2807SJeff Garzik /** 2872c6fd2807SJeff Garzik * sata_print_link_status - Print SATA link status 2873936fd732STejun Heo * @link: SATA link to printk link status about 2874c6fd2807SJeff Garzik * 2875c6fd2807SJeff Garzik * This function prints link speed and status of a SATA link. 2876c6fd2807SJeff Garzik * 2877c6fd2807SJeff Garzik * LOCKING: 2878c6fd2807SJeff Garzik * None. 2879c6fd2807SJeff Garzik */ 28806bdb4fc9SAdrian Bunk static void sata_print_link_status(struct ata_link *link) 2881c6fd2807SJeff Garzik { 2882c6fd2807SJeff Garzik u32 sstatus, scontrol, tmp; 2883c6fd2807SJeff Garzik 2884936fd732STejun Heo if (sata_scr_read(link, SCR_STATUS, &sstatus)) 2885c6fd2807SJeff Garzik return; 2886936fd732STejun Heo sata_scr_read(link, SCR_CONTROL, &scontrol); 2887c6fd2807SJeff Garzik 2888b1c72916STejun Heo if (ata_phys_link_online(link)) { 2889c6fd2807SJeff Garzik tmp = (sstatus >> 4) & 0xf; 2890936fd732STejun Heo ata_link_printk(link, KERN_INFO, 2891c6fd2807SJeff Garzik "SATA link up %s (SStatus %X SControl %X)\n", 2892c6fd2807SJeff Garzik sata_spd_string(tmp), sstatus, scontrol); 2893c6fd2807SJeff Garzik } else { 2894936fd732STejun Heo ata_link_printk(link, KERN_INFO, 2895c6fd2807SJeff Garzik "SATA link down (SStatus %X SControl %X)\n", 2896c6fd2807SJeff Garzik sstatus, scontrol); 2897c6fd2807SJeff Garzik } 2898c6fd2807SJeff Garzik } 2899c6fd2807SJeff Garzik 2900c6fd2807SJeff Garzik /** 2901c6fd2807SJeff Garzik * ata_dev_pair - return other device on cable 2902c6fd2807SJeff Garzik * @adev: device 2903c6fd2807SJeff Garzik * 2904c6fd2807SJeff Garzik * Obtain the other device on the same cable, or if none is 2905c6fd2807SJeff Garzik * present NULL is returned 2906c6fd2807SJeff Garzik */ 2907c6fd2807SJeff Garzik 2908c6fd2807SJeff Garzik struct ata_device *ata_dev_pair(struct ata_device *adev) 2909c6fd2807SJeff Garzik { 29109af5c9c9STejun Heo struct ata_link *link = adev->link; 29119af5c9c9STejun Heo struct ata_device *pair = &link->device[1 - adev->devno]; 2912c6fd2807SJeff Garzik if (!ata_dev_enabled(pair)) 2913c6fd2807SJeff Garzik return NULL; 2914c6fd2807SJeff Garzik return pair; 2915c6fd2807SJeff Garzik } 2916c6fd2807SJeff Garzik 2917c6fd2807SJeff Garzik /** 2918c6fd2807SJeff Garzik * ata_port_disable - Disable port. 2919c6fd2807SJeff Garzik * @ap: Port to be disabled. 2920c6fd2807SJeff Garzik * 2921c6fd2807SJeff Garzik * Modify @ap data structure such that the system 2922c6fd2807SJeff Garzik * thinks that the entire port is disabled, and should 2923c6fd2807SJeff Garzik * never attempt to probe or communicate with devices 2924c6fd2807SJeff Garzik * on this port. 2925c6fd2807SJeff Garzik * 2926cca3974eSJeff Garzik * LOCKING: host lock, or some other form of 2927c6fd2807SJeff Garzik * serialization. 2928c6fd2807SJeff Garzik */ 2929c6fd2807SJeff Garzik 2930c6fd2807SJeff Garzik void ata_port_disable(struct ata_port *ap) 2931c6fd2807SJeff Garzik { 29329af5c9c9STejun Heo ap->link.device[0].class = ATA_DEV_NONE; 29339af5c9c9STejun Heo ap->link.device[1].class = ATA_DEV_NONE; 2934c6fd2807SJeff Garzik ap->flags |= ATA_FLAG_DISABLED; 2935c6fd2807SJeff Garzik } 2936c6fd2807SJeff Garzik 2937c6fd2807SJeff Garzik /** 2938c6fd2807SJeff Garzik * sata_down_spd_limit - adjust SATA spd limit downward 2939936fd732STejun Heo * @link: Link to adjust SATA spd limit for 2940a07d499bSTejun Heo * @spd_limit: Additional limit 2941c6fd2807SJeff Garzik * 2942936fd732STejun Heo * Adjust SATA spd limit of @link downward. Note that this 2943c6fd2807SJeff Garzik * function only adjusts the limit. The change must be applied 2944c6fd2807SJeff Garzik * using sata_set_spd(). 2945c6fd2807SJeff Garzik * 2946a07d499bSTejun Heo * If @spd_limit is non-zero, the speed is limited to equal to or 2947a07d499bSTejun Heo * lower than @spd_limit if such speed is supported. If 2948a07d499bSTejun Heo * @spd_limit is slower than any supported speed, only the lowest 2949a07d499bSTejun Heo * supported speed is allowed. 2950a07d499bSTejun Heo * 2951c6fd2807SJeff Garzik * LOCKING: 2952c6fd2807SJeff Garzik * Inherited from caller. 2953c6fd2807SJeff Garzik * 2954c6fd2807SJeff Garzik * RETURNS: 2955c6fd2807SJeff Garzik * 0 on success, negative errno on failure 2956c6fd2807SJeff Garzik */ 2957a07d499bSTejun Heo int sata_down_spd_limit(struct ata_link *link, u32 spd_limit) 2958c6fd2807SJeff Garzik { 2959c6fd2807SJeff Garzik u32 sstatus, spd, mask; 2960a07d499bSTejun Heo int rc, bit; 2961c6fd2807SJeff Garzik 2962936fd732STejun Heo if (!sata_scr_valid(link)) 2963008a7896STejun Heo return -EOPNOTSUPP; 2964008a7896STejun Heo 2965008a7896STejun Heo /* If SCR can be read, use it to determine the current SPD. 2966936fd732STejun Heo * If not, use cached value in link->sata_spd. 2967008a7896STejun Heo */ 2968936fd732STejun Heo rc = sata_scr_read(link, SCR_STATUS, &sstatus); 29699913ff8aSTejun Heo if (rc == 0 && ata_sstatus_online(sstatus)) 2970008a7896STejun Heo spd = (sstatus >> 4) & 0xf; 2971008a7896STejun Heo else 2972936fd732STejun Heo spd = link->sata_spd; 2973c6fd2807SJeff Garzik 2974936fd732STejun Heo mask = link->sata_spd_limit; 2975c6fd2807SJeff Garzik if (mask <= 1) 2976c6fd2807SJeff Garzik return -EINVAL; 2977008a7896STejun Heo 2978008a7896STejun Heo /* unconditionally mask off the highest bit */ 2979a07d499bSTejun Heo bit = fls(mask) - 1; 2980a07d499bSTejun Heo mask &= ~(1 << bit); 2981c6fd2807SJeff Garzik 2982008a7896STejun Heo /* Mask off all speeds higher than or equal to the current 2983008a7896STejun Heo * one. Force 1.5Gbps if current SPD is not available. 2984008a7896STejun Heo */ 2985008a7896STejun Heo if (spd > 1) 2986008a7896STejun Heo mask &= (1 << (spd - 1)) - 1; 2987008a7896STejun Heo else 2988008a7896STejun Heo mask &= 1; 2989008a7896STejun Heo 2990008a7896STejun Heo /* were we already at the bottom? */ 2991c6fd2807SJeff Garzik if (!mask) 2992c6fd2807SJeff Garzik return -EINVAL; 2993c6fd2807SJeff Garzik 2994a07d499bSTejun Heo if (spd_limit) { 2995a07d499bSTejun Heo if (mask & ((1 << spd_limit) - 1)) 2996a07d499bSTejun Heo mask &= (1 << spd_limit) - 1; 2997a07d499bSTejun Heo else { 2998a07d499bSTejun Heo bit = ffs(mask) - 1; 2999a07d499bSTejun Heo mask = 1 << bit; 3000a07d499bSTejun Heo } 3001a07d499bSTejun Heo } 3002a07d499bSTejun Heo 3003936fd732STejun Heo link->sata_spd_limit = mask; 3004c6fd2807SJeff Garzik 3005936fd732STejun Heo ata_link_printk(link, KERN_WARNING, "limiting SATA link speed to %s\n", 3006c6fd2807SJeff Garzik sata_spd_string(fls(mask))); 3007c6fd2807SJeff Garzik 3008c6fd2807SJeff Garzik return 0; 3009c6fd2807SJeff Garzik } 3010c6fd2807SJeff Garzik 3011936fd732STejun Heo static int __sata_set_spd_needed(struct ata_link *link, u32 *scontrol) 3012c6fd2807SJeff Garzik { 30135270222fSTejun Heo struct ata_link *host_link = &link->ap->link; 30145270222fSTejun Heo u32 limit, target, spd; 3015c6fd2807SJeff Garzik 30165270222fSTejun Heo limit = link->sata_spd_limit; 30175270222fSTejun Heo 30185270222fSTejun Heo /* Don't configure downstream link faster than upstream link. 30195270222fSTejun Heo * It doesn't speed up anything and some PMPs choke on such 30205270222fSTejun Heo * configuration. 30215270222fSTejun Heo */ 30225270222fSTejun Heo if (!ata_is_host_link(link) && host_link->sata_spd) 30235270222fSTejun Heo limit &= (1 << host_link->sata_spd) - 1; 30245270222fSTejun Heo 30255270222fSTejun Heo if (limit == UINT_MAX) 30265270222fSTejun Heo target = 0; 3027c6fd2807SJeff Garzik else 30285270222fSTejun Heo target = fls(limit); 3029c6fd2807SJeff Garzik 3030c6fd2807SJeff Garzik spd = (*scontrol >> 4) & 0xf; 30315270222fSTejun Heo *scontrol = (*scontrol & ~0xf0) | ((target & 0xf) << 4); 3032c6fd2807SJeff Garzik 30335270222fSTejun Heo return spd != target; 3034c6fd2807SJeff Garzik } 3035c6fd2807SJeff Garzik 3036c6fd2807SJeff Garzik /** 3037c6fd2807SJeff Garzik * sata_set_spd_needed - is SATA spd configuration needed 3038936fd732STejun Heo * @link: Link in question 3039c6fd2807SJeff Garzik * 3040c6fd2807SJeff Garzik * Test whether the spd limit in SControl matches 3041936fd732STejun Heo * @link->sata_spd_limit. This function is used to determine 3042c6fd2807SJeff Garzik * whether hardreset is necessary to apply SATA spd 3043c6fd2807SJeff Garzik * configuration. 3044c6fd2807SJeff Garzik * 3045c6fd2807SJeff Garzik * LOCKING: 3046c6fd2807SJeff Garzik * Inherited from caller. 3047c6fd2807SJeff Garzik * 3048c6fd2807SJeff Garzik * RETURNS: 3049c6fd2807SJeff Garzik * 1 if SATA spd configuration is needed, 0 otherwise. 3050c6fd2807SJeff Garzik */ 30511dc55e87SAdrian Bunk static int sata_set_spd_needed(struct ata_link *link) 3052c6fd2807SJeff Garzik { 3053c6fd2807SJeff Garzik u32 scontrol; 3054c6fd2807SJeff Garzik 3055936fd732STejun Heo if (sata_scr_read(link, SCR_CONTROL, &scontrol)) 3056db64bcf3STejun Heo return 1; 3057c6fd2807SJeff Garzik 3058936fd732STejun Heo return __sata_set_spd_needed(link, &scontrol); 3059c6fd2807SJeff Garzik } 3060c6fd2807SJeff Garzik 3061c6fd2807SJeff Garzik /** 3062c6fd2807SJeff Garzik * sata_set_spd - set SATA spd according to spd limit 3063936fd732STejun Heo * @link: Link to set SATA spd for 3064c6fd2807SJeff Garzik * 3065936fd732STejun Heo * Set SATA spd of @link according to sata_spd_limit. 3066c6fd2807SJeff Garzik * 3067c6fd2807SJeff Garzik * LOCKING: 3068c6fd2807SJeff Garzik * Inherited from caller. 3069c6fd2807SJeff Garzik * 3070c6fd2807SJeff Garzik * RETURNS: 3071c6fd2807SJeff Garzik * 0 if spd doesn't need to be changed, 1 if spd has been 3072c6fd2807SJeff Garzik * changed. Negative errno if SCR registers are inaccessible. 3073c6fd2807SJeff Garzik */ 3074936fd732STejun Heo int sata_set_spd(struct ata_link *link) 3075c6fd2807SJeff Garzik { 3076c6fd2807SJeff Garzik u32 scontrol; 3077c6fd2807SJeff Garzik int rc; 3078c6fd2807SJeff Garzik 3079936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 3080c6fd2807SJeff Garzik return rc; 3081c6fd2807SJeff Garzik 3082936fd732STejun Heo if (!__sata_set_spd_needed(link, &scontrol)) 3083c6fd2807SJeff Garzik return 0; 3084c6fd2807SJeff Garzik 3085936fd732STejun Heo if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol))) 3086c6fd2807SJeff Garzik return rc; 3087c6fd2807SJeff Garzik 3088c6fd2807SJeff Garzik return 1; 3089c6fd2807SJeff Garzik } 3090c6fd2807SJeff Garzik 3091c6fd2807SJeff Garzik /* 3092c6fd2807SJeff Garzik * This mode timing computation functionality is ported over from 3093c6fd2807SJeff Garzik * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik 3094c6fd2807SJeff Garzik */ 3095c6fd2807SJeff Garzik /* 3096b352e57dSAlan Cox * PIO 0-4, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds). 3097c6fd2807SJeff Garzik * These were taken from ATA/ATAPI-6 standard, rev 0a, except 3098b352e57dSAlan Cox * for UDMA6, which is currently supported only by Maxtor drives. 3099b352e57dSAlan Cox * 3100b352e57dSAlan Cox * For PIO 5/6 MWDMA 3/4 see the CFA specification 3.0. 3101c6fd2807SJeff Garzik */ 3102c6fd2807SJeff Garzik 3103c6fd2807SJeff Garzik static const struct ata_timing ata_timing[] = { 31043ada9c12SDavid Daney /* { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 0, 960, 0 }, */ 31053ada9c12SDavid Daney { XFER_PIO_0, 70, 290, 240, 600, 165, 150, 0, 600, 0 }, 31063ada9c12SDavid Daney { XFER_PIO_1, 50, 290, 93, 383, 125, 100, 0, 383, 0 }, 31073ada9c12SDavid Daney { XFER_PIO_2, 30, 290, 40, 330, 100, 90, 0, 240, 0 }, 31083ada9c12SDavid Daney { XFER_PIO_3, 30, 80, 70, 180, 80, 70, 0, 180, 0 }, 31093ada9c12SDavid Daney { XFER_PIO_4, 25, 70, 25, 120, 70, 25, 0, 120, 0 }, 31103ada9c12SDavid Daney { XFER_PIO_5, 15, 65, 25, 100, 65, 25, 0, 100, 0 }, 31113ada9c12SDavid Daney { XFER_PIO_6, 10, 55, 20, 80, 55, 20, 0, 80, 0 }, 3112c6fd2807SJeff Garzik 31133ada9c12SDavid Daney { XFER_SW_DMA_0, 120, 0, 0, 0, 480, 480, 50, 960, 0 }, 31143ada9c12SDavid Daney { XFER_SW_DMA_1, 90, 0, 0, 0, 240, 240, 30, 480, 0 }, 31153ada9c12SDavid Daney { XFER_SW_DMA_2, 60, 0, 0, 0, 120, 120, 20, 240, 0 }, 3116c6fd2807SJeff Garzik 31173ada9c12SDavid Daney { XFER_MW_DMA_0, 60, 0, 0, 0, 215, 215, 20, 480, 0 }, 31183ada9c12SDavid Daney { XFER_MW_DMA_1, 45, 0, 0, 0, 80, 50, 5, 150, 0 }, 31193ada9c12SDavid Daney { XFER_MW_DMA_2, 25, 0, 0, 0, 70, 25, 5, 120, 0 }, 31203ada9c12SDavid Daney { XFER_MW_DMA_3, 25, 0, 0, 0, 65, 25, 5, 100, 0 }, 31213ada9c12SDavid Daney { XFER_MW_DMA_4, 25, 0, 0, 0, 55, 20, 5, 80, 0 }, 3122c6fd2807SJeff Garzik 31233ada9c12SDavid Daney /* { XFER_UDMA_SLOW, 0, 0, 0, 0, 0, 0, 0, 0, 150 }, */ 31243ada9c12SDavid Daney { XFER_UDMA_0, 0, 0, 0, 0, 0, 0, 0, 0, 120 }, 31253ada9c12SDavid Daney { XFER_UDMA_1, 0, 0, 0, 0, 0, 0, 0, 0, 80 }, 31263ada9c12SDavid Daney { XFER_UDMA_2, 0, 0, 0, 0, 0, 0, 0, 0, 60 }, 31273ada9c12SDavid Daney { XFER_UDMA_3, 0, 0, 0, 0, 0, 0, 0, 0, 45 }, 31283ada9c12SDavid Daney { XFER_UDMA_4, 0, 0, 0, 0, 0, 0, 0, 0, 30 }, 31293ada9c12SDavid Daney { XFER_UDMA_5, 0, 0, 0, 0, 0, 0, 0, 0, 20 }, 31303ada9c12SDavid Daney { XFER_UDMA_6, 0, 0, 0, 0, 0, 0, 0, 0, 15 }, 3131c6fd2807SJeff Garzik 3132c6fd2807SJeff Garzik { 0xFF } 3133c6fd2807SJeff Garzik }; 3134c6fd2807SJeff Garzik 3135c6fd2807SJeff Garzik #define ENOUGH(v, unit) (((v)-1)/(unit)+1) 3136c6fd2807SJeff Garzik #define EZ(v, unit) ((v)?ENOUGH(v, unit):0) 3137c6fd2807SJeff Garzik 3138c6fd2807SJeff Garzik static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT) 3139c6fd2807SJeff Garzik { 3140c6fd2807SJeff Garzik q->setup = EZ(t->setup * 1000, T); 3141c6fd2807SJeff Garzik q->act8b = EZ(t->act8b * 1000, T); 3142c6fd2807SJeff Garzik q->rec8b = EZ(t->rec8b * 1000, T); 3143c6fd2807SJeff Garzik q->cyc8b = EZ(t->cyc8b * 1000, T); 3144c6fd2807SJeff Garzik q->active = EZ(t->active * 1000, T); 3145c6fd2807SJeff Garzik q->recover = EZ(t->recover * 1000, T); 31463ada9c12SDavid Daney q->dmack_hold = EZ(t->dmack_hold * 1000, T); 3147c6fd2807SJeff Garzik q->cycle = EZ(t->cycle * 1000, T); 3148c6fd2807SJeff Garzik q->udma = EZ(t->udma * 1000, UT); 3149c6fd2807SJeff Garzik } 3150c6fd2807SJeff Garzik 3151c6fd2807SJeff Garzik void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b, 3152c6fd2807SJeff Garzik struct ata_timing *m, unsigned int what) 3153c6fd2807SJeff Garzik { 3154c6fd2807SJeff Garzik if (what & ATA_TIMING_SETUP ) m->setup = max(a->setup, b->setup); 3155c6fd2807SJeff Garzik if (what & ATA_TIMING_ACT8B ) m->act8b = max(a->act8b, b->act8b); 3156c6fd2807SJeff Garzik if (what & ATA_TIMING_REC8B ) m->rec8b = max(a->rec8b, b->rec8b); 3157c6fd2807SJeff Garzik if (what & ATA_TIMING_CYC8B ) m->cyc8b = max(a->cyc8b, b->cyc8b); 3158c6fd2807SJeff Garzik if (what & ATA_TIMING_ACTIVE ) m->active = max(a->active, b->active); 3159c6fd2807SJeff Garzik if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover); 31603ada9c12SDavid Daney if (what & ATA_TIMING_DMACK_HOLD) m->dmack_hold = max(a->dmack_hold, b->dmack_hold); 3161c6fd2807SJeff Garzik if (what & ATA_TIMING_CYCLE ) m->cycle = max(a->cycle, b->cycle); 3162c6fd2807SJeff Garzik if (what & ATA_TIMING_UDMA ) m->udma = max(a->udma, b->udma); 3163c6fd2807SJeff Garzik } 3164c6fd2807SJeff Garzik 31656357357cSTejun Heo const struct ata_timing *ata_timing_find_mode(u8 xfer_mode) 3166c6fd2807SJeff Garzik { 316770cd071eSTejun Heo const struct ata_timing *t = ata_timing; 3168c6fd2807SJeff Garzik 316970cd071eSTejun Heo while (xfer_mode > t->mode) 317070cd071eSTejun Heo t++; 317170cd071eSTejun Heo 317270cd071eSTejun Heo if (xfer_mode == t->mode) 3173c6fd2807SJeff Garzik return t; 317470cd071eSTejun Heo return NULL; 3175c6fd2807SJeff Garzik } 3176c6fd2807SJeff Garzik 3177c6fd2807SJeff Garzik int ata_timing_compute(struct ata_device *adev, unsigned short speed, 3178c6fd2807SJeff Garzik struct ata_timing *t, int T, int UT) 3179c6fd2807SJeff Garzik { 3180c6fd2807SJeff Garzik const struct ata_timing *s; 3181c6fd2807SJeff Garzik struct ata_timing p; 3182c6fd2807SJeff Garzik 3183c6fd2807SJeff Garzik /* 3184c6fd2807SJeff Garzik * Find the mode. 3185c6fd2807SJeff Garzik */ 3186c6fd2807SJeff Garzik 3187c6fd2807SJeff Garzik if (!(s = ata_timing_find_mode(speed))) 3188c6fd2807SJeff Garzik return -EINVAL; 3189c6fd2807SJeff Garzik 3190c6fd2807SJeff Garzik memcpy(t, s, sizeof(*s)); 3191c6fd2807SJeff Garzik 3192c6fd2807SJeff Garzik /* 3193c6fd2807SJeff Garzik * If the drive is an EIDE drive, it can tell us it needs extended 3194c6fd2807SJeff Garzik * PIO/MW_DMA cycle timing. 3195c6fd2807SJeff Garzik */ 3196c6fd2807SJeff Garzik 3197c6fd2807SJeff Garzik if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */ 3198c6fd2807SJeff Garzik memset(&p, 0, sizeof(p)); 3199c6fd2807SJeff Garzik if (speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) { 3200c6fd2807SJeff Garzik if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO]; 3201c6fd2807SJeff Garzik else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY]; 3202c6fd2807SJeff Garzik } else if (speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) { 3203c6fd2807SJeff Garzik p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN]; 3204c6fd2807SJeff Garzik } 3205c6fd2807SJeff Garzik ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B); 3206c6fd2807SJeff Garzik } 3207c6fd2807SJeff Garzik 3208c6fd2807SJeff Garzik /* 3209c6fd2807SJeff Garzik * Convert the timing to bus clock counts. 3210c6fd2807SJeff Garzik */ 3211c6fd2807SJeff Garzik 3212c6fd2807SJeff Garzik ata_timing_quantize(t, t, T, UT); 3213c6fd2807SJeff Garzik 3214c6fd2807SJeff Garzik /* 3215c6fd2807SJeff Garzik * Even in DMA/UDMA modes we still use PIO access for IDENTIFY, 3216c6fd2807SJeff Garzik * S.M.A.R.T * and some other commands. We have to ensure that the 3217c6fd2807SJeff Garzik * DMA cycle timing is slower/equal than the fastest PIO timing. 3218c6fd2807SJeff Garzik */ 3219c6fd2807SJeff Garzik 3220fd3367afSAlan if (speed > XFER_PIO_6) { 3221c6fd2807SJeff Garzik ata_timing_compute(adev, adev->pio_mode, &p, T, UT); 3222c6fd2807SJeff Garzik ata_timing_merge(&p, t, t, ATA_TIMING_ALL); 3223c6fd2807SJeff Garzik } 3224c6fd2807SJeff Garzik 3225c6fd2807SJeff Garzik /* 3226c6fd2807SJeff Garzik * Lengthen active & recovery time so that cycle time is correct. 3227c6fd2807SJeff Garzik */ 3228c6fd2807SJeff Garzik 3229c6fd2807SJeff Garzik if (t->act8b + t->rec8b < t->cyc8b) { 3230c6fd2807SJeff Garzik t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2; 3231c6fd2807SJeff Garzik t->rec8b = t->cyc8b - t->act8b; 3232c6fd2807SJeff Garzik } 3233c6fd2807SJeff Garzik 3234c6fd2807SJeff Garzik if (t->active + t->recover < t->cycle) { 3235c6fd2807SJeff Garzik t->active += (t->cycle - (t->active + t->recover)) / 2; 3236c6fd2807SJeff Garzik t->recover = t->cycle - t->active; 3237c6fd2807SJeff Garzik } 32384f701d1eSAlan Cox 32394f701d1eSAlan Cox /* In a few cases quantisation may produce enough errors to 32404f701d1eSAlan Cox leave t->cycle too low for the sum of active and recovery 32414f701d1eSAlan Cox if so we must correct this */ 32424f701d1eSAlan Cox if (t->active + t->recover > t->cycle) 32434f701d1eSAlan Cox t->cycle = t->active + t->recover; 3244c6fd2807SJeff Garzik 3245c6fd2807SJeff Garzik return 0; 3246c6fd2807SJeff Garzik } 3247c6fd2807SJeff Garzik 3248c6fd2807SJeff Garzik /** 3249a0f79b92STejun Heo * ata_timing_cycle2mode - find xfer mode for the specified cycle duration 3250a0f79b92STejun Heo * @xfer_shift: ATA_SHIFT_* value for transfer type to examine. 3251a0f79b92STejun Heo * @cycle: cycle duration in ns 3252a0f79b92STejun Heo * 3253a0f79b92STejun Heo * Return matching xfer mode for @cycle. The returned mode is of 3254a0f79b92STejun Heo * the transfer type specified by @xfer_shift. If @cycle is too 3255a0f79b92STejun Heo * slow for @xfer_shift, 0xff is returned. If @cycle is faster 3256a0f79b92STejun Heo * than the fastest known mode, the fasted mode is returned. 3257a0f79b92STejun Heo * 3258a0f79b92STejun Heo * LOCKING: 3259a0f79b92STejun Heo * None. 3260a0f79b92STejun Heo * 3261a0f79b92STejun Heo * RETURNS: 3262a0f79b92STejun Heo * Matching xfer_mode, 0xff if no match found. 3263a0f79b92STejun Heo */ 3264a0f79b92STejun Heo u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle) 3265a0f79b92STejun Heo { 3266a0f79b92STejun Heo u8 base_mode = 0xff, last_mode = 0xff; 3267a0f79b92STejun Heo const struct ata_xfer_ent *ent; 3268a0f79b92STejun Heo const struct ata_timing *t; 3269a0f79b92STejun Heo 3270a0f79b92STejun Heo for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 3271a0f79b92STejun Heo if (ent->shift == xfer_shift) 3272a0f79b92STejun Heo base_mode = ent->base; 3273a0f79b92STejun Heo 3274a0f79b92STejun Heo for (t = ata_timing_find_mode(base_mode); 3275a0f79b92STejun Heo t && ata_xfer_mode2shift(t->mode) == xfer_shift; t++) { 3276a0f79b92STejun Heo unsigned short this_cycle; 3277a0f79b92STejun Heo 3278a0f79b92STejun Heo switch (xfer_shift) { 3279a0f79b92STejun Heo case ATA_SHIFT_PIO: 3280a0f79b92STejun Heo case ATA_SHIFT_MWDMA: 3281a0f79b92STejun Heo this_cycle = t->cycle; 3282a0f79b92STejun Heo break; 3283a0f79b92STejun Heo case ATA_SHIFT_UDMA: 3284a0f79b92STejun Heo this_cycle = t->udma; 3285a0f79b92STejun Heo break; 3286a0f79b92STejun Heo default: 3287a0f79b92STejun Heo return 0xff; 3288a0f79b92STejun Heo } 3289a0f79b92STejun Heo 3290a0f79b92STejun Heo if (cycle > this_cycle) 3291a0f79b92STejun Heo break; 3292a0f79b92STejun Heo 3293a0f79b92STejun Heo last_mode = t->mode; 3294a0f79b92STejun Heo } 3295a0f79b92STejun Heo 3296a0f79b92STejun Heo return last_mode; 3297a0f79b92STejun Heo } 3298a0f79b92STejun Heo 3299a0f79b92STejun Heo /** 3300c6fd2807SJeff Garzik * ata_down_xfermask_limit - adjust dev xfer masks downward 3301c6fd2807SJeff Garzik * @dev: Device to adjust xfer masks 3302458337dbSTejun Heo * @sel: ATA_DNXFER_* selector 3303c6fd2807SJeff Garzik * 3304c6fd2807SJeff Garzik * Adjust xfer masks of @dev downward. Note that this function 3305c6fd2807SJeff Garzik * does not apply the change. Invoking ata_set_mode() afterwards 3306c6fd2807SJeff Garzik * will apply the limit. 3307c6fd2807SJeff Garzik * 3308c6fd2807SJeff Garzik * LOCKING: 3309c6fd2807SJeff Garzik * Inherited from caller. 3310c6fd2807SJeff Garzik * 3311c6fd2807SJeff Garzik * RETURNS: 3312c6fd2807SJeff Garzik * 0 on success, negative errno on failure 3313c6fd2807SJeff Garzik */ 3314458337dbSTejun Heo int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel) 3315c6fd2807SJeff Garzik { 3316458337dbSTejun Heo char buf[32]; 33177dc951aeSTejun Heo unsigned long orig_mask, xfer_mask; 33187dc951aeSTejun Heo unsigned long pio_mask, mwdma_mask, udma_mask; 3319458337dbSTejun Heo int quiet, highbit; 3320c6fd2807SJeff Garzik 3321458337dbSTejun Heo quiet = !!(sel & ATA_DNXFER_QUIET); 3322458337dbSTejun Heo sel &= ~ATA_DNXFER_QUIET; 3323458337dbSTejun Heo 3324458337dbSTejun Heo xfer_mask = orig_mask = ata_pack_xfermask(dev->pio_mask, 3325458337dbSTejun Heo dev->mwdma_mask, 3326c6fd2807SJeff Garzik dev->udma_mask); 3327458337dbSTejun Heo ata_unpack_xfermask(xfer_mask, &pio_mask, &mwdma_mask, &udma_mask); 3328c6fd2807SJeff Garzik 3329458337dbSTejun Heo switch (sel) { 3330458337dbSTejun Heo case ATA_DNXFER_PIO: 3331458337dbSTejun Heo highbit = fls(pio_mask) - 1; 3332458337dbSTejun Heo pio_mask &= ~(1 << highbit); 3333458337dbSTejun Heo break; 3334458337dbSTejun Heo 3335458337dbSTejun Heo case ATA_DNXFER_DMA: 3336458337dbSTejun Heo if (udma_mask) { 3337458337dbSTejun Heo highbit = fls(udma_mask) - 1; 3338458337dbSTejun Heo udma_mask &= ~(1 << highbit); 3339458337dbSTejun Heo if (!udma_mask) 3340458337dbSTejun Heo return -ENOENT; 3341458337dbSTejun Heo } else if (mwdma_mask) { 3342458337dbSTejun Heo highbit = fls(mwdma_mask) - 1; 3343458337dbSTejun Heo mwdma_mask &= ~(1 << highbit); 3344458337dbSTejun Heo if (!mwdma_mask) 3345458337dbSTejun Heo return -ENOENT; 3346458337dbSTejun Heo } 3347458337dbSTejun Heo break; 3348458337dbSTejun Heo 3349458337dbSTejun Heo case ATA_DNXFER_40C: 3350458337dbSTejun Heo udma_mask &= ATA_UDMA_MASK_40C; 3351458337dbSTejun Heo break; 3352458337dbSTejun Heo 3353458337dbSTejun Heo case ATA_DNXFER_FORCE_PIO0: 3354458337dbSTejun Heo pio_mask &= 1; 3355458337dbSTejun Heo case ATA_DNXFER_FORCE_PIO: 3356458337dbSTejun Heo mwdma_mask = 0; 3357458337dbSTejun Heo udma_mask = 0; 3358458337dbSTejun Heo break; 3359458337dbSTejun Heo 3360458337dbSTejun Heo default: 3361458337dbSTejun Heo BUG(); 3362458337dbSTejun Heo } 3363458337dbSTejun Heo 3364458337dbSTejun Heo xfer_mask &= ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask); 3365458337dbSTejun Heo 3366458337dbSTejun Heo if (!(xfer_mask & ATA_MASK_PIO) || xfer_mask == orig_mask) 3367458337dbSTejun Heo return -ENOENT; 3368458337dbSTejun Heo 3369458337dbSTejun Heo if (!quiet) { 3370458337dbSTejun Heo if (xfer_mask & (ATA_MASK_MWDMA | ATA_MASK_UDMA)) 3371458337dbSTejun Heo snprintf(buf, sizeof(buf), "%s:%s", 3372458337dbSTejun Heo ata_mode_string(xfer_mask), 3373458337dbSTejun Heo ata_mode_string(xfer_mask & ATA_MASK_PIO)); 3374458337dbSTejun Heo else 3375458337dbSTejun Heo snprintf(buf, sizeof(buf), "%s", 3376458337dbSTejun Heo ata_mode_string(xfer_mask)); 3377458337dbSTejun Heo 3378458337dbSTejun Heo ata_dev_printk(dev, KERN_WARNING, 3379458337dbSTejun Heo "limiting speed to %s\n", buf); 3380458337dbSTejun Heo } 3381c6fd2807SJeff Garzik 3382c6fd2807SJeff Garzik ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask, 3383c6fd2807SJeff Garzik &dev->udma_mask); 3384c6fd2807SJeff Garzik 3385c6fd2807SJeff Garzik return 0; 3386c6fd2807SJeff Garzik } 3387c6fd2807SJeff Garzik 3388c6fd2807SJeff Garzik static int ata_dev_set_mode(struct ata_device *dev) 3389c6fd2807SJeff Garzik { 33909af5c9c9STejun Heo struct ata_eh_context *ehc = &dev->link->eh_context; 33914055dee7STejun Heo const char *dev_err_whine = ""; 33924055dee7STejun Heo int ign_dev_err = 0; 3393c6fd2807SJeff Garzik unsigned int err_mask; 3394c6fd2807SJeff Garzik int rc; 3395c6fd2807SJeff Garzik 3396c6fd2807SJeff Garzik dev->flags &= ~ATA_DFLAG_PIO; 3397c6fd2807SJeff Garzik if (dev->xfer_shift == ATA_SHIFT_PIO) 3398c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_PIO; 3399c6fd2807SJeff Garzik 3400c6fd2807SJeff Garzik err_mask = ata_dev_set_xfermode(dev); 34012dcb407eSJeff Garzik 34024055dee7STejun Heo if (err_mask & ~AC_ERR_DEV) 34034055dee7STejun Heo goto fail; 34042dcb407eSJeff Garzik 34054055dee7STejun Heo /* revalidate */ 3406baa1e78aSTejun Heo ehc->i.flags |= ATA_EHI_POST_SETMODE; 3407422c9daaSTejun Heo rc = ata_dev_revalidate(dev, ATA_DEV_UNKNOWN, 0); 3408baa1e78aSTejun Heo ehc->i.flags &= ~ATA_EHI_POST_SETMODE; 3409c6fd2807SJeff Garzik if (rc) 3410c6fd2807SJeff Garzik return rc; 3411c6fd2807SJeff Garzik 3412b93fda12SAlan Cox if (dev->xfer_shift == ATA_SHIFT_PIO) { 34134055dee7STejun Heo /* Old CFA may refuse this command, which is just fine */ 3414b93fda12SAlan Cox if (ata_id_is_cfa(dev->id)) 34154055dee7STejun Heo ign_dev_err = 1; 3416b93fda12SAlan Cox /* Catch several broken garbage emulations plus some pre 3417b93fda12SAlan Cox ATA devices */ 3418b93fda12SAlan Cox if (ata_id_major_version(dev->id) == 0 && 34194055dee7STejun Heo dev->pio_mode <= XFER_PIO_2) 34204055dee7STejun Heo ign_dev_err = 1; 3421b93fda12SAlan Cox /* Some very old devices and some bad newer ones fail 3422b93fda12SAlan Cox any kind of SET_XFERMODE request but support PIO0-2 3423b93fda12SAlan Cox timings and no IORDY */ 3424b93fda12SAlan Cox if (!ata_id_has_iordy(dev->id) && dev->pio_mode <= XFER_PIO_2) 3425b93fda12SAlan Cox ign_dev_err = 1; 3426b93fda12SAlan Cox } 34274055dee7STejun Heo /* Early MWDMA devices do DMA but don't allow DMA mode setting. 34284055dee7STejun Heo Don't fail an MWDMA0 set IFF the device indicates it is in MWDMA0 */ 34294055dee7STejun Heo if (dev->xfer_shift == ATA_SHIFT_MWDMA && 34304055dee7STejun Heo dev->dma_mode == XFER_MW_DMA_0 && 34314055dee7STejun Heo (dev->id[63] >> 8) & 1) 34324055dee7STejun Heo ign_dev_err = 1; 34334055dee7STejun Heo 34344055dee7STejun Heo /* if the device is actually configured correctly, ignore dev err */ 34354055dee7STejun Heo if (dev->xfer_mode == ata_xfer_mask2mode(ata_id_xfermask(dev->id))) 34364055dee7STejun Heo ign_dev_err = 1; 34374055dee7STejun Heo 34384055dee7STejun Heo if (err_mask & AC_ERR_DEV) { 34394055dee7STejun Heo if (!ign_dev_err) 34404055dee7STejun Heo goto fail; 34414055dee7STejun Heo else 34424055dee7STejun Heo dev_err_whine = " (device error ignored)"; 34434055dee7STejun Heo } 34444055dee7STejun Heo 3445c6fd2807SJeff Garzik DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n", 3446c6fd2807SJeff Garzik dev->xfer_shift, (int)dev->xfer_mode); 3447c6fd2807SJeff Garzik 34484055dee7STejun Heo ata_dev_printk(dev, KERN_INFO, "configured for %s%s\n", 34494055dee7STejun Heo ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)), 34504055dee7STejun Heo dev_err_whine); 34514055dee7STejun Heo 3452c6fd2807SJeff Garzik return 0; 34534055dee7STejun Heo 34544055dee7STejun Heo fail: 34554055dee7STejun Heo ata_dev_printk(dev, KERN_ERR, "failed to set xfermode " 34564055dee7STejun Heo "(err_mask=0x%x)\n", err_mask); 34574055dee7STejun Heo return -EIO; 3458c6fd2807SJeff Garzik } 3459c6fd2807SJeff Garzik 3460c6fd2807SJeff Garzik /** 346104351821SAlan * ata_do_set_mode - Program timings and issue SET FEATURES - XFER 34620260731fSTejun Heo * @link: link on which timings will be programmed 34631967b7ffSJoe Perches * @r_failed_dev: out parameter for failed device 3464c6fd2807SJeff Garzik * 346504351821SAlan * Standard implementation of the function used to tune and set 346604351821SAlan * ATA device disk transfer mode (PIO3, UDMA6, etc.). If 346704351821SAlan * ata_dev_set_mode() fails, pointer to the failing device is 3468c6fd2807SJeff Garzik * returned in @r_failed_dev. 3469c6fd2807SJeff Garzik * 3470c6fd2807SJeff Garzik * LOCKING: 3471c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 3472c6fd2807SJeff Garzik * 3473c6fd2807SJeff Garzik * RETURNS: 3474c6fd2807SJeff Garzik * 0 on success, negative errno otherwise 3475c6fd2807SJeff Garzik */ 347604351821SAlan 34770260731fSTejun Heo int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev) 3478c6fd2807SJeff Garzik { 34790260731fSTejun Heo struct ata_port *ap = link->ap; 3480c6fd2807SJeff Garzik struct ata_device *dev; 3481f58229f8STejun Heo int rc = 0, used_dma = 0, found = 0; 3482c6fd2807SJeff Garzik 3483c6fd2807SJeff Garzik /* step 1: calculate xfer_mask */ 34841eca4365STejun Heo ata_for_each_dev(dev, link, ENABLED) { 34857dc951aeSTejun Heo unsigned long pio_mask, dma_mask; 3486b3a70601SAlan Cox unsigned int mode_mask; 3487c6fd2807SJeff Garzik 3488b3a70601SAlan Cox mode_mask = ATA_DMA_MASK_ATA; 3489b3a70601SAlan Cox if (dev->class == ATA_DEV_ATAPI) 3490b3a70601SAlan Cox mode_mask = ATA_DMA_MASK_ATAPI; 3491b3a70601SAlan Cox else if (ata_id_is_cfa(dev->id)) 3492b3a70601SAlan Cox mode_mask = ATA_DMA_MASK_CFA; 3493b3a70601SAlan Cox 3494c6fd2807SJeff Garzik ata_dev_xfermask(dev); 349533267325STejun Heo ata_force_xfermask(dev); 3496c6fd2807SJeff Garzik 3497c6fd2807SJeff Garzik pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0); 3498c6fd2807SJeff Garzik dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask); 3499b3a70601SAlan Cox 3500b3a70601SAlan Cox if (libata_dma_mask & mode_mask) 3501b3a70601SAlan Cox dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask); 3502b3a70601SAlan Cox else 3503b3a70601SAlan Cox dma_mask = 0; 3504b3a70601SAlan Cox 3505c6fd2807SJeff Garzik dev->pio_mode = ata_xfer_mask2mode(pio_mask); 3506c6fd2807SJeff Garzik dev->dma_mode = ata_xfer_mask2mode(dma_mask); 3507c6fd2807SJeff Garzik 3508c6fd2807SJeff Garzik found = 1; 3509b15b3ebaSAlan Cox if (ata_dma_enabled(dev)) 3510c6fd2807SJeff Garzik used_dma = 1; 3511c6fd2807SJeff Garzik } 3512c6fd2807SJeff Garzik if (!found) 3513c6fd2807SJeff Garzik goto out; 3514c6fd2807SJeff Garzik 3515c6fd2807SJeff Garzik /* step 2: always set host PIO timings */ 35161eca4365STejun Heo ata_for_each_dev(dev, link, ENABLED) { 351770cd071eSTejun Heo if (dev->pio_mode == 0xff) { 3518c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "no PIO support\n"); 3519c6fd2807SJeff Garzik rc = -EINVAL; 3520c6fd2807SJeff Garzik goto out; 3521c6fd2807SJeff Garzik } 3522c6fd2807SJeff Garzik 3523c6fd2807SJeff Garzik dev->xfer_mode = dev->pio_mode; 3524c6fd2807SJeff Garzik dev->xfer_shift = ATA_SHIFT_PIO; 3525c6fd2807SJeff Garzik if (ap->ops->set_piomode) 3526c6fd2807SJeff Garzik ap->ops->set_piomode(ap, dev); 3527c6fd2807SJeff Garzik } 3528c6fd2807SJeff Garzik 3529c6fd2807SJeff Garzik /* step 3: set host DMA timings */ 35301eca4365STejun Heo ata_for_each_dev(dev, link, ENABLED) { 35311eca4365STejun Heo if (!ata_dma_enabled(dev)) 3532c6fd2807SJeff Garzik continue; 3533c6fd2807SJeff Garzik 3534c6fd2807SJeff Garzik dev->xfer_mode = dev->dma_mode; 3535c6fd2807SJeff Garzik dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode); 3536c6fd2807SJeff Garzik if (ap->ops->set_dmamode) 3537c6fd2807SJeff Garzik ap->ops->set_dmamode(ap, dev); 3538c6fd2807SJeff Garzik } 3539c6fd2807SJeff Garzik 3540c6fd2807SJeff Garzik /* step 4: update devices' xfer mode */ 35411eca4365STejun Heo ata_for_each_dev(dev, link, ENABLED) { 3542c6fd2807SJeff Garzik rc = ata_dev_set_mode(dev); 3543c6fd2807SJeff Garzik if (rc) 3544c6fd2807SJeff Garzik goto out; 3545c6fd2807SJeff Garzik } 3546c6fd2807SJeff Garzik 3547c6fd2807SJeff Garzik /* Record simplex status. If we selected DMA then the other 3548c6fd2807SJeff Garzik * host channels are not permitted to do so. 3549c6fd2807SJeff Garzik */ 3550cca3974eSJeff Garzik if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX)) 3551032af1ceSAlan ap->host->simplex_claimed = ap; 3552c6fd2807SJeff Garzik 3553c6fd2807SJeff Garzik out: 3554c6fd2807SJeff Garzik if (rc) 3555c6fd2807SJeff Garzik *r_failed_dev = dev; 3556c6fd2807SJeff Garzik return rc; 3557c6fd2807SJeff Garzik } 3558c6fd2807SJeff Garzik 3559c6fd2807SJeff Garzik /** 3560aa2731adSTejun Heo * ata_wait_ready - wait for link to become ready 3561aa2731adSTejun Heo * @link: link to be waited on 3562aa2731adSTejun Heo * @deadline: deadline jiffies for the operation 3563aa2731adSTejun Heo * @check_ready: callback to check link readiness 3564aa2731adSTejun Heo * 3565aa2731adSTejun Heo * Wait for @link to become ready. @check_ready should return 3566aa2731adSTejun Heo * positive number if @link is ready, 0 if it isn't, -ENODEV if 3567aa2731adSTejun Heo * link doesn't seem to be occupied, other errno for other error 3568aa2731adSTejun Heo * conditions. 3569aa2731adSTejun Heo * 3570aa2731adSTejun Heo * Transient -ENODEV conditions are allowed for 3571aa2731adSTejun Heo * ATA_TMOUT_FF_WAIT. 3572aa2731adSTejun Heo * 3573aa2731adSTejun Heo * LOCKING: 3574aa2731adSTejun Heo * EH context. 3575aa2731adSTejun Heo * 3576aa2731adSTejun Heo * RETURNS: 3577aa2731adSTejun Heo * 0 if @linke is ready before @deadline; otherwise, -errno. 3578aa2731adSTejun Heo */ 3579aa2731adSTejun Heo int ata_wait_ready(struct ata_link *link, unsigned long deadline, 3580aa2731adSTejun Heo int (*check_ready)(struct ata_link *link)) 3581aa2731adSTejun Heo { 3582aa2731adSTejun Heo unsigned long start = jiffies; 3583341c2c95STejun Heo unsigned long nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT); 3584aa2731adSTejun Heo int warned = 0; 3585aa2731adSTejun Heo 3586b1c72916STejun Heo /* Slave readiness can't be tested separately from master. On 3587b1c72916STejun Heo * M/S emulation configuration, this function should be called 3588b1c72916STejun Heo * only on the master and it will handle both master and slave. 3589b1c72916STejun Heo */ 3590b1c72916STejun Heo WARN_ON(link == link->ap->slave_link); 3591b1c72916STejun Heo 3592aa2731adSTejun Heo if (time_after(nodev_deadline, deadline)) 3593aa2731adSTejun Heo nodev_deadline = deadline; 3594aa2731adSTejun Heo 3595aa2731adSTejun Heo while (1) { 3596aa2731adSTejun Heo unsigned long now = jiffies; 3597aa2731adSTejun Heo int ready, tmp; 3598aa2731adSTejun Heo 3599aa2731adSTejun Heo ready = tmp = check_ready(link); 3600aa2731adSTejun Heo if (ready > 0) 3601aa2731adSTejun Heo return 0; 3602aa2731adSTejun Heo 3603aa2731adSTejun Heo /* -ENODEV could be transient. Ignore -ENODEV if link 3604aa2731adSTejun Heo * is online. Also, some SATA devices take a long 3605aa2731adSTejun Heo * time to clear 0xff after reset. For example, 3606aa2731adSTejun Heo * HHD424020F7SV00 iVDR needs >= 800ms while Quantum 3607aa2731adSTejun Heo * GoVault needs even more than that. Wait for 3608aa2731adSTejun Heo * ATA_TMOUT_FF_WAIT on -ENODEV if link isn't offline. 3609aa2731adSTejun Heo * 3610aa2731adSTejun Heo * Note that some PATA controllers (pata_ali) explode 3611aa2731adSTejun Heo * if status register is read more than once when 3612aa2731adSTejun Heo * there's no device attached. 3613aa2731adSTejun Heo */ 3614aa2731adSTejun Heo if (ready == -ENODEV) { 3615aa2731adSTejun Heo if (ata_link_online(link)) 3616aa2731adSTejun Heo ready = 0; 3617aa2731adSTejun Heo else if ((link->ap->flags & ATA_FLAG_SATA) && 3618aa2731adSTejun Heo !ata_link_offline(link) && 3619aa2731adSTejun Heo time_before(now, nodev_deadline)) 3620aa2731adSTejun Heo ready = 0; 3621aa2731adSTejun Heo } 3622aa2731adSTejun Heo 3623aa2731adSTejun Heo if (ready) 3624aa2731adSTejun Heo return ready; 3625aa2731adSTejun Heo if (time_after(now, deadline)) 3626aa2731adSTejun Heo return -EBUSY; 3627aa2731adSTejun Heo 3628aa2731adSTejun Heo if (!warned && time_after(now, start + 5 * HZ) && 3629aa2731adSTejun Heo (deadline - now > 3 * HZ)) { 3630aa2731adSTejun Heo ata_link_printk(link, KERN_WARNING, 3631aa2731adSTejun Heo "link is slow to respond, please be patient " 3632aa2731adSTejun Heo "(ready=%d)\n", tmp); 3633aa2731adSTejun Heo warned = 1; 3634aa2731adSTejun Heo } 3635aa2731adSTejun Heo 3636aa2731adSTejun Heo msleep(50); 3637aa2731adSTejun Heo } 3638aa2731adSTejun Heo } 3639aa2731adSTejun Heo 3640aa2731adSTejun Heo /** 3641aa2731adSTejun Heo * ata_wait_after_reset - wait for link to become ready after reset 3642aa2731adSTejun Heo * @link: link to be waited on 3643aa2731adSTejun Heo * @deadline: deadline jiffies for the operation 3644aa2731adSTejun Heo * @check_ready: callback to check link readiness 3645aa2731adSTejun Heo * 3646aa2731adSTejun Heo * Wait for @link to become ready after reset. 3647aa2731adSTejun Heo * 3648aa2731adSTejun Heo * LOCKING: 3649aa2731adSTejun Heo * EH context. 3650aa2731adSTejun Heo * 3651aa2731adSTejun Heo * RETURNS: 3652aa2731adSTejun Heo * 0 if @linke is ready before @deadline; otherwise, -errno. 3653aa2731adSTejun Heo */ 36542b4221bbSHarvey Harrison int ata_wait_after_reset(struct ata_link *link, unsigned long deadline, 3655aa2731adSTejun Heo int (*check_ready)(struct ata_link *link)) 3656aa2731adSTejun Heo { 3657341c2c95STejun Heo msleep(ATA_WAIT_AFTER_RESET); 3658aa2731adSTejun Heo 3659aa2731adSTejun Heo return ata_wait_ready(link, deadline, check_ready); 3660aa2731adSTejun Heo } 3661aa2731adSTejun Heo 3662aa2731adSTejun Heo /** 3663936fd732STejun Heo * sata_link_debounce - debounce SATA phy status 3664936fd732STejun Heo * @link: ATA link to debounce SATA phy status for 3665c6fd2807SJeff Garzik * @params: timing parameters { interval, duratinon, timeout } in msec 3666d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3667c6fd2807SJeff Garzik * 3668936fd732STejun Heo * Make sure SStatus of @link reaches stable state, determined by 3669c6fd2807SJeff Garzik * holding the same value where DET is not 1 for @duration polled 3670c6fd2807SJeff Garzik * every @interval, before @timeout. Timeout constraints the 3671d4b2bab4STejun Heo * beginning of the stable state. Because DET gets stuck at 1 on 3672d4b2bab4STejun Heo * some controllers after hot unplugging, this functions waits 3673c6fd2807SJeff Garzik * until timeout then returns 0 if DET is stable at 1. 3674c6fd2807SJeff Garzik * 3675d4b2bab4STejun Heo * @timeout is further limited by @deadline. The sooner of the 3676d4b2bab4STejun Heo * two is used. 3677d4b2bab4STejun Heo * 3678c6fd2807SJeff Garzik * LOCKING: 3679c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3680c6fd2807SJeff Garzik * 3681c6fd2807SJeff Garzik * RETURNS: 3682c6fd2807SJeff Garzik * 0 on success, -errno on failure. 3683c6fd2807SJeff Garzik */ 3684936fd732STejun Heo int sata_link_debounce(struct ata_link *link, const unsigned long *params, 3685d4b2bab4STejun Heo unsigned long deadline) 3686c6fd2807SJeff Garzik { 3687341c2c95STejun Heo unsigned long interval = params[0]; 3688341c2c95STejun Heo unsigned long duration = params[1]; 3689d4b2bab4STejun Heo unsigned long last_jiffies, t; 3690c6fd2807SJeff Garzik u32 last, cur; 3691c6fd2807SJeff Garzik int rc; 3692c6fd2807SJeff Garzik 3693341c2c95STejun Heo t = ata_deadline(jiffies, params[2]); 3694d4b2bab4STejun Heo if (time_before(t, deadline)) 3695d4b2bab4STejun Heo deadline = t; 3696d4b2bab4STejun Heo 3697936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_STATUS, &cur))) 3698c6fd2807SJeff Garzik return rc; 3699c6fd2807SJeff Garzik cur &= 0xf; 3700c6fd2807SJeff Garzik 3701c6fd2807SJeff Garzik last = cur; 3702c6fd2807SJeff Garzik last_jiffies = jiffies; 3703c6fd2807SJeff Garzik 3704c6fd2807SJeff Garzik while (1) { 3705341c2c95STejun Heo msleep(interval); 3706936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_STATUS, &cur))) 3707c6fd2807SJeff Garzik return rc; 3708c6fd2807SJeff Garzik cur &= 0xf; 3709c6fd2807SJeff Garzik 3710c6fd2807SJeff Garzik /* DET stable? */ 3711c6fd2807SJeff Garzik if (cur == last) { 3712d4b2bab4STejun Heo if (cur == 1 && time_before(jiffies, deadline)) 3713c6fd2807SJeff Garzik continue; 3714341c2c95STejun Heo if (time_after(jiffies, 3715341c2c95STejun Heo ata_deadline(last_jiffies, duration))) 3716c6fd2807SJeff Garzik return 0; 3717c6fd2807SJeff Garzik continue; 3718c6fd2807SJeff Garzik } 3719c6fd2807SJeff Garzik 3720c6fd2807SJeff Garzik /* unstable, start over */ 3721c6fd2807SJeff Garzik last = cur; 3722c6fd2807SJeff Garzik last_jiffies = jiffies; 3723c6fd2807SJeff Garzik 3724f1545154STejun Heo /* Check deadline. If debouncing failed, return 3725f1545154STejun Heo * -EPIPE to tell upper layer to lower link speed. 3726f1545154STejun Heo */ 3727d4b2bab4STejun Heo if (time_after(jiffies, deadline)) 3728f1545154STejun Heo return -EPIPE; 3729c6fd2807SJeff Garzik } 3730c6fd2807SJeff Garzik } 3731c6fd2807SJeff Garzik 3732c6fd2807SJeff Garzik /** 3733936fd732STejun Heo * sata_link_resume - resume SATA link 3734936fd732STejun Heo * @link: ATA link to resume SATA 3735c6fd2807SJeff Garzik * @params: timing parameters { interval, duratinon, timeout } in msec 3736d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3737c6fd2807SJeff Garzik * 3738936fd732STejun Heo * Resume SATA phy @link and debounce it. 3739c6fd2807SJeff Garzik * 3740c6fd2807SJeff Garzik * LOCKING: 3741c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3742c6fd2807SJeff Garzik * 3743c6fd2807SJeff Garzik * RETURNS: 3744c6fd2807SJeff Garzik * 0 on success, -errno on failure. 3745c6fd2807SJeff Garzik */ 3746936fd732STejun Heo int sata_link_resume(struct ata_link *link, const unsigned long *params, 3747d4b2bab4STejun Heo unsigned long deadline) 3748c6fd2807SJeff Garzik { 3749ac371987STejun Heo u32 scontrol, serror; 3750c6fd2807SJeff Garzik int rc; 3751c6fd2807SJeff Garzik 3752936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 3753c6fd2807SJeff Garzik return rc; 3754c6fd2807SJeff Garzik 3755c6fd2807SJeff Garzik scontrol = (scontrol & 0x0f0) | 0x300; 3756c6fd2807SJeff Garzik 3757936fd732STejun Heo if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol))) 3758c6fd2807SJeff Garzik return rc; 3759c6fd2807SJeff Garzik 3760c6fd2807SJeff Garzik /* Some PHYs react badly if SStatus is pounded immediately 3761c6fd2807SJeff Garzik * after resuming. Delay 200ms before debouncing. 3762c6fd2807SJeff Garzik */ 3763c6fd2807SJeff Garzik msleep(200); 3764c6fd2807SJeff Garzik 3765ac371987STejun Heo if ((rc = sata_link_debounce(link, params, deadline))) 3766ac371987STejun Heo return rc; 3767ac371987STejun Heo 3768f046519fSTejun Heo /* clear SError, some PHYs require this even for SRST to work */ 3769ac371987STejun Heo if (!(rc = sata_scr_read(link, SCR_ERROR, &serror))) 3770ac371987STejun Heo rc = sata_scr_write(link, SCR_ERROR, serror); 3771ac371987STejun Heo 3772f046519fSTejun Heo return rc != -EINVAL ? rc : 0; 3773c6fd2807SJeff Garzik } 3774c6fd2807SJeff Garzik 3775c6fd2807SJeff Garzik /** 37760aa1113dSTejun Heo * ata_std_prereset - prepare for reset 3777cc0680a5STejun Heo * @link: ATA link to be reset 3778d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3779c6fd2807SJeff Garzik * 3780cc0680a5STejun Heo * @link is about to be reset. Initialize it. Failure from 3781b8cffc6aSTejun Heo * prereset makes libata abort whole reset sequence and give up 3782b8cffc6aSTejun Heo * that port, so prereset should be best-effort. It does its 3783b8cffc6aSTejun Heo * best to prepare for reset sequence but if things go wrong, it 3784b8cffc6aSTejun Heo * should just whine, not fail. 3785c6fd2807SJeff Garzik * 3786c6fd2807SJeff Garzik * LOCKING: 3787c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3788c6fd2807SJeff Garzik * 3789c6fd2807SJeff Garzik * RETURNS: 3790c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 3791c6fd2807SJeff Garzik */ 37920aa1113dSTejun Heo int ata_std_prereset(struct ata_link *link, unsigned long deadline) 3793c6fd2807SJeff Garzik { 3794cc0680a5STejun Heo struct ata_port *ap = link->ap; 3795936fd732STejun Heo struct ata_eh_context *ehc = &link->eh_context; 3796c6fd2807SJeff Garzik const unsigned long *timing = sata_ehc_deb_timing(ehc); 3797c6fd2807SJeff Garzik int rc; 3798c6fd2807SJeff Garzik 3799c6fd2807SJeff Garzik /* if we're about to do hardreset, nothing more to do */ 3800c6fd2807SJeff Garzik if (ehc->i.action & ATA_EH_HARDRESET) 3801c6fd2807SJeff Garzik return 0; 3802c6fd2807SJeff Garzik 3803936fd732STejun Heo /* if SATA, resume link */ 3804a16abc0bSTejun Heo if (ap->flags & ATA_FLAG_SATA) { 3805936fd732STejun Heo rc = sata_link_resume(link, timing, deadline); 3806b8cffc6aSTejun Heo /* whine about phy resume failure but proceed */ 3807b8cffc6aSTejun Heo if (rc && rc != -EOPNOTSUPP) 3808cc0680a5STejun Heo ata_link_printk(link, KERN_WARNING, "failed to resume " 3809c6fd2807SJeff Garzik "link for reset (errno=%d)\n", rc); 3810c6fd2807SJeff Garzik } 3811c6fd2807SJeff Garzik 381245db2f6cSTejun Heo /* no point in trying softreset on offline link */ 3813b1c72916STejun Heo if (ata_phys_link_offline(link)) 381445db2f6cSTejun Heo ehc->i.action &= ~ATA_EH_SOFTRESET; 381545db2f6cSTejun Heo 3816c6fd2807SJeff Garzik return 0; 3817c6fd2807SJeff Garzik } 3818c6fd2807SJeff Garzik 3819c6fd2807SJeff Garzik /** 3820cc0680a5STejun Heo * sata_link_hardreset - reset link via SATA phy reset 3821cc0680a5STejun Heo * @link: link to reset 3822b6103f6dSTejun Heo * @timing: timing parameters { interval, duratinon, timeout } in msec 3823d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 38249dadd45bSTejun Heo * @online: optional out parameter indicating link onlineness 38259dadd45bSTejun Heo * @check_ready: optional callback to check link readiness 3826c6fd2807SJeff Garzik * 3827cc0680a5STejun Heo * SATA phy-reset @link using DET bits of SControl register. 38289dadd45bSTejun Heo * After hardreset, link readiness is waited upon using 38299dadd45bSTejun Heo * ata_wait_ready() if @check_ready is specified. LLDs are 38309dadd45bSTejun Heo * allowed to not specify @check_ready and wait itself after this 38319dadd45bSTejun Heo * function returns. Device classification is LLD's 38329dadd45bSTejun Heo * responsibility. 38339dadd45bSTejun Heo * 38349dadd45bSTejun Heo * *@online is set to one iff reset succeeded and @link is online 38359dadd45bSTejun Heo * after reset. 3836c6fd2807SJeff Garzik * 3837c6fd2807SJeff Garzik * LOCKING: 3838c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3839c6fd2807SJeff Garzik * 3840c6fd2807SJeff Garzik * RETURNS: 3841c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 3842c6fd2807SJeff Garzik */ 3843cc0680a5STejun Heo int sata_link_hardreset(struct ata_link *link, const unsigned long *timing, 38449dadd45bSTejun Heo unsigned long deadline, 38459dadd45bSTejun Heo bool *online, int (*check_ready)(struct ata_link *)) 3846c6fd2807SJeff Garzik { 3847c6fd2807SJeff Garzik u32 scontrol; 3848c6fd2807SJeff Garzik int rc; 3849c6fd2807SJeff Garzik 3850c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 3851c6fd2807SJeff Garzik 38529dadd45bSTejun Heo if (online) 38539dadd45bSTejun Heo *online = false; 38549dadd45bSTejun Heo 3855936fd732STejun Heo if (sata_set_spd_needed(link)) { 3856c6fd2807SJeff Garzik /* SATA spec says nothing about how to reconfigure 3857c6fd2807SJeff Garzik * spd. To be on the safe side, turn off phy during 3858c6fd2807SJeff Garzik * reconfiguration. This works for at least ICH7 AHCI 3859c6fd2807SJeff Garzik * and Sil3124. 3860c6fd2807SJeff Garzik */ 3861936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 3862b6103f6dSTejun Heo goto out; 3863c6fd2807SJeff Garzik 3864cea0d336SJeff Garzik scontrol = (scontrol & 0x0f0) | 0x304; 3865c6fd2807SJeff Garzik 3866936fd732STejun Heo if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol))) 3867b6103f6dSTejun Heo goto out; 3868c6fd2807SJeff Garzik 3869936fd732STejun Heo sata_set_spd(link); 3870c6fd2807SJeff Garzik } 3871c6fd2807SJeff Garzik 3872c6fd2807SJeff Garzik /* issue phy wake/reset */ 3873936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 3874b6103f6dSTejun Heo goto out; 3875c6fd2807SJeff Garzik 3876c6fd2807SJeff Garzik scontrol = (scontrol & 0x0f0) | 0x301; 3877c6fd2807SJeff Garzik 3878936fd732STejun Heo if ((rc = sata_scr_write_flush(link, SCR_CONTROL, scontrol))) 3879b6103f6dSTejun Heo goto out; 3880c6fd2807SJeff Garzik 3881c6fd2807SJeff Garzik /* Couldn't find anything in SATA I/II specs, but AHCI-1.1 3882c6fd2807SJeff Garzik * 10.4.2 says at least 1 ms. 3883c6fd2807SJeff Garzik */ 3884c6fd2807SJeff Garzik msleep(1); 3885c6fd2807SJeff Garzik 3886936fd732STejun Heo /* bring link back */ 3887936fd732STejun Heo rc = sata_link_resume(link, timing, deadline); 38889dadd45bSTejun Heo if (rc) 38899dadd45bSTejun Heo goto out; 38909dadd45bSTejun Heo /* if link is offline nothing more to do */ 3891b1c72916STejun Heo if (ata_phys_link_offline(link)) 38929dadd45bSTejun Heo goto out; 38939dadd45bSTejun Heo 38949dadd45bSTejun Heo /* Link is online. From this point, -ENODEV too is an error. */ 38959dadd45bSTejun Heo if (online) 38969dadd45bSTejun Heo *online = true; 38979dadd45bSTejun Heo 3898071f44b1STejun Heo if (sata_pmp_supported(link->ap) && ata_is_host_link(link)) { 38999dadd45bSTejun Heo /* If PMP is supported, we have to do follow-up SRST. 39009dadd45bSTejun Heo * Some PMPs don't send D2H Reg FIS after hardreset if 39019dadd45bSTejun Heo * the first port is empty. Wait only for 39029dadd45bSTejun Heo * ATA_TMOUT_PMP_SRST_WAIT. 39039dadd45bSTejun Heo */ 39049dadd45bSTejun Heo if (check_ready) { 39059dadd45bSTejun Heo unsigned long pmp_deadline; 39069dadd45bSTejun Heo 3907341c2c95STejun Heo pmp_deadline = ata_deadline(jiffies, 3908341c2c95STejun Heo ATA_TMOUT_PMP_SRST_WAIT); 39099dadd45bSTejun Heo if (time_after(pmp_deadline, deadline)) 39109dadd45bSTejun Heo pmp_deadline = deadline; 39119dadd45bSTejun Heo ata_wait_ready(link, pmp_deadline, check_ready); 39129dadd45bSTejun Heo } 39139dadd45bSTejun Heo rc = -EAGAIN; 39149dadd45bSTejun Heo goto out; 39159dadd45bSTejun Heo } 39169dadd45bSTejun Heo 39179dadd45bSTejun Heo rc = 0; 39189dadd45bSTejun Heo if (check_ready) 39199dadd45bSTejun Heo rc = ata_wait_ready(link, deadline, check_ready); 3920b6103f6dSTejun Heo out: 39210cbf0711STejun Heo if (rc && rc != -EAGAIN) { 39220cbf0711STejun Heo /* online is set iff link is online && reset succeeded */ 39230cbf0711STejun Heo if (online) 39240cbf0711STejun Heo *online = false; 39259dadd45bSTejun Heo ata_link_printk(link, KERN_ERR, 39269dadd45bSTejun Heo "COMRESET failed (errno=%d)\n", rc); 39270cbf0711STejun Heo } 3928b6103f6dSTejun Heo DPRINTK("EXIT, rc=%d\n", rc); 3929b6103f6dSTejun Heo return rc; 3930b6103f6dSTejun Heo } 3931b6103f6dSTejun Heo 3932b6103f6dSTejun Heo /** 393357c9efdfSTejun Heo * sata_std_hardreset - COMRESET w/o waiting or classification 393457c9efdfSTejun Heo * @link: link to reset 393557c9efdfSTejun Heo * @class: resulting class of attached device 393657c9efdfSTejun Heo * @deadline: deadline jiffies for the operation 393757c9efdfSTejun Heo * 393857c9efdfSTejun Heo * Standard SATA COMRESET w/o waiting or classification. 393957c9efdfSTejun Heo * 394057c9efdfSTejun Heo * LOCKING: 394157c9efdfSTejun Heo * Kernel thread context (may sleep) 394257c9efdfSTejun Heo * 394357c9efdfSTejun Heo * RETURNS: 394457c9efdfSTejun Heo * 0 if link offline, -EAGAIN if link online, -errno on errors. 394557c9efdfSTejun Heo */ 394657c9efdfSTejun Heo int sata_std_hardreset(struct ata_link *link, unsigned int *class, 394757c9efdfSTejun Heo unsigned long deadline) 394857c9efdfSTejun Heo { 394957c9efdfSTejun Heo const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context); 395057c9efdfSTejun Heo bool online; 395157c9efdfSTejun Heo int rc; 395257c9efdfSTejun Heo 395357c9efdfSTejun Heo /* do hardreset */ 395457c9efdfSTejun Heo rc = sata_link_hardreset(link, timing, deadline, &online, NULL); 395557c9efdfSTejun Heo return online ? -EAGAIN : rc; 395657c9efdfSTejun Heo } 395757c9efdfSTejun Heo 395857c9efdfSTejun Heo /** 3959203c75b8STejun Heo * ata_std_postreset - standard postreset callback 3960cc0680a5STejun Heo * @link: the target ata_link 3961c6fd2807SJeff Garzik * @classes: classes of attached devices 3962c6fd2807SJeff Garzik * 3963c6fd2807SJeff Garzik * This function is invoked after a successful reset. Note that 3964c6fd2807SJeff Garzik * the device might have been reset more than once using 3965c6fd2807SJeff Garzik * different reset methods before postreset is invoked. 3966c6fd2807SJeff Garzik * 3967c6fd2807SJeff Garzik * LOCKING: 3968c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3969c6fd2807SJeff Garzik */ 3970203c75b8STejun Heo void ata_std_postreset(struct ata_link *link, unsigned int *classes) 3971c6fd2807SJeff Garzik { 3972f046519fSTejun Heo u32 serror; 3973f046519fSTejun Heo 3974c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 3975c6fd2807SJeff Garzik 3976f046519fSTejun Heo /* reset complete, clear SError */ 3977f046519fSTejun Heo if (!sata_scr_read(link, SCR_ERROR, &serror)) 3978f046519fSTejun Heo sata_scr_write(link, SCR_ERROR, serror); 3979f046519fSTejun Heo 3980c6fd2807SJeff Garzik /* print link status */ 3981936fd732STejun Heo sata_print_link_status(link); 3982c6fd2807SJeff Garzik 3983c6fd2807SJeff Garzik DPRINTK("EXIT\n"); 3984c6fd2807SJeff Garzik } 3985c6fd2807SJeff Garzik 3986c6fd2807SJeff Garzik /** 3987c6fd2807SJeff Garzik * ata_dev_same_device - Determine whether new ID matches configured device 3988c6fd2807SJeff Garzik * @dev: device to compare against 3989c6fd2807SJeff Garzik * @new_class: class of the new device 3990c6fd2807SJeff Garzik * @new_id: IDENTIFY page of the new device 3991c6fd2807SJeff Garzik * 3992c6fd2807SJeff Garzik * Compare @new_class and @new_id against @dev and determine 3993c6fd2807SJeff Garzik * whether @dev is the device indicated by @new_class and 3994c6fd2807SJeff Garzik * @new_id. 3995c6fd2807SJeff Garzik * 3996c6fd2807SJeff Garzik * LOCKING: 3997c6fd2807SJeff Garzik * None. 3998c6fd2807SJeff Garzik * 3999c6fd2807SJeff Garzik * RETURNS: 4000c6fd2807SJeff Garzik * 1 if @dev matches @new_class and @new_id, 0 otherwise. 4001c6fd2807SJeff Garzik */ 4002c6fd2807SJeff Garzik static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class, 4003c6fd2807SJeff Garzik const u16 *new_id) 4004c6fd2807SJeff Garzik { 4005c6fd2807SJeff Garzik const u16 *old_id = dev->id; 4006a0cf733bSTejun Heo unsigned char model[2][ATA_ID_PROD_LEN + 1]; 4007a0cf733bSTejun Heo unsigned char serial[2][ATA_ID_SERNO_LEN + 1]; 4008c6fd2807SJeff Garzik 4009c6fd2807SJeff Garzik if (dev->class != new_class) { 4010c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "class mismatch %d != %d\n", 4011c6fd2807SJeff Garzik dev->class, new_class); 4012c6fd2807SJeff Garzik return 0; 4013c6fd2807SJeff Garzik } 4014c6fd2807SJeff Garzik 4015a0cf733bSTejun Heo ata_id_c_string(old_id, model[0], ATA_ID_PROD, sizeof(model[0])); 4016a0cf733bSTejun Heo ata_id_c_string(new_id, model[1], ATA_ID_PROD, sizeof(model[1])); 4017a0cf733bSTejun Heo ata_id_c_string(old_id, serial[0], ATA_ID_SERNO, sizeof(serial[0])); 4018a0cf733bSTejun Heo ata_id_c_string(new_id, serial[1], ATA_ID_SERNO, sizeof(serial[1])); 4019c6fd2807SJeff Garzik 4020c6fd2807SJeff Garzik if (strcmp(model[0], model[1])) { 4021c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "model number mismatch " 4022c6fd2807SJeff Garzik "'%s' != '%s'\n", model[0], model[1]); 4023c6fd2807SJeff Garzik return 0; 4024c6fd2807SJeff Garzik } 4025c6fd2807SJeff Garzik 4026c6fd2807SJeff Garzik if (strcmp(serial[0], serial[1])) { 4027c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "serial number mismatch " 4028c6fd2807SJeff Garzik "'%s' != '%s'\n", serial[0], serial[1]); 4029c6fd2807SJeff Garzik return 0; 4030c6fd2807SJeff Garzik } 4031c6fd2807SJeff Garzik 4032c6fd2807SJeff Garzik return 1; 4033c6fd2807SJeff Garzik } 4034c6fd2807SJeff Garzik 4035c6fd2807SJeff Garzik /** 4036fe30911bSTejun Heo * ata_dev_reread_id - Re-read IDENTIFY data 40373fae450cSHenrik Kretzschmar * @dev: target ATA device 4038bff04647STejun Heo * @readid_flags: read ID flags 4039c6fd2807SJeff Garzik * 4040c6fd2807SJeff Garzik * Re-read IDENTIFY page and make sure @dev is still attached to 4041c6fd2807SJeff Garzik * the port. 4042c6fd2807SJeff Garzik * 4043c6fd2807SJeff Garzik * LOCKING: 4044c6fd2807SJeff Garzik * Kernel thread context (may sleep) 4045c6fd2807SJeff Garzik * 4046c6fd2807SJeff Garzik * RETURNS: 4047c6fd2807SJeff Garzik * 0 on success, negative errno otherwise 4048c6fd2807SJeff Garzik */ 4049fe30911bSTejun Heo int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags) 4050c6fd2807SJeff Garzik { 4051c6fd2807SJeff Garzik unsigned int class = dev->class; 40529af5c9c9STejun Heo u16 *id = (void *)dev->link->ap->sector_buf; 4053c6fd2807SJeff Garzik int rc; 4054c6fd2807SJeff Garzik 4055c6fd2807SJeff Garzik /* read ID data */ 4056bff04647STejun Heo rc = ata_dev_read_id(dev, &class, readid_flags, id); 4057c6fd2807SJeff Garzik if (rc) 4058fe30911bSTejun Heo return rc; 4059c6fd2807SJeff Garzik 4060c6fd2807SJeff Garzik /* is the device still there? */ 4061fe30911bSTejun Heo if (!ata_dev_same_device(dev, class, id)) 4062fe30911bSTejun Heo return -ENODEV; 4063c6fd2807SJeff Garzik 4064c6fd2807SJeff Garzik memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS); 4065fe30911bSTejun Heo return 0; 4066fe30911bSTejun Heo } 4067fe30911bSTejun Heo 4068fe30911bSTejun Heo /** 4069fe30911bSTejun Heo * ata_dev_revalidate - Revalidate ATA device 4070fe30911bSTejun Heo * @dev: device to revalidate 4071422c9daaSTejun Heo * @new_class: new class code 4072fe30911bSTejun Heo * @readid_flags: read ID flags 4073fe30911bSTejun Heo * 4074fe30911bSTejun Heo * Re-read IDENTIFY page, make sure @dev is still attached to the 4075fe30911bSTejun Heo * port and reconfigure it according to the new IDENTIFY page. 4076fe30911bSTejun Heo * 4077fe30911bSTejun Heo * LOCKING: 4078fe30911bSTejun Heo * Kernel thread context (may sleep) 4079fe30911bSTejun Heo * 4080fe30911bSTejun Heo * RETURNS: 4081fe30911bSTejun Heo * 0 on success, negative errno otherwise 4082fe30911bSTejun Heo */ 4083422c9daaSTejun Heo int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class, 4084422c9daaSTejun Heo unsigned int readid_flags) 4085fe30911bSTejun Heo { 40866ddcd3b0STejun Heo u64 n_sectors = dev->n_sectors; 4087fe30911bSTejun Heo int rc; 4088fe30911bSTejun Heo 4089fe30911bSTejun Heo if (!ata_dev_enabled(dev)) 4090fe30911bSTejun Heo return -ENODEV; 4091fe30911bSTejun Heo 4092422c9daaSTejun Heo /* fail early if !ATA && !ATAPI to avoid issuing [P]IDENTIFY to PMP */ 4093422c9daaSTejun Heo if (ata_class_enabled(new_class) && 4094f0d0613dSBorislav Petkov new_class != ATA_DEV_ATA && 4095f0d0613dSBorislav Petkov new_class != ATA_DEV_ATAPI && 4096f0d0613dSBorislav Petkov new_class != ATA_DEV_SEMB) { 4097422c9daaSTejun Heo ata_dev_printk(dev, KERN_INFO, "class mismatch %u != %u\n", 4098422c9daaSTejun Heo dev->class, new_class); 4099422c9daaSTejun Heo rc = -ENODEV; 4100422c9daaSTejun Heo goto fail; 4101422c9daaSTejun Heo } 4102422c9daaSTejun Heo 4103fe30911bSTejun Heo /* re-read ID */ 4104fe30911bSTejun Heo rc = ata_dev_reread_id(dev, readid_flags); 4105fe30911bSTejun Heo if (rc) 4106fe30911bSTejun Heo goto fail; 4107c6fd2807SJeff Garzik 4108c6fd2807SJeff Garzik /* configure device according to the new ID */ 4109efdaedc4STejun Heo rc = ata_dev_configure(dev); 41106ddcd3b0STejun Heo if (rc) 41116ddcd3b0STejun Heo goto fail; 41126ddcd3b0STejun Heo 41136ddcd3b0STejun Heo /* verify n_sectors hasn't changed */ 4114b54eebd6STejun Heo if (dev->class == ATA_DEV_ATA && n_sectors && 4115b54eebd6STejun Heo dev->n_sectors != n_sectors) { 41166ddcd3b0STejun Heo ata_dev_printk(dev, KERN_INFO, "n_sectors mismatch " 41176ddcd3b0STejun Heo "%llu != %llu\n", 41186ddcd3b0STejun Heo (unsigned long long)n_sectors, 41196ddcd3b0STejun Heo (unsigned long long)dev->n_sectors); 41208270bec4STejun Heo 41218270bec4STejun Heo /* restore original n_sectors */ 41228270bec4STejun Heo dev->n_sectors = n_sectors; 41238270bec4STejun Heo 41246ddcd3b0STejun Heo rc = -ENODEV; 41256ddcd3b0STejun Heo goto fail; 41266ddcd3b0STejun Heo } 41276ddcd3b0STejun Heo 4128c6fd2807SJeff Garzik return 0; 4129c6fd2807SJeff Garzik 4130c6fd2807SJeff Garzik fail: 4131c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_ERR, "revalidation failed (errno=%d)\n", rc); 4132c6fd2807SJeff Garzik return rc; 4133c6fd2807SJeff Garzik } 4134c6fd2807SJeff Garzik 41356919a0a6SAlan Cox struct ata_blacklist_entry { 41366919a0a6SAlan Cox const char *model_num; 41376919a0a6SAlan Cox const char *model_rev; 41386919a0a6SAlan Cox unsigned long horkage; 41396919a0a6SAlan Cox }; 41406919a0a6SAlan Cox 41416919a0a6SAlan Cox static const struct ata_blacklist_entry ata_device_blacklist [] = { 41426919a0a6SAlan Cox /* Devices with DMA related problems under Linux */ 41436919a0a6SAlan Cox { "WDC AC11000H", NULL, ATA_HORKAGE_NODMA }, 41446919a0a6SAlan Cox { "WDC AC22100H", NULL, ATA_HORKAGE_NODMA }, 41456919a0a6SAlan Cox { "WDC AC32500H", NULL, ATA_HORKAGE_NODMA }, 41466919a0a6SAlan Cox { "WDC AC33100H", NULL, ATA_HORKAGE_NODMA }, 41476919a0a6SAlan Cox { "WDC AC31600H", NULL, ATA_HORKAGE_NODMA }, 41486919a0a6SAlan Cox { "WDC AC32100H", "24.09P07", ATA_HORKAGE_NODMA }, 41496919a0a6SAlan Cox { "WDC AC23200L", "21.10N21", ATA_HORKAGE_NODMA }, 41506919a0a6SAlan Cox { "Compaq CRD-8241B", NULL, ATA_HORKAGE_NODMA }, 41516919a0a6SAlan Cox { "CRD-8400B", NULL, ATA_HORKAGE_NODMA }, 41526919a0a6SAlan Cox { "CRD-8480B", NULL, ATA_HORKAGE_NODMA }, 41536919a0a6SAlan Cox { "CRD-8482B", NULL, ATA_HORKAGE_NODMA }, 41546919a0a6SAlan Cox { "CRD-84", NULL, ATA_HORKAGE_NODMA }, 41556919a0a6SAlan Cox { "SanDisk SDP3B", NULL, ATA_HORKAGE_NODMA }, 41566919a0a6SAlan Cox { "SanDisk SDP3B-64", NULL, ATA_HORKAGE_NODMA }, 41576919a0a6SAlan Cox { "SANYO CD-ROM CRD", NULL, ATA_HORKAGE_NODMA }, 41586919a0a6SAlan Cox { "HITACHI CDR-8", NULL, ATA_HORKAGE_NODMA }, 41596919a0a6SAlan Cox { "HITACHI CDR-8335", NULL, ATA_HORKAGE_NODMA }, 41606919a0a6SAlan Cox { "HITACHI CDR-8435", NULL, ATA_HORKAGE_NODMA }, 41616919a0a6SAlan Cox { "Toshiba CD-ROM XM-6202B", NULL, ATA_HORKAGE_NODMA }, 41626919a0a6SAlan Cox { "TOSHIBA CD-ROM XM-1702BC", NULL, ATA_HORKAGE_NODMA }, 41636919a0a6SAlan Cox { "CD-532E-A", NULL, ATA_HORKAGE_NODMA }, 41646919a0a6SAlan Cox { "E-IDE CD-ROM CR-840",NULL, ATA_HORKAGE_NODMA }, 41656919a0a6SAlan Cox { "CD-ROM Drive/F5A", NULL, ATA_HORKAGE_NODMA }, 41666919a0a6SAlan Cox { "WPI CDD-820", NULL, ATA_HORKAGE_NODMA }, 41676919a0a6SAlan Cox { "SAMSUNG CD-ROM SC-148C", NULL, ATA_HORKAGE_NODMA }, 41686919a0a6SAlan Cox { "SAMSUNG CD-ROM SC", NULL, ATA_HORKAGE_NODMA }, 41696919a0a6SAlan Cox { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA }, 41706919a0a6SAlan Cox { "_NEC DV5800A", NULL, ATA_HORKAGE_NODMA }, 41716919a0a6SAlan Cox { "SAMSUNG CD-ROM SN-124", "N001", ATA_HORKAGE_NODMA }, 417239f19886SDave Jones { "Seagate STT20000A", NULL, ATA_HORKAGE_NODMA }, 41733af9a77aSTejun Heo /* Odd clown on sil3726/4726 PMPs */ 417450af2fa1STejun Heo { "Config Disk", NULL, ATA_HORKAGE_DISABLE }, 41756919a0a6SAlan Cox 417618d6e9d5SAlbert Lee /* Weird ATAPI devices */ 417740a1d531STejun Heo { "TORiSAN DVD-ROM DRD-N216", NULL, ATA_HORKAGE_MAX_SEC_128 }, 41786a87e42eSTejun Heo { "QUANTUM DAT DAT72-000", NULL, ATA_HORKAGE_ATAPI_MOD16_DMA }, 417918d6e9d5SAlbert Lee 41806919a0a6SAlan Cox /* Devices we expect to fail diagnostics */ 41816919a0a6SAlan Cox 41826919a0a6SAlan Cox /* Devices where NCQ should be avoided */ 41836919a0a6SAlan Cox /* NCQ is slow */ 41846919a0a6SAlan Cox { "WDC WD740ADFD-00", NULL, ATA_HORKAGE_NONCQ }, 4185459ad688STejun Heo { "WDC WD740ADFD-00NLR1", NULL, ATA_HORKAGE_NONCQ, }, 418609125ea6STejun Heo /* http://thread.gmane.org/gmane.linux.ide/14907 */ 418709125ea6STejun Heo { "FUJITSU MHT2060BH", NULL, ATA_HORKAGE_NONCQ }, 41887acfaf30SPaul Rolland /* NCQ is broken */ 4189539cc7c7SJeff Garzik { "Maxtor *", "BANC*", ATA_HORKAGE_NONCQ }, 41900e3dbc01SAlan Cox { "Maxtor 7V300F0", "VA111630", ATA_HORKAGE_NONCQ }, 4191da6f0ec2SPaolo Ornati { "ST380817AS", "3.42", ATA_HORKAGE_NONCQ }, 4192e41bd3e8STejun Heo { "ST3160023AS", "3.42", ATA_HORKAGE_NONCQ }, 41935ccfca97SLubomir Bulej { "OCZ CORE_SSD", "02.10104", ATA_HORKAGE_NONCQ }, 4194539cc7c7SJeff Garzik 4195ac70a964STejun Heo /* Seagate NCQ + FLUSH CACHE firmware bug */ 4196d10d491fSTejun Heo { "ST31500341AS", "SD15", ATA_HORKAGE_NONCQ | 4197ac70a964STejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4198d10d491fSTejun Heo { "ST31500341AS", "SD16", ATA_HORKAGE_NONCQ | 4199ac70a964STejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4200d10d491fSTejun Heo { "ST31500341AS", "SD17", ATA_HORKAGE_NONCQ | 4201ac70a964STejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4202d10d491fSTejun Heo { "ST31500341AS", "SD18", ATA_HORKAGE_NONCQ | 4203ac70a964STejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4204d10d491fSTejun Heo { "ST31500341AS", "SD19", ATA_HORKAGE_NONCQ | 4205ac70a964STejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4206d10d491fSTejun Heo 4207d10d491fSTejun Heo { "ST31000333AS", "SD15", ATA_HORKAGE_NONCQ | 4208d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4209d10d491fSTejun Heo { "ST31000333AS", "SD16", ATA_HORKAGE_NONCQ | 4210d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4211d10d491fSTejun Heo { "ST31000333AS", "SD17", ATA_HORKAGE_NONCQ | 4212d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4213d10d491fSTejun Heo { "ST31000333AS", "SD18", ATA_HORKAGE_NONCQ | 4214d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4215d10d491fSTejun Heo { "ST31000333AS", "SD19", ATA_HORKAGE_NONCQ | 4216d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4217d10d491fSTejun Heo 4218d10d491fSTejun Heo { "ST3640623AS", "SD15", ATA_HORKAGE_NONCQ | 4219d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4220d10d491fSTejun Heo { "ST3640623AS", "SD16", ATA_HORKAGE_NONCQ | 4221d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4222d10d491fSTejun Heo { "ST3640623AS", "SD17", ATA_HORKAGE_NONCQ | 4223d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4224d10d491fSTejun Heo { "ST3640623AS", "SD18", ATA_HORKAGE_NONCQ | 4225d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4226d10d491fSTejun Heo { "ST3640623AS", "SD19", ATA_HORKAGE_NONCQ | 4227d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4228d10d491fSTejun Heo 4229d10d491fSTejun Heo { "ST3640323AS", "SD15", ATA_HORKAGE_NONCQ | 4230d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4231d10d491fSTejun Heo { "ST3640323AS", "SD16", ATA_HORKAGE_NONCQ | 4232d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4233d10d491fSTejun Heo { "ST3640323AS", "SD17", ATA_HORKAGE_NONCQ | 4234d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4235d10d491fSTejun Heo { "ST3640323AS", "SD18", ATA_HORKAGE_NONCQ | 4236d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4237d10d491fSTejun Heo { "ST3640323AS", "SD19", ATA_HORKAGE_NONCQ | 4238d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4239d10d491fSTejun Heo 4240d10d491fSTejun Heo { "ST3320813AS", "SD15", ATA_HORKAGE_NONCQ | 4241d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4242d10d491fSTejun Heo { "ST3320813AS", "SD16", ATA_HORKAGE_NONCQ | 4243d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4244d10d491fSTejun Heo { "ST3320813AS", "SD17", ATA_HORKAGE_NONCQ | 4245d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4246d10d491fSTejun Heo { "ST3320813AS", "SD18", ATA_HORKAGE_NONCQ | 4247d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4248d10d491fSTejun Heo { "ST3320813AS", "SD19", ATA_HORKAGE_NONCQ | 4249d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4250d10d491fSTejun Heo 4251d10d491fSTejun Heo { "ST3320613AS", "SD15", ATA_HORKAGE_NONCQ | 4252d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4253d10d491fSTejun Heo { "ST3320613AS", "SD16", ATA_HORKAGE_NONCQ | 4254d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4255d10d491fSTejun Heo { "ST3320613AS", "SD17", ATA_HORKAGE_NONCQ | 4256d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4257d10d491fSTejun Heo { "ST3320613AS", "SD18", ATA_HORKAGE_NONCQ | 4258d10d491fSTejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4259d10d491fSTejun Heo { "ST3320613AS", "SD19", ATA_HORKAGE_NONCQ | 4260ac70a964STejun Heo ATA_HORKAGE_FIRMWARE_WARN }, 4261ac70a964STejun Heo 426236e337d0SRobert Hancock /* Blacklist entries taken from Silicon Image 3124/3132 426336e337d0SRobert Hancock Windows driver .inf file - also several Linux problem reports */ 426436e337d0SRobert Hancock { "HTS541060G9SA00", "MB3OC60D", ATA_HORKAGE_NONCQ, }, 426536e337d0SRobert Hancock { "HTS541080G9SA00", "MB4OC60D", ATA_HORKAGE_NONCQ, }, 426636e337d0SRobert Hancock { "HTS541010G9SA00", "MBZOC60D", ATA_HORKAGE_NONCQ, }, 42676919a0a6SAlan Cox 426816c55b03STejun Heo /* devices which puke on READ_NATIVE_MAX */ 426916c55b03STejun Heo { "HDS724040KLSA80", "KFAOA20N", ATA_HORKAGE_BROKEN_HPA, }, 427016c55b03STejun Heo { "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_HORKAGE_BROKEN_HPA }, 427116c55b03STejun Heo { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA }, 427216c55b03STejun Heo { "MAXTOR 6L080L4", "A93.0500", ATA_HORKAGE_BROKEN_HPA }, 42736919a0a6SAlan Cox 427493328e11SAlan Cox /* Devices which report 1 sector over size HPA */ 427593328e11SAlan Cox { "ST340823A", NULL, ATA_HORKAGE_HPA_SIZE, }, 427693328e11SAlan Cox { "ST320413A", NULL, ATA_HORKAGE_HPA_SIZE, }, 4277b152fcd3SMikko Rapeli { "ST310211A", NULL, ATA_HORKAGE_HPA_SIZE, }, 427893328e11SAlan Cox 42796bbfd53dSAlan Cox /* Devices which get the IVB wrong */ 42806bbfd53dSAlan Cox { "QUANTUM FIREBALLlct10 05", "A03.0900", ATA_HORKAGE_IVB, }, 4281a79067e5SAlan Cox /* Maybe we should just blacklist TSSTcorp... */ 4282a79067e5SAlan Cox { "TSSTcorp CDDVDW SH-S202H", "SB00", ATA_HORKAGE_IVB, }, 4283a79067e5SAlan Cox { "TSSTcorp CDDVDW SH-S202H", "SB01", ATA_HORKAGE_IVB, }, 42846bbfd53dSAlan Cox { "TSSTcorp CDDVDW SH-S202J", "SB00", ATA_HORKAGE_IVB, }, 4285e9f33406SPeter Missel { "TSSTcorp CDDVDW SH-S202J", "SB01", ATA_HORKAGE_IVB, }, 4286e9f33406SPeter Missel { "TSSTcorp CDDVDW SH-S202N", "SB00", ATA_HORKAGE_IVB, }, 4287e9f33406SPeter Missel { "TSSTcorp CDDVDW SH-S202N", "SB01", ATA_HORKAGE_IVB, }, 42886bbfd53dSAlan Cox 42899ce8e307SJens Axboe /* Devices that do not need bridging limits applied */ 42909ce8e307SJens Axboe { "MTRON MSP-SATA*", NULL, ATA_HORKAGE_BRIDGE_OK, }, 42919ce8e307SJens Axboe 42929062712fSTejun Heo /* Devices which aren't very happy with higher link speeds */ 42939062712fSTejun Heo { "WD My Book", NULL, ATA_HORKAGE_1_5_GBPS, }, 42949062712fSTejun Heo 42956919a0a6SAlan Cox /* End Marker */ 42966919a0a6SAlan Cox { } 4297c6fd2807SJeff Garzik }; 4298c6fd2807SJeff Garzik 4299741b7763SAdrian Bunk static int strn_pattern_cmp(const char *patt, const char *name, int wildchar) 4300539cc7c7SJeff Garzik { 4301539cc7c7SJeff Garzik const char *p; 4302539cc7c7SJeff Garzik int len; 4303539cc7c7SJeff Garzik 4304539cc7c7SJeff Garzik /* 4305539cc7c7SJeff Garzik * check for trailing wildcard: *\0 4306539cc7c7SJeff Garzik */ 4307539cc7c7SJeff Garzik p = strchr(patt, wildchar); 4308539cc7c7SJeff Garzik if (p && ((*(p + 1)) == 0)) 4309539cc7c7SJeff Garzik len = p - patt; 4310317b50b8SAndrew Paprocki else { 4311539cc7c7SJeff Garzik len = strlen(name); 4312317b50b8SAndrew Paprocki if (!len) { 4313317b50b8SAndrew Paprocki if (!*patt) 4314317b50b8SAndrew Paprocki return 0; 4315317b50b8SAndrew Paprocki return -1; 4316317b50b8SAndrew Paprocki } 4317317b50b8SAndrew Paprocki } 4318539cc7c7SJeff Garzik 4319539cc7c7SJeff Garzik return strncmp(patt, name, len); 4320539cc7c7SJeff Garzik } 4321539cc7c7SJeff Garzik 432275683fe7STejun Heo static unsigned long ata_dev_blacklisted(const struct ata_device *dev) 4323c6fd2807SJeff Garzik { 43248bfa79fcSTejun Heo unsigned char model_num[ATA_ID_PROD_LEN + 1]; 43258bfa79fcSTejun Heo unsigned char model_rev[ATA_ID_FW_REV_LEN + 1]; 43266919a0a6SAlan Cox const struct ata_blacklist_entry *ad = ata_device_blacklist; 4327c6fd2807SJeff Garzik 43288bfa79fcSTejun Heo ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num)); 43298bfa79fcSTejun Heo ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev)); 4330c6fd2807SJeff Garzik 43316919a0a6SAlan Cox while (ad->model_num) { 4332539cc7c7SJeff Garzik if (!strn_pattern_cmp(ad->model_num, model_num, '*')) { 43336919a0a6SAlan Cox if (ad->model_rev == NULL) 43346919a0a6SAlan Cox return ad->horkage; 4335539cc7c7SJeff Garzik if (!strn_pattern_cmp(ad->model_rev, model_rev, '*')) 43366919a0a6SAlan Cox return ad->horkage; 4337c6fd2807SJeff Garzik } 43386919a0a6SAlan Cox ad++; 4339c6fd2807SJeff Garzik } 4340c6fd2807SJeff Garzik return 0; 4341c6fd2807SJeff Garzik } 4342c6fd2807SJeff Garzik 43436919a0a6SAlan Cox static int ata_dma_blacklisted(const struct ata_device *dev) 43446919a0a6SAlan Cox { 43456919a0a6SAlan Cox /* We don't support polling DMA. 43466919a0a6SAlan Cox * DMA blacklist those ATAPI devices with CDB-intr (and use PIO) 43476919a0a6SAlan Cox * if the LLDD handles only interrupts in the HSM_ST_LAST state. 43486919a0a6SAlan Cox */ 43499af5c9c9STejun Heo if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) && 43506919a0a6SAlan Cox (dev->flags & ATA_DFLAG_CDB_INTR)) 43516919a0a6SAlan Cox return 1; 435275683fe7STejun Heo return (dev->horkage & ATA_HORKAGE_NODMA) ? 1 : 0; 43536919a0a6SAlan Cox } 43546919a0a6SAlan Cox 4355c6fd2807SJeff Garzik /** 43566bbfd53dSAlan Cox * ata_is_40wire - check drive side detection 43576bbfd53dSAlan Cox * @dev: device 43586bbfd53dSAlan Cox * 43596bbfd53dSAlan Cox * Perform drive side detection decoding, allowing for device vendors 43606bbfd53dSAlan Cox * who can't follow the documentation. 43616bbfd53dSAlan Cox */ 43626bbfd53dSAlan Cox 43636bbfd53dSAlan Cox static int ata_is_40wire(struct ata_device *dev) 43646bbfd53dSAlan Cox { 43656bbfd53dSAlan Cox if (dev->horkage & ATA_HORKAGE_IVB) 43666bbfd53dSAlan Cox return ata_drive_40wire_relaxed(dev->id); 43676bbfd53dSAlan Cox return ata_drive_40wire(dev->id); 43686bbfd53dSAlan Cox } 43696bbfd53dSAlan Cox 43706bbfd53dSAlan Cox /** 437115a5551cSAlan Cox * cable_is_40wire - 40/80/SATA decider 437215a5551cSAlan Cox * @ap: port to consider 437315a5551cSAlan Cox * 437415a5551cSAlan Cox * This function encapsulates the policy for speed management 437515a5551cSAlan Cox * in one place. At the moment we don't cache the result but 437615a5551cSAlan Cox * there is a good case for setting ap->cbl to the result when 437715a5551cSAlan Cox * we are called with unknown cables (and figuring out if it 437815a5551cSAlan Cox * impacts hotplug at all). 437915a5551cSAlan Cox * 438015a5551cSAlan Cox * Return 1 if the cable appears to be 40 wire. 438115a5551cSAlan Cox */ 438215a5551cSAlan Cox 438315a5551cSAlan Cox static int cable_is_40wire(struct ata_port *ap) 438415a5551cSAlan Cox { 438515a5551cSAlan Cox struct ata_link *link; 438615a5551cSAlan Cox struct ata_device *dev; 438715a5551cSAlan Cox 43884a9c7b33STejun Heo /* If the controller thinks we are 40 wire, we are. */ 438915a5551cSAlan Cox if (ap->cbl == ATA_CBL_PATA40) 439015a5551cSAlan Cox return 1; 43914a9c7b33STejun Heo 43924a9c7b33STejun Heo /* If the controller thinks we are 80 wire, we are. */ 439315a5551cSAlan Cox if (ap->cbl == ATA_CBL_PATA80 || ap->cbl == ATA_CBL_SATA) 439415a5551cSAlan Cox return 0; 43954a9c7b33STejun Heo 43964a9c7b33STejun Heo /* If the system is known to be 40 wire short cable (eg 43974a9c7b33STejun Heo * laptop), then we allow 80 wire modes even if the drive 43984a9c7b33STejun Heo * isn't sure. 43994a9c7b33STejun Heo */ 4400f792068eSAlan Cox if (ap->cbl == ATA_CBL_PATA40_SHORT) 4401f792068eSAlan Cox return 0; 440215a5551cSAlan Cox 44034a9c7b33STejun Heo /* If the controller doesn't know, we scan. 44044a9c7b33STejun Heo * 44054a9c7b33STejun Heo * Note: We look for all 40 wire detects at this point. Any 44064a9c7b33STejun Heo * 80 wire detect is taken to be 80 wire cable because 44074a9c7b33STejun Heo * - in many setups only the one drive (slave if present) will 44084a9c7b33STejun Heo * give a valid detect 44094a9c7b33STejun Heo * - if you have a non detect capable drive you don't want it 44104a9c7b33STejun Heo * to colour the choice 441115a5551cSAlan Cox */ 44121eca4365STejun Heo ata_for_each_link(link, ap, EDGE) { 44131eca4365STejun Heo ata_for_each_dev(dev, link, ENABLED) { 44141eca4365STejun Heo if (!ata_is_40wire(dev)) 441515a5551cSAlan Cox return 0; 441615a5551cSAlan Cox } 441715a5551cSAlan Cox } 441815a5551cSAlan Cox return 1; 441915a5551cSAlan Cox } 442015a5551cSAlan Cox 442115a5551cSAlan Cox /** 4422c6fd2807SJeff Garzik * ata_dev_xfermask - Compute supported xfermask of the given device 4423c6fd2807SJeff Garzik * @dev: Device to compute xfermask for 4424c6fd2807SJeff Garzik * 4425c6fd2807SJeff Garzik * Compute supported xfermask of @dev and store it in 4426c6fd2807SJeff Garzik * dev->*_mask. This function is responsible for applying all 4427c6fd2807SJeff Garzik * known limits including host controller limits, device 4428c6fd2807SJeff Garzik * blacklist, etc... 4429c6fd2807SJeff Garzik * 4430c6fd2807SJeff Garzik * LOCKING: 4431c6fd2807SJeff Garzik * None. 4432c6fd2807SJeff Garzik */ 4433c6fd2807SJeff Garzik static void ata_dev_xfermask(struct ata_device *dev) 4434c6fd2807SJeff Garzik { 44359af5c9c9STejun Heo struct ata_link *link = dev->link; 44369af5c9c9STejun Heo struct ata_port *ap = link->ap; 4437cca3974eSJeff Garzik struct ata_host *host = ap->host; 4438c6fd2807SJeff Garzik unsigned long xfer_mask; 4439c6fd2807SJeff Garzik 4440c6fd2807SJeff Garzik /* controller modes available */ 4441c6fd2807SJeff Garzik xfer_mask = ata_pack_xfermask(ap->pio_mask, 4442c6fd2807SJeff Garzik ap->mwdma_mask, ap->udma_mask); 4443c6fd2807SJeff Garzik 44448343f889SRobert Hancock /* drive modes available */ 4445c6fd2807SJeff Garzik xfer_mask &= ata_pack_xfermask(dev->pio_mask, 4446c6fd2807SJeff Garzik dev->mwdma_mask, dev->udma_mask); 4447c6fd2807SJeff Garzik xfer_mask &= ata_id_xfermask(dev->id); 4448c6fd2807SJeff Garzik 4449b352e57dSAlan Cox /* 4450b352e57dSAlan Cox * CFA Advanced TrueIDE timings are not allowed on a shared 4451b352e57dSAlan Cox * cable 4452b352e57dSAlan Cox */ 4453b352e57dSAlan Cox if (ata_dev_pair(dev)) { 4454b352e57dSAlan Cox /* No PIO5 or PIO6 */ 4455b352e57dSAlan Cox xfer_mask &= ~(0x03 << (ATA_SHIFT_PIO + 5)); 4456b352e57dSAlan Cox /* No MWDMA3 or MWDMA 4 */ 4457b352e57dSAlan Cox xfer_mask &= ~(0x03 << (ATA_SHIFT_MWDMA + 3)); 4458b352e57dSAlan Cox } 4459b352e57dSAlan Cox 4460c6fd2807SJeff Garzik if (ata_dma_blacklisted(dev)) { 4461c6fd2807SJeff Garzik xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA); 4462c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 4463c6fd2807SJeff Garzik "device is on DMA blacklist, disabling DMA\n"); 4464c6fd2807SJeff Garzik } 4465c6fd2807SJeff Garzik 446614d66ab7SPetr Vandrovec if ((host->flags & ATA_HOST_SIMPLEX) && 446714d66ab7SPetr Vandrovec host->simplex_claimed && host->simplex_claimed != ap) { 4468c6fd2807SJeff Garzik xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA); 4469c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "simplex DMA is claimed by " 4470c6fd2807SJeff Garzik "other device, disabling DMA\n"); 4471c6fd2807SJeff Garzik } 4472c6fd2807SJeff Garzik 4473e424675fSJeff Garzik if (ap->flags & ATA_FLAG_NO_IORDY) 4474e424675fSJeff Garzik xfer_mask &= ata_pio_mask_no_iordy(dev); 4475e424675fSJeff Garzik 4476c6fd2807SJeff Garzik if (ap->ops->mode_filter) 4477a76b62caSAlan Cox xfer_mask = ap->ops->mode_filter(dev, xfer_mask); 4478c6fd2807SJeff Garzik 44798343f889SRobert Hancock /* Apply cable rule here. Don't apply it early because when 44808343f889SRobert Hancock * we handle hot plug the cable type can itself change. 44818343f889SRobert Hancock * Check this last so that we know if the transfer rate was 44828343f889SRobert Hancock * solely limited by the cable. 44838343f889SRobert Hancock * Unknown or 80 wire cables reported host side are checked 44848343f889SRobert Hancock * drive side as well. Cases where we know a 40wire cable 44858343f889SRobert Hancock * is used safely for 80 are not checked here. 44868343f889SRobert Hancock */ 44878343f889SRobert Hancock if (xfer_mask & (0xF8 << ATA_SHIFT_UDMA)) 44888343f889SRobert Hancock /* UDMA/44 or higher would be available */ 448915a5551cSAlan Cox if (cable_is_40wire(ap)) { 44908343f889SRobert Hancock ata_dev_printk(dev, KERN_WARNING, 44918343f889SRobert Hancock "limited to UDMA/33 due to 40-wire cable\n"); 44928343f889SRobert Hancock xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA); 44938343f889SRobert Hancock } 44948343f889SRobert Hancock 4495c6fd2807SJeff Garzik ata_unpack_xfermask(xfer_mask, &dev->pio_mask, 4496c6fd2807SJeff Garzik &dev->mwdma_mask, &dev->udma_mask); 4497c6fd2807SJeff Garzik } 4498c6fd2807SJeff Garzik 4499c6fd2807SJeff Garzik /** 4500c6fd2807SJeff Garzik * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command 4501c6fd2807SJeff Garzik * @dev: Device to which command will be sent 4502c6fd2807SJeff Garzik * 4503c6fd2807SJeff Garzik * Issue SET FEATURES - XFER MODE command to device @dev 4504c6fd2807SJeff Garzik * on port @ap. 4505c6fd2807SJeff Garzik * 4506c6fd2807SJeff Garzik * LOCKING: 4507c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 4508c6fd2807SJeff Garzik * 4509c6fd2807SJeff Garzik * RETURNS: 4510c6fd2807SJeff Garzik * 0 on success, AC_ERR_* mask otherwise. 4511c6fd2807SJeff Garzik */ 4512c6fd2807SJeff Garzik 4513c6fd2807SJeff Garzik static unsigned int ata_dev_set_xfermode(struct ata_device *dev) 4514c6fd2807SJeff Garzik { 4515c6fd2807SJeff Garzik struct ata_taskfile tf; 4516c6fd2807SJeff Garzik unsigned int err_mask; 4517c6fd2807SJeff Garzik 4518c6fd2807SJeff Garzik /* set up set-features taskfile */ 4519c6fd2807SJeff Garzik DPRINTK("set features - xfer mode\n"); 4520c6fd2807SJeff Garzik 4521464cf177STejun Heo /* Some controllers and ATAPI devices show flaky interrupt 4522464cf177STejun Heo * behavior after setting xfer mode. Use polling instead. 4523464cf177STejun Heo */ 4524c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 4525c6fd2807SJeff Garzik tf.command = ATA_CMD_SET_FEATURES; 4526c6fd2807SJeff Garzik tf.feature = SETFEATURES_XFER; 4527464cf177STejun Heo tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_POLLING; 4528c6fd2807SJeff Garzik tf.protocol = ATA_PROT_NODATA; 4529b9f8ab2dSAlan Cox /* If we are using IORDY we must send the mode setting command */ 4530b9f8ab2dSAlan Cox if (ata_pio_need_iordy(dev)) 4531c6fd2807SJeff Garzik tf.nsect = dev->xfer_mode; 4532b9f8ab2dSAlan Cox /* If the device has IORDY and the controller does not - turn it off */ 4533b9f8ab2dSAlan Cox else if (ata_id_has_iordy(dev->id)) 4534b9f8ab2dSAlan Cox tf.nsect = 0x01; 4535b9f8ab2dSAlan Cox else /* In the ancient relic department - skip all of this */ 4536b9f8ab2dSAlan Cox return 0; 4537c6fd2807SJeff Garzik 45382b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 4539c6fd2807SJeff Garzik 4540c6fd2807SJeff Garzik DPRINTK("EXIT, err_mask=%x\n", err_mask); 4541c6fd2807SJeff Garzik return err_mask; 4542c6fd2807SJeff Garzik } 4543c6fd2807SJeff Garzik /** 4544218f3d30SJeff Garzik * ata_dev_set_feature - Issue SET FEATURES - SATA FEATURES 45459f45cbd3SKristen Carlson Accardi * @dev: Device to which command will be sent 45469f45cbd3SKristen Carlson Accardi * @enable: Whether to enable or disable the feature 4547218f3d30SJeff Garzik * @feature: The sector count represents the feature to set 45489f45cbd3SKristen Carlson Accardi * 45499f45cbd3SKristen Carlson Accardi * Issue SET FEATURES - SATA FEATURES command to device @dev 4550218f3d30SJeff Garzik * on port @ap with sector count 45519f45cbd3SKristen Carlson Accardi * 45529f45cbd3SKristen Carlson Accardi * LOCKING: 45539f45cbd3SKristen Carlson Accardi * PCI/etc. bus probe sem. 45549f45cbd3SKristen Carlson Accardi * 45559f45cbd3SKristen Carlson Accardi * RETURNS: 45569f45cbd3SKristen Carlson Accardi * 0 on success, AC_ERR_* mask otherwise. 45579f45cbd3SKristen Carlson Accardi */ 4558218f3d30SJeff Garzik static unsigned int ata_dev_set_feature(struct ata_device *dev, u8 enable, 4559218f3d30SJeff Garzik u8 feature) 45609f45cbd3SKristen Carlson Accardi { 45619f45cbd3SKristen Carlson Accardi struct ata_taskfile tf; 45629f45cbd3SKristen Carlson Accardi unsigned int err_mask; 45639f45cbd3SKristen Carlson Accardi 45649f45cbd3SKristen Carlson Accardi /* set up set-features taskfile */ 45659f45cbd3SKristen Carlson Accardi DPRINTK("set features - SATA features\n"); 45669f45cbd3SKristen Carlson Accardi 45679f45cbd3SKristen Carlson Accardi ata_tf_init(dev, &tf); 45689f45cbd3SKristen Carlson Accardi tf.command = ATA_CMD_SET_FEATURES; 45699f45cbd3SKristen Carlson Accardi tf.feature = enable; 45709f45cbd3SKristen Carlson Accardi tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 45719f45cbd3SKristen Carlson Accardi tf.protocol = ATA_PROT_NODATA; 4572218f3d30SJeff Garzik tf.nsect = feature; 45739f45cbd3SKristen Carlson Accardi 45742b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 45759f45cbd3SKristen Carlson Accardi 45769f45cbd3SKristen Carlson Accardi DPRINTK("EXIT, err_mask=%x\n", err_mask); 45779f45cbd3SKristen Carlson Accardi return err_mask; 45789f45cbd3SKristen Carlson Accardi } 45799f45cbd3SKristen Carlson Accardi 45809f45cbd3SKristen Carlson Accardi /** 4581c6fd2807SJeff Garzik * ata_dev_init_params - Issue INIT DEV PARAMS command 4582c6fd2807SJeff Garzik * @dev: Device to which command will be sent 4583c6fd2807SJeff Garzik * @heads: Number of heads (taskfile parameter) 4584c6fd2807SJeff Garzik * @sectors: Number of sectors (taskfile parameter) 4585c6fd2807SJeff Garzik * 4586c6fd2807SJeff Garzik * LOCKING: 4587c6fd2807SJeff Garzik * Kernel thread context (may sleep) 4588c6fd2807SJeff Garzik * 4589c6fd2807SJeff Garzik * RETURNS: 4590c6fd2807SJeff Garzik * 0 on success, AC_ERR_* mask otherwise. 4591c6fd2807SJeff Garzik */ 4592c6fd2807SJeff Garzik static unsigned int ata_dev_init_params(struct ata_device *dev, 4593c6fd2807SJeff Garzik u16 heads, u16 sectors) 4594c6fd2807SJeff Garzik { 4595c6fd2807SJeff Garzik struct ata_taskfile tf; 4596c6fd2807SJeff Garzik unsigned int err_mask; 4597c6fd2807SJeff Garzik 4598c6fd2807SJeff Garzik /* Number of sectors per track 1-255. Number of heads 1-16 */ 4599c6fd2807SJeff Garzik if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16) 4600c6fd2807SJeff Garzik return AC_ERR_INVALID; 4601c6fd2807SJeff Garzik 4602c6fd2807SJeff Garzik /* set up init dev params taskfile */ 4603c6fd2807SJeff Garzik DPRINTK("init dev params \n"); 4604c6fd2807SJeff Garzik 4605c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 4606c6fd2807SJeff Garzik tf.command = ATA_CMD_INIT_DEV_PARAMS; 4607c6fd2807SJeff Garzik tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 4608c6fd2807SJeff Garzik tf.protocol = ATA_PROT_NODATA; 4609c6fd2807SJeff Garzik tf.nsect = sectors; 4610c6fd2807SJeff Garzik tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */ 4611c6fd2807SJeff Garzik 46122b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 461318b2466cSAlan Cox /* A clean abort indicates an original or just out of spec drive 461418b2466cSAlan Cox and we should continue as we issue the setup based on the 461518b2466cSAlan Cox drive reported working geometry */ 461618b2466cSAlan Cox if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED)) 461718b2466cSAlan Cox err_mask = 0; 4618c6fd2807SJeff Garzik 4619c6fd2807SJeff Garzik DPRINTK("EXIT, err_mask=%x\n", err_mask); 4620c6fd2807SJeff Garzik return err_mask; 4621c6fd2807SJeff Garzik } 4622c6fd2807SJeff Garzik 4623c6fd2807SJeff Garzik /** 4624c6fd2807SJeff Garzik * ata_sg_clean - Unmap DMA memory associated with command 4625c6fd2807SJeff Garzik * @qc: Command containing DMA memory to be released 4626c6fd2807SJeff Garzik * 4627c6fd2807SJeff Garzik * Unmap all mapped DMA memory associated with this command. 4628c6fd2807SJeff Garzik * 4629c6fd2807SJeff Garzik * LOCKING: 4630cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4631c6fd2807SJeff Garzik */ 463270e6ad0cSTejun Heo void ata_sg_clean(struct ata_queued_cmd *qc) 4633c6fd2807SJeff Garzik { 4634c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4635ff2aeb1eSTejun Heo struct scatterlist *sg = qc->sg; 4636c6fd2807SJeff Garzik int dir = qc->dma_dir; 4637c6fd2807SJeff Garzik 4638efcb3cf7STejun Heo WARN_ON_ONCE(sg == NULL); 4639c6fd2807SJeff Garzik 4640dde20207SJames Bottomley VPRINTK("unmapping %u sg elements\n", qc->n_elem); 4641c6fd2807SJeff Garzik 4642dde20207SJames Bottomley if (qc->n_elem) 46435825627cSFUJITA Tomonori dma_unmap_sg(ap->dev, sg, qc->orig_n_elem, dir); 4644c6fd2807SJeff Garzik 4645c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_DMAMAP; 4646ff2aeb1eSTejun Heo qc->sg = NULL; 4647c6fd2807SJeff Garzik } 4648c6fd2807SJeff Garzik 4649c6fd2807SJeff Garzik /** 46505895ef9aSTejun Heo * atapi_check_dma - Check whether ATAPI DMA can be supported 4651c6fd2807SJeff Garzik * @qc: Metadata associated with taskfile to check 4652c6fd2807SJeff Garzik * 4653c6fd2807SJeff Garzik * Allow low-level driver to filter ATA PACKET commands, returning 4654c6fd2807SJeff Garzik * a status indicating whether or not it is OK to use DMA for the 4655c6fd2807SJeff Garzik * supplied PACKET command. 4656c6fd2807SJeff Garzik * 4657c6fd2807SJeff Garzik * LOCKING: 4658cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4659c6fd2807SJeff Garzik * 4660c6fd2807SJeff Garzik * RETURNS: 0 when ATAPI DMA can be used 4661c6fd2807SJeff Garzik * nonzero otherwise 4662c6fd2807SJeff Garzik */ 46635895ef9aSTejun Heo int atapi_check_dma(struct ata_queued_cmd *qc) 4664c6fd2807SJeff Garzik { 4665c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4666c6fd2807SJeff Garzik 4667b9a4197eSTejun Heo /* Don't allow DMA if it isn't multiple of 16 bytes. Quite a 4668b9a4197eSTejun Heo * few ATAPI devices choke on such DMA requests. 4669b9a4197eSTejun Heo */ 46706a87e42eSTejun Heo if (!(qc->dev->horkage & ATA_HORKAGE_ATAPI_MOD16_DMA) && 46716a87e42eSTejun Heo unlikely(qc->nbytes & 15)) 46726f23a31dSAlbert Lee return 1; 46736f23a31dSAlbert Lee 4674c6fd2807SJeff Garzik if (ap->ops->check_atapi_dma) 4675b9a4197eSTejun Heo return ap->ops->check_atapi_dma(qc); 4676c6fd2807SJeff Garzik 4677b9a4197eSTejun Heo return 0; 4678c6fd2807SJeff Garzik } 4679b9a4197eSTejun Heo 4680c6fd2807SJeff Garzik /** 468131cc23b3STejun Heo * ata_std_qc_defer - Check whether a qc needs to be deferred 468231cc23b3STejun Heo * @qc: ATA command in question 468331cc23b3STejun Heo * 468431cc23b3STejun Heo * Non-NCQ commands cannot run with any other command, NCQ or 468531cc23b3STejun Heo * not. As upper layer only knows the queue depth, we are 468631cc23b3STejun Heo * responsible for maintaining exclusion. This function checks 468731cc23b3STejun Heo * whether a new command @qc can be issued. 468831cc23b3STejun Heo * 468931cc23b3STejun Heo * LOCKING: 469031cc23b3STejun Heo * spin_lock_irqsave(host lock) 469131cc23b3STejun Heo * 469231cc23b3STejun Heo * RETURNS: 469331cc23b3STejun Heo * ATA_DEFER_* if deferring is needed, 0 otherwise. 469431cc23b3STejun Heo */ 469531cc23b3STejun Heo int ata_std_qc_defer(struct ata_queued_cmd *qc) 469631cc23b3STejun Heo { 469731cc23b3STejun Heo struct ata_link *link = qc->dev->link; 469831cc23b3STejun Heo 469931cc23b3STejun Heo if (qc->tf.protocol == ATA_PROT_NCQ) { 470031cc23b3STejun Heo if (!ata_tag_valid(link->active_tag)) 470131cc23b3STejun Heo return 0; 470231cc23b3STejun Heo } else { 470331cc23b3STejun Heo if (!ata_tag_valid(link->active_tag) && !link->sactive) 470431cc23b3STejun Heo return 0; 470531cc23b3STejun Heo } 470631cc23b3STejun Heo 470731cc23b3STejun Heo return ATA_DEFER_LINK; 470831cc23b3STejun Heo } 470931cc23b3STejun Heo 4710c6fd2807SJeff Garzik void ata_noop_qc_prep(struct ata_queued_cmd *qc) { } 4711c6fd2807SJeff Garzik 4712c6fd2807SJeff Garzik /** 4713c6fd2807SJeff Garzik * ata_sg_init - Associate command with scatter-gather table. 4714c6fd2807SJeff Garzik * @qc: Command to be associated 4715c6fd2807SJeff Garzik * @sg: Scatter-gather table. 4716c6fd2807SJeff Garzik * @n_elem: Number of elements in s/g table. 4717c6fd2807SJeff Garzik * 4718c6fd2807SJeff Garzik * Initialize the data-related elements of queued_cmd @qc 4719c6fd2807SJeff Garzik * to point to a scatter-gather table @sg, containing @n_elem 4720c6fd2807SJeff Garzik * elements. 4721c6fd2807SJeff Garzik * 4722c6fd2807SJeff Garzik * LOCKING: 4723cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4724c6fd2807SJeff Garzik */ 4725c6fd2807SJeff Garzik void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg, 4726c6fd2807SJeff Garzik unsigned int n_elem) 4727c6fd2807SJeff Garzik { 4728ff2aeb1eSTejun Heo qc->sg = sg; 4729c6fd2807SJeff Garzik qc->n_elem = n_elem; 4730ff2aeb1eSTejun Heo qc->cursg = qc->sg; 4731ff2aeb1eSTejun Heo } 4732ff2aeb1eSTejun Heo 4733c6fd2807SJeff Garzik /** 4734c6fd2807SJeff Garzik * ata_sg_setup - DMA-map the scatter-gather table associated with a command. 4735c6fd2807SJeff Garzik * @qc: Command with scatter-gather table to be mapped. 4736c6fd2807SJeff Garzik * 4737c6fd2807SJeff Garzik * DMA-map the scatter-gather table associated with queued_cmd @qc. 4738c6fd2807SJeff Garzik * 4739c6fd2807SJeff Garzik * LOCKING: 4740cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4741c6fd2807SJeff Garzik * 4742c6fd2807SJeff Garzik * RETURNS: 4743c6fd2807SJeff Garzik * Zero on success, negative on error. 4744c6fd2807SJeff Garzik * 4745c6fd2807SJeff Garzik */ 4746c6fd2807SJeff Garzik static int ata_sg_setup(struct ata_queued_cmd *qc) 4747c6fd2807SJeff Garzik { 4748c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4749dde20207SJames Bottomley unsigned int n_elem; 4750c6fd2807SJeff Garzik 475144877b4eSTejun Heo VPRINTK("ENTER, ata%u\n", ap->print_id); 4752c6fd2807SJeff Garzik 4753dde20207SJames Bottomley n_elem = dma_map_sg(ap->dev, qc->sg, qc->n_elem, qc->dma_dir); 4754dde20207SJames Bottomley if (n_elem < 1) 4755c6fd2807SJeff Garzik return -1; 4756c6fd2807SJeff Garzik 4757dde20207SJames Bottomley DPRINTK("%d sg elements mapped\n", n_elem); 47585825627cSFUJITA Tomonori qc->orig_n_elem = qc->n_elem; 4759dde20207SJames Bottomley qc->n_elem = n_elem; 4760f92a2636STejun Heo qc->flags |= ATA_QCFLAG_DMAMAP; 4761c6fd2807SJeff Garzik 4762c6fd2807SJeff Garzik return 0; 4763c6fd2807SJeff Garzik } 4764c6fd2807SJeff Garzik 4765c6fd2807SJeff Garzik /** 4766c6fd2807SJeff Garzik * swap_buf_le16 - swap halves of 16-bit words in place 4767c6fd2807SJeff Garzik * @buf: Buffer to swap 4768c6fd2807SJeff Garzik * @buf_words: Number of 16-bit words in buffer. 4769c6fd2807SJeff Garzik * 4770c6fd2807SJeff Garzik * Swap halves of 16-bit words if needed to convert from 4771c6fd2807SJeff Garzik * little-endian byte order to native cpu byte order, or 4772c6fd2807SJeff Garzik * vice-versa. 4773c6fd2807SJeff Garzik * 4774c6fd2807SJeff Garzik * LOCKING: 4775c6fd2807SJeff Garzik * Inherited from caller. 4776c6fd2807SJeff Garzik */ 4777c6fd2807SJeff Garzik void swap_buf_le16(u16 *buf, unsigned int buf_words) 4778c6fd2807SJeff Garzik { 4779c6fd2807SJeff Garzik #ifdef __BIG_ENDIAN 4780c6fd2807SJeff Garzik unsigned int i; 4781c6fd2807SJeff Garzik 4782c6fd2807SJeff Garzik for (i = 0; i < buf_words; i++) 4783c6fd2807SJeff Garzik buf[i] = le16_to_cpu(buf[i]); 4784c6fd2807SJeff Garzik #endif /* __BIG_ENDIAN */ 4785c6fd2807SJeff Garzik } 4786c6fd2807SJeff Garzik 4787c6fd2807SJeff Garzik /** 47888a8bc223STejun Heo * ata_qc_new - Request an available ATA command, for queueing 47895eb66fe0SRandy Dunlap * @ap: target port 47908a8bc223STejun Heo * 47918a8bc223STejun Heo * LOCKING: 47928a8bc223STejun Heo * None. 47938a8bc223STejun Heo */ 47948a8bc223STejun Heo 47958a8bc223STejun Heo static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap) 47968a8bc223STejun Heo { 47978a8bc223STejun Heo struct ata_queued_cmd *qc = NULL; 47988a8bc223STejun Heo unsigned int i; 47998a8bc223STejun Heo 48008a8bc223STejun Heo /* no command while frozen */ 48018a8bc223STejun Heo if (unlikely(ap->pflags & ATA_PFLAG_FROZEN)) 48028a8bc223STejun Heo return NULL; 48038a8bc223STejun Heo 48048a8bc223STejun Heo /* the last tag is reserved for internal command. */ 48058a8bc223STejun Heo for (i = 0; i < ATA_MAX_QUEUE - 1; i++) 48068a8bc223STejun Heo if (!test_and_set_bit(i, &ap->qc_allocated)) { 48078a8bc223STejun Heo qc = __ata_qc_from_tag(ap, i); 48088a8bc223STejun Heo break; 48098a8bc223STejun Heo } 48108a8bc223STejun Heo 48118a8bc223STejun Heo if (qc) 48128a8bc223STejun Heo qc->tag = i; 48138a8bc223STejun Heo 48148a8bc223STejun Heo return qc; 48158a8bc223STejun Heo } 48168a8bc223STejun Heo 48178a8bc223STejun Heo /** 4818c6fd2807SJeff Garzik * ata_qc_new_init - Request an available ATA command, and initialize it 4819c6fd2807SJeff Garzik * @dev: Device from whom we request an available command structure 4820c6fd2807SJeff Garzik * 4821c6fd2807SJeff Garzik * LOCKING: 4822c6fd2807SJeff Garzik * None. 4823c6fd2807SJeff Garzik */ 4824c6fd2807SJeff Garzik 48258a8bc223STejun Heo struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev) 4826c6fd2807SJeff Garzik { 48279af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 4828c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 4829c6fd2807SJeff Garzik 48308a8bc223STejun Heo qc = ata_qc_new(ap); 4831c6fd2807SJeff Garzik if (qc) { 4832c6fd2807SJeff Garzik qc->scsicmd = NULL; 4833c6fd2807SJeff Garzik qc->ap = ap; 4834c6fd2807SJeff Garzik qc->dev = dev; 4835c6fd2807SJeff Garzik 4836c6fd2807SJeff Garzik ata_qc_reinit(qc); 4837c6fd2807SJeff Garzik } 4838c6fd2807SJeff Garzik 4839c6fd2807SJeff Garzik return qc; 4840c6fd2807SJeff Garzik } 4841c6fd2807SJeff Garzik 48428a8bc223STejun Heo /** 48438a8bc223STejun Heo * ata_qc_free - free unused ata_queued_cmd 48448a8bc223STejun Heo * @qc: Command to complete 48458a8bc223STejun Heo * 48468a8bc223STejun Heo * Designed to free unused ata_queued_cmd object 48478a8bc223STejun Heo * in case something prevents using it. 48488a8bc223STejun Heo * 48498a8bc223STejun Heo * LOCKING: 48508a8bc223STejun Heo * spin_lock_irqsave(host lock) 48518a8bc223STejun Heo */ 48528a8bc223STejun Heo void ata_qc_free(struct ata_queued_cmd *qc) 48538a8bc223STejun Heo { 48548a8bc223STejun Heo struct ata_port *ap = qc->ap; 48558a8bc223STejun Heo unsigned int tag; 48568a8bc223STejun Heo 4857efcb3cf7STejun Heo WARN_ON_ONCE(qc == NULL); /* ata_qc_from_tag _might_ return NULL */ 48588a8bc223STejun Heo 48598a8bc223STejun Heo qc->flags = 0; 48608a8bc223STejun Heo tag = qc->tag; 48618a8bc223STejun Heo if (likely(ata_tag_valid(tag))) { 48628a8bc223STejun Heo qc->tag = ATA_TAG_POISON; 48638a8bc223STejun Heo clear_bit(tag, &ap->qc_allocated); 48648a8bc223STejun Heo } 48658a8bc223STejun Heo } 48668a8bc223STejun Heo 4867c6fd2807SJeff Garzik void __ata_qc_complete(struct ata_queued_cmd *qc) 4868c6fd2807SJeff Garzik { 4869c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 48709af5c9c9STejun Heo struct ata_link *link = qc->dev->link; 4871c6fd2807SJeff Garzik 4872efcb3cf7STejun Heo WARN_ON_ONCE(qc == NULL); /* ata_qc_from_tag _might_ return NULL */ 4873efcb3cf7STejun Heo WARN_ON_ONCE(!(qc->flags & ATA_QCFLAG_ACTIVE)); 4874c6fd2807SJeff Garzik 4875c6fd2807SJeff Garzik if (likely(qc->flags & ATA_QCFLAG_DMAMAP)) 4876c6fd2807SJeff Garzik ata_sg_clean(qc); 4877c6fd2807SJeff Garzik 4878c6fd2807SJeff Garzik /* command should be marked inactive atomically with qc completion */ 4879da917d69STejun Heo if (qc->tf.protocol == ATA_PROT_NCQ) { 48809af5c9c9STejun Heo link->sactive &= ~(1 << qc->tag); 4881da917d69STejun Heo if (!link->sactive) 4882da917d69STejun Heo ap->nr_active_links--; 4883da917d69STejun Heo } else { 48849af5c9c9STejun Heo link->active_tag = ATA_TAG_POISON; 4885da917d69STejun Heo ap->nr_active_links--; 4886da917d69STejun Heo } 4887da917d69STejun Heo 4888da917d69STejun Heo /* clear exclusive status */ 4889da917d69STejun Heo if (unlikely(qc->flags & ATA_QCFLAG_CLEAR_EXCL && 4890da917d69STejun Heo ap->excl_link == link)) 4891da917d69STejun Heo ap->excl_link = NULL; 4892c6fd2807SJeff Garzik 4893c6fd2807SJeff Garzik /* atapi: mark qc as inactive to prevent the interrupt handler 4894c6fd2807SJeff Garzik * from completing the command twice later, before the error handler 4895c6fd2807SJeff Garzik * is called. (when rc != 0 and atapi request sense is needed) 4896c6fd2807SJeff Garzik */ 4897c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_ACTIVE; 4898c6fd2807SJeff Garzik ap->qc_active &= ~(1 << qc->tag); 4899c6fd2807SJeff Garzik 4900c6fd2807SJeff Garzik /* call completion callback */ 4901c6fd2807SJeff Garzik qc->complete_fn(qc); 4902c6fd2807SJeff Garzik } 4903c6fd2807SJeff Garzik 490439599a53STejun Heo static void fill_result_tf(struct ata_queued_cmd *qc) 490539599a53STejun Heo { 490639599a53STejun Heo struct ata_port *ap = qc->ap; 490739599a53STejun Heo 490839599a53STejun Heo qc->result_tf.flags = qc->tf.flags; 490922183bf5STejun Heo ap->ops->qc_fill_rtf(qc); 491039599a53STejun Heo } 491139599a53STejun Heo 491200115e0fSTejun Heo static void ata_verify_xfer(struct ata_queued_cmd *qc) 491300115e0fSTejun Heo { 491400115e0fSTejun Heo struct ata_device *dev = qc->dev; 491500115e0fSTejun Heo 491600115e0fSTejun Heo if (ata_tag_internal(qc->tag)) 491700115e0fSTejun Heo return; 491800115e0fSTejun Heo 491900115e0fSTejun Heo if (ata_is_nodata(qc->tf.protocol)) 492000115e0fSTejun Heo return; 492100115e0fSTejun Heo 492200115e0fSTejun Heo if ((dev->mwdma_mask || dev->udma_mask) && ata_is_pio(qc->tf.protocol)) 492300115e0fSTejun Heo return; 492400115e0fSTejun Heo 492500115e0fSTejun Heo dev->flags &= ~ATA_DFLAG_DUBIOUS_XFER; 492600115e0fSTejun Heo } 492700115e0fSTejun Heo 4928c6fd2807SJeff Garzik /** 4929c6fd2807SJeff Garzik * ata_qc_complete - Complete an active ATA command 4930c6fd2807SJeff Garzik * @qc: Command to complete 4931c6fd2807SJeff Garzik * 4932c6fd2807SJeff Garzik * Indicate to the mid and upper layers that an ATA 4933c6fd2807SJeff Garzik * command has completed, with either an ok or not-ok status. 4934c6fd2807SJeff Garzik * 4935c6fd2807SJeff Garzik * LOCKING: 4936cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4937c6fd2807SJeff Garzik */ 4938c6fd2807SJeff Garzik void ata_qc_complete(struct ata_queued_cmd *qc) 4939c6fd2807SJeff Garzik { 4940c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4941c6fd2807SJeff Garzik 4942c6fd2807SJeff Garzik /* XXX: New EH and old EH use different mechanisms to 4943c6fd2807SJeff Garzik * synchronize EH with regular execution path. 4944c6fd2807SJeff Garzik * 4945c6fd2807SJeff Garzik * In new EH, a failed qc is marked with ATA_QCFLAG_FAILED. 4946c6fd2807SJeff Garzik * Normal execution path is responsible for not accessing a 4947c6fd2807SJeff Garzik * failed qc. libata core enforces the rule by returning NULL 4948c6fd2807SJeff Garzik * from ata_qc_from_tag() for failed qcs. 4949c6fd2807SJeff Garzik * 4950c6fd2807SJeff Garzik * Old EH depends on ata_qc_complete() nullifying completion 4951c6fd2807SJeff Garzik * requests if ATA_QCFLAG_EH_SCHEDULED is set. Old EH does 4952c6fd2807SJeff Garzik * not synchronize with interrupt handler. Only PIO task is 4953c6fd2807SJeff Garzik * taken care of. 4954c6fd2807SJeff Garzik */ 4955c6fd2807SJeff Garzik if (ap->ops->error_handler) { 49564dbfa39bSTejun Heo struct ata_device *dev = qc->dev; 49574dbfa39bSTejun Heo struct ata_eh_info *ehi = &dev->link->eh_info; 49584dbfa39bSTejun Heo 4959efcb3cf7STejun Heo WARN_ON_ONCE(ap->pflags & ATA_PFLAG_FROZEN); 4960c6fd2807SJeff Garzik 4961c6fd2807SJeff Garzik if (unlikely(qc->err_mask)) 4962c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_FAILED; 4963c6fd2807SJeff Garzik 4964c6fd2807SJeff Garzik if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) { 4965c6fd2807SJeff Garzik if (!ata_tag_internal(qc->tag)) { 4966c6fd2807SJeff Garzik /* always fill result TF for failed qc */ 496739599a53STejun Heo fill_result_tf(qc); 4968c6fd2807SJeff Garzik ata_qc_schedule_eh(qc); 4969c6fd2807SJeff Garzik return; 4970c6fd2807SJeff Garzik } 4971c6fd2807SJeff Garzik } 4972c6fd2807SJeff Garzik 4973c6fd2807SJeff Garzik /* read result TF if requested */ 4974c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_RESULT_TF) 497539599a53STejun Heo fill_result_tf(qc); 4976c6fd2807SJeff Garzik 49774dbfa39bSTejun Heo /* Some commands need post-processing after successful 49784dbfa39bSTejun Heo * completion. 49794dbfa39bSTejun Heo */ 49804dbfa39bSTejun Heo switch (qc->tf.command) { 49814dbfa39bSTejun Heo case ATA_CMD_SET_FEATURES: 49824dbfa39bSTejun Heo if (qc->tf.feature != SETFEATURES_WC_ON && 49834dbfa39bSTejun Heo qc->tf.feature != SETFEATURES_WC_OFF) 49844dbfa39bSTejun Heo break; 49854dbfa39bSTejun Heo /* fall through */ 49864dbfa39bSTejun Heo case ATA_CMD_INIT_DEV_PARAMS: /* CHS translation changed */ 49874dbfa39bSTejun Heo case ATA_CMD_SET_MULTI: /* multi_count changed */ 49884dbfa39bSTejun Heo /* revalidate device */ 49894dbfa39bSTejun Heo ehi->dev_action[dev->devno] |= ATA_EH_REVALIDATE; 49904dbfa39bSTejun Heo ata_port_schedule_eh(ap); 49914dbfa39bSTejun Heo break; 4992054a5fbaSTejun Heo 4993054a5fbaSTejun Heo case ATA_CMD_SLEEP: 4994054a5fbaSTejun Heo dev->flags |= ATA_DFLAG_SLEEPING; 4995054a5fbaSTejun Heo break; 49964dbfa39bSTejun Heo } 49974dbfa39bSTejun Heo 499800115e0fSTejun Heo if (unlikely(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) 499900115e0fSTejun Heo ata_verify_xfer(qc); 500000115e0fSTejun Heo 5001c6fd2807SJeff Garzik __ata_qc_complete(qc); 5002c6fd2807SJeff Garzik } else { 5003c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_EH_SCHEDULED) 5004c6fd2807SJeff Garzik return; 5005c6fd2807SJeff Garzik 5006c6fd2807SJeff Garzik /* read result TF if failed or requested */ 5007c6fd2807SJeff Garzik if (qc->err_mask || qc->flags & ATA_QCFLAG_RESULT_TF) 500839599a53STejun Heo fill_result_tf(qc); 5009c6fd2807SJeff Garzik 5010c6fd2807SJeff Garzik __ata_qc_complete(qc); 5011c6fd2807SJeff Garzik } 5012c6fd2807SJeff Garzik } 5013c6fd2807SJeff Garzik 5014c6fd2807SJeff Garzik /** 5015c6fd2807SJeff Garzik * ata_qc_complete_multiple - Complete multiple qcs successfully 5016c6fd2807SJeff Garzik * @ap: port in question 5017c6fd2807SJeff Garzik * @qc_active: new qc_active mask 5018c6fd2807SJeff Garzik * 5019c6fd2807SJeff Garzik * Complete in-flight commands. This functions is meant to be 5020c6fd2807SJeff Garzik * called from low-level driver's interrupt routine to complete 5021c6fd2807SJeff Garzik * requests normally. ap->qc_active and @qc_active is compared 5022c6fd2807SJeff Garzik * and commands are completed accordingly. 5023c6fd2807SJeff Garzik * 5024c6fd2807SJeff Garzik * LOCKING: 5025cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 5026c6fd2807SJeff Garzik * 5027c6fd2807SJeff Garzik * RETURNS: 5028c6fd2807SJeff Garzik * Number of completed commands on success, -errno otherwise. 5029c6fd2807SJeff Garzik */ 503079f97dadSTejun Heo int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active) 5031c6fd2807SJeff Garzik { 5032c6fd2807SJeff Garzik int nr_done = 0; 5033c6fd2807SJeff Garzik u32 done_mask; 5034c6fd2807SJeff Garzik int i; 5035c6fd2807SJeff Garzik 5036c6fd2807SJeff Garzik done_mask = ap->qc_active ^ qc_active; 5037c6fd2807SJeff Garzik 5038c6fd2807SJeff Garzik if (unlikely(done_mask & qc_active)) { 5039c6fd2807SJeff Garzik ata_port_printk(ap, KERN_ERR, "illegal qc_active transition " 5040c6fd2807SJeff Garzik "(%08x->%08x)\n", ap->qc_active, qc_active); 5041c6fd2807SJeff Garzik return -EINVAL; 5042c6fd2807SJeff Garzik } 5043c6fd2807SJeff Garzik 5044c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_QUEUE; i++) { 5045c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 5046c6fd2807SJeff Garzik 5047c6fd2807SJeff Garzik if (!(done_mask & (1 << i))) 5048c6fd2807SJeff Garzik continue; 5049c6fd2807SJeff Garzik 5050c6fd2807SJeff Garzik if ((qc = ata_qc_from_tag(ap, i))) { 5051c6fd2807SJeff Garzik ata_qc_complete(qc); 5052c6fd2807SJeff Garzik nr_done++; 5053c6fd2807SJeff Garzik } 5054c6fd2807SJeff Garzik } 5055c6fd2807SJeff Garzik 5056c6fd2807SJeff Garzik return nr_done; 5057c6fd2807SJeff Garzik } 5058c6fd2807SJeff Garzik 5059c6fd2807SJeff Garzik /** 5060c6fd2807SJeff Garzik * ata_qc_issue - issue taskfile to device 5061c6fd2807SJeff Garzik * @qc: command to issue to device 5062c6fd2807SJeff Garzik * 5063c6fd2807SJeff Garzik * Prepare an ATA command to submission to device. 5064c6fd2807SJeff Garzik * This includes mapping the data into a DMA-able 5065c6fd2807SJeff Garzik * area, filling in the S/G table, and finally 5066c6fd2807SJeff Garzik * writing the taskfile to hardware, starting the command. 5067c6fd2807SJeff Garzik * 5068c6fd2807SJeff Garzik * LOCKING: 5069cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 5070c6fd2807SJeff Garzik */ 5071c6fd2807SJeff Garzik void ata_qc_issue(struct ata_queued_cmd *qc) 5072c6fd2807SJeff Garzik { 5073c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 50749af5c9c9STejun Heo struct ata_link *link = qc->dev->link; 5075405e66b3STejun Heo u8 prot = qc->tf.protocol; 5076c6fd2807SJeff Garzik 5077c6fd2807SJeff Garzik /* Make sure only one non-NCQ command is outstanding. The 5078c6fd2807SJeff Garzik * check is skipped for old EH because it reuses active qc to 5079c6fd2807SJeff Garzik * request ATAPI sense. 5080c6fd2807SJeff Garzik */ 5081efcb3cf7STejun Heo WARN_ON_ONCE(ap->ops->error_handler && ata_tag_valid(link->active_tag)); 5082c6fd2807SJeff Garzik 50831973a023STejun Heo if (ata_is_ncq(prot)) { 5084efcb3cf7STejun Heo WARN_ON_ONCE(link->sactive & (1 << qc->tag)); 5085da917d69STejun Heo 5086da917d69STejun Heo if (!link->sactive) 5087da917d69STejun Heo ap->nr_active_links++; 50889af5c9c9STejun Heo link->sactive |= 1 << qc->tag; 5089c6fd2807SJeff Garzik } else { 5090efcb3cf7STejun Heo WARN_ON_ONCE(link->sactive); 5091da917d69STejun Heo 5092da917d69STejun Heo ap->nr_active_links++; 50939af5c9c9STejun Heo link->active_tag = qc->tag; 5094c6fd2807SJeff Garzik } 5095c6fd2807SJeff Garzik 5096c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_ACTIVE; 5097c6fd2807SJeff Garzik ap->qc_active |= 1 << qc->tag; 5098c6fd2807SJeff Garzik 5099f92a2636STejun Heo /* We guarantee to LLDs that they will have at least one 5100f92a2636STejun Heo * non-zero sg if the command is a data command. 5101f92a2636STejun Heo */ 5102ff2aeb1eSTejun Heo BUG_ON(ata_is_data(prot) && (!qc->sg || !qc->n_elem || !qc->nbytes)); 5103f92a2636STejun Heo 5104405e66b3STejun Heo if (ata_is_dma(prot) || (ata_is_pio(prot) && 5105f92a2636STejun Heo (ap->flags & ATA_FLAG_PIO_DMA))) 5106c6fd2807SJeff Garzik if (ata_sg_setup(qc)) 5107c6fd2807SJeff Garzik goto sg_err; 5108c6fd2807SJeff Garzik 5109cf480626STejun Heo /* if device is sleeping, schedule reset and abort the link */ 5110054a5fbaSTejun Heo if (unlikely(qc->dev->flags & ATA_DFLAG_SLEEPING)) { 5111cf480626STejun Heo link->eh_info.action |= ATA_EH_RESET; 5112054a5fbaSTejun Heo ata_ehi_push_desc(&link->eh_info, "waking up from sleep"); 5113054a5fbaSTejun Heo ata_link_abort(link); 5114054a5fbaSTejun Heo return; 5115054a5fbaSTejun Heo } 5116054a5fbaSTejun Heo 5117c6fd2807SJeff Garzik ap->ops->qc_prep(qc); 5118c6fd2807SJeff Garzik 5119c6fd2807SJeff Garzik qc->err_mask |= ap->ops->qc_issue(qc); 5120c6fd2807SJeff Garzik if (unlikely(qc->err_mask)) 5121c6fd2807SJeff Garzik goto err; 5122c6fd2807SJeff Garzik return; 5123c6fd2807SJeff Garzik 5124c6fd2807SJeff Garzik sg_err: 5125c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_SYSTEM; 5126c6fd2807SJeff Garzik err: 5127c6fd2807SJeff Garzik ata_qc_complete(qc); 5128c6fd2807SJeff Garzik } 5129c6fd2807SJeff Garzik 5130c6fd2807SJeff Garzik /** 5131c6fd2807SJeff Garzik * sata_scr_valid - test whether SCRs are accessible 5132936fd732STejun Heo * @link: ATA link to test SCR accessibility for 5133c6fd2807SJeff Garzik * 5134936fd732STejun Heo * Test whether SCRs are accessible for @link. 5135c6fd2807SJeff Garzik * 5136c6fd2807SJeff Garzik * LOCKING: 5137c6fd2807SJeff Garzik * None. 5138c6fd2807SJeff Garzik * 5139c6fd2807SJeff Garzik * RETURNS: 5140c6fd2807SJeff Garzik * 1 if SCRs are accessible, 0 otherwise. 5141c6fd2807SJeff Garzik */ 5142936fd732STejun Heo int sata_scr_valid(struct ata_link *link) 5143c6fd2807SJeff Garzik { 5144936fd732STejun Heo struct ata_port *ap = link->ap; 5145936fd732STejun Heo 5146a16abc0bSTejun Heo return (ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read; 5147c6fd2807SJeff Garzik } 5148c6fd2807SJeff Garzik 5149c6fd2807SJeff Garzik /** 5150c6fd2807SJeff Garzik * sata_scr_read - read SCR register of the specified port 5151936fd732STejun Heo * @link: ATA link to read SCR for 5152c6fd2807SJeff Garzik * @reg: SCR to read 5153c6fd2807SJeff Garzik * @val: Place to store read value 5154c6fd2807SJeff Garzik * 5155936fd732STejun Heo * Read SCR register @reg of @link into *@val. This function is 5156633273a3STejun Heo * guaranteed to succeed if @link is ap->link, the cable type of 5157633273a3STejun Heo * the port is SATA and the port implements ->scr_read. 5158c6fd2807SJeff Garzik * 5159c6fd2807SJeff Garzik * LOCKING: 5160633273a3STejun Heo * None if @link is ap->link. Kernel thread context otherwise. 5161c6fd2807SJeff Garzik * 5162c6fd2807SJeff Garzik * RETURNS: 5163c6fd2807SJeff Garzik * 0 on success, negative errno on failure. 5164c6fd2807SJeff Garzik */ 5165936fd732STejun Heo int sata_scr_read(struct ata_link *link, int reg, u32 *val) 5166c6fd2807SJeff Garzik { 5167633273a3STejun Heo if (ata_is_host_link(link)) { 5168936fd732STejun Heo if (sata_scr_valid(link)) 516982ef04fbSTejun Heo return link->ap->ops->scr_read(link, reg, val); 5170c6fd2807SJeff Garzik return -EOPNOTSUPP; 5171c6fd2807SJeff Garzik } 5172c6fd2807SJeff Garzik 5173633273a3STejun Heo return sata_pmp_scr_read(link, reg, val); 5174633273a3STejun Heo } 5175633273a3STejun Heo 5176c6fd2807SJeff Garzik /** 5177c6fd2807SJeff Garzik * sata_scr_write - write SCR register of the specified port 5178936fd732STejun Heo * @link: ATA link to write SCR for 5179c6fd2807SJeff Garzik * @reg: SCR to write 5180c6fd2807SJeff Garzik * @val: value to write 5181c6fd2807SJeff Garzik * 5182936fd732STejun Heo * Write @val to SCR register @reg of @link. This function is 5183633273a3STejun Heo * guaranteed to succeed if @link is ap->link, the cable type of 5184633273a3STejun Heo * the port is SATA and the port implements ->scr_read. 5185c6fd2807SJeff Garzik * 5186c6fd2807SJeff Garzik * LOCKING: 5187633273a3STejun Heo * None if @link is ap->link. Kernel thread context otherwise. 5188c6fd2807SJeff Garzik * 5189c6fd2807SJeff Garzik * RETURNS: 5190c6fd2807SJeff Garzik * 0 on success, negative errno on failure. 5191c6fd2807SJeff Garzik */ 5192936fd732STejun Heo int sata_scr_write(struct ata_link *link, int reg, u32 val) 5193c6fd2807SJeff Garzik { 5194633273a3STejun Heo if (ata_is_host_link(link)) { 5195936fd732STejun Heo if (sata_scr_valid(link)) 519682ef04fbSTejun Heo return link->ap->ops->scr_write(link, reg, val); 5197c6fd2807SJeff Garzik return -EOPNOTSUPP; 5198c6fd2807SJeff Garzik } 5199c6fd2807SJeff Garzik 5200633273a3STejun Heo return sata_pmp_scr_write(link, reg, val); 5201633273a3STejun Heo } 5202633273a3STejun Heo 5203c6fd2807SJeff Garzik /** 5204c6fd2807SJeff Garzik * sata_scr_write_flush - write SCR register of the specified port and flush 5205936fd732STejun Heo * @link: ATA link to write SCR for 5206c6fd2807SJeff Garzik * @reg: SCR to write 5207c6fd2807SJeff Garzik * @val: value to write 5208c6fd2807SJeff Garzik * 5209c6fd2807SJeff Garzik * This function is identical to sata_scr_write() except that this 5210c6fd2807SJeff Garzik * function performs flush after writing to the register. 5211c6fd2807SJeff Garzik * 5212c6fd2807SJeff Garzik * LOCKING: 5213633273a3STejun Heo * None if @link is ap->link. Kernel thread context otherwise. 5214c6fd2807SJeff Garzik * 5215c6fd2807SJeff Garzik * RETURNS: 5216c6fd2807SJeff Garzik * 0 on success, negative errno on failure. 5217c6fd2807SJeff Garzik */ 5218936fd732STejun Heo int sata_scr_write_flush(struct ata_link *link, int reg, u32 val) 5219c6fd2807SJeff Garzik { 5220633273a3STejun Heo if (ata_is_host_link(link)) { 5221da3dbb17STejun Heo int rc; 5222da3dbb17STejun Heo 5223936fd732STejun Heo if (sata_scr_valid(link)) { 522482ef04fbSTejun Heo rc = link->ap->ops->scr_write(link, reg, val); 5225da3dbb17STejun Heo if (rc == 0) 522682ef04fbSTejun Heo rc = link->ap->ops->scr_read(link, reg, &val); 5227da3dbb17STejun Heo return rc; 5228c6fd2807SJeff Garzik } 5229c6fd2807SJeff Garzik return -EOPNOTSUPP; 5230c6fd2807SJeff Garzik } 5231c6fd2807SJeff Garzik 5232633273a3STejun Heo return sata_pmp_scr_write(link, reg, val); 5233633273a3STejun Heo } 5234633273a3STejun Heo 5235c6fd2807SJeff Garzik /** 5236b1c72916STejun Heo * ata_phys_link_online - test whether the given link is online 5237936fd732STejun Heo * @link: ATA link to test 5238c6fd2807SJeff Garzik * 5239936fd732STejun Heo * Test whether @link is online. Note that this function returns 5240936fd732STejun Heo * 0 if online status of @link cannot be obtained, so 5241936fd732STejun Heo * ata_link_online(link) != !ata_link_offline(link). 5242c6fd2807SJeff Garzik * 5243c6fd2807SJeff Garzik * LOCKING: 5244c6fd2807SJeff Garzik * None. 5245c6fd2807SJeff Garzik * 5246c6fd2807SJeff Garzik * RETURNS: 5247b5b3fa38STejun Heo * True if the port online status is available and online. 5248c6fd2807SJeff Garzik */ 5249b1c72916STejun Heo bool ata_phys_link_online(struct ata_link *link) 5250c6fd2807SJeff Garzik { 5251c6fd2807SJeff Garzik u32 sstatus; 5252c6fd2807SJeff Garzik 5253936fd732STejun Heo if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 && 52549913ff8aSTejun Heo ata_sstatus_online(sstatus)) 5255b5b3fa38STejun Heo return true; 5256b5b3fa38STejun Heo return false; 5257c6fd2807SJeff Garzik } 5258c6fd2807SJeff Garzik 5259c6fd2807SJeff Garzik /** 5260b1c72916STejun Heo * ata_phys_link_offline - test whether the given link is offline 5261936fd732STejun Heo * @link: ATA link to test 5262c6fd2807SJeff Garzik * 5263936fd732STejun Heo * Test whether @link is offline. Note that this function 5264936fd732STejun Heo * returns 0 if offline status of @link cannot be obtained, so 5265936fd732STejun Heo * ata_link_online(link) != !ata_link_offline(link). 5266c6fd2807SJeff Garzik * 5267c6fd2807SJeff Garzik * LOCKING: 5268c6fd2807SJeff Garzik * None. 5269c6fd2807SJeff Garzik * 5270c6fd2807SJeff Garzik * RETURNS: 5271b5b3fa38STejun Heo * True if the port offline status is available and offline. 5272c6fd2807SJeff Garzik */ 5273b1c72916STejun Heo bool ata_phys_link_offline(struct ata_link *link) 5274c6fd2807SJeff Garzik { 5275c6fd2807SJeff Garzik u32 sstatus; 5276c6fd2807SJeff Garzik 5277936fd732STejun Heo if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 && 52789913ff8aSTejun Heo !ata_sstatus_online(sstatus)) 5279b5b3fa38STejun Heo return true; 5280b5b3fa38STejun Heo return false; 5281c6fd2807SJeff Garzik } 5282c6fd2807SJeff Garzik 5283b1c72916STejun Heo /** 5284b1c72916STejun Heo * ata_link_online - test whether the given link is online 5285b1c72916STejun Heo * @link: ATA link to test 5286b1c72916STejun Heo * 5287b1c72916STejun Heo * Test whether @link is online. This is identical to 5288b1c72916STejun Heo * ata_phys_link_online() when there's no slave link. When 5289b1c72916STejun Heo * there's a slave link, this function should only be called on 5290b1c72916STejun Heo * the master link and will return true if any of M/S links is 5291b1c72916STejun Heo * online. 5292b1c72916STejun Heo * 5293b1c72916STejun Heo * LOCKING: 5294b1c72916STejun Heo * None. 5295b1c72916STejun Heo * 5296b1c72916STejun Heo * RETURNS: 5297b1c72916STejun Heo * True if the port online status is available and online. 5298b1c72916STejun Heo */ 5299b1c72916STejun Heo bool ata_link_online(struct ata_link *link) 5300b1c72916STejun Heo { 5301b1c72916STejun Heo struct ata_link *slave = link->ap->slave_link; 5302b1c72916STejun Heo 5303b1c72916STejun Heo WARN_ON(link == slave); /* shouldn't be called on slave link */ 5304b1c72916STejun Heo 5305b1c72916STejun Heo return ata_phys_link_online(link) || 5306b1c72916STejun Heo (slave && ata_phys_link_online(slave)); 5307b1c72916STejun Heo } 5308b1c72916STejun Heo 5309b1c72916STejun Heo /** 5310b1c72916STejun Heo * ata_link_offline - test whether the given link is offline 5311b1c72916STejun Heo * @link: ATA link to test 5312b1c72916STejun Heo * 5313b1c72916STejun Heo * Test whether @link is offline. This is identical to 5314b1c72916STejun Heo * ata_phys_link_offline() when there's no slave link. When 5315b1c72916STejun Heo * there's a slave link, this function should only be called on 5316b1c72916STejun Heo * the master link and will return true if both M/S links are 5317b1c72916STejun Heo * offline. 5318b1c72916STejun Heo * 5319b1c72916STejun Heo * LOCKING: 5320b1c72916STejun Heo * None. 5321b1c72916STejun Heo * 5322b1c72916STejun Heo * RETURNS: 5323b1c72916STejun Heo * True if the port offline status is available and offline. 5324b1c72916STejun Heo */ 5325b1c72916STejun Heo bool ata_link_offline(struct ata_link *link) 5326b1c72916STejun Heo { 5327b1c72916STejun Heo struct ata_link *slave = link->ap->slave_link; 5328b1c72916STejun Heo 5329b1c72916STejun Heo WARN_ON(link == slave); /* shouldn't be called on slave link */ 5330b1c72916STejun Heo 5331b1c72916STejun Heo return ata_phys_link_offline(link) && 5332b1c72916STejun Heo (!slave || ata_phys_link_offline(slave)); 5333b1c72916STejun Heo } 5334b1c72916STejun Heo 53356ffa01d8STejun Heo #ifdef CONFIG_PM 5336cca3974eSJeff Garzik static int ata_host_request_pm(struct ata_host *host, pm_message_t mesg, 5337cca3974eSJeff Garzik unsigned int action, unsigned int ehi_flags, 5338cca3974eSJeff Garzik int wait) 5339c6fd2807SJeff Garzik { 5340c6fd2807SJeff Garzik unsigned long flags; 5341c6fd2807SJeff Garzik int i, rc; 5342c6fd2807SJeff Garzik 5343cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 5344cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 5345e3667ebfSTejun Heo struct ata_link *link; 5346c6fd2807SJeff Garzik 5347c6fd2807SJeff Garzik /* Previous resume operation might still be in 5348c6fd2807SJeff Garzik * progress. Wait for PM_PENDING to clear. 5349c6fd2807SJeff Garzik */ 5350c6fd2807SJeff Garzik if (ap->pflags & ATA_PFLAG_PM_PENDING) { 5351c6fd2807SJeff Garzik ata_port_wait_eh(ap); 5352c6fd2807SJeff Garzik WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING); 5353c6fd2807SJeff Garzik } 5354c6fd2807SJeff Garzik 5355c6fd2807SJeff Garzik /* request PM ops to EH */ 5356c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 5357c6fd2807SJeff Garzik 5358c6fd2807SJeff Garzik ap->pm_mesg = mesg; 5359c6fd2807SJeff Garzik if (wait) { 5360c6fd2807SJeff Garzik rc = 0; 5361c6fd2807SJeff Garzik ap->pm_result = &rc; 5362c6fd2807SJeff Garzik } 5363c6fd2807SJeff Garzik 5364c6fd2807SJeff Garzik ap->pflags |= ATA_PFLAG_PM_PENDING; 53651eca4365STejun Heo ata_for_each_link(link, ap, HOST_FIRST) { 5366e3667ebfSTejun Heo link->eh_info.action |= action; 5367e3667ebfSTejun Heo link->eh_info.flags |= ehi_flags; 5368e3667ebfSTejun Heo } 5369c6fd2807SJeff Garzik 5370c6fd2807SJeff Garzik ata_port_schedule_eh(ap); 5371c6fd2807SJeff Garzik 5372c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5373c6fd2807SJeff Garzik 5374c6fd2807SJeff Garzik /* wait and check result */ 5375c6fd2807SJeff Garzik if (wait) { 5376c6fd2807SJeff Garzik ata_port_wait_eh(ap); 5377c6fd2807SJeff Garzik WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING); 5378c6fd2807SJeff Garzik if (rc) 5379c6fd2807SJeff Garzik return rc; 5380c6fd2807SJeff Garzik } 5381c6fd2807SJeff Garzik } 5382c6fd2807SJeff Garzik 5383c6fd2807SJeff Garzik return 0; 5384c6fd2807SJeff Garzik } 5385c6fd2807SJeff Garzik 5386c6fd2807SJeff Garzik /** 5387cca3974eSJeff Garzik * ata_host_suspend - suspend host 5388cca3974eSJeff Garzik * @host: host to suspend 5389c6fd2807SJeff Garzik * @mesg: PM message 5390c6fd2807SJeff Garzik * 5391cca3974eSJeff Garzik * Suspend @host. Actual operation is performed by EH. This 5392c6fd2807SJeff Garzik * function requests EH to perform PM operations and waits for EH 5393c6fd2807SJeff Garzik * to finish. 5394c6fd2807SJeff Garzik * 5395c6fd2807SJeff Garzik * LOCKING: 5396c6fd2807SJeff Garzik * Kernel thread context (may sleep). 5397c6fd2807SJeff Garzik * 5398c6fd2807SJeff Garzik * RETURNS: 5399c6fd2807SJeff Garzik * 0 on success, -errno on failure. 5400c6fd2807SJeff Garzik */ 5401cca3974eSJeff Garzik int ata_host_suspend(struct ata_host *host, pm_message_t mesg) 5402c6fd2807SJeff Garzik { 54039666f400STejun Heo int rc; 5404c6fd2807SJeff Garzik 5405ca77329fSKristen Carlson Accardi /* 5406ca77329fSKristen Carlson Accardi * disable link pm on all ports before requesting 5407ca77329fSKristen Carlson Accardi * any pm activity 5408ca77329fSKristen Carlson Accardi */ 5409ca77329fSKristen Carlson Accardi ata_lpm_enable(host); 5410ca77329fSKristen Carlson Accardi 5411cca3974eSJeff Garzik rc = ata_host_request_pm(host, mesg, 0, ATA_EHI_QUIET, 1); 541272ad6ec4SJeff Garzik if (rc == 0) 541372ad6ec4SJeff Garzik host->dev->power.power_state = mesg; 5414c6fd2807SJeff Garzik return rc; 5415c6fd2807SJeff Garzik } 5416c6fd2807SJeff Garzik 5417c6fd2807SJeff Garzik /** 5418cca3974eSJeff Garzik * ata_host_resume - resume host 5419cca3974eSJeff Garzik * @host: host to resume 5420c6fd2807SJeff Garzik * 5421cca3974eSJeff Garzik * Resume @host. Actual operation is performed by EH. This 5422c6fd2807SJeff Garzik * function requests EH to perform PM operations and returns. 5423c6fd2807SJeff Garzik * Note that all resume operations are performed parallely. 5424c6fd2807SJeff Garzik * 5425c6fd2807SJeff Garzik * LOCKING: 5426c6fd2807SJeff Garzik * Kernel thread context (may sleep). 5427c6fd2807SJeff Garzik */ 5428cca3974eSJeff Garzik void ata_host_resume(struct ata_host *host) 5429c6fd2807SJeff Garzik { 5430cf480626STejun Heo ata_host_request_pm(host, PMSG_ON, ATA_EH_RESET, 5431c6fd2807SJeff Garzik ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET, 0); 543272ad6ec4SJeff Garzik host->dev->power.power_state = PMSG_ON; 5433ca77329fSKristen Carlson Accardi 5434ca77329fSKristen Carlson Accardi /* reenable link pm */ 5435ca77329fSKristen Carlson Accardi ata_lpm_disable(host); 5436c6fd2807SJeff Garzik } 54376ffa01d8STejun Heo #endif 5438c6fd2807SJeff Garzik 5439c6fd2807SJeff Garzik /** 5440c6fd2807SJeff Garzik * ata_port_start - Set port up for dma. 5441c6fd2807SJeff Garzik * @ap: Port to initialize 5442c6fd2807SJeff Garzik * 5443c6fd2807SJeff Garzik * Called just after data structures for each port are 5444c6fd2807SJeff Garzik * initialized. Allocates space for PRD table. 5445c6fd2807SJeff Garzik * 5446c6fd2807SJeff Garzik * May be used as the port_start() entry in ata_port_operations. 5447c6fd2807SJeff Garzik * 5448c6fd2807SJeff Garzik * LOCKING: 5449c6fd2807SJeff Garzik * Inherited from caller. 5450c6fd2807SJeff Garzik */ 5451c6fd2807SJeff Garzik int ata_port_start(struct ata_port *ap) 5452c6fd2807SJeff Garzik { 5453c6fd2807SJeff Garzik struct device *dev = ap->dev; 5454c6fd2807SJeff Garzik 5455f0d36efdSTejun Heo ap->prd = dmam_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, 5456f0d36efdSTejun Heo GFP_KERNEL); 5457c6fd2807SJeff Garzik if (!ap->prd) 5458c6fd2807SJeff Garzik return -ENOMEM; 5459c6fd2807SJeff Garzik 5460c6fd2807SJeff Garzik return 0; 5461c6fd2807SJeff Garzik } 5462c6fd2807SJeff Garzik 5463c6fd2807SJeff Garzik /** 5464c6fd2807SJeff Garzik * ata_dev_init - Initialize an ata_device structure 5465c6fd2807SJeff Garzik * @dev: Device structure to initialize 5466c6fd2807SJeff Garzik * 5467c6fd2807SJeff Garzik * Initialize @dev in preparation for probing. 5468c6fd2807SJeff Garzik * 5469c6fd2807SJeff Garzik * LOCKING: 5470c6fd2807SJeff Garzik * Inherited from caller. 5471c6fd2807SJeff Garzik */ 5472c6fd2807SJeff Garzik void ata_dev_init(struct ata_device *dev) 5473c6fd2807SJeff Garzik { 5474b1c72916STejun Heo struct ata_link *link = ata_dev_phys_link(dev); 54759af5c9c9STejun Heo struct ata_port *ap = link->ap; 5476c6fd2807SJeff Garzik unsigned long flags; 5477c6fd2807SJeff Garzik 5478b1c72916STejun Heo /* SATA spd limit is bound to the attached device, reset together */ 54799af5c9c9STejun Heo link->sata_spd_limit = link->hw_sata_spd_limit; 54809af5c9c9STejun Heo link->sata_spd = 0; 5481c6fd2807SJeff Garzik 5482c6fd2807SJeff Garzik /* High bits of dev->flags are used to record warm plug 5483c6fd2807SJeff Garzik * requests which occur asynchronously. Synchronize using 5484cca3974eSJeff Garzik * host lock. 5485c6fd2807SJeff Garzik */ 5486c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 5487c6fd2807SJeff Garzik dev->flags &= ~ATA_DFLAG_INIT_MASK; 54883dcc323fSTejun Heo dev->horkage = 0; 5489c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5490c6fd2807SJeff Garzik 549199cf610aSTejun Heo memset((void *)dev + ATA_DEVICE_CLEAR_BEGIN, 0, 549299cf610aSTejun Heo ATA_DEVICE_CLEAR_END - ATA_DEVICE_CLEAR_BEGIN); 5493c6fd2807SJeff Garzik dev->pio_mask = UINT_MAX; 5494c6fd2807SJeff Garzik dev->mwdma_mask = UINT_MAX; 5495c6fd2807SJeff Garzik dev->udma_mask = UINT_MAX; 5496c6fd2807SJeff Garzik } 5497c6fd2807SJeff Garzik 5498c6fd2807SJeff Garzik /** 54994fb37a25STejun Heo * ata_link_init - Initialize an ata_link structure 55004fb37a25STejun Heo * @ap: ATA port link is attached to 55014fb37a25STejun Heo * @link: Link structure to initialize 55028989805dSTejun Heo * @pmp: Port multiplier port number 55034fb37a25STejun Heo * 55044fb37a25STejun Heo * Initialize @link. 55054fb37a25STejun Heo * 55064fb37a25STejun Heo * LOCKING: 55074fb37a25STejun Heo * Kernel thread context (may sleep) 55084fb37a25STejun Heo */ 5509fb7fd614STejun Heo void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp) 55104fb37a25STejun Heo { 55114fb37a25STejun Heo int i; 55124fb37a25STejun Heo 55134fb37a25STejun Heo /* clear everything except for devices */ 55144fb37a25STejun Heo memset(link, 0, offsetof(struct ata_link, device[0])); 55154fb37a25STejun Heo 55164fb37a25STejun Heo link->ap = ap; 55178989805dSTejun Heo link->pmp = pmp; 55184fb37a25STejun Heo link->active_tag = ATA_TAG_POISON; 55194fb37a25STejun Heo link->hw_sata_spd_limit = UINT_MAX; 55204fb37a25STejun Heo 55214fb37a25STejun Heo /* can't use iterator, ap isn't initialized yet */ 55224fb37a25STejun Heo for (i = 0; i < ATA_MAX_DEVICES; i++) { 55234fb37a25STejun Heo struct ata_device *dev = &link->device[i]; 55244fb37a25STejun Heo 55254fb37a25STejun Heo dev->link = link; 55264fb37a25STejun Heo dev->devno = dev - link->device; 55274fb37a25STejun Heo ata_dev_init(dev); 55284fb37a25STejun Heo } 55294fb37a25STejun Heo } 55304fb37a25STejun Heo 55314fb37a25STejun Heo /** 55324fb37a25STejun Heo * sata_link_init_spd - Initialize link->sata_spd_limit 55334fb37a25STejun Heo * @link: Link to configure sata_spd_limit for 55344fb37a25STejun Heo * 55354fb37a25STejun Heo * Initialize @link->[hw_]sata_spd_limit to the currently 55364fb37a25STejun Heo * configured value. 55374fb37a25STejun Heo * 55384fb37a25STejun Heo * LOCKING: 55394fb37a25STejun Heo * Kernel thread context (may sleep). 55404fb37a25STejun Heo * 55414fb37a25STejun Heo * RETURNS: 55424fb37a25STejun Heo * 0 on success, -errno on failure. 55434fb37a25STejun Heo */ 5544fb7fd614STejun Heo int sata_link_init_spd(struct ata_link *link) 55454fb37a25STejun Heo { 554633267325STejun Heo u8 spd; 55474fb37a25STejun Heo int rc; 55484fb37a25STejun Heo 5549d127ea7bSTejun Heo rc = sata_scr_read(link, SCR_CONTROL, &link->saved_scontrol); 55504fb37a25STejun Heo if (rc) 55514fb37a25STejun Heo return rc; 55524fb37a25STejun Heo 5553d127ea7bSTejun Heo spd = (link->saved_scontrol >> 4) & 0xf; 55544fb37a25STejun Heo if (spd) 55554fb37a25STejun Heo link->hw_sata_spd_limit &= (1 << spd) - 1; 55564fb37a25STejun Heo 555705944bdfSTejun Heo ata_force_link_limits(link); 555833267325STejun Heo 55594fb37a25STejun Heo link->sata_spd_limit = link->hw_sata_spd_limit; 55604fb37a25STejun Heo 55614fb37a25STejun Heo return 0; 55624fb37a25STejun Heo } 55634fb37a25STejun Heo 55644fb37a25STejun Heo /** 5565f3187195STejun Heo * ata_port_alloc - allocate and initialize basic ATA port resources 5566f3187195STejun Heo * @host: ATA host this allocated port belongs to 5567c6fd2807SJeff Garzik * 5568f3187195STejun Heo * Allocate and initialize basic ATA port resources. 5569f3187195STejun Heo * 5570f3187195STejun Heo * RETURNS: 5571f3187195STejun Heo * Allocate ATA port on success, NULL on failure. 5572c6fd2807SJeff Garzik * 5573c6fd2807SJeff Garzik * LOCKING: 5574f3187195STejun Heo * Inherited from calling layer (may sleep). 5575c6fd2807SJeff Garzik */ 5576f3187195STejun Heo struct ata_port *ata_port_alloc(struct ata_host *host) 5577c6fd2807SJeff Garzik { 5578f3187195STejun Heo struct ata_port *ap; 5579c6fd2807SJeff Garzik 5580f3187195STejun Heo DPRINTK("ENTER\n"); 5581f3187195STejun Heo 5582f3187195STejun Heo ap = kzalloc(sizeof(*ap), GFP_KERNEL); 5583f3187195STejun Heo if (!ap) 5584f3187195STejun Heo return NULL; 5585f3187195STejun Heo 5586f4d6d004STejun Heo ap->pflags |= ATA_PFLAG_INITIALIZING; 5587cca3974eSJeff Garzik ap->lock = &host->lock; 5588c6fd2807SJeff Garzik ap->flags = ATA_FLAG_DISABLED; 5589f3187195STejun Heo ap->print_id = -1; 5590c6fd2807SJeff Garzik ap->ctl = ATA_DEVCTL_OBS; 5591cca3974eSJeff Garzik ap->host = host; 5592f3187195STejun Heo ap->dev = host->dev; 5593c6fd2807SJeff Garzik ap->last_ctl = 0xFF; 5594c6fd2807SJeff Garzik 5595c6fd2807SJeff Garzik #if defined(ATA_VERBOSE_DEBUG) 5596c6fd2807SJeff Garzik /* turn on all debugging levels */ 5597c6fd2807SJeff Garzik ap->msg_enable = 0x00FF; 5598c6fd2807SJeff Garzik #elif defined(ATA_DEBUG) 5599c6fd2807SJeff Garzik ap->msg_enable = ATA_MSG_DRV | ATA_MSG_INFO | ATA_MSG_CTL | ATA_MSG_WARN | ATA_MSG_ERR; 5600c6fd2807SJeff Garzik #else 5601c6fd2807SJeff Garzik ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR | ATA_MSG_WARN; 5602c6fd2807SJeff Garzik #endif 5603c6fd2807SJeff Garzik 5604127102aeSTejun Heo #ifdef CONFIG_ATA_SFF 5605442eacc3SJeff Garzik INIT_DELAYED_WORK(&ap->port_task, ata_pio_task); 5606f667fdbbSTejun Heo #else 5607f667fdbbSTejun Heo INIT_DELAYED_WORK(&ap->port_task, NULL); 5608127102aeSTejun Heo #endif 560965f27f38SDavid Howells INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug); 561065f27f38SDavid Howells INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan); 5611c6fd2807SJeff Garzik INIT_LIST_HEAD(&ap->eh_done_q); 5612c6fd2807SJeff Garzik init_waitqueue_head(&ap->eh_wait_q); 561345fabbb7SElias Oltmanns init_completion(&ap->park_req_pending); 56145ddf24c5STejun Heo init_timer_deferrable(&ap->fastdrain_timer); 56155ddf24c5STejun Heo ap->fastdrain_timer.function = ata_eh_fastdrain_timerfn; 56165ddf24c5STejun Heo ap->fastdrain_timer.data = (unsigned long)ap; 5617c6fd2807SJeff Garzik 5618c6fd2807SJeff Garzik ap->cbl = ATA_CBL_NONE; 5619c6fd2807SJeff Garzik 56208989805dSTejun Heo ata_link_init(ap, &ap->link, 0); 5621c6fd2807SJeff Garzik 5622c6fd2807SJeff Garzik #ifdef ATA_IRQ_TRAP 5623c6fd2807SJeff Garzik ap->stats.unhandled_irq = 1; 5624c6fd2807SJeff Garzik ap->stats.idle_irq = 1; 5625c6fd2807SJeff Garzik #endif 5626c6fd2807SJeff Garzik return ap; 5627c6fd2807SJeff Garzik } 5628c6fd2807SJeff Garzik 5629f0d36efdSTejun Heo static void ata_host_release(struct device *gendev, void *res) 5630f0d36efdSTejun Heo { 5631f0d36efdSTejun Heo struct ata_host *host = dev_get_drvdata(gendev); 5632f0d36efdSTejun Heo int i; 5633f0d36efdSTejun Heo 5634f0d36efdSTejun Heo for (i = 0; i < host->n_ports; i++) { 5635f0d36efdSTejun Heo struct ata_port *ap = host->ports[i]; 5636f0d36efdSTejun Heo 5637ecef7253STejun Heo if (!ap) 5638ecef7253STejun Heo continue; 5639ecef7253STejun Heo 56404911487aSTejun Heo if (ap->scsi_host) 56411aa506e4STejun Heo scsi_host_put(ap->scsi_host); 56421aa506e4STejun Heo 5643633273a3STejun Heo kfree(ap->pmp_link); 5644b1c72916STejun Heo kfree(ap->slave_link); 56454911487aSTejun Heo kfree(ap); 56461aa506e4STejun Heo host->ports[i] = NULL; 56471aa506e4STejun Heo } 56481aa506e4STejun Heo 56491aa56ccaSTejun Heo dev_set_drvdata(gendev, NULL); 5650f0d36efdSTejun Heo } 5651f0d36efdSTejun Heo 5652c6fd2807SJeff Garzik /** 5653f3187195STejun Heo * ata_host_alloc - allocate and init basic ATA host resources 5654f3187195STejun Heo * @dev: generic device this host is associated with 5655f3187195STejun Heo * @max_ports: maximum number of ATA ports associated with this host 5656f3187195STejun Heo * 5657f3187195STejun Heo * Allocate and initialize basic ATA host resources. LLD calls 5658f3187195STejun Heo * this function to allocate a host, initializes it fully and 5659f3187195STejun Heo * attaches it using ata_host_register(). 5660f3187195STejun Heo * 5661f3187195STejun Heo * @max_ports ports are allocated and host->n_ports is 5662f3187195STejun Heo * initialized to @max_ports. The caller is allowed to decrease 5663f3187195STejun Heo * host->n_ports before calling ata_host_register(). The unused 5664f3187195STejun Heo * ports will be automatically freed on registration. 5665f3187195STejun Heo * 5666f3187195STejun Heo * RETURNS: 5667f3187195STejun Heo * Allocate ATA host on success, NULL on failure. 5668f3187195STejun Heo * 5669f3187195STejun Heo * LOCKING: 5670f3187195STejun Heo * Inherited from calling layer (may sleep). 5671f3187195STejun Heo */ 5672f3187195STejun Heo struct ata_host *ata_host_alloc(struct device *dev, int max_ports) 5673f3187195STejun Heo { 5674f3187195STejun Heo struct ata_host *host; 5675f3187195STejun Heo size_t sz; 5676f3187195STejun Heo int i; 5677f3187195STejun Heo 5678f3187195STejun Heo DPRINTK("ENTER\n"); 5679f3187195STejun Heo 5680f3187195STejun Heo if (!devres_open_group(dev, NULL, GFP_KERNEL)) 5681f3187195STejun Heo return NULL; 5682f3187195STejun Heo 5683f3187195STejun Heo /* alloc a container for our list of ATA ports (buses) */ 5684f3187195STejun Heo sz = sizeof(struct ata_host) + (max_ports + 1) * sizeof(void *); 5685f3187195STejun Heo /* alloc a container for our list of ATA ports (buses) */ 5686f3187195STejun Heo host = devres_alloc(ata_host_release, sz, GFP_KERNEL); 5687f3187195STejun Heo if (!host) 5688f3187195STejun Heo goto err_out; 5689f3187195STejun Heo 5690f3187195STejun Heo devres_add(dev, host); 5691f3187195STejun Heo dev_set_drvdata(dev, host); 5692f3187195STejun Heo 5693f3187195STejun Heo spin_lock_init(&host->lock); 5694f3187195STejun Heo host->dev = dev; 5695f3187195STejun Heo host->n_ports = max_ports; 5696f3187195STejun Heo 5697f3187195STejun Heo /* allocate ports bound to this host */ 5698f3187195STejun Heo for (i = 0; i < max_ports; i++) { 5699f3187195STejun Heo struct ata_port *ap; 5700f3187195STejun Heo 5701f3187195STejun Heo ap = ata_port_alloc(host); 5702f3187195STejun Heo if (!ap) 5703f3187195STejun Heo goto err_out; 5704f3187195STejun Heo 5705f3187195STejun Heo ap->port_no = i; 5706f3187195STejun Heo host->ports[i] = ap; 5707f3187195STejun Heo } 5708f3187195STejun Heo 5709f3187195STejun Heo devres_remove_group(dev, NULL); 5710f3187195STejun Heo return host; 5711f3187195STejun Heo 5712f3187195STejun Heo err_out: 5713f3187195STejun Heo devres_release_group(dev, NULL); 5714f3187195STejun Heo return NULL; 5715f3187195STejun Heo } 5716f3187195STejun Heo 5717f3187195STejun Heo /** 5718f5cda257STejun Heo * ata_host_alloc_pinfo - alloc host and init with port_info array 5719f5cda257STejun Heo * @dev: generic device this host is associated with 5720f5cda257STejun Heo * @ppi: array of ATA port_info to initialize host with 5721f5cda257STejun Heo * @n_ports: number of ATA ports attached to this host 5722f5cda257STejun Heo * 5723f5cda257STejun Heo * Allocate ATA host and initialize with info from @ppi. If NULL 5724f5cda257STejun Heo * terminated, @ppi may contain fewer entries than @n_ports. The 5725f5cda257STejun Heo * last entry will be used for the remaining ports. 5726f5cda257STejun Heo * 5727f5cda257STejun Heo * RETURNS: 5728f5cda257STejun Heo * Allocate ATA host on success, NULL on failure. 5729f5cda257STejun Heo * 5730f5cda257STejun Heo * LOCKING: 5731f5cda257STejun Heo * Inherited from calling layer (may sleep). 5732f5cda257STejun Heo */ 5733f5cda257STejun Heo struct ata_host *ata_host_alloc_pinfo(struct device *dev, 5734f5cda257STejun Heo const struct ata_port_info * const * ppi, 5735f5cda257STejun Heo int n_ports) 5736f5cda257STejun Heo { 5737f5cda257STejun Heo const struct ata_port_info *pi; 5738f5cda257STejun Heo struct ata_host *host; 5739f5cda257STejun Heo int i, j; 5740f5cda257STejun Heo 5741f5cda257STejun Heo host = ata_host_alloc(dev, n_ports); 5742f5cda257STejun Heo if (!host) 5743f5cda257STejun Heo return NULL; 5744f5cda257STejun Heo 5745f5cda257STejun Heo for (i = 0, j = 0, pi = NULL; i < host->n_ports; i++) { 5746f5cda257STejun Heo struct ata_port *ap = host->ports[i]; 5747f5cda257STejun Heo 5748f5cda257STejun Heo if (ppi[j]) 5749f5cda257STejun Heo pi = ppi[j++]; 5750f5cda257STejun Heo 5751f5cda257STejun Heo ap->pio_mask = pi->pio_mask; 5752f5cda257STejun Heo ap->mwdma_mask = pi->mwdma_mask; 5753f5cda257STejun Heo ap->udma_mask = pi->udma_mask; 5754f5cda257STejun Heo ap->flags |= pi->flags; 57550c88758bSTejun Heo ap->link.flags |= pi->link_flags; 5756f5cda257STejun Heo ap->ops = pi->port_ops; 5757f5cda257STejun Heo 5758f5cda257STejun Heo if (!host->ops && (pi->port_ops != &ata_dummy_port_ops)) 5759f5cda257STejun Heo host->ops = pi->port_ops; 5760f5cda257STejun Heo } 5761f5cda257STejun Heo 5762f5cda257STejun Heo return host; 5763f5cda257STejun Heo } 5764f5cda257STejun Heo 5765b1c72916STejun Heo /** 5766b1c72916STejun Heo * ata_slave_link_init - initialize slave link 5767b1c72916STejun Heo * @ap: port to initialize slave link for 5768b1c72916STejun Heo * 5769b1c72916STejun Heo * Create and initialize slave link for @ap. This enables slave 5770b1c72916STejun Heo * link handling on the port. 5771b1c72916STejun Heo * 5772b1c72916STejun Heo * In libata, a port contains links and a link contains devices. 5773b1c72916STejun Heo * There is single host link but if a PMP is attached to it, 5774b1c72916STejun Heo * there can be multiple fan-out links. On SATA, there's usually 5775b1c72916STejun Heo * a single device connected to a link but PATA and SATA 5776b1c72916STejun Heo * controllers emulating TF based interface can have two - master 5777b1c72916STejun Heo * and slave. 5778b1c72916STejun Heo * 5779b1c72916STejun Heo * However, there are a few controllers which don't fit into this 5780b1c72916STejun Heo * abstraction too well - SATA controllers which emulate TF 5781b1c72916STejun Heo * interface with both master and slave devices but also have 5782b1c72916STejun Heo * separate SCR register sets for each device. These controllers 5783b1c72916STejun Heo * need separate links for physical link handling 5784b1c72916STejun Heo * (e.g. onlineness, link speed) but should be treated like a 5785b1c72916STejun Heo * traditional M/S controller for everything else (e.g. command 5786b1c72916STejun Heo * issue, softreset). 5787b1c72916STejun Heo * 5788b1c72916STejun Heo * slave_link is libata's way of handling this class of 5789b1c72916STejun Heo * controllers without impacting core layer too much. For 5790b1c72916STejun Heo * anything other than physical link handling, the default host 5791b1c72916STejun Heo * link is used for both master and slave. For physical link 5792b1c72916STejun Heo * handling, separate @ap->slave_link is used. All dirty details 5793b1c72916STejun Heo * are implemented inside libata core layer. From LLD's POV, the 5794b1c72916STejun Heo * only difference is that prereset, hardreset and postreset are 5795b1c72916STejun Heo * called once more for the slave link, so the reset sequence 5796b1c72916STejun Heo * looks like the following. 5797b1c72916STejun Heo * 5798b1c72916STejun Heo * prereset(M) -> prereset(S) -> hardreset(M) -> hardreset(S) -> 5799b1c72916STejun Heo * softreset(M) -> postreset(M) -> postreset(S) 5800b1c72916STejun Heo * 5801b1c72916STejun Heo * Note that softreset is called only for the master. Softreset 5802b1c72916STejun Heo * resets both M/S by definition, so SRST on master should handle 5803b1c72916STejun Heo * both (the standard method will work just fine). 5804b1c72916STejun Heo * 5805b1c72916STejun Heo * LOCKING: 5806b1c72916STejun Heo * Should be called before host is registered. 5807b1c72916STejun Heo * 5808b1c72916STejun Heo * RETURNS: 5809b1c72916STejun Heo * 0 on success, -errno on failure. 5810b1c72916STejun Heo */ 5811b1c72916STejun Heo int ata_slave_link_init(struct ata_port *ap) 5812b1c72916STejun Heo { 5813b1c72916STejun Heo struct ata_link *link; 5814b1c72916STejun Heo 5815b1c72916STejun Heo WARN_ON(ap->slave_link); 5816b1c72916STejun Heo WARN_ON(ap->flags & ATA_FLAG_PMP); 5817b1c72916STejun Heo 5818b1c72916STejun Heo link = kzalloc(sizeof(*link), GFP_KERNEL); 5819b1c72916STejun Heo if (!link) 5820b1c72916STejun Heo return -ENOMEM; 5821b1c72916STejun Heo 5822b1c72916STejun Heo ata_link_init(ap, link, 1); 5823b1c72916STejun Heo ap->slave_link = link; 5824b1c72916STejun Heo return 0; 5825b1c72916STejun Heo } 5826b1c72916STejun Heo 582732ebbc0cSTejun Heo static void ata_host_stop(struct device *gendev, void *res) 582832ebbc0cSTejun Heo { 582932ebbc0cSTejun Heo struct ata_host *host = dev_get_drvdata(gendev); 583032ebbc0cSTejun Heo int i; 583132ebbc0cSTejun Heo 583232ebbc0cSTejun Heo WARN_ON(!(host->flags & ATA_HOST_STARTED)); 583332ebbc0cSTejun Heo 583432ebbc0cSTejun Heo for (i = 0; i < host->n_ports; i++) { 583532ebbc0cSTejun Heo struct ata_port *ap = host->ports[i]; 583632ebbc0cSTejun Heo 583732ebbc0cSTejun Heo if (ap->ops->port_stop) 583832ebbc0cSTejun Heo ap->ops->port_stop(ap); 583932ebbc0cSTejun Heo } 584032ebbc0cSTejun Heo 584132ebbc0cSTejun Heo if (host->ops->host_stop) 584232ebbc0cSTejun Heo host->ops->host_stop(host); 584332ebbc0cSTejun Heo } 584432ebbc0cSTejun Heo 5845f5cda257STejun Heo /** 5846029cfd6bSTejun Heo * ata_finalize_port_ops - finalize ata_port_operations 5847029cfd6bSTejun Heo * @ops: ata_port_operations to finalize 5848029cfd6bSTejun Heo * 5849029cfd6bSTejun Heo * An ata_port_operations can inherit from another ops and that 5850029cfd6bSTejun Heo * ops can again inherit from another. This can go on as many 5851029cfd6bSTejun Heo * times as necessary as long as there is no loop in the 5852029cfd6bSTejun Heo * inheritance chain. 5853029cfd6bSTejun Heo * 5854029cfd6bSTejun Heo * Ops tables are finalized when the host is started. NULL or 5855029cfd6bSTejun Heo * unspecified entries are inherited from the closet ancestor 5856029cfd6bSTejun Heo * which has the method and the entry is populated with it. 5857029cfd6bSTejun Heo * After finalization, the ops table directly points to all the 5858029cfd6bSTejun Heo * methods and ->inherits is no longer necessary and cleared. 5859029cfd6bSTejun Heo * 5860029cfd6bSTejun Heo * Using ATA_OP_NULL, inheriting ops can force a method to NULL. 5861029cfd6bSTejun Heo * 5862029cfd6bSTejun Heo * LOCKING: 5863029cfd6bSTejun Heo * None. 5864029cfd6bSTejun Heo */ 5865029cfd6bSTejun Heo static void ata_finalize_port_ops(struct ata_port_operations *ops) 5866029cfd6bSTejun Heo { 58672da67659SPradeep Singh Rautela static DEFINE_SPINLOCK(lock); 5868029cfd6bSTejun Heo const struct ata_port_operations *cur; 5869029cfd6bSTejun Heo void **begin = (void **)ops; 5870029cfd6bSTejun Heo void **end = (void **)&ops->inherits; 5871029cfd6bSTejun Heo void **pp; 5872029cfd6bSTejun Heo 5873029cfd6bSTejun Heo if (!ops || !ops->inherits) 5874029cfd6bSTejun Heo return; 5875029cfd6bSTejun Heo 5876029cfd6bSTejun Heo spin_lock(&lock); 5877029cfd6bSTejun Heo 5878029cfd6bSTejun Heo for (cur = ops->inherits; cur; cur = cur->inherits) { 5879029cfd6bSTejun Heo void **inherit = (void **)cur; 5880029cfd6bSTejun Heo 5881029cfd6bSTejun Heo for (pp = begin; pp < end; pp++, inherit++) 5882029cfd6bSTejun Heo if (!*pp) 5883029cfd6bSTejun Heo *pp = *inherit; 5884029cfd6bSTejun Heo } 5885029cfd6bSTejun Heo 5886029cfd6bSTejun Heo for (pp = begin; pp < end; pp++) 5887029cfd6bSTejun Heo if (IS_ERR(*pp)) 5888029cfd6bSTejun Heo *pp = NULL; 5889029cfd6bSTejun Heo 5890029cfd6bSTejun Heo ops->inherits = NULL; 5891029cfd6bSTejun Heo 5892029cfd6bSTejun Heo spin_unlock(&lock); 5893029cfd6bSTejun Heo } 5894029cfd6bSTejun Heo 5895029cfd6bSTejun Heo /** 5896ecef7253STejun Heo * ata_host_start - start and freeze ports of an ATA host 5897ecef7253STejun Heo * @host: ATA host to start ports for 5898ecef7253STejun Heo * 5899ecef7253STejun Heo * Start and then freeze ports of @host. Started status is 5900ecef7253STejun Heo * recorded in host->flags, so this function can be called 5901ecef7253STejun Heo * multiple times. Ports are guaranteed to get started only 5902f3187195STejun Heo * once. If host->ops isn't initialized yet, its set to the 5903f3187195STejun Heo * first non-dummy port ops. 5904ecef7253STejun Heo * 5905ecef7253STejun Heo * LOCKING: 5906ecef7253STejun Heo * Inherited from calling layer (may sleep). 5907ecef7253STejun Heo * 5908ecef7253STejun Heo * RETURNS: 5909ecef7253STejun Heo * 0 if all ports are started successfully, -errno otherwise. 5910ecef7253STejun Heo */ 5911ecef7253STejun Heo int ata_host_start(struct ata_host *host) 5912ecef7253STejun Heo { 591332ebbc0cSTejun Heo int have_stop = 0; 591432ebbc0cSTejun Heo void *start_dr = NULL; 5915ecef7253STejun Heo int i, rc; 5916ecef7253STejun Heo 5917ecef7253STejun Heo if (host->flags & ATA_HOST_STARTED) 5918ecef7253STejun Heo return 0; 5919ecef7253STejun Heo 5920029cfd6bSTejun Heo ata_finalize_port_ops(host->ops); 5921029cfd6bSTejun Heo 5922ecef7253STejun Heo for (i = 0; i < host->n_ports; i++) { 5923ecef7253STejun Heo struct ata_port *ap = host->ports[i]; 5924ecef7253STejun Heo 5925029cfd6bSTejun Heo ata_finalize_port_ops(ap->ops); 5926029cfd6bSTejun Heo 5927f3187195STejun Heo if (!host->ops && !ata_port_is_dummy(ap)) 5928f3187195STejun Heo host->ops = ap->ops; 5929f3187195STejun Heo 593032ebbc0cSTejun Heo if (ap->ops->port_stop) 593132ebbc0cSTejun Heo have_stop = 1; 593232ebbc0cSTejun Heo } 593332ebbc0cSTejun Heo 593432ebbc0cSTejun Heo if (host->ops->host_stop) 593532ebbc0cSTejun Heo have_stop = 1; 593632ebbc0cSTejun Heo 593732ebbc0cSTejun Heo if (have_stop) { 593832ebbc0cSTejun Heo start_dr = devres_alloc(ata_host_stop, 0, GFP_KERNEL); 593932ebbc0cSTejun Heo if (!start_dr) 594032ebbc0cSTejun Heo return -ENOMEM; 594132ebbc0cSTejun Heo } 594232ebbc0cSTejun Heo 594332ebbc0cSTejun Heo for (i = 0; i < host->n_ports; i++) { 594432ebbc0cSTejun Heo struct ata_port *ap = host->ports[i]; 594532ebbc0cSTejun Heo 5946ecef7253STejun Heo if (ap->ops->port_start) { 5947ecef7253STejun Heo rc = ap->ops->port_start(ap); 5948ecef7253STejun Heo if (rc) { 59490f9fe9b7SAlan Cox if (rc != -ENODEV) 59500f757743SAndrew Morton dev_printk(KERN_ERR, host->dev, 59510f757743SAndrew Morton "failed to start port %d " 59520f757743SAndrew Morton "(errno=%d)\n", i, rc); 5953ecef7253STejun Heo goto err_out; 5954ecef7253STejun Heo } 5955ecef7253STejun Heo } 5956ecef7253STejun Heo ata_eh_freeze_port(ap); 5957ecef7253STejun Heo } 5958ecef7253STejun Heo 595932ebbc0cSTejun Heo if (start_dr) 596032ebbc0cSTejun Heo devres_add(host->dev, start_dr); 5961ecef7253STejun Heo host->flags |= ATA_HOST_STARTED; 5962ecef7253STejun Heo return 0; 5963ecef7253STejun Heo 5964ecef7253STejun Heo err_out: 5965ecef7253STejun Heo while (--i >= 0) { 5966ecef7253STejun Heo struct ata_port *ap = host->ports[i]; 5967ecef7253STejun Heo 5968ecef7253STejun Heo if (ap->ops->port_stop) 5969ecef7253STejun Heo ap->ops->port_stop(ap); 5970ecef7253STejun Heo } 597132ebbc0cSTejun Heo devres_free(start_dr); 5972ecef7253STejun Heo return rc; 5973ecef7253STejun Heo } 5974ecef7253STejun Heo 5975ecef7253STejun Heo /** 5976cca3974eSJeff Garzik * ata_sas_host_init - Initialize a host struct 5977cca3974eSJeff Garzik * @host: host to initialize 5978cca3974eSJeff Garzik * @dev: device host is attached to 5979cca3974eSJeff Garzik * @flags: host flags 5980c6fd2807SJeff Garzik * @ops: port_ops 5981c6fd2807SJeff Garzik * 5982c6fd2807SJeff Garzik * LOCKING: 5983c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 5984c6fd2807SJeff Garzik * 5985c6fd2807SJeff Garzik */ 5986f3187195STejun Heo /* KILLME - the only user left is ipr */ 5987cca3974eSJeff Garzik void ata_host_init(struct ata_host *host, struct device *dev, 5988029cfd6bSTejun Heo unsigned long flags, struct ata_port_operations *ops) 5989c6fd2807SJeff Garzik { 5990cca3974eSJeff Garzik spin_lock_init(&host->lock); 5991cca3974eSJeff Garzik host->dev = dev; 5992cca3974eSJeff Garzik host->flags = flags; 5993cca3974eSJeff Garzik host->ops = ops; 5994c6fd2807SJeff Garzik } 5995c6fd2807SJeff Garzik 599679318057SArjan van de Ven 599779318057SArjan van de Ven static void async_port_probe(void *data, async_cookie_t cookie) 599879318057SArjan van de Ven { 599979318057SArjan van de Ven int rc; 600079318057SArjan van de Ven struct ata_port *ap = data; 6001886ad09fSArjan van de Ven 6002886ad09fSArjan van de Ven /* 6003886ad09fSArjan van de Ven * If we're not allowed to scan this host in parallel, 6004886ad09fSArjan van de Ven * we need to wait until all previous scans have completed 6005886ad09fSArjan van de Ven * before going further. 6006fa853a48SArjan van de Ven * Jeff Garzik says this is only within a controller, so we 6007fa853a48SArjan van de Ven * don't need to wait for port 0, only for later ports. 6008886ad09fSArjan van de Ven */ 6009fa853a48SArjan van de Ven if (!(ap->host->flags & ATA_HOST_PARALLEL_SCAN) && ap->port_no != 0) 6010886ad09fSArjan van de Ven async_synchronize_cookie(cookie); 6011886ad09fSArjan van de Ven 601279318057SArjan van de Ven /* probe */ 601379318057SArjan van de Ven if (ap->ops->error_handler) { 601479318057SArjan van de Ven struct ata_eh_info *ehi = &ap->link.eh_info; 601579318057SArjan van de Ven unsigned long flags; 601679318057SArjan van de Ven 601779318057SArjan van de Ven ata_port_probe(ap); 601879318057SArjan van de Ven 601979318057SArjan van de Ven /* kick EH for boot probing */ 602079318057SArjan van de Ven spin_lock_irqsave(ap->lock, flags); 602179318057SArjan van de Ven 602279318057SArjan van de Ven ehi->probe_mask |= ATA_ALL_DEVICES; 602379318057SArjan van de Ven ehi->action |= ATA_EH_RESET | ATA_EH_LPM; 602479318057SArjan van de Ven ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET; 602579318057SArjan van de Ven 602679318057SArjan van de Ven ap->pflags &= ~ATA_PFLAG_INITIALIZING; 602779318057SArjan van de Ven ap->pflags |= ATA_PFLAG_LOADING; 602879318057SArjan van de Ven ata_port_schedule_eh(ap); 602979318057SArjan van de Ven 603079318057SArjan van de Ven spin_unlock_irqrestore(ap->lock, flags); 603179318057SArjan van de Ven 603279318057SArjan van de Ven /* wait for EH to finish */ 603379318057SArjan van de Ven ata_port_wait_eh(ap); 603479318057SArjan van de Ven } else { 603579318057SArjan van de Ven DPRINTK("ata%u: bus probe begin\n", ap->print_id); 603679318057SArjan van de Ven rc = ata_bus_probe(ap); 603779318057SArjan van de Ven DPRINTK("ata%u: bus probe end\n", ap->print_id); 603879318057SArjan van de Ven 603979318057SArjan van de Ven if (rc) { 604079318057SArjan van de Ven /* FIXME: do something useful here? 604179318057SArjan van de Ven * Current libata behavior will 604279318057SArjan van de Ven * tear down everything when 604379318057SArjan van de Ven * the module is removed 604479318057SArjan van de Ven * or the h/w is unplugged. 604579318057SArjan van de Ven */ 604679318057SArjan van de Ven } 604779318057SArjan van de Ven } 6048f29d3b23SArjan van de Ven 6049f29d3b23SArjan van de Ven /* in order to keep device order, we need to synchronize at this point */ 6050f29d3b23SArjan van de Ven async_synchronize_cookie(cookie); 6051f29d3b23SArjan van de Ven 6052f29d3b23SArjan van de Ven ata_scsi_scan_host(ap, 1); 6053f29d3b23SArjan van de Ven 605479318057SArjan van de Ven } 6055c6fd2807SJeff Garzik /** 6056f3187195STejun Heo * ata_host_register - register initialized ATA host 6057f3187195STejun Heo * @host: ATA host to register 6058f3187195STejun Heo * @sht: template for SCSI host 6059c6fd2807SJeff Garzik * 6060f3187195STejun Heo * Register initialized ATA host. @host is allocated using 6061f3187195STejun Heo * ata_host_alloc() and fully initialized by LLD. This function 6062f3187195STejun Heo * starts ports, registers @host with ATA and SCSI layers and 6063f3187195STejun Heo * probe registered devices. 6064c6fd2807SJeff Garzik * 6065c6fd2807SJeff Garzik * LOCKING: 6066f3187195STejun Heo * Inherited from calling layer (may sleep). 6067c6fd2807SJeff Garzik * 6068c6fd2807SJeff Garzik * RETURNS: 6069f3187195STejun Heo * 0 on success, -errno otherwise. 6070c6fd2807SJeff Garzik */ 6071f3187195STejun Heo int ata_host_register(struct ata_host *host, struct scsi_host_template *sht) 6072c6fd2807SJeff Garzik { 6073f3187195STejun Heo int i, rc; 6074c6fd2807SJeff Garzik 6075f3187195STejun Heo /* host must have been started */ 6076f3187195STejun Heo if (!(host->flags & ATA_HOST_STARTED)) { 6077f3187195STejun Heo dev_printk(KERN_ERR, host->dev, 6078f3187195STejun Heo "BUG: trying to register unstarted host\n"); 6079f3187195STejun Heo WARN_ON(1); 6080f3187195STejun Heo return -EINVAL; 608102f076aaSAlan Cox } 6082f0d36efdSTejun Heo 6083f3187195STejun Heo /* Blow away unused ports. This happens when LLD can't 6084f3187195STejun Heo * determine the exact number of ports to allocate at 6085f3187195STejun Heo * allocation time. 6086f3187195STejun Heo */ 6087f3187195STejun Heo for (i = host->n_ports; host->ports[i]; i++) 6088f3187195STejun Heo kfree(host->ports[i]); 6089f0d36efdSTejun Heo 6090f3187195STejun Heo /* give ports names and add SCSI hosts */ 6091f3187195STejun Heo for (i = 0; i < host->n_ports; i++) 6092f3187195STejun Heo host->ports[i]->print_id = ata_print_id++; 6093c6fd2807SJeff Garzik 6094f3187195STejun Heo rc = ata_scsi_add_hosts(host, sht); 6095ecef7253STejun Heo if (rc) 6096f3187195STejun Heo return rc; 6097ecef7253STejun Heo 6098fafbae87STejun Heo /* associate with ACPI nodes */ 6099fafbae87STejun Heo ata_acpi_associate(host); 6100fafbae87STejun Heo 6101f3187195STejun Heo /* set cable, sata_spd_limit and report */ 6102cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 6103cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 6104f3187195STejun Heo unsigned long xfer_mask; 6105f3187195STejun Heo 6106f3187195STejun Heo /* set SATA cable type if still unset */ 6107f3187195STejun Heo if (ap->cbl == ATA_CBL_NONE && (ap->flags & ATA_FLAG_SATA)) 6108f3187195STejun Heo ap->cbl = ATA_CBL_SATA; 6109c6fd2807SJeff Garzik 6110c6fd2807SJeff Garzik /* init sata_spd_limit to the current value */ 61114fb37a25STejun Heo sata_link_init_spd(&ap->link); 6112b1c72916STejun Heo if (ap->slave_link) 6113b1c72916STejun Heo sata_link_init_spd(ap->slave_link); 6114c6fd2807SJeff Garzik 6115cbcdd875STejun Heo /* print per-port info to dmesg */ 6116f3187195STejun Heo xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask, 6117f3187195STejun Heo ap->udma_mask); 6118f3187195STejun Heo 6119abf6e8edSTejun Heo if (!ata_port_is_dummy(ap)) { 6120cbcdd875STejun Heo ata_port_printk(ap, KERN_INFO, 6121cbcdd875STejun Heo "%cATA max %s %s\n", 6122a16abc0bSTejun Heo (ap->flags & ATA_FLAG_SATA) ? 'S' : 'P', 6123f3187195STejun Heo ata_mode_string(xfer_mask), 6124cbcdd875STejun Heo ap->link.eh_info.desc); 6125abf6e8edSTejun Heo ata_ehi_clear_desc(&ap->link.eh_info); 6126abf6e8edSTejun Heo } else 6127f3187195STejun Heo ata_port_printk(ap, KERN_INFO, "DUMMY\n"); 6128c6fd2807SJeff Garzik } 6129c6fd2807SJeff Garzik 6130f6005354SVegard Nossum /* perform each probe asynchronously */ 6131f3187195STejun Heo for (i = 0; i < host->n_ports; i++) { 6132f3187195STejun Heo struct ata_port *ap = host->ports[i]; 613379318057SArjan van de Ven async_schedule(async_port_probe, ap); 6134c6fd2807SJeff Garzik } 6135c6fd2807SJeff Garzik 6136f3187195STejun Heo return 0; 6137f3187195STejun Heo } 6138f3187195STejun Heo 6139f3187195STejun Heo /** 6140f5cda257STejun Heo * ata_host_activate - start host, request IRQ and register it 6141f5cda257STejun Heo * @host: target ATA host 6142f5cda257STejun Heo * @irq: IRQ to request 6143f5cda257STejun Heo * @irq_handler: irq_handler used when requesting IRQ 6144f5cda257STejun Heo * @irq_flags: irq_flags used when requesting IRQ 6145f5cda257STejun Heo * @sht: scsi_host_template to use when registering the host 6146f5cda257STejun Heo * 6147f5cda257STejun Heo * After allocating an ATA host and initializing it, most libata 6148f5cda257STejun Heo * LLDs perform three steps to activate the host - start host, 6149f5cda257STejun Heo * request IRQ and register it. This helper takes necessasry 6150f5cda257STejun Heo * arguments and performs the three steps in one go. 6151f5cda257STejun Heo * 61523d46b2e2SPaul Mundt * An invalid IRQ skips the IRQ registration and expects the host to 61533d46b2e2SPaul Mundt * have set polling mode on the port. In this case, @irq_handler 61543d46b2e2SPaul Mundt * should be NULL. 61553d46b2e2SPaul Mundt * 6156f5cda257STejun Heo * LOCKING: 6157f5cda257STejun Heo * Inherited from calling layer (may sleep). 6158f5cda257STejun Heo * 6159f5cda257STejun Heo * RETURNS: 6160f5cda257STejun Heo * 0 on success, -errno otherwise. 6161f5cda257STejun Heo */ 6162f5cda257STejun Heo int ata_host_activate(struct ata_host *host, int irq, 6163f5cda257STejun Heo irq_handler_t irq_handler, unsigned long irq_flags, 6164f5cda257STejun Heo struct scsi_host_template *sht) 6165f5cda257STejun Heo { 6166cbcdd875STejun Heo int i, rc; 6167f5cda257STejun Heo 6168f5cda257STejun Heo rc = ata_host_start(host); 6169f5cda257STejun Heo if (rc) 6170f5cda257STejun Heo return rc; 6171f5cda257STejun Heo 61723d46b2e2SPaul Mundt /* Special case for polling mode */ 61733d46b2e2SPaul Mundt if (!irq) { 61743d46b2e2SPaul Mundt WARN_ON(irq_handler); 61753d46b2e2SPaul Mundt return ata_host_register(host, sht); 61763d46b2e2SPaul Mundt } 61773d46b2e2SPaul Mundt 6178f5cda257STejun Heo rc = devm_request_irq(host->dev, irq, irq_handler, irq_flags, 6179f5cda257STejun Heo dev_driver_string(host->dev), host); 6180f5cda257STejun Heo if (rc) 6181f5cda257STejun Heo return rc; 6182f5cda257STejun Heo 6183cbcdd875STejun Heo for (i = 0; i < host->n_ports; i++) 6184cbcdd875STejun Heo ata_port_desc(host->ports[i], "irq %d", irq); 61854031826bSTejun Heo 6186f5cda257STejun Heo rc = ata_host_register(host, sht); 6187f5cda257STejun Heo /* if failed, just free the IRQ and leave ports alone */ 6188f5cda257STejun Heo if (rc) 6189f5cda257STejun Heo devm_free_irq(host->dev, irq, host); 6190f5cda257STejun Heo 6191f5cda257STejun Heo return rc; 6192f5cda257STejun Heo } 6193f5cda257STejun Heo 6194f5cda257STejun Heo /** 6195c6fd2807SJeff Garzik * ata_port_detach - Detach ATA port in prepration of device removal 6196c6fd2807SJeff Garzik * @ap: ATA port to be detached 6197c6fd2807SJeff Garzik * 6198c6fd2807SJeff Garzik * Detach all ATA devices and the associated SCSI devices of @ap; 6199c6fd2807SJeff Garzik * then, remove the associated SCSI host. @ap is guaranteed to 6200c6fd2807SJeff Garzik * be quiescent on return from this function. 6201c6fd2807SJeff Garzik * 6202c6fd2807SJeff Garzik * LOCKING: 6203c6fd2807SJeff Garzik * Kernel thread context (may sleep). 6204c6fd2807SJeff Garzik */ 6205741b7763SAdrian Bunk static void ata_port_detach(struct ata_port *ap) 6206c6fd2807SJeff Garzik { 6207c6fd2807SJeff Garzik unsigned long flags; 6208c6fd2807SJeff Garzik 6209c6fd2807SJeff Garzik if (!ap->ops->error_handler) 6210c6fd2807SJeff Garzik goto skip_eh; 6211c6fd2807SJeff Garzik 6212c6fd2807SJeff Garzik /* tell EH we're leaving & flush EH */ 6213c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 6214c6fd2807SJeff Garzik ap->pflags |= ATA_PFLAG_UNLOADING; 6215ece180d1STejun Heo ata_port_schedule_eh(ap); 6216c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 6217c6fd2807SJeff Garzik 6218ece180d1STejun Heo /* wait till EH commits suicide */ 6219c6fd2807SJeff Garzik ata_port_wait_eh(ap); 6220c6fd2807SJeff Garzik 6221ece180d1STejun Heo /* it better be dead now */ 6222ece180d1STejun Heo WARN_ON(!(ap->pflags & ATA_PFLAG_UNLOADED)); 6223c6fd2807SJeff Garzik 622445a66c1cSOleg Nesterov cancel_rearming_delayed_work(&ap->hotplug_task); 6225c6fd2807SJeff Garzik 6226c6fd2807SJeff Garzik skip_eh: 6227c6fd2807SJeff Garzik /* remove the associated SCSI host */ 6228cca3974eSJeff Garzik scsi_remove_host(ap->scsi_host); 6229c6fd2807SJeff Garzik } 6230c6fd2807SJeff Garzik 6231c6fd2807SJeff Garzik /** 62320529c159STejun Heo * ata_host_detach - Detach all ports of an ATA host 62330529c159STejun Heo * @host: Host to detach 62340529c159STejun Heo * 62350529c159STejun Heo * Detach all ports of @host. 62360529c159STejun Heo * 62370529c159STejun Heo * LOCKING: 62380529c159STejun Heo * Kernel thread context (may sleep). 62390529c159STejun Heo */ 62400529c159STejun Heo void ata_host_detach(struct ata_host *host) 62410529c159STejun Heo { 62420529c159STejun Heo int i; 62430529c159STejun Heo 62440529c159STejun Heo for (i = 0; i < host->n_ports; i++) 62450529c159STejun Heo ata_port_detach(host->ports[i]); 6246562f0c2dSTejun Heo 6247562f0c2dSTejun Heo /* the host is dead now, dissociate ACPI */ 6248562f0c2dSTejun Heo ata_acpi_dissociate(host); 62490529c159STejun Heo } 62500529c159STejun Heo 6251c6fd2807SJeff Garzik #ifdef CONFIG_PCI 6252c6fd2807SJeff Garzik 6253c6fd2807SJeff Garzik /** 6254c6fd2807SJeff Garzik * ata_pci_remove_one - PCI layer callback for device removal 6255c6fd2807SJeff Garzik * @pdev: PCI device that was removed 6256c6fd2807SJeff Garzik * 6257b878ca5dSTejun Heo * PCI layer indicates to libata via this hook that hot-unplug or 6258b878ca5dSTejun Heo * module unload event has occurred. Detach all ports. Resource 6259b878ca5dSTejun Heo * release is handled via devres. 6260c6fd2807SJeff Garzik * 6261c6fd2807SJeff Garzik * LOCKING: 6262c6fd2807SJeff Garzik * Inherited from PCI layer (may sleep). 6263c6fd2807SJeff Garzik */ 6264c6fd2807SJeff Garzik void ata_pci_remove_one(struct pci_dev *pdev) 6265c6fd2807SJeff Garzik { 62662855568bSJeff Garzik struct device *dev = &pdev->dev; 6267cca3974eSJeff Garzik struct ata_host *host = dev_get_drvdata(dev); 6268c6fd2807SJeff Garzik 6269f0d36efdSTejun Heo ata_host_detach(host); 6270c6fd2807SJeff Garzik } 6271c6fd2807SJeff Garzik 6272c6fd2807SJeff Garzik /* move to PCI subsystem */ 6273c6fd2807SJeff Garzik int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits) 6274c6fd2807SJeff Garzik { 6275c6fd2807SJeff Garzik unsigned long tmp = 0; 6276c6fd2807SJeff Garzik 6277c6fd2807SJeff Garzik switch (bits->width) { 6278c6fd2807SJeff Garzik case 1: { 6279c6fd2807SJeff Garzik u8 tmp8 = 0; 6280c6fd2807SJeff Garzik pci_read_config_byte(pdev, bits->reg, &tmp8); 6281c6fd2807SJeff Garzik tmp = tmp8; 6282c6fd2807SJeff Garzik break; 6283c6fd2807SJeff Garzik } 6284c6fd2807SJeff Garzik case 2: { 6285c6fd2807SJeff Garzik u16 tmp16 = 0; 6286c6fd2807SJeff Garzik pci_read_config_word(pdev, bits->reg, &tmp16); 6287c6fd2807SJeff Garzik tmp = tmp16; 6288c6fd2807SJeff Garzik break; 6289c6fd2807SJeff Garzik } 6290c6fd2807SJeff Garzik case 4: { 6291c6fd2807SJeff Garzik u32 tmp32 = 0; 6292c6fd2807SJeff Garzik pci_read_config_dword(pdev, bits->reg, &tmp32); 6293c6fd2807SJeff Garzik tmp = tmp32; 6294c6fd2807SJeff Garzik break; 6295c6fd2807SJeff Garzik } 6296c6fd2807SJeff Garzik 6297c6fd2807SJeff Garzik default: 6298c6fd2807SJeff Garzik return -EINVAL; 6299c6fd2807SJeff Garzik } 6300c6fd2807SJeff Garzik 6301c6fd2807SJeff Garzik tmp &= bits->mask; 6302c6fd2807SJeff Garzik 6303c6fd2807SJeff Garzik return (tmp == bits->val) ? 1 : 0; 6304c6fd2807SJeff Garzik } 6305c6fd2807SJeff Garzik 63066ffa01d8STejun Heo #ifdef CONFIG_PM 6307c6fd2807SJeff Garzik void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg) 6308c6fd2807SJeff Garzik { 6309c6fd2807SJeff Garzik pci_save_state(pdev); 6310c6fd2807SJeff Garzik pci_disable_device(pdev); 63114c90d971STejun Heo 63123a2d5b70SRafael J. Wysocki if (mesg.event & PM_EVENT_SLEEP) 6313c6fd2807SJeff Garzik pci_set_power_state(pdev, PCI_D3hot); 6314c6fd2807SJeff Garzik } 6315c6fd2807SJeff Garzik 6316553c4aa6STejun Heo int ata_pci_device_do_resume(struct pci_dev *pdev) 6317c6fd2807SJeff Garzik { 6318553c4aa6STejun Heo int rc; 6319553c4aa6STejun Heo 6320c6fd2807SJeff Garzik pci_set_power_state(pdev, PCI_D0); 6321c6fd2807SJeff Garzik pci_restore_state(pdev); 6322553c4aa6STejun Heo 6323f0d36efdSTejun Heo rc = pcim_enable_device(pdev); 6324553c4aa6STejun Heo if (rc) { 6325553c4aa6STejun Heo dev_printk(KERN_ERR, &pdev->dev, 6326553c4aa6STejun Heo "failed to enable device after resume (%d)\n", rc); 6327553c4aa6STejun Heo return rc; 6328553c4aa6STejun Heo } 6329553c4aa6STejun Heo 6330c6fd2807SJeff Garzik pci_set_master(pdev); 6331553c4aa6STejun Heo return 0; 6332c6fd2807SJeff Garzik } 6333c6fd2807SJeff Garzik 6334c6fd2807SJeff Garzik int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg) 6335c6fd2807SJeff Garzik { 6336cca3974eSJeff Garzik struct ata_host *host = dev_get_drvdata(&pdev->dev); 6337c6fd2807SJeff Garzik int rc = 0; 6338c6fd2807SJeff Garzik 6339cca3974eSJeff Garzik rc = ata_host_suspend(host, mesg); 6340c6fd2807SJeff Garzik if (rc) 6341c6fd2807SJeff Garzik return rc; 6342c6fd2807SJeff Garzik 6343c6fd2807SJeff Garzik ata_pci_device_do_suspend(pdev, mesg); 6344c6fd2807SJeff Garzik 6345c6fd2807SJeff Garzik return 0; 6346c6fd2807SJeff Garzik } 6347c6fd2807SJeff Garzik 6348c6fd2807SJeff Garzik int ata_pci_device_resume(struct pci_dev *pdev) 6349c6fd2807SJeff Garzik { 6350cca3974eSJeff Garzik struct ata_host *host = dev_get_drvdata(&pdev->dev); 6351553c4aa6STejun Heo int rc; 6352c6fd2807SJeff Garzik 6353553c4aa6STejun Heo rc = ata_pci_device_do_resume(pdev); 6354553c4aa6STejun Heo if (rc == 0) 6355cca3974eSJeff Garzik ata_host_resume(host); 6356553c4aa6STejun Heo return rc; 6357c6fd2807SJeff Garzik } 63586ffa01d8STejun Heo #endif /* CONFIG_PM */ 63596ffa01d8STejun Heo 6360c6fd2807SJeff Garzik #endif /* CONFIG_PCI */ 6361c6fd2807SJeff Garzik 636233267325STejun Heo static int __init ata_parse_force_one(char **cur, 636333267325STejun Heo struct ata_force_ent *force_ent, 636433267325STejun Heo const char **reason) 636533267325STejun Heo { 636633267325STejun Heo /* FIXME: Currently, there's no way to tag init const data and 636733267325STejun Heo * using __initdata causes build failure on some versions of 636833267325STejun Heo * gcc. Once __initdataconst is implemented, add const to the 636933267325STejun Heo * following structure. 637033267325STejun Heo */ 637133267325STejun Heo static struct ata_force_param force_tbl[] __initdata = { 637233267325STejun Heo { "40c", .cbl = ATA_CBL_PATA40 }, 637333267325STejun Heo { "80c", .cbl = ATA_CBL_PATA80 }, 637433267325STejun Heo { "short40c", .cbl = ATA_CBL_PATA40_SHORT }, 637533267325STejun Heo { "unk", .cbl = ATA_CBL_PATA_UNK }, 637633267325STejun Heo { "ign", .cbl = ATA_CBL_PATA_IGN }, 637733267325STejun Heo { "sata", .cbl = ATA_CBL_SATA }, 637833267325STejun Heo { "1.5Gbps", .spd_limit = 1 }, 637933267325STejun Heo { "3.0Gbps", .spd_limit = 2 }, 638033267325STejun Heo { "noncq", .horkage_on = ATA_HORKAGE_NONCQ }, 638133267325STejun Heo { "ncq", .horkage_off = ATA_HORKAGE_NONCQ }, 638233267325STejun Heo { "pio0", .xfer_mask = 1 << (ATA_SHIFT_PIO + 0) }, 638333267325STejun Heo { "pio1", .xfer_mask = 1 << (ATA_SHIFT_PIO + 1) }, 638433267325STejun Heo { "pio2", .xfer_mask = 1 << (ATA_SHIFT_PIO + 2) }, 638533267325STejun Heo { "pio3", .xfer_mask = 1 << (ATA_SHIFT_PIO + 3) }, 638633267325STejun Heo { "pio4", .xfer_mask = 1 << (ATA_SHIFT_PIO + 4) }, 638733267325STejun Heo { "pio5", .xfer_mask = 1 << (ATA_SHIFT_PIO + 5) }, 638833267325STejun Heo { "pio6", .xfer_mask = 1 << (ATA_SHIFT_PIO + 6) }, 638933267325STejun Heo { "mwdma0", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 0) }, 639033267325STejun Heo { "mwdma1", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 1) }, 639133267325STejun Heo { "mwdma2", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 2) }, 639233267325STejun Heo { "mwdma3", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 3) }, 639333267325STejun Heo { "mwdma4", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 4) }, 639433267325STejun Heo { "udma0", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 0) }, 639533267325STejun Heo { "udma16", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 0) }, 639633267325STejun Heo { "udma/16", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 0) }, 639733267325STejun Heo { "udma1", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 1) }, 639833267325STejun Heo { "udma25", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 1) }, 639933267325STejun Heo { "udma/25", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 1) }, 640033267325STejun Heo { "udma2", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 2) }, 640133267325STejun Heo { "udma33", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 2) }, 640233267325STejun Heo { "udma/33", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 2) }, 640333267325STejun Heo { "udma3", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 3) }, 640433267325STejun Heo { "udma44", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 3) }, 640533267325STejun Heo { "udma/44", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 3) }, 640633267325STejun Heo { "udma4", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 4) }, 640733267325STejun Heo { "udma66", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 4) }, 640833267325STejun Heo { "udma/66", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 4) }, 640933267325STejun Heo { "udma5", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 5) }, 641033267325STejun Heo { "udma100", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 5) }, 641133267325STejun Heo { "udma/100", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 5) }, 641233267325STejun Heo { "udma6", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 6) }, 641333267325STejun Heo { "udma133", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 6) }, 641433267325STejun Heo { "udma/133", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 6) }, 641533267325STejun Heo { "udma7", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 7) }, 641605944bdfSTejun Heo { "nohrst", .lflags = ATA_LFLAG_NO_HRST }, 641705944bdfSTejun Heo { "nosrst", .lflags = ATA_LFLAG_NO_SRST }, 641805944bdfSTejun Heo { "norst", .lflags = ATA_LFLAG_NO_HRST | ATA_LFLAG_NO_SRST }, 641933267325STejun Heo }; 642033267325STejun Heo char *start = *cur, *p = *cur; 642133267325STejun Heo char *id, *val, *endp; 642233267325STejun Heo const struct ata_force_param *match_fp = NULL; 642333267325STejun Heo int nr_matches = 0, i; 642433267325STejun Heo 642533267325STejun Heo /* find where this param ends and update *cur */ 642633267325STejun Heo while (*p != '\0' && *p != ',') 642733267325STejun Heo p++; 642833267325STejun Heo 642933267325STejun Heo if (*p == '\0') 643033267325STejun Heo *cur = p; 643133267325STejun Heo else 643233267325STejun Heo *cur = p + 1; 643333267325STejun Heo 643433267325STejun Heo *p = '\0'; 643533267325STejun Heo 643633267325STejun Heo /* parse */ 643733267325STejun Heo p = strchr(start, ':'); 643833267325STejun Heo if (!p) { 643933267325STejun Heo val = strstrip(start); 644033267325STejun Heo goto parse_val; 644133267325STejun Heo } 644233267325STejun Heo *p = '\0'; 644333267325STejun Heo 644433267325STejun Heo id = strstrip(start); 644533267325STejun Heo val = strstrip(p + 1); 644633267325STejun Heo 644733267325STejun Heo /* parse id */ 644833267325STejun Heo p = strchr(id, '.'); 644933267325STejun Heo if (p) { 645033267325STejun Heo *p++ = '\0'; 645133267325STejun Heo force_ent->device = simple_strtoul(p, &endp, 10); 645233267325STejun Heo if (p == endp || *endp != '\0') { 645333267325STejun Heo *reason = "invalid device"; 645433267325STejun Heo return -EINVAL; 645533267325STejun Heo } 645633267325STejun Heo } 645733267325STejun Heo 645833267325STejun Heo force_ent->port = simple_strtoul(id, &endp, 10); 645933267325STejun Heo if (p == endp || *endp != '\0') { 646033267325STejun Heo *reason = "invalid port/link"; 646133267325STejun Heo return -EINVAL; 646233267325STejun Heo } 646333267325STejun Heo 646433267325STejun Heo parse_val: 646533267325STejun Heo /* parse val, allow shortcuts so that both 1.5 and 1.5Gbps work */ 646633267325STejun Heo for (i = 0; i < ARRAY_SIZE(force_tbl); i++) { 646733267325STejun Heo const struct ata_force_param *fp = &force_tbl[i]; 646833267325STejun Heo 646933267325STejun Heo if (strncasecmp(val, fp->name, strlen(val))) 647033267325STejun Heo continue; 647133267325STejun Heo 647233267325STejun Heo nr_matches++; 647333267325STejun Heo match_fp = fp; 647433267325STejun Heo 647533267325STejun Heo if (strcasecmp(val, fp->name) == 0) { 647633267325STejun Heo nr_matches = 1; 647733267325STejun Heo break; 647833267325STejun Heo } 647933267325STejun Heo } 648033267325STejun Heo 648133267325STejun Heo if (!nr_matches) { 648233267325STejun Heo *reason = "unknown value"; 648333267325STejun Heo return -EINVAL; 648433267325STejun Heo } 648533267325STejun Heo if (nr_matches > 1) { 648633267325STejun Heo *reason = "ambigious value"; 648733267325STejun Heo return -EINVAL; 648833267325STejun Heo } 648933267325STejun Heo 649033267325STejun Heo force_ent->param = *match_fp; 649133267325STejun Heo 649233267325STejun Heo return 0; 649333267325STejun Heo } 649433267325STejun Heo 649533267325STejun Heo static void __init ata_parse_force_param(void) 649633267325STejun Heo { 649733267325STejun Heo int idx = 0, size = 1; 649833267325STejun Heo int last_port = -1, last_device = -1; 649933267325STejun Heo char *p, *cur, *next; 650033267325STejun Heo 650133267325STejun Heo /* calculate maximum number of params and allocate force_tbl */ 650233267325STejun Heo for (p = ata_force_param_buf; *p; p++) 650333267325STejun Heo if (*p == ',') 650433267325STejun Heo size++; 650533267325STejun Heo 650633267325STejun Heo ata_force_tbl = kzalloc(sizeof(ata_force_tbl[0]) * size, GFP_KERNEL); 650733267325STejun Heo if (!ata_force_tbl) { 650833267325STejun Heo printk(KERN_WARNING "ata: failed to extend force table, " 650933267325STejun Heo "libata.force ignored\n"); 651033267325STejun Heo return; 651133267325STejun Heo } 651233267325STejun Heo 651333267325STejun Heo /* parse and populate the table */ 651433267325STejun Heo for (cur = ata_force_param_buf; *cur != '\0'; cur = next) { 651533267325STejun Heo const char *reason = ""; 651633267325STejun Heo struct ata_force_ent te = { .port = -1, .device = -1 }; 651733267325STejun Heo 651833267325STejun Heo next = cur; 651933267325STejun Heo if (ata_parse_force_one(&next, &te, &reason)) { 652033267325STejun Heo printk(KERN_WARNING "ata: failed to parse force " 652133267325STejun Heo "parameter \"%s\" (%s)\n", 652233267325STejun Heo cur, reason); 652333267325STejun Heo continue; 652433267325STejun Heo } 652533267325STejun Heo 652633267325STejun Heo if (te.port == -1) { 652733267325STejun Heo te.port = last_port; 652833267325STejun Heo te.device = last_device; 652933267325STejun Heo } 653033267325STejun Heo 653133267325STejun Heo ata_force_tbl[idx++] = te; 653233267325STejun Heo 653333267325STejun Heo last_port = te.port; 653433267325STejun Heo last_device = te.device; 653533267325STejun Heo } 653633267325STejun Heo 653733267325STejun Heo ata_force_tbl_size = idx; 653833267325STejun Heo } 6539c6fd2807SJeff Garzik 6540c6fd2807SJeff Garzik static int __init ata_init(void) 6541c6fd2807SJeff Garzik { 654233267325STejun Heo ata_parse_force_param(); 654333267325STejun Heo 6544c6fd2807SJeff Garzik ata_wq = create_workqueue("ata"); 6545c6fd2807SJeff Garzik if (!ata_wq) 654649ea3b04SElias Oltmanns goto free_force_tbl; 6547c6fd2807SJeff Garzik 6548c6fd2807SJeff Garzik ata_aux_wq = create_singlethread_workqueue("ata_aux"); 654949ea3b04SElias Oltmanns if (!ata_aux_wq) 655049ea3b04SElias Oltmanns goto free_wq; 6551c6fd2807SJeff Garzik 6552c6fd2807SJeff Garzik printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n"); 6553c6fd2807SJeff Garzik return 0; 655449ea3b04SElias Oltmanns 655549ea3b04SElias Oltmanns free_wq: 655649ea3b04SElias Oltmanns destroy_workqueue(ata_wq); 655749ea3b04SElias Oltmanns free_force_tbl: 655849ea3b04SElias Oltmanns kfree(ata_force_tbl); 655949ea3b04SElias Oltmanns return -ENOMEM; 6560c6fd2807SJeff Garzik } 6561c6fd2807SJeff Garzik 6562c6fd2807SJeff Garzik static void __exit ata_exit(void) 6563c6fd2807SJeff Garzik { 656433267325STejun Heo kfree(ata_force_tbl); 6565c6fd2807SJeff Garzik destroy_workqueue(ata_wq); 6566c6fd2807SJeff Garzik destroy_workqueue(ata_aux_wq); 6567c6fd2807SJeff Garzik } 6568c6fd2807SJeff Garzik 6569a4625085SBrian King subsys_initcall(ata_init); 6570c6fd2807SJeff Garzik module_exit(ata_exit); 6571c6fd2807SJeff Garzik 6572c6fd2807SJeff Garzik static unsigned long ratelimit_time; 6573c6fd2807SJeff Garzik static DEFINE_SPINLOCK(ata_ratelimit_lock); 6574c6fd2807SJeff Garzik 6575c6fd2807SJeff Garzik int ata_ratelimit(void) 6576c6fd2807SJeff Garzik { 6577c6fd2807SJeff Garzik int rc; 6578c6fd2807SJeff Garzik unsigned long flags; 6579c6fd2807SJeff Garzik 6580c6fd2807SJeff Garzik spin_lock_irqsave(&ata_ratelimit_lock, flags); 6581c6fd2807SJeff Garzik 6582c6fd2807SJeff Garzik if (time_after(jiffies, ratelimit_time)) { 6583c6fd2807SJeff Garzik rc = 1; 6584c6fd2807SJeff Garzik ratelimit_time = jiffies + (HZ/5); 6585c6fd2807SJeff Garzik } else 6586c6fd2807SJeff Garzik rc = 0; 6587c6fd2807SJeff Garzik 6588c6fd2807SJeff Garzik spin_unlock_irqrestore(&ata_ratelimit_lock, flags); 6589c6fd2807SJeff Garzik 6590c6fd2807SJeff Garzik return rc; 6591c6fd2807SJeff Garzik } 6592c6fd2807SJeff Garzik 6593c6fd2807SJeff Garzik /** 6594c6fd2807SJeff Garzik * ata_wait_register - wait until register value changes 6595c6fd2807SJeff Garzik * @reg: IO-mapped register 6596c6fd2807SJeff Garzik * @mask: Mask to apply to read register value 6597c6fd2807SJeff Garzik * @val: Wait condition 6598341c2c95STejun Heo * @interval: polling interval in milliseconds 6599341c2c95STejun Heo * @timeout: timeout in milliseconds 6600c6fd2807SJeff Garzik * 6601c6fd2807SJeff Garzik * Waiting for some bits of register to change is a common 6602c6fd2807SJeff Garzik * operation for ATA controllers. This function reads 32bit LE 6603c6fd2807SJeff Garzik * IO-mapped register @reg and tests for the following condition. 6604c6fd2807SJeff Garzik * 6605c6fd2807SJeff Garzik * (*@reg & mask) != val 6606c6fd2807SJeff Garzik * 6607c6fd2807SJeff Garzik * If the condition is met, it returns; otherwise, the process is 6608c6fd2807SJeff Garzik * repeated after @interval_msec until timeout. 6609c6fd2807SJeff Garzik * 6610c6fd2807SJeff Garzik * LOCKING: 6611c6fd2807SJeff Garzik * Kernel thread context (may sleep) 6612c6fd2807SJeff Garzik * 6613c6fd2807SJeff Garzik * RETURNS: 6614c6fd2807SJeff Garzik * The final register value. 6615c6fd2807SJeff Garzik */ 6616c6fd2807SJeff Garzik u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val, 6617341c2c95STejun Heo unsigned long interval, unsigned long timeout) 6618c6fd2807SJeff Garzik { 6619341c2c95STejun Heo unsigned long deadline; 6620c6fd2807SJeff Garzik u32 tmp; 6621c6fd2807SJeff Garzik 6622c6fd2807SJeff Garzik tmp = ioread32(reg); 6623c6fd2807SJeff Garzik 6624c6fd2807SJeff Garzik /* Calculate timeout _after_ the first read to make sure 6625c6fd2807SJeff Garzik * preceding writes reach the controller before starting to 6626c6fd2807SJeff Garzik * eat away the timeout. 6627c6fd2807SJeff Garzik */ 6628341c2c95STejun Heo deadline = ata_deadline(jiffies, timeout); 6629c6fd2807SJeff Garzik 6630341c2c95STejun Heo while ((tmp & mask) == val && time_before(jiffies, deadline)) { 6631341c2c95STejun Heo msleep(interval); 6632c6fd2807SJeff Garzik tmp = ioread32(reg); 6633c6fd2807SJeff Garzik } 6634c6fd2807SJeff Garzik 6635c6fd2807SJeff Garzik return tmp; 6636c6fd2807SJeff Garzik } 6637c6fd2807SJeff Garzik 6638c6fd2807SJeff Garzik /* 6639c6fd2807SJeff Garzik * Dummy port_ops 6640c6fd2807SJeff Garzik */ 6641c6fd2807SJeff Garzik static unsigned int ata_dummy_qc_issue(struct ata_queued_cmd *qc) 6642c6fd2807SJeff Garzik { 6643c6fd2807SJeff Garzik return AC_ERR_SYSTEM; 6644c6fd2807SJeff Garzik } 6645c6fd2807SJeff Garzik 6646182d7bbaSTejun Heo static void ata_dummy_error_handler(struct ata_port *ap) 6647182d7bbaSTejun Heo { 6648182d7bbaSTejun Heo /* truly dummy */ 6649182d7bbaSTejun Heo } 6650182d7bbaSTejun Heo 6651029cfd6bSTejun Heo struct ata_port_operations ata_dummy_port_ops = { 6652c6fd2807SJeff Garzik .qc_prep = ata_noop_qc_prep, 6653c6fd2807SJeff Garzik .qc_issue = ata_dummy_qc_issue, 6654182d7bbaSTejun Heo .error_handler = ata_dummy_error_handler, 6655c6fd2807SJeff Garzik }; 6656c6fd2807SJeff Garzik 665721b0ad4fSTejun Heo const struct ata_port_info ata_dummy_port_info = { 665821b0ad4fSTejun Heo .port_ops = &ata_dummy_port_ops, 665921b0ad4fSTejun Heo }; 666021b0ad4fSTejun Heo 6661c6fd2807SJeff Garzik /* 6662c6fd2807SJeff Garzik * libata is essentially a library of internal helper functions for 6663c6fd2807SJeff Garzik * low-level ATA host controller drivers. As such, the API/ABI is 6664c6fd2807SJeff Garzik * likely to change as new drivers are added and updated. 6665c6fd2807SJeff Garzik * Do not depend on ABI/API stability. 6666c6fd2807SJeff Garzik */ 6667c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_deb_timing_normal); 6668c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_deb_timing_hotplug); 6669c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_deb_timing_long); 6670029cfd6bSTejun Heo EXPORT_SYMBOL_GPL(ata_base_port_ops); 6671029cfd6bSTejun Heo EXPORT_SYMBOL_GPL(sata_port_ops); 6672c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_dummy_port_ops); 667321b0ad4fSTejun Heo EXPORT_SYMBOL_GPL(ata_dummy_port_info); 66741eca4365STejun Heo EXPORT_SYMBOL_GPL(ata_link_next); 66751eca4365STejun Heo EXPORT_SYMBOL_GPL(ata_dev_next); 6676c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_bios_param); 6677cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_init); 6678f3187195STejun Heo EXPORT_SYMBOL_GPL(ata_host_alloc); 6679f5cda257STejun Heo EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo); 6680b1c72916STejun Heo EXPORT_SYMBOL_GPL(ata_slave_link_init); 6681ecef7253STejun Heo EXPORT_SYMBOL_GPL(ata_host_start); 6682f3187195STejun Heo EXPORT_SYMBOL_GPL(ata_host_register); 6683f5cda257STejun Heo EXPORT_SYMBOL_GPL(ata_host_activate); 66840529c159STejun Heo EXPORT_SYMBOL_GPL(ata_host_detach); 6685c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_sg_init); 6686c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_complete); 6687c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_complete_multiple); 6688436d34b3STejun Heo EXPORT_SYMBOL_GPL(atapi_cmd_type); 6689c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_to_fis); 6690c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_from_fis); 66916357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_pack_xfermask); 66926357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_unpack_xfermask); 66936357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_xfer_mask2mode); 66946357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_xfer_mode2mask); 66956357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_xfer_mode2shift); 66966357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_mode_string); 66976357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_id_xfermask); 6698c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_start); 669904351821SAlan EXPORT_SYMBOL_GPL(ata_do_set_mode); 670031cc23b3STejun Heo EXPORT_SYMBOL_GPL(ata_std_qc_defer); 6701c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_noop_qc_prep); 6702c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_probe); 670310305f0fSAlan EXPORT_SYMBOL_GPL(ata_dev_disable); 6704c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_set_spd); 6705aa2731adSTejun Heo EXPORT_SYMBOL_GPL(ata_wait_after_reset); 6706936fd732STejun Heo EXPORT_SYMBOL_GPL(sata_link_debounce); 6707936fd732STejun Heo EXPORT_SYMBOL_GPL(sata_link_resume); 67080aa1113dSTejun Heo EXPORT_SYMBOL_GPL(ata_std_prereset); 6709cc0680a5STejun Heo EXPORT_SYMBOL_GPL(sata_link_hardreset); 671057c9efdfSTejun Heo EXPORT_SYMBOL_GPL(sata_std_hardreset); 6711203c75b8STejun Heo EXPORT_SYMBOL_GPL(ata_std_postreset); 6712c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_dev_classify); 6713c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_dev_pair); 6714c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_disable); 6715c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_ratelimit); 6716c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_wait_register); 6717c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_queuecmd); 6718c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_slave_config); 6719c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_slave_destroy); 6720c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth); 6721c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_valid); 6722c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_read); 6723c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_write); 6724c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_write_flush); 6725936fd732STejun Heo EXPORT_SYMBOL_GPL(ata_link_online); 6726936fd732STejun Heo EXPORT_SYMBOL_GPL(ata_link_offline); 67276ffa01d8STejun Heo #ifdef CONFIG_PM 6728cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_suspend); 6729cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_resume); 67306ffa01d8STejun Heo #endif /* CONFIG_PM */ 6731c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_id_string); 6732c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_id_c_string); 6733963e4975SAlan Cox EXPORT_SYMBOL_GPL(ata_do_dev_read_id); 6734c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_simulate); 6735c6fd2807SJeff Garzik 67361a660164SMark Lord EXPORT_SYMBOL_GPL(ata_pio_queue_task); 6737c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pio_need_iordy); 67386357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_timing_find_mode); 6739c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_timing_compute); 6740c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_timing_merge); 6741a0f79b92STejun Heo EXPORT_SYMBOL_GPL(ata_timing_cycle2mode); 6742c6fd2807SJeff Garzik 6743c6fd2807SJeff Garzik #ifdef CONFIG_PCI 6744c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(pci_test_config_bits); 6745c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_remove_one); 67466ffa01d8STejun Heo #ifdef CONFIG_PM 6747c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_do_suspend); 6748c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_do_resume); 6749c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_suspend); 6750c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_resume); 67516ffa01d8STejun Heo #endif /* CONFIG_PM */ 6752c6fd2807SJeff Garzik #endif /* CONFIG_PCI */ 6753c6fd2807SJeff Garzik 6754b64bbc39STejun Heo EXPORT_SYMBOL_GPL(__ata_ehi_push_desc); 6755b64bbc39STejun Heo EXPORT_SYMBOL_GPL(ata_ehi_push_desc); 6756b64bbc39STejun Heo EXPORT_SYMBOL_GPL(ata_ehi_clear_desc); 6757cbcdd875STejun Heo EXPORT_SYMBOL_GPL(ata_port_desc); 6758cbcdd875STejun Heo #ifdef CONFIG_PCI 6759cbcdd875STejun Heo EXPORT_SYMBOL_GPL(ata_port_pbar_desc); 6760cbcdd875STejun Heo #endif /* CONFIG_PCI */ 6761c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_schedule_eh); 6762dbd82616STejun Heo EXPORT_SYMBOL_GPL(ata_link_abort); 6763c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_abort); 6764c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_freeze); 67657d77b247STejun Heo EXPORT_SYMBOL_GPL(sata_async_notification); 6766c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_freeze_port); 6767c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_thaw_port); 6768c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_qc_complete); 6769c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_qc_retry); 677010acf3b0SMark Lord EXPORT_SYMBOL_GPL(ata_eh_analyze_ncq_error); 6771c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_do_eh); 6772a1efdabaSTejun Heo EXPORT_SYMBOL_GPL(ata_std_error_handler); 6773be0d18dfSAlan Cox 6774be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_40wire); 6775be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_80wire); 6776be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_unknown); 6777c88f90c3STejun Heo EXPORT_SYMBOL_GPL(ata_cable_ignore); 6778be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_sata); 6779