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> 59c6fd2807SJeff Garzik #include <scsi/scsi.h> 60c6fd2807SJeff Garzik #include <scsi/scsi_cmnd.h> 61c6fd2807SJeff Garzik #include <scsi/scsi_host.h> 62c6fd2807SJeff Garzik #include <linux/libata.h> 63c6fd2807SJeff Garzik #include <asm/byteorder.h> 64140b5e59STejun Heo #include <linux/cdrom.h> 65c6fd2807SJeff Garzik 66c6fd2807SJeff Garzik #include "libata.h" 67c6fd2807SJeff Garzik 68fda0efc5SJeff Garzik 69c6fd2807SJeff Garzik /* debounce timing parameters in msecs { interval, duration, timeout } */ 70c6fd2807SJeff Garzik const unsigned long sata_deb_timing_normal[] = { 5, 100, 2000 }; 71c6fd2807SJeff Garzik const unsigned long sata_deb_timing_hotplug[] = { 25, 500, 2000 }; 72c6fd2807SJeff Garzik const unsigned long sata_deb_timing_long[] = { 100, 2000, 5000 }; 73c6fd2807SJeff Garzik 74029cfd6bSTejun Heo const struct ata_port_operations ata_base_port_ops = { 750aa1113dSTejun Heo .prereset = ata_std_prereset, 76203c75b8STejun Heo .postreset = ata_std_postreset, 77a1efdabaSTejun Heo .error_handler = ata_std_error_handler, 78029cfd6bSTejun Heo }; 79029cfd6bSTejun Heo 80029cfd6bSTejun Heo const struct ata_port_operations sata_port_ops = { 81029cfd6bSTejun Heo .inherits = &ata_base_port_ops, 82029cfd6bSTejun Heo 83029cfd6bSTejun Heo .qc_defer = ata_std_qc_defer, 8457c9efdfSTejun Heo .hardreset = sata_std_hardreset, 85029cfd6bSTejun Heo }; 86029cfd6bSTejun Heo 87c6fd2807SJeff Garzik static unsigned int ata_dev_init_params(struct ata_device *dev, 88c6fd2807SJeff Garzik u16 heads, u16 sectors); 89c6fd2807SJeff Garzik static unsigned int ata_dev_set_xfermode(struct ata_device *dev); 90218f3d30SJeff Garzik static unsigned int ata_dev_set_feature(struct ata_device *dev, 91218f3d30SJeff Garzik u8 enable, u8 feature); 92c6fd2807SJeff Garzik static void ata_dev_xfermask(struct ata_device *dev); 9375683fe7STejun Heo static unsigned long ata_dev_blacklisted(const struct ata_device *dev); 94c6fd2807SJeff Garzik 95f3187195STejun Heo unsigned int ata_print_id = 1; 96c6fd2807SJeff Garzik static struct workqueue_struct *ata_wq; 97c6fd2807SJeff Garzik 98c6fd2807SJeff Garzik struct workqueue_struct *ata_aux_wq; 99c6fd2807SJeff Garzik 10033267325STejun Heo struct ata_force_param { 10133267325STejun Heo const char *name; 10233267325STejun Heo unsigned int cbl; 10333267325STejun Heo int spd_limit; 10433267325STejun Heo unsigned long xfer_mask; 10533267325STejun Heo unsigned int horkage_on; 10633267325STejun Heo unsigned int horkage_off; 10733267325STejun Heo }; 10833267325STejun Heo 10933267325STejun Heo struct ata_force_ent { 11033267325STejun Heo int port; 11133267325STejun Heo int device; 11233267325STejun Heo struct ata_force_param param; 11333267325STejun Heo }; 11433267325STejun Heo 11533267325STejun Heo static struct ata_force_ent *ata_force_tbl; 11633267325STejun Heo static int ata_force_tbl_size; 11733267325STejun Heo 11833267325STejun Heo static char ata_force_param_buf[PAGE_SIZE] __initdata; 1197afb4222STejun Heo /* param_buf is thrown away after initialization, disallow read */ 1207afb4222STejun Heo module_param_string(force, ata_force_param_buf, sizeof(ata_force_param_buf), 0); 12133267325STejun Heo MODULE_PARM_DESC(force, "Force ATA configurations including cable type, link speed and transfer mode (see Documentation/kernel-parameters.txt for details)"); 12233267325STejun Heo 123c6fd2807SJeff Garzik int atapi_enabled = 1; 124c6fd2807SJeff Garzik module_param(atapi_enabled, int, 0444); 125c6fd2807SJeff Garzik MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)"); 126c6fd2807SJeff Garzik 127c5c61bdaSAdrian Bunk static int atapi_dmadir = 0; 128c6fd2807SJeff Garzik module_param(atapi_dmadir, int, 0444); 129c6fd2807SJeff Garzik MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)"); 130c6fd2807SJeff Garzik 131baf4fdfaSMark Lord int atapi_passthru16 = 1; 132baf4fdfaSMark Lord module_param(atapi_passthru16, int, 0444); 133baf4fdfaSMark Lord MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices; on by default (0=off, 1=on)"); 134baf4fdfaSMark Lord 135c6fd2807SJeff Garzik int libata_fua = 0; 136c6fd2807SJeff Garzik module_param_named(fua, libata_fua, int, 0444); 137c6fd2807SJeff Garzik MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)"); 138c6fd2807SJeff Garzik 1392dcb407eSJeff Garzik static int ata_ignore_hpa; 1401e999736SAlan Cox module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644); 1411e999736SAlan Cox MODULE_PARM_DESC(ignore_hpa, "Ignore HPA limit (0=keep BIOS limits, 1=ignore limits, using full disk)"); 1421e999736SAlan Cox 143b3a70601SAlan Cox static int libata_dma_mask = ATA_DMA_MASK_ATA|ATA_DMA_MASK_ATAPI|ATA_DMA_MASK_CFA; 144b3a70601SAlan Cox module_param_named(dma, libata_dma_mask, int, 0444); 145b3a70601SAlan Cox MODULE_PARM_DESC(dma, "DMA enable/disable (0x1==ATA, 0x2==ATAPI, 0x4==CF)"); 146b3a70601SAlan Cox 147341c2c95STejun Heo static int ata_probe_timeout = ATA_TMOUT_INTERNAL / 1000; 148c6fd2807SJeff Garzik module_param(ata_probe_timeout, int, 0444); 149c6fd2807SJeff Garzik MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)"); 150c6fd2807SJeff Garzik 1516ebe9d86SJeff Garzik int libata_noacpi = 0; 152d7d0dad6SJeff Garzik module_param_named(noacpi, libata_noacpi, int, 0444); 1536ebe9d86SJeff Garzik MODULE_PARM_DESC(noacpi, "Disables the use of ACPI in probe/suspend/resume when set"); 15411ef697bSKristen Carlson Accardi 155ae8d4ee7SAlan Cox int libata_allow_tpm = 0; 156ae8d4ee7SAlan Cox module_param_named(allow_tpm, libata_allow_tpm, int, 0444); 157ae8d4ee7SAlan Cox MODULE_PARM_DESC(allow_tpm, "Permit the use of TPM commands"); 158ae8d4ee7SAlan Cox 159c6fd2807SJeff Garzik MODULE_AUTHOR("Jeff Garzik"); 160c6fd2807SJeff Garzik MODULE_DESCRIPTION("Library module for ATA devices"); 161c6fd2807SJeff Garzik MODULE_LICENSE("GPL"); 162c6fd2807SJeff Garzik MODULE_VERSION(DRV_VERSION); 163c6fd2807SJeff Garzik 164c6fd2807SJeff Garzik 165c6fd2807SJeff Garzik /** 16633267325STejun Heo * ata_force_cbl - force cable type according to libata.force 1674cdfa1b3SRandy Dunlap * @ap: ATA port of interest 16833267325STejun Heo * 16933267325STejun Heo * Force cable type according to libata.force and whine about it. 17033267325STejun Heo * The last entry which has matching port number is used, so it 17133267325STejun Heo * can be specified as part of device force parameters. For 17233267325STejun Heo * example, both "a:40c,1.00:udma4" and "1.00:40c,udma4" have the 17333267325STejun Heo * same effect. 17433267325STejun Heo * 17533267325STejun Heo * LOCKING: 17633267325STejun Heo * EH context. 17733267325STejun Heo */ 17833267325STejun Heo void ata_force_cbl(struct ata_port *ap) 17933267325STejun Heo { 18033267325STejun Heo int i; 18133267325STejun Heo 18233267325STejun Heo for (i = ata_force_tbl_size - 1; i >= 0; i--) { 18333267325STejun Heo const struct ata_force_ent *fe = &ata_force_tbl[i]; 18433267325STejun Heo 18533267325STejun Heo if (fe->port != -1 && fe->port != ap->print_id) 18633267325STejun Heo continue; 18733267325STejun Heo 18833267325STejun Heo if (fe->param.cbl == ATA_CBL_NONE) 18933267325STejun Heo continue; 19033267325STejun Heo 19133267325STejun Heo ap->cbl = fe->param.cbl; 19233267325STejun Heo ata_port_printk(ap, KERN_NOTICE, 19333267325STejun Heo "FORCE: cable set to %s\n", fe->param.name); 19433267325STejun Heo return; 19533267325STejun Heo } 19633267325STejun Heo } 19733267325STejun Heo 19833267325STejun Heo /** 19933267325STejun Heo * ata_force_spd_limit - force SATA spd limit according to libata.force 20033267325STejun Heo * @link: ATA link of interest 20133267325STejun Heo * 20233267325STejun Heo * Force SATA spd limit according to libata.force and whine about 20333267325STejun Heo * it. When only the port part is specified (e.g. 1:), the limit 20433267325STejun Heo * applies to all links connected to both the host link and all 20533267325STejun Heo * fan-out ports connected via PMP. If the device part is 20633267325STejun Heo * specified as 0 (e.g. 1.00:), it specifies the first fan-out 20733267325STejun Heo * link not the host link. Device number 15 always points to the 20833267325STejun Heo * host link whether PMP is attached or not. 20933267325STejun Heo * 21033267325STejun Heo * LOCKING: 21133267325STejun Heo * EH context. 21233267325STejun Heo */ 21333267325STejun Heo static void ata_force_spd_limit(struct ata_link *link) 21433267325STejun Heo { 21533267325STejun Heo int linkno, i; 21633267325STejun Heo 21733267325STejun Heo if (ata_is_host_link(link)) 21833267325STejun Heo linkno = 15; 21933267325STejun Heo else 22033267325STejun Heo linkno = link->pmp; 22133267325STejun Heo 22233267325STejun Heo for (i = ata_force_tbl_size - 1; i >= 0; i--) { 22333267325STejun Heo const struct ata_force_ent *fe = &ata_force_tbl[i]; 22433267325STejun Heo 22533267325STejun Heo if (fe->port != -1 && fe->port != link->ap->print_id) 22633267325STejun Heo continue; 22733267325STejun Heo 22833267325STejun Heo if (fe->device != -1 && fe->device != linkno) 22933267325STejun Heo continue; 23033267325STejun Heo 23133267325STejun Heo if (!fe->param.spd_limit) 23233267325STejun Heo continue; 23333267325STejun Heo 23433267325STejun Heo link->hw_sata_spd_limit = (1 << fe->param.spd_limit) - 1; 23533267325STejun Heo ata_link_printk(link, KERN_NOTICE, 23633267325STejun Heo "FORCE: PHY spd limit set to %s\n", fe->param.name); 23733267325STejun Heo return; 23833267325STejun Heo } 23933267325STejun Heo } 24033267325STejun Heo 24133267325STejun Heo /** 24233267325STejun Heo * ata_force_xfermask - force xfermask according to libata.force 24333267325STejun Heo * @dev: ATA device of interest 24433267325STejun Heo * 24533267325STejun Heo * Force xfer_mask according to libata.force and whine about it. 24633267325STejun Heo * For consistency with link selection, device number 15 selects 24733267325STejun Heo * the first device connected to the host link. 24833267325STejun Heo * 24933267325STejun Heo * LOCKING: 25033267325STejun Heo * EH context. 25133267325STejun Heo */ 25233267325STejun Heo static void ata_force_xfermask(struct ata_device *dev) 25333267325STejun Heo { 25433267325STejun Heo int devno = dev->link->pmp + dev->devno; 25533267325STejun Heo int alt_devno = devno; 25633267325STejun Heo int i; 25733267325STejun Heo 25833267325STejun Heo /* allow n.15 for the first device attached to host port */ 25933267325STejun Heo if (ata_is_host_link(dev->link) && devno == 0) 26033267325STejun Heo alt_devno = 15; 26133267325STejun Heo 26233267325STejun Heo for (i = ata_force_tbl_size - 1; i >= 0; i--) { 26333267325STejun Heo const struct ata_force_ent *fe = &ata_force_tbl[i]; 26433267325STejun Heo unsigned long pio_mask, mwdma_mask, udma_mask; 26533267325STejun Heo 26633267325STejun Heo if (fe->port != -1 && fe->port != dev->link->ap->print_id) 26733267325STejun Heo continue; 26833267325STejun Heo 26933267325STejun Heo if (fe->device != -1 && fe->device != devno && 27033267325STejun Heo fe->device != alt_devno) 27133267325STejun Heo continue; 27233267325STejun Heo 27333267325STejun Heo if (!fe->param.xfer_mask) 27433267325STejun Heo continue; 27533267325STejun Heo 27633267325STejun Heo ata_unpack_xfermask(fe->param.xfer_mask, 27733267325STejun Heo &pio_mask, &mwdma_mask, &udma_mask); 27833267325STejun Heo if (udma_mask) 27933267325STejun Heo dev->udma_mask = udma_mask; 28033267325STejun Heo else if (mwdma_mask) { 28133267325STejun Heo dev->udma_mask = 0; 28233267325STejun Heo dev->mwdma_mask = mwdma_mask; 28333267325STejun Heo } else { 28433267325STejun Heo dev->udma_mask = 0; 28533267325STejun Heo dev->mwdma_mask = 0; 28633267325STejun Heo dev->pio_mask = pio_mask; 28733267325STejun Heo } 28833267325STejun Heo 28933267325STejun Heo ata_dev_printk(dev, KERN_NOTICE, 29033267325STejun Heo "FORCE: xfer_mask set to %s\n", fe->param.name); 29133267325STejun Heo return; 29233267325STejun Heo } 29333267325STejun Heo } 29433267325STejun Heo 29533267325STejun Heo /** 29633267325STejun Heo * ata_force_horkage - force horkage according to libata.force 29733267325STejun Heo * @dev: ATA device of interest 29833267325STejun Heo * 29933267325STejun Heo * Force horkage according to libata.force and whine about it. 30033267325STejun Heo * For consistency with link selection, device number 15 selects 30133267325STejun Heo * the first device connected to the host link. 30233267325STejun Heo * 30333267325STejun Heo * LOCKING: 30433267325STejun Heo * EH context. 30533267325STejun Heo */ 30633267325STejun Heo static void ata_force_horkage(struct ata_device *dev) 30733267325STejun Heo { 30833267325STejun Heo int devno = dev->link->pmp + dev->devno; 30933267325STejun Heo int alt_devno = devno; 31033267325STejun Heo int i; 31133267325STejun Heo 31233267325STejun Heo /* allow n.15 for the first device attached to host port */ 31333267325STejun Heo if (ata_is_host_link(dev->link) && devno == 0) 31433267325STejun Heo alt_devno = 15; 31533267325STejun Heo 31633267325STejun Heo for (i = 0; i < ata_force_tbl_size; i++) { 31733267325STejun Heo const struct ata_force_ent *fe = &ata_force_tbl[i]; 31833267325STejun Heo 31933267325STejun Heo if (fe->port != -1 && fe->port != dev->link->ap->print_id) 32033267325STejun Heo continue; 32133267325STejun Heo 32233267325STejun Heo if (fe->device != -1 && fe->device != devno && 32333267325STejun Heo fe->device != alt_devno) 32433267325STejun Heo continue; 32533267325STejun Heo 32633267325STejun Heo if (!(~dev->horkage & fe->param.horkage_on) && 32733267325STejun Heo !(dev->horkage & fe->param.horkage_off)) 32833267325STejun Heo continue; 32933267325STejun Heo 33033267325STejun Heo dev->horkage |= fe->param.horkage_on; 33133267325STejun Heo dev->horkage &= ~fe->param.horkage_off; 33233267325STejun Heo 33333267325STejun Heo ata_dev_printk(dev, KERN_NOTICE, 33433267325STejun Heo "FORCE: horkage modified (%s)\n", fe->param.name); 33533267325STejun Heo } 33633267325STejun Heo } 33733267325STejun Heo 33833267325STejun Heo /** 339436d34b3STejun Heo * atapi_cmd_type - Determine ATAPI command type from SCSI opcode 340436d34b3STejun Heo * @opcode: SCSI opcode 341436d34b3STejun Heo * 342436d34b3STejun Heo * Determine ATAPI command type from @opcode. 343436d34b3STejun Heo * 344436d34b3STejun Heo * LOCKING: 345436d34b3STejun Heo * None. 346436d34b3STejun Heo * 347436d34b3STejun Heo * RETURNS: 348436d34b3STejun Heo * ATAPI_{READ|WRITE|READ_CD|PASS_THRU|MISC} 349436d34b3STejun Heo */ 350436d34b3STejun Heo int atapi_cmd_type(u8 opcode) 351436d34b3STejun Heo { 352436d34b3STejun Heo switch (opcode) { 353436d34b3STejun Heo case GPCMD_READ_10: 354436d34b3STejun Heo case GPCMD_READ_12: 355436d34b3STejun Heo return ATAPI_READ; 356436d34b3STejun Heo 357436d34b3STejun Heo case GPCMD_WRITE_10: 358436d34b3STejun Heo case GPCMD_WRITE_12: 359436d34b3STejun Heo case GPCMD_WRITE_AND_VERIFY_10: 360436d34b3STejun Heo return ATAPI_WRITE; 361436d34b3STejun Heo 362436d34b3STejun Heo case GPCMD_READ_CD: 363436d34b3STejun Heo case GPCMD_READ_CD_MSF: 364436d34b3STejun Heo return ATAPI_READ_CD; 365436d34b3STejun Heo 366e52dcc48STejun Heo case ATA_16: 367e52dcc48STejun Heo case ATA_12: 368e52dcc48STejun Heo if (atapi_passthru16) 369e52dcc48STejun Heo return ATAPI_PASS_THRU; 370e52dcc48STejun Heo /* fall thru */ 371436d34b3STejun Heo default: 372436d34b3STejun Heo return ATAPI_MISC; 373436d34b3STejun Heo } 374436d34b3STejun Heo } 375436d34b3STejun Heo 376436d34b3STejun Heo /** 377c6fd2807SJeff Garzik * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure 378c6fd2807SJeff Garzik * @tf: Taskfile to convert 379c6fd2807SJeff Garzik * @pmp: Port multiplier port 3809977126cSTejun Heo * @is_cmd: This FIS is for command 3819977126cSTejun Heo * @fis: Buffer into which data will output 382c6fd2807SJeff Garzik * 383c6fd2807SJeff Garzik * Converts a standard ATA taskfile to a Serial ATA 384c6fd2807SJeff Garzik * FIS structure (Register - Host to Device). 385c6fd2807SJeff Garzik * 386c6fd2807SJeff Garzik * LOCKING: 387c6fd2807SJeff Garzik * Inherited from caller. 388c6fd2807SJeff Garzik */ 3899977126cSTejun Heo void ata_tf_to_fis(const struct ata_taskfile *tf, u8 pmp, int is_cmd, u8 *fis) 390c6fd2807SJeff Garzik { 391c6fd2807SJeff Garzik fis[0] = 0x27; /* Register - Host to Device FIS */ 3929977126cSTejun Heo fis[1] = pmp & 0xf; /* Port multiplier number*/ 3939977126cSTejun Heo if (is_cmd) 3949977126cSTejun Heo fis[1] |= (1 << 7); /* bit 7 indicates Command FIS */ 3959977126cSTejun Heo 396c6fd2807SJeff Garzik fis[2] = tf->command; 397c6fd2807SJeff Garzik fis[3] = tf->feature; 398c6fd2807SJeff Garzik 399c6fd2807SJeff Garzik fis[4] = tf->lbal; 400c6fd2807SJeff Garzik fis[5] = tf->lbam; 401c6fd2807SJeff Garzik fis[6] = tf->lbah; 402c6fd2807SJeff Garzik fis[7] = tf->device; 403c6fd2807SJeff Garzik 404c6fd2807SJeff Garzik fis[8] = tf->hob_lbal; 405c6fd2807SJeff Garzik fis[9] = tf->hob_lbam; 406c6fd2807SJeff Garzik fis[10] = tf->hob_lbah; 407c6fd2807SJeff Garzik fis[11] = tf->hob_feature; 408c6fd2807SJeff Garzik 409c6fd2807SJeff Garzik fis[12] = tf->nsect; 410c6fd2807SJeff Garzik fis[13] = tf->hob_nsect; 411c6fd2807SJeff Garzik fis[14] = 0; 412c6fd2807SJeff Garzik fis[15] = tf->ctl; 413c6fd2807SJeff Garzik 414c6fd2807SJeff Garzik fis[16] = 0; 415c6fd2807SJeff Garzik fis[17] = 0; 416c6fd2807SJeff Garzik fis[18] = 0; 417c6fd2807SJeff Garzik fis[19] = 0; 418c6fd2807SJeff Garzik } 419c6fd2807SJeff Garzik 420c6fd2807SJeff Garzik /** 421c6fd2807SJeff Garzik * ata_tf_from_fis - Convert SATA FIS to ATA taskfile 422c6fd2807SJeff Garzik * @fis: Buffer from which data will be input 423c6fd2807SJeff Garzik * @tf: Taskfile to output 424c6fd2807SJeff Garzik * 425c6fd2807SJeff Garzik * Converts a serial ATA FIS structure to a standard ATA taskfile. 426c6fd2807SJeff Garzik * 427c6fd2807SJeff Garzik * LOCKING: 428c6fd2807SJeff Garzik * Inherited from caller. 429c6fd2807SJeff Garzik */ 430c6fd2807SJeff Garzik 431c6fd2807SJeff Garzik void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf) 432c6fd2807SJeff Garzik { 433c6fd2807SJeff Garzik tf->command = fis[2]; /* status */ 434c6fd2807SJeff Garzik tf->feature = fis[3]; /* error */ 435c6fd2807SJeff Garzik 436c6fd2807SJeff Garzik tf->lbal = fis[4]; 437c6fd2807SJeff Garzik tf->lbam = fis[5]; 438c6fd2807SJeff Garzik tf->lbah = fis[6]; 439c6fd2807SJeff Garzik tf->device = fis[7]; 440c6fd2807SJeff Garzik 441c6fd2807SJeff Garzik tf->hob_lbal = fis[8]; 442c6fd2807SJeff Garzik tf->hob_lbam = fis[9]; 443c6fd2807SJeff Garzik tf->hob_lbah = fis[10]; 444c6fd2807SJeff Garzik 445c6fd2807SJeff Garzik tf->nsect = fis[12]; 446c6fd2807SJeff Garzik tf->hob_nsect = fis[13]; 447c6fd2807SJeff Garzik } 448c6fd2807SJeff Garzik 449c6fd2807SJeff Garzik static const u8 ata_rw_cmds[] = { 450c6fd2807SJeff Garzik /* pio multi */ 451c6fd2807SJeff Garzik ATA_CMD_READ_MULTI, 452c6fd2807SJeff Garzik ATA_CMD_WRITE_MULTI, 453c6fd2807SJeff Garzik ATA_CMD_READ_MULTI_EXT, 454c6fd2807SJeff Garzik ATA_CMD_WRITE_MULTI_EXT, 455c6fd2807SJeff Garzik 0, 456c6fd2807SJeff Garzik 0, 457c6fd2807SJeff Garzik 0, 458c6fd2807SJeff Garzik ATA_CMD_WRITE_MULTI_FUA_EXT, 459c6fd2807SJeff Garzik /* pio */ 460c6fd2807SJeff Garzik ATA_CMD_PIO_READ, 461c6fd2807SJeff Garzik ATA_CMD_PIO_WRITE, 462c6fd2807SJeff Garzik ATA_CMD_PIO_READ_EXT, 463c6fd2807SJeff Garzik ATA_CMD_PIO_WRITE_EXT, 464c6fd2807SJeff Garzik 0, 465c6fd2807SJeff Garzik 0, 466c6fd2807SJeff Garzik 0, 467c6fd2807SJeff Garzik 0, 468c6fd2807SJeff Garzik /* dma */ 469c6fd2807SJeff Garzik ATA_CMD_READ, 470c6fd2807SJeff Garzik ATA_CMD_WRITE, 471c6fd2807SJeff Garzik ATA_CMD_READ_EXT, 472c6fd2807SJeff Garzik ATA_CMD_WRITE_EXT, 473c6fd2807SJeff Garzik 0, 474c6fd2807SJeff Garzik 0, 475c6fd2807SJeff Garzik 0, 476c6fd2807SJeff Garzik ATA_CMD_WRITE_FUA_EXT 477c6fd2807SJeff Garzik }; 478c6fd2807SJeff Garzik 479c6fd2807SJeff Garzik /** 480c6fd2807SJeff Garzik * ata_rwcmd_protocol - set taskfile r/w commands and protocol 481bd056d7eSTejun Heo * @tf: command to examine and configure 482bd056d7eSTejun Heo * @dev: device tf belongs to 483c6fd2807SJeff Garzik * 484c6fd2807SJeff Garzik * Examine the device configuration and tf->flags to calculate 485c6fd2807SJeff Garzik * the proper read/write commands and protocol to use. 486c6fd2807SJeff Garzik * 487c6fd2807SJeff Garzik * LOCKING: 488c6fd2807SJeff Garzik * caller. 489c6fd2807SJeff Garzik */ 490bd056d7eSTejun Heo static int ata_rwcmd_protocol(struct ata_taskfile *tf, struct ata_device *dev) 491c6fd2807SJeff Garzik { 492c6fd2807SJeff Garzik u8 cmd; 493c6fd2807SJeff Garzik 494c6fd2807SJeff Garzik int index, fua, lba48, write; 495c6fd2807SJeff Garzik 496c6fd2807SJeff Garzik fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0; 497c6fd2807SJeff Garzik lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0; 498c6fd2807SJeff Garzik write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0; 499c6fd2807SJeff Garzik 500c6fd2807SJeff Garzik if (dev->flags & ATA_DFLAG_PIO) { 501c6fd2807SJeff Garzik tf->protocol = ATA_PROT_PIO; 502c6fd2807SJeff Garzik index = dev->multi_count ? 0 : 8; 5039af5c9c9STejun Heo } else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) { 504c6fd2807SJeff Garzik /* Unable to use DMA due to host limitation */ 505c6fd2807SJeff Garzik tf->protocol = ATA_PROT_PIO; 506c6fd2807SJeff Garzik index = dev->multi_count ? 0 : 8; 507c6fd2807SJeff Garzik } else { 508c6fd2807SJeff Garzik tf->protocol = ATA_PROT_DMA; 509c6fd2807SJeff Garzik index = 16; 510c6fd2807SJeff Garzik } 511c6fd2807SJeff Garzik 512c6fd2807SJeff Garzik cmd = ata_rw_cmds[index + fua + lba48 + write]; 513c6fd2807SJeff Garzik if (cmd) { 514c6fd2807SJeff Garzik tf->command = cmd; 515c6fd2807SJeff Garzik return 0; 516c6fd2807SJeff Garzik } 517c6fd2807SJeff Garzik return -1; 518c6fd2807SJeff Garzik } 519c6fd2807SJeff Garzik 520c6fd2807SJeff Garzik /** 52135b649feSTejun Heo * ata_tf_read_block - Read block address from ATA taskfile 52235b649feSTejun Heo * @tf: ATA taskfile of interest 52335b649feSTejun Heo * @dev: ATA device @tf belongs to 52435b649feSTejun Heo * 52535b649feSTejun Heo * LOCKING: 52635b649feSTejun Heo * None. 52735b649feSTejun Heo * 52835b649feSTejun Heo * Read block address from @tf. This function can handle all 52935b649feSTejun Heo * three address formats - LBA, LBA48 and CHS. tf->protocol and 53035b649feSTejun Heo * flags select the address format to use. 53135b649feSTejun Heo * 53235b649feSTejun Heo * RETURNS: 53335b649feSTejun Heo * Block address read from @tf. 53435b649feSTejun Heo */ 53535b649feSTejun Heo u64 ata_tf_read_block(struct ata_taskfile *tf, struct ata_device *dev) 53635b649feSTejun Heo { 53735b649feSTejun Heo u64 block = 0; 53835b649feSTejun Heo 53935b649feSTejun Heo if (tf->flags & ATA_TFLAG_LBA) { 54035b649feSTejun Heo if (tf->flags & ATA_TFLAG_LBA48) { 54135b649feSTejun Heo block |= (u64)tf->hob_lbah << 40; 54235b649feSTejun Heo block |= (u64)tf->hob_lbam << 32; 54335b649feSTejun Heo block |= tf->hob_lbal << 24; 54435b649feSTejun Heo } else 54535b649feSTejun Heo block |= (tf->device & 0xf) << 24; 54635b649feSTejun Heo 54735b649feSTejun Heo block |= tf->lbah << 16; 54835b649feSTejun Heo block |= tf->lbam << 8; 54935b649feSTejun Heo block |= tf->lbal; 55035b649feSTejun Heo } else { 55135b649feSTejun Heo u32 cyl, head, sect; 55235b649feSTejun Heo 55335b649feSTejun Heo cyl = tf->lbam | (tf->lbah << 8); 55435b649feSTejun Heo head = tf->device & 0xf; 55535b649feSTejun Heo sect = tf->lbal; 55635b649feSTejun Heo 55735b649feSTejun Heo block = (cyl * dev->heads + head) * dev->sectors + sect; 55835b649feSTejun Heo } 55935b649feSTejun Heo 56035b649feSTejun Heo return block; 56135b649feSTejun Heo } 56235b649feSTejun Heo 56335b649feSTejun Heo /** 564bd056d7eSTejun Heo * ata_build_rw_tf - Build ATA taskfile for given read/write request 565bd056d7eSTejun Heo * @tf: Target ATA taskfile 566bd056d7eSTejun Heo * @dev: ATA device @tf belongs to 567bd056d7eSTejun Heo * @block: Block address 568bd056d7eSTejun Heo * @n_block: Number of blocks 569bd056d7eSTejun Heo * @tf_flags: RW/FUA etc... 570bd056d7eSTejun Heo * @tag: tag 571bd056d7eSTejun Heo * 572bd056d7eSTejun Heo * LOCKING: 573bd056d7eSTejun Heo * None. 574bd056d7eSTejun Heo * 575bd056d7eSTejun Heo * Build ATA taskfile @tf for read/write request described by 576bd056d7eSTejun Heo * @block, @n_block, @tf_flags and @tag on @dev. 577bd056d7eSTejun Heo * 578bd056d7eSTejun Heo * RETURNS: 579bd056d7eSTejun Heo * 580bd056d7eSTejun Heo * 0 on success, -ERANGE if the request is too large for @dev, 581bd056d7eSTejun Heo * -EINVAL if the request is invalid. 582bd056d7eSTejun Heo */ 583bd056d7eSTejun Heo int ata_build_rw_tf(struct ata_taskfile *tf, struct ata_device *dev, 584bd056d7eSTejun Heo u64 block, u32 n_block, unsigned int tf_flags, 585bd056d7eSTejun Heo unsigned int tag) 586bd056d7eSTejun Heo { 587bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 588bd056d7eSTejun Heo tf->flags |= tf_flags; 589bd056d7eSTejun Heo 5906d1245bfSTejun Heo if (ata_ncq_enabled(dev) && likely(tag != ATA_TAG_INTERNAL)) { 591bd056d7eSTejun Heo /* yay, NCQ */ 592bd056d7eSTejun Heo if (!lba_48_ok(block, n_block)) 593bd056d7eSTejun Heo return -ERANGE; 594bd056d7eSTejun Heo 595bd056d7eSTejun Heo tf->protocol = ATA_PROT_NCQ; 596bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48; 597bd056d7eSTejun Heo 598bd056d7eSTejun Heo if (tf->flags & ATA_TFLAG_WRITE) 599bd056d7eSTejun Heo tf->command = ATA_CMD_FPDMA_WRITE; 600bd056d7eSTejun Heo else 601bd056d7eSTejun Heo tf->command = ATA_CMD_FPDMA_READ; 602bd056d7eSTejun Heo 603bd056d7eSTejun Heo tf->nsect = tag << 3; 604bd056d7eSTejun Heo tf->hob_feature = (n_block >> 8) & 0xff; 605bd056d7eSTejun Heo tf->feature = n_block & 0xff; 606bd056d7eSTejun Heo 607bd056d7eSTejun Heo tf->hob_lbah = (block >> 40) & 0xff; 608bd056d7eSTejun Heo tf->hob_lbam = (block >> 32) & 0xff; 609bd056d7eSTejun Heo tf->hob_lbal = (block >> 24) & 0xff; 610bd056d7eSTejun Heo tf->lbah = (block >> 16) & 0xff; 611bd056d7eSTejun Heo tf->lbam = (block >> 8) & 0xff; 612bd056d7eSTejun Heo tf->lbal = block & 0xff; 613bd056d7eSTejun Heo 614bd056d7eSTejun Heo tf->device = 1 << 6; 615bd056d7eSTejun Heo if (tf->flags & ATA_TFLAG_FUA) 616bd056d7eSTejun Heo tf->device |= 1 << 7; 617bd056d7eSTejun Heo } else if (dev->flags & ATA_DFLAG_LBA) { 618bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_LBA; 619bd056d7eSTejun Heo 620bd056d7eSTejun Heo if (lba_28_ok(block, n_block)) { 621bd056d7eSTejun Heo /* use LBA28 */ 622bd056d7eSTejun Heo tf->device |= (block >> 24) & 0xf; 623bd056d7eSTejun Heo } else if (lba_48_ok(block, n_block)) { 624bd056d7eSTejun Heo if (!(dev->flags & ATA_DFLAG_LBA48)) 625bd056d7eSTejun Heo return -ERANGE; 626bd056d7eSTejun Heo 627bd056d7eSTejun Heo /* use LBA48 */ 628bd056d7eSTejun Heo tf->flags |= ATA_TFLAG_LBA48; 629bd056d7eSTejun Heo 630bd056d7eSTejun Heo tf->hob_nsect = (n_block >> 8) & 0xff; 631bd056d7eSTejun Heo 632bd056d7eSTejun Heo tf->hob_lbah = (block >> 40) & 0xff; 633bd056d7eSTejun Heo tf->hob_lbam = (block >> 32) & 0xff; 634bd056d7eSTejun Heo tf->hob_lbal = (block >> 24) & 0xff; 635bd056d7eSTejun Heo } else 636bd056d7eSTejun Heo /* request too large even for LBA48 */ 637bd056d7eSTejun Heo return -ERANGE; 638bd056d7eSTejun Heo 639bd056d7eSTejun Heo if (unlikely(ata_rwcmd_protocol(tf, dev) < 0)) 640bd056d7eSTejun Heo return -EINVAL; 641bd056d7eSTejun Heo 642bd056d7eSTejun Heo tf->nsect = n_block & 0xff; 643bd056d7eSTejun Heo 644bd056d7eSTejun Heo tf->lbah = (block >> 16) & 0xff; 645bd056d7eSTejun Heo tf->lbam = (block >> 8) & 0xff; 646bd056d7eSTejun Heo tf->lbal = block & 0xff; 647bd056d7eSTejun Heo 648bd056d7eSTejun Heo tf->device |= ATA_LBA; 649bd056d7eSTejun Heo } else { 650bd056d7eSTejun Heo /* CHS */ 651bd056d7eSTejun Heo u32 sect, head, cyl, track; 652bd056d7eSTejun Heo 653bd056d7eSTejun Heo /* The request -may- be too large for CHS addressing. */ 654bd056d7eSTejun Heo if (!lba_28_ok(block, n_block)) 655bd056d7eSTejun Heo return -ERANGE; 656bd056d7eSTejun Heo 657bd056d7eSTejun Heo if (unlikely(ata_rwcmd_protocol(tf, dev) < 0)) 658bd056d7eSTejun Heo return -EINVAL; 659bd056d7eSTejun Heo 660bd056d7eSTejun Heo /* Convert LBA to CHS */ 661bd056d7eSTejun Heo track = (u32)block / dev->sectors; 662bd056d7eSTejun Heo cyl = track / dev->heads; 663bd056d7eSTejun Heo head = track % dev->heads; 664bd056d7eSTejun Heo sect = (u32)block % dev->sectors + 1; 665bd056d7eSTejun Heo 666bd056d7eSTejun Heo DPRINTK("block %u track %u cyl %u head %u sect %u\n", 667bd056d7eSTejun Heo (u32)block, track, cyl, head, sect); 668bd056d7eSTejun Heo 669bd056d7eSTejun Heo /* Check whether the converted CHS can fit. 670bd056d7eSTejun Heo Cylinder: 0-65535 671bd056d7eSTejun Heo Head: 0-15 672bd056d7eSTejun Heo Sector: 1-255*/ 673bd056d7eSTejun Heo if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect)) 674bd056d7eSTejun Heo return -ERANGE; 675bd056d7eSTejun Heo 676bd056d7eSTejun Heo tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */ 677bd056d7eSTejun Heo tf->lbal = sect; 678bd056d7eSTejun Heo tf->lbam = cyl; 679bd056d7eSTejun Heo tf->lbah = cyl >> 8; 680bd056d7eSTejun Heo tf->device |= head; 681bd056d7eSTejun Heo } 682bd056d7eSTejun Heo 683bd056d7eSTejun Heo return 0; 684bd056d7eSTejun Heo } 685bd056d7eSTejun Heo 686bd056d7eSTejun Heo /** 687c6fd2807SJeff Garzik * ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask 688c6fd2807SJeff Garzik * @pio_mask: pio_mask 689c6fd2807SJeff Garzik * @mwdma_mask: mwdma_mask 690c6fd2807SJeff Garzik * @udma_mask: udma_mask 691c6fd2807SJeff Garzik * 692c6fd2807SJeff Garzik * Pack @pio_mask, @mwdma_mask and @udma_mask into a single 693c6fd2807SJeff Garzik * unsigned int xfer_mask. 694c6fd2807SJeff Garzik * 695c6fd2807SJeff Garzik * LOCKING: 696c6fd2807SJeff Garzik * None. 697c6fd2807SJeff Garzik * 698c6fd2807SJeff Garzik * RETURNS: 699c6fd2807SJeff Garzik * Packed xfer_mask. 700c6fd2807SJeff Garzik */ 7017dc951aeSTejun Heo unsigned long ata_pack_xfermask(unsigned long pio_mask, 7027dc951aeSTejun Heo unsigned long mwdma_mask, 7037dc951aeSTejun Heo unsigned long udma_mask) 704c6fd2807SJeff Garzik { 705c6fd2807SJeff Garzik return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) | 706c6fd2807SJeff Garzik ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) | 707c6fd2807SJeff Garzik ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA); 708c6fd2807SJeff Garzik } 709c6fd2807SJeff Garzik 710c6fd2807SJeff Garzik /** 711c6fd2807SJeff Garzik * ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks 712c6fd2807SJeff Garzik * @xfer_mask: xfer_mask to unpack 713c6fd2807SJeff Garzik * @pio_mask: resulting pio_mask 714c6fd2807SJeff Garzik * @mwdma_mask: resulting mwdma_mask 715c6fd2807SJeff Garzik * @udma_mask: resulting udma_mask 716c6fd2807SJeff Garzik * 717c6fd2807SJeff Garzik * Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask. 718c6fd2807SJeff Garzik * Any NULL distination masks will be ignored. 719c6fd2807SJeff Garzik */ 7207dc951aeSTejun Heo void ata_unpack_xfermask(unsigned long xfer_mask, unsigned long *pio_mask, 7217dc951aeSTejun Heo unsigned long *mwdma_mask, unsigned long *udma_mask) 722c6fd2807SJeff Garzik { 723c6fd2807SJeff Garzik if (pio_mask) 724c6fd2807SJeff Garzik *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO; 725c6fd2807SJeff Garzik if (mwdma_mask) 726c6fd2807SJeff Garzik *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA; 727c6fd2807SJeff Garzik if (udma_mask) 728c6fd2807SJeff Garzik *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA; 729c6fd2807SJeff Garzik } 730c6fd2807SJeff Garzik 731c6fd2807SJeff Garzik static const struct ata_xfer_ent { 732c6fd2807SJeff Garzik int shift, bits; 733c6fd2807SJeff Garzik u8 base; 734c6fd2807SJeff Garzik } ata_xfer_tbl[] = { 73570cd071eSTejun Heo { ATA_SHIFT_PIO, ATA_NR_PIO_MODES, XFER_PIO_0 }, 73670cd071eSTejun Heo { ATA_SHIFT_MWDMA, ATA_NR_MWDMA_MODES, XFER_MW_DMA_0 }, 73770cd071eSTejun Heo { ATA_SHIFT_UDMA, ATA_NR_UDMA_MODES, XFER_UDMA_0 }, 738c6fd2807SJeff Garzik { -1, }, 739c6fd2807SJeff Garzik }; 740c6fd2807SJeff Garzik 741c6fd2807SJeff Garzik /** 742c6fd2807SJeff Garzik * ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask 743c6fd2807SJeff Garzik * @xfer_mask: xfer_mask of interest 744c6fd2807SJeff Garzik * 745c6fd2807SJeff Garzik * Return matching XFER_* value for @xfer_mask. Only the highest 746c6fd2807SJeff Garzik * bit of @xfer_mask is considered. 747c6fd2807SJeff Garzik * 748c6fd2807SJeff Garzik * LOCKING: 749c6fd2807SJeff Garzik * None. 750c6fd2807SJeff Garzik * 751c6fd2807SJeff Garzik * RETURNS: 75270cd071eSTejun Heo * Matching XFER_* value, 0xff if no match found. 753c6fd2807SJeff Garzik */ 7547dc951aeSTejun Heo u8 ata_xfer_mask2mode(unsigned long xfer_mask) 755c6fd2807SJeff Garzik { 756c6fd2807SJeff Garzik int highbit = fls(xfer_mask) - 1; 757c6fd2807SJeff Garzik const struct ata_xfer_ent *ent; 758c6fd2807SJeff Garzik 759c6fd2807SJeff Garzik for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 760c6fd2807SJeff Garzik if (highbit >= ent->shift && highbit < ent->shift + ent->bits) 761c6fd2807SJeff Garzik return ent->base + highbit - ent->shift; 76270cd071eSTejun Heo return 0xff; 763c6fd2807SJeff Garzik } 764c6fd2807SJeff Garzik 765c6fd2807SJeff Garzik /** 766c6fd2807SJeff Garzik * ata_xfer_mode2mask - Find matching xfer_mask for XFER_* 767c6fd2807SJeff Garzik * @xfer_mode: XFER_* of interest 768c6fd2807SJeff Garzik * 769c6fd2807SJeff Garzik * Return matching xfer_mask for @xfer_mode. 770c6fd2807SJeff Garzik * 771c6fd2807SJeff Garzik * LOCKING: 772c6fd2807SJeff Garzik * None. 773c6fd2807SJeff Garzik * 774c6fd2807SJeff Garzik * RETURNS: 775c6fd2807SJeff Garzik * Matching xfer_mask, 0 if no match found. 776c6fd2807SJeff Garzik */ 7777dc951aeSTejun Heo unsigned long ata_xfer_mode2mask(u8 xfer_mode) 778c6fd2807SJeff Garzik { 779c6fd2807SJeff Garzik const struct ata_xfer_ent *ent; 780c6fd2807SJeff Garzik 781c6fd2807SJeff Garzik for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 782c6fd2807SJeff Garzik if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits) 78370cd071eSTejun Heo return ((2 << (ent->shift + xfer_mode - ent->base)) - 1) 78470cd071eSTejun Heo & ~((1 << ent->shift) - 1); 785c6fd2807SJeff Garzik return 0; 786c6fd2807SJeff Garzik } 787c6fd2807SJeff Garzik 788c6fd2807SJeff Garzik /** 789c6fd2807SJeff Garzik * ata_xfer_mode2shift - Find matching xfer_shift for XFER_* 790c6fd2807SJeff Garzik * @xfer_mode: XFER_* of interest 791c6fd2807SJeff Garzik * 792c6fd2807SJeff Garzik * Return matching xfer_shift for @xfer_mode. 793c6fd2807SJeff Garzik * 794c6fd2807SJeff Garzik * LOCKING: 795c6fd2807SJeff Garzik * None. 796c6fd2807SJeff Garzik * 797c6fd2807SJeff Garzik * RETURNS: 798c6fd2807SJeff Garzik * Matching xfer_shift, -1 if no match found. 799c6fd2807SJeff Garzik */ 8007dc951aeSTejun Heo int ata_xfer_mode2shift(unsigned long xfer_mode) 801c6fd2807SJeff Garzik { 802c6fd2807SJeff Garzik const struct ata_xfer_ent *ent; 803c6fd2807SJeff Garzik 804c6fd2807SJeff Garzik for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 805c6fd2807SJeff Garzik if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits) 806c6fd2807SJeff Garzik return ent->shift; 807c6fd2807SJeff Garzik return -1; 808c6fd2807SJeff Garzik } 809c6fd2807SJeff Garzik 810c6fd2807SJeff Garzik /** 811c6fd2807SJeff Garzik * ata_mode_string - convert xfer_mask to string 812c6fd2807SJeff Garzik * @xfer_mask: mask of bits supported; only highest bit counts. 813c6fd2807SJeff Garzik * 814c6fd2807SJeff Garzik * Determine string which represents the highest speed 815c6fd2807SJeff Garzik * (highest bit in @modemask). 816c6fd2807SJeff Garzik * 817c6fd2807SJeff Garzik * LOCKING: 818c6fd2807SJeff Garzik * None. 819c6fd2807SJeff Garzik * 820c6fd2807SJeff Garzik * RETURNS: 821c6fd2807SJeff Garzik * Constant C string representing highest speed listed in 822c6fd2807SJeff Garzik * @mode_mask, or the constant C string "<n/a>". 823c6fd2807SJeff Garzik */ 8247dc951aeSTejun Heo const char *ata_mode_string(unsigned long xfer_mask) 825c6fd2807SJeff Garzik { 826c6fd2807SJeff Garzik static const char * const xfer_mode_str[] = { 827c6fd2807SJeff Garzik "PIO0", 828c6fd2807SJeff Garzik "PIO1", 829c6fd2807SJeff Garzik "PIO2", 830c6fd2807SJeff Garzik "PIO3", 831c6fd2807SJeff Garzik "PIO4", 832b352e57dSAlan Cox "PIO5", 833b352e57dSAlan Cox "PIO6", 834c6fd2807SJeff Garzik "MWDMA0", 835c6fd2807SJeff Garzik "MWDMA1", 836c6fd2807SJeff Garzik "MWDMA2", 837b352e57dSAlan Cox "MWDMA3", 838b352e57dSAlan Cox "MWDMA4", 839c6fd2807SJeff Garzik "UDMA/16", 840c6fd2807SJeff Garzik "UDMA/25", 841c6fd2807SJeff Garzik "UDMA/33", 842c6fd2807SJeff Garzik "UDMA/44", 843c6fd2807SJeff Garzik "UDMA/66", 844c6fd2807SJeff Garzik "UDMA/100", 845c6fd2807SJeff Garzik "UDMA/133", 846c6fd2807SJeff Garzik "UDMA7", 847c6fd2807SJeff Garzik }; 848c6fd2807SJeff Garzik int highbit; 849c6fd2807SJeff Garzik 850c6fd2807SJeff Garzik highbit = fls(xfer_mask) - 1; 851c6fd2807SJeff Garzik if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str)) 852c6fd2807SJeff Garzik return xfer_mode_str[highbit]; 853c6fd2807SJeff Garzik return "<n/a>"; 854c6fd2807SJeff Garzik } 855c6fd2807SJeff Garzik 856c6fd2807SJeff Garzik static const char *sata_spd_string(unsigned int spd) 857c6fd2807SJeff Garzik { 858c6fd2807SJeff Garzik static const char * const spd_str[] = { 859c6fd2807SJeff Garzik "1.5 Gbps", 860c6fd2807SJeff Garzik "3.0 Gbps", 861c6fd2807SJeff Garzik }; 862c6fd2807SJeff Garzik 863c6fd2807SJeff Garzik if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str)) 864c6fd2807SJeff Garzik return "<unknown>"; 865c6fd2807SJeff Garzik return spd_str[spd - 1]; 866c6fd2807SJeff Garzik } 867c6fd2807SJeff Garzik 868c6fd2807SJeff Garzik void ata_dev_disable(struct ata_device *dev) 869c6fd2807SJeff Garzik { 87009d7f9b0STejun Heo if (ata_dev_enabled(dev)) { 8719af5c9c9STejun Heo if (ata_msg_drv(dev->link->ap)) 872c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "disabled\n"); 873562f0c2dSTejun Heo ata_acpi_on_disable(dev); 8744ae72a1eSTejun Heo ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | 8754ae72a1eSTejun Heo ATA_DNXFER_QUIET); 876c6fd2807SJeff Garzik dev->class++; 877c6fd2807SJeff Garzik } 878c6fd2807SJeff Garzik } 879c6fd2807SJeff Garzik 880ca77329fSKristen Carlson Accardi static int ata_dev_set_dipm(struct ata_device *dev, enum link_pm policy) 881ca77329fSKristen Carlson Accardi { 882ca77329fSKristen Carlson Accardi struct ata_link *link = dev->link; 883ca77329fSKristen Carlson Accardi struct ata_port *ap = link->ap; 884ca77329fSKristen Carlson Accardi u32 scontrol; 885ca77329fSKristen Carlson Accardi unsigned int err_mask; 886ca77329fSKristen Carlson Accardi int rc; 887ca77329fSKristen Carlson Accardi 888ca77329fSKristen Carlson Accardi /* 889ca77329fSKristen Carlson Accardi * disallow DIPM for drivers which haven't set 890ca77329fSKristen Carlson Accardi * ATA_FLAG_IPM. This is because when DIPM is enabled, 891ca77329fSKristen Carlson Accardi * phy ready will be set in the interrupt status on 892ca77329fSKristen Carlson Accardi * state changes, which will cause some drivers to 893ca77329fSKristen Carlson Accardi * think there are errors - additionally drivers will 894ca77329fSKristen Carlson Accardi * need to disable hot plug. 895ca77329fSKristen Carlson Accardi */ 896ca77329fSKristen Carlson Accardi if (!(ap->flags & ATA_FLAG_IPM) || !ata_dev_enabled(dev)) { 897ca77329fSKristen Carlson Accardi ap->pm_policy = NOT_AVAILABLE; 898ca77329fSKristen Carlson Accardi return -EINVAL; 899ca77329fSKristen Carlson Accardi } 900ca77329fSKristen Carlson Accardi 901ca77329fSKristen Carlson Accardi /* 902ca77329fSKristen Carlson Accardi * For DIPM, we will only enable it for the 903ca77329fSKristen Carlson Accardi * min_power setting. 904ca77329fSKristen Carlson Accardi * 905ca77329fSKristen Carlson Accardi * Why? Because Disks are too stupid to know that 906ca77329fSKristen Carlson Accardi * If the host rejects a request to go to SLUMBER 907ca77329fSKristen Carlson Accardi * they should retry at PARTIAL, and instead it 908ca77329fSKristen Carlson Accardi * just would give up. So, for medium_power to 909ca77329fSKristen Carlson Accardi * work at all, we need to only allow HIPM. 910ca77329fSKristen Carlson Accardi */ 911ca77329fSKristen Carlson Accardi rc = sata_scr_read(link, SCR_CONTROL, &scontrol); 912ca77329fSKristen Carlson Accardi if (rc) 913ca77329fSKristen Carlson Accardi return rc; 914ca77329fSKristen Carlson Accardi 915ca77329fSKristen Carlson Accardi switch (policy) { 916ca77329fSKristen Carlson Accardi case MIN_POWER: 917ca77329fSKristen Carlson Accardi /* no restrictions on IPM transitions */ 918ca77329fSKristen Carlson Accardi scontrol &= ~(0x3 << 8); 919ca77329fSKristen Carlson Accardi rc = sata_scr_write(link, SCR_CONTROL, scontrol); 920ca77329fSKristen Carlson Accardi if (rc) 921ca77329fSKristen Carlson Accardi return rc; 922ca77329fSKristen Carlson Accardi 923ca77329fSKristen Carlson Accardi /* enable DIPM */ 924ca77329fSKristen Carlson Accardi if (dev->flags & ATA_DFLAG_DIPM) 925ca77329fSKristen Carlson Accardi err_mask = ata_dev_set_feature(dev, 926ca77329fSKristen Carlson Accardi SETFEATURES_SATA_ENABLE, SATA_DIPM); 927ca77329fSKristen Carlson Accardi break; 928ca77329fSKristen Carlson Accardi case MEDIUM_POWER: 929ca77329fSKristen Carlson Accardi /* allow IPM to PARTIAL */ 930ca77329fSKristen Carlson Accardi scontrol &= ~(0x1 << 8); 931ca77329fSKristen Carlson Accardi scontrol |= (0x2 << 8); 932ca77329fSKristen Carlson Accardi rc = sata_scr_write(link, SCR_CONTROL, scontrol); 933ca77329fSKristen Carlson Accardi if (rc) 934ca77329fSKristen Carlson Accardi return rc; 935ca77329fSKristen Carlson Accardi 936f5456b63SKristen Carlson Accardi /* 937f5456b63SKristen Carlson Accardi * we don't have to disable DIPM since IPM flags 938f5456b63SKristen Carlson Accardi * disallow transitions to SLUMBER, which effectively 939f5456b63SKristen Carlson Accardi * disable DIPM if it does not support PARTIAL 940f5456b63SKristen Carlson Accardi */ 941ca77329fSKristen Carlson Accardi break; 942ca77329fSKristen Carlson Accardi case NOT_AVAILABLE: 943ca77329fSKristen Carlson Accardi case MAX_PERFORMANCE: 944ca77329fSKristen Carlson Accardi /* disable all IPM transitions */ 945ca77329fSKristen Carlson Accardi scontrol |= (0x3 << 8); 946ca77329fSKristen Carlson Accardi rc = sata_scr_write(link, SCR_CONTROL, scontrol); 947ca77329fSKristen Carlson Accardi if (rc) 948ca77329fSKristen Carlson Accardi return rc; 949ca77329fSKristen Carlson Accardi 950f5456b63SKristen Carlson Accardi /* 951f5456b63SKristen Carlson Accardi * we don't have to disable DIPM since IPM flags 952f5456b63SKristen Carlson Accardi * disallow all transitions which effectively 953f5456b63SKristen Carlson Accardi * disable DIPM anyway. 954f5456b63SKristen Carlson Accardi */ 955ca77329fSKristen Carlson Accardi break; 956ca77329fSKristen Carlson Accardi } 957ca77329fSKristen Carlson Accardi 958ca77329fSKristen Carlson Accardi /* FIXME: handle SET FEATURES failure */ 959ca77329fSKristen Carlson Accardi (void) err_mask; 960ca77329fSKristen Carlson Accardi 961ca77329fSKristen Carlson Accardi return 0; 962ca77329fSKristen Carlson Accardi } 963ca77329fSKristen Carlson Accardi 964ca77329fSKristen Carlson Accardi /** 965ca77329fSKristen Carlson Accardi * ata_dev_enable_pm - enable SATA interface power management 96648166fd9SStephen Hemminger * @dev: device to enable power management 96748166fd9SStephen Hemminger * @policy: the link power management policy 968ca77329fSKristen Carlson Accardi * 969ca77329fSKristen Carlson Accardi * Enable SATA Interface power management. This will enable 970ca77329fSKristen Carlson Accardi * Device Interface Power Management (DIPM) for min_power 971ca77329fSKristen Carlson Accardi * policy, and then call driver specific callbacks for 972ca77329fSKristen Carlson Accardi * enabling Host Initiated Power management. 973ca77329fSKristen Carlson Accardi * 974ca77329fSKristen Carlson Accardi * Locking: Caller. 975ca77329fSKristen Carlson Accardi * Returns: -EINVAL if IPM is not supported, 0 otherwise. 976ca77329fSKristen Carlson Accardi */ 977ca77329fSKristen Carlson Accardi void ata_dev_enable_pm(struct ata_device *dev, enum link_pm policy) 978ca77329fSKristen Carlson Accardi { 979ca77329fSKristen Carlson Accardi int rc = 0; 980ca77329fSKristen Carlson Accardi struct ata_port *ap = dev->link->ap; 981ca77329fSKristen Carlson Accardi 982ca77329fSKristen Carlson Accardi /* set HIPM first, then DIPM */ 983ca77329fSKristen Carlson Accardi if (ap->ops->enable_pm) 984ca77329fSKristen Carlson Accardi rc = ap->ops->enable_pm(ap, policy); 985ca77329fSKristen Carlson Accardi if (rc) 986ca77329fSKristen Carlson Accardi goto enable_pm_out; 987ca77329fSKristen Carlson Accardi rc = ata_dev_set_dipm(dev, policy); 988ca77329fSKristen Carlson Accardi 989ca77329fSKristen Carlson Accardi enable_pm_out: 990ca77329fSKristen Carlson Accardi if (rc) 991ca77329fSKristen Carlson Accardi ap->pm_policy = MAX_PERFORMANCE; 992ca77329fSKristen Carlson Accardi else 993ca77329fSKristen Carlson Accardi ap->pm_policy = policy; 994ca77329fSKristen Carlson Accardi return /* rc */; /* hopefully we can use 'rc' eventually */ 995ca77329fSKristen Carlson Accardi } 996ca77329fSKristen Carlson Accardi 9971992a5edSStephen Rothwell #ifdef CONFIG_PM 998ca77329fSKristen Carlson Accardi /** 999ca77329fSKristen Carlson Accardi * ata_dev_disable_pm - disable SATA interface power management 100048166fd9SStephen Hemminger * @dev: device to disable power management 1001ca77329fSKristen Carlson Accardi * 1002ca77329fSKristen Carlson Accardi * Disable SATA Interface power management. This will disable 1003ca77329fSKristen Carlson Accardi * Device Interface Power Management (DIPM) without changing 1004ca77329fSKristen Carlson Accardi * policy, call driver specific callbacks for disabling Host 1005ca77329fSKristen Carlson Accardi * Initiated Power management. 1006ca77329fSKristen Carlson Accardi * 1007ca77329fSKristen Carlson Accardi * Locking: Caller. 1008ca77329fSKristen Carlson Accardi * Returns: void 1009ca77329fSKristen Carlson Accardi */ 1010ca77329fSKristen Carlson Accardi static void ata_dev_disable_pm(struct ata_device *dev) 1011ca77329fSKristen Carlson Accardi { 1012ca77329fSKristen Carlson Accardi struct ata_port *ap = dev->link->ap; 1013ca77329fSKristen Carlson Accardi 1014ca77329fSKristen Carlson Accardi ata_dev_set_dipm(dev, MAX_PERFORMANCE); 1015ca77329fSKristen Carlson Accardi if (ap->ops->disable_pm) 1016ca77329fSKristen Carlson Accardi ap->ops->disable_pm(ap); 1017ca77329fSKristen Carlson Accardi } 10181992a5edSStephen Rothwell #endif /* CONFIG_PM */ 1019ca77329fSKristen Carlson Accardi 1020ca77329fSKristen Carlson Accardi void ata_lpm_schedule(struct ata_port *ap, enum link_pm policy) 1021ca77329fSKristen Carlson Accardi { 1022ca77329fSKristen Carlson Accardi ap->pm_policy = policy; 10233ec25ebdSTejun Heo ap->link.eh_info.action |= ATA_EH_LPM; 1024ca77329fSKristen Carlson Accardi ap->link.eh_info.flags |= ATA_EHI_NO_AUTOPSY; 1025ca77329fSKristen Carlson Accardi ata_port_schedule_eh(ap); 1026ca77329fSKristen Carlson Accardi } 1027ca77329fSKristen Carlson Accardi 10281992a5edSStephen Rothwell #ifdef CONFIG_PM 1029ca77329fSKristen Carlson Accardi static void ata_lpm_enable(struct ata_host *host) 1030ca77329fSKristen Carlson Accardi { 1031ca77329fSKristen Carlson Accardi struct ata_link *link; 1032ca77329fSKristen Carlson Accardi struct ata_port *ap; 1033ca77329fSKristen Carlson Accardi struct ata_device *dev; 1034ca77329fSKristen Carlson Accardi int i; 1035ca77329fSKristen Carlson Accardi 1036ca77329fSKristen Carlson Accardi for (i = 0; i < host->n_ports; i++) { 1037ca77329fSKristen Carlson Accardi ap = host->ports[i]; 1038ca77329fSKristen Carlson Accardi ata_port_for_each_link(link, ap) { 1039ca77329fSKristen Carlson Accardi ata_link_for_each_dev(dev, link) 1040ca77329fSKristen Carlson Accardi ata_dev_disable_pm(dev); 1041ca77329fSKristen Carlson Accardi } 1042ca77329fSKristen Carlson Accardi } 1043ca77329fSKristen Carlson Accardi } 1044ca77329fSKristen Carlson Accardi 1045ca77329fSKristen Carlson Accardi static void ata_lpm_disable(struct ata_host *host) 1046ca77329fSKristen Carlson Accardi { 1047ca77329fSKristen Carlson Accardi int i; 1048ca77329fSKristen Carlson Accardi 1049ca77329fSKristen Carlson Accardi for (i = 0; i < host->n_ports; i++) { 1050ca77329fSKristen Carlson Accardi struct ata_port *ap = host->ports[i]; 1051ca77329fSKristen Carlson Accardi ata_lpm_schedule(ap, ap->pm_policy); 1052ca77329fSKristen Carlson Accardi } 1053ca77329fSKristen Carlson Accardi } 10541992a5edSStephen Rothwell #endif /* CONFIG_PM */ 1055ca77329fSKristen Carlson Accardi 1056c6fd2807SJeff Garzik /** 1057c6fd2807SJeff Garzik * ata_dev_classify - determine device type based on ATA-spec signature 1058c6fd2807SJeff Garzik * @tf: ATA taskfile register set for device to be identified 1059c6fd2807SJeff Garzik * 1060c6fd2807SJeff Garzik * Determine from taskfile register contents whether a device is 1061c6fd2807SJeff Garzik * ATA or ATAPI, as per "Signature and persistence" section 1062c6fd2807SJeff Garzik * of ATA/PI spec (volume 1, sect 5.14). 1063c6fd2807SJeff Garzik * 1064c6fd2807SJeff Garzik * LOCKING: 1065c6fd2807SJeff Garzik * None. 1066c6fd2807SJeff Garzik * 1067c6fd2807SJeff Garzik * RETURNS: 1068633273a3STejun Heo * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, %ATA_DEV_PMP or 1069633273a3STejun Heo * %ATA_DEV_UNKNOWN the event of failure. 1070c6fd2807SJeff Garzik */ 1071c6fd2807SJeff Garzik unsigned int ata_dev_classify(const struct ata_taskfile *tf) 1072c6fd2807SJeff Garzik { 1073c6fd2807SJeff Garzik /* Apple's open source Darwin code hints that some devices only 1074c6fd2807SJeff Garzik * put a proper signature into the LBA mid/high registers, 1075c6fd2807SJeff Garzik * So, we only check those. It's sufficient for uniqueness. 1076633273a3STejun Heo * 1077633273a3STejun Heo * ATA/ATAPI-7 (d1532v1r1: Feb. 19, 2003) specified separate 1078633273a3STejun Heo * signatures for ATA and ATAPI devices attached on SerialATA, 1079633273a3STejun Heo * 0x3c/0xc3 and 0x69/0x96 respectively. However, SerialATA 1080633273a3STejun Heo * spec has never mentioned about using different signatures 1081633273a3STejun Heo * for ATA/ATAPI devices. Then, Serial ATA II: Port 1082633273a3STejun Heo * Multiplier specification began to use 0x69/0x96 to identify 1083633273a3STejun Heo * port multpliers and 0x3c/0xc3 to identify SEMB device. 1084633273a3STejun Heo * ATA/ATAPI-7 dropped descriptions about 0x3c/0xc3 and 1085633273a3STejun Heo * 0x69/0x96 shortly and described them as reserved for 1086633273a3STejun Heo * SerialATA. 1087633273a3STejun Heo * 1088633273a3STejun Heo * We follow the current spec and consider that 0x69/0x96 1089633273a3STejun Heo * identifies a port multiplier and 0x3c/0xc3 a SEMB device. 1090c6fd2807SJeff Garzik */ 1091633273a3STejun Heo if ((tf->lbam == 0) && (tf->lbah == 0)) { 1092c6fd2807SJeff Garzik DPRINTK("found ATA device by sig\n"); 1093c6fd2807SJeff Garzik return ATA_DEV_ATA; 1094c6fd2807SJeff Garzik } 1095c6fd2807SJeff Garzik 1096633273a3STejun Heo if ((tf->lbam == 0x14) && (tf->lbah == 0xeb)) { 1097c6fd2807SJeff Garzik DPRINTK("found ATAPI device by sig\n"); 1098c6fd2807SJeff Garzik return ATA_DEV_ATAPI; 1099c6fd2807SJeff Garzik } 1100c6fd2807SJeff Garzik 1101633273a3STejun Heo if ((tf->lbam == 0x69) && (tf->lbah == 0x96)) { 1102633273a3STejun Heo DPRINTK("found PMP device by sig\n"); 1103633273a3STejun Heo return ATA_DEV_PMP; 1104633273a3STejun Heo } 1105633273a3STejun Heo 1106633273a3STejun Heo if ((tf->lbam == 0x3c) && (tf->lbah == 0xc3)) { 11072dcb407eSJeff Garzik printk(KERN_INFO "ata: SEMB device ignored\n"); 1108633273a3STejun Heo return ATA_DEV_SEMB_UNSUP; /* not yet */ 1109633273a3STejun Heo } 1110633273a3STejun Heo 1111c6fd2807SJeff Garzik DPRINTK("unknown device\n"); 1112c6fd2807SJeff Garzik return ATA_DEV_UNKNOWN; 1113c6fd2807SJeff Garzik } 1114c6fd2807SJeff Garzik 1115c6fd2807SJeff Garzik /** 1116c6fd2807SJeff Garzik * ata_id_string - Convert IDENTIFY DEVICE page into string 1117c6fd2807SJeff Garzik * @id: IDENTIFY DEVICE results we will examine 1118c6fd2807SJeff Garzik * @s: string into which data is output 1119c6fd2807SJeff Garzik * @ofs: offset into identify device page 1120c6fd2807SJeff Garzik * @len: length of string to return. must be an even number. 1121c6fd2807SJeff Garzik * 1122c6fd2807SJeff Garzik * The strings in the IDENTIFY DEVICE page are broken up into 1123c6fd2807SJeff Garzik * 16-bit chunks. Run through the string, and output each 1124c6fd2807SJeff Garzik * 8-bit chunk linearly, regardless of platform. 1125c6fd2807SJeff Garzik * 1126c6fd2807SJeff Garzik * LOCKING: 1127c6fd2807SJeff Garzik * caller. 1128c6fd2807SJeff Garzik */ 1129c6fd2807SJeff Garzik 1130c6fd2807SJeff Garzik void ata_id_string(const u16 *id, unsigned char *s, 1131c6fd2807SJeff Garzik unsigned int ofs, unsigned int len) 1132c6fd2807SJeff Garzik { 1133c6fd2807SJeff Garzik unsigned int c; 1134c6fd2807SJeff Garzik 1135c6fd2807SJeff Garzik while (len > 0) { 1136c6fd2807SJeff Garzik c = id[ofs] >> 8; 1137c6fd2807SJeff Garzik *s = c; 1138c6fd2807SJeff Garzik s++; 1139c6fd2807SJeff Garzik 1140c6fd2807SJeff Garzik c = id[ofs] & 0xff; 1141c6fd2807SJeff Garzik *s = c; 1142c6fd2807SJeff Garzik s++; 1143c6fd2807SJeff Garzik 1144c6fd2807SJeff Garzik ofs++; 1145c6fd2807SJeff Garzik len -= 2; 1146c6fd2807SJeff Garzik } 1147c6fd2807SJeff Garzik } 1148c6fd2807SJeff Garzik 1149c6fd2807SJeff Garzik /** 1150c6fd2807SJeff Garzik * ata_id_c_string - Convert IDENTIFY DEVICE page into C string 1151c6fd2807SJeff Garzik * @id: IDENTIFY DEVICE results we will examine 1152c6fd2807SJeff Garzik * @s: string into which data is output 1153c6fd2807SJeff Garzik * @ofs: offset into identify device page 1154c6fd2807SJeff Garzik * @len: length of string to return. must be an odd number. 1155c6fd2807SJeff Garzik * 1156c6fd2807SJeff Garzik * This function is identical to ata_id_string except that it 1157c6fd2807SJeff Garzik * trims trailing spaces and terminates the resulting string with 1158c6fd2807SJeff Garzik * null. @len must be actual maximum length (even number) + 1. 1159c6fd2807SJeff Garzik * 1160c6fd2807SJeff Garzik * LOCKING: 1161c6fd2807SJeff Garzik * caller. 1162c6fd2807SJeff Garzik */ 1163c6fd2807SJeff Garzik void ata_id_c_string(const u16 *id, unsigned char *s, 1164c6fd2807SJeff Garzik unsigned int ofs, unsigned int len) 1165c6fd2807SJeff Garzik { 1166c6fd2807SJeff Garzik unsigned char *p; 1167c6fd2807SJeff Garzik 1168c6fd2807SJeff Garzik WARN_ON(!(len & 1)); 1169c6fd2807SJeff Garzik 1170c6fd2807SJeff Garzik ata_id_string(id, s, ofs, len - 1); 1171c6fd2807SJeff Garzik 1172c6fd2807SJeff Garzik p = s + strnlen(s, len - 1); 1173c6fd2807SJeff Garzik while (p > s && p[-1] == ' ') 1174c6fd2807SJeff Garzik p--; 1175c6fd2807SJeff Garzik *p = '\0'; 1176c6fd2807SJeff Garzik } 1177c6fd2807SJeff Garzik 1178db6f8759STejun Heo static u64 ata_id_n_sectors(const u16 *id) 1179db6f8759STejun Heo { 1180db6f8759STejun Heo if (ata_id_has_lba(id)) { 1181db6f8759STejun Heo if (ata_id_has_lba48(id)) 1182db6f8759STejun Heo return ata_id_u64(id, 100); 1183db6f8759STejun Heo else 1184db6f8759STejun Heo return ata_id_u32(id, 60); 1185db6f8759STejun Heo } else { 1186db6f8759STejun Heo if (ata_id_current_chs_valid(id)) 1187db6f8759STejun Heo return ata_id_u32(id, 57); 1188db6f8759STejun Heo else 1189db6f8759STejun Heo return id[1] * id[3] * id[6]; 1190db6f8759STejun Heo } 1191db6f8759STejun Heo } 1192db6f8759STejun Heo 1193a5987e0aSTejun Heo u64 ata_tf_to_lba48(const struct ata_taskfile *tf) 11941e999736SAlan Cox { 11951e999736SAlan Cox u64 sectors = 0; 11961e999736SAlan Cox 11971e999736SAlan Cox sectors |= ((u64)(tf->hob_lbah & 0xff)) << 40; 11981e999736SAlan Cox sectors |= ((u64)(tf->hob_lbam & 0xff)) << 32; 11991e999736SAlan Cox sectors |= (tf->hob_lbal & 0xff) << 24; 12001e999736SAlan Cox sectors |= (tf->lbah & 0xff) << 16; 12011e999736SAlan Cox sectors |= (tf->lbam & 0xff) << 8; 12021e999736SAlan Cox sectors |= (tf->lbal & 0xff); 12031e999736SAlan Cox 1204a5987e0aSTejun Heo return sectors; 12051e999736SAlan Cox } 12061e999736SAlan Cox 1207a5987e0aSTejun Heo u64 ata_tf_to_lba(const struct ata_taskfile *tf) 12081e999736SAlan Cox { 12091e999736SAlan Cox u64 sectors = 0; 12101e999736SAlan Cox 12111e999736SAlan Cox sectors |= (tf->device & 0x0f) << 24; 12121e999736SAlan Cox sectors |= (tf->lbah & 0xff) << 16; 12131e999736SAlan Cox sectors |= (tf->lbam & 0xff) << 8; 12141e999736SAlan Cox sectors |= (tf->lbal & 0xff); 12151e999736SAlan Cox 1216a5987e0aSTejun Heo return sectors; 12171e999736SAlan Cox } 12181e999736SAlan Cox 12191e999736SAlan Cox /** 1220c728a914STejun Heo * ata_read_native_max_address - Read native max address 1221c728a914STejun Heo * @dev: target device 1222c728a914STejun Heo * @max_sectors: out parameter for the result native max address 12231e999736SAlan Cox * 1224c728a914STejun Heo * Perform an LBA48 or LBA28 native size query upon the device in 1225c728a914STejun Heo * question. 1226c728a914STejun Heo * 1227c728a914STejun Heo * RETURNS: 1228c728a914STejun Heo * 0 on success, -EACCES if command is aborted by the drive. 1229c728a914STejun Heo * -EIO on other errors. 12301e999736SAlan Cox */ 1231c728a914STejun Heo static int ata_read_native_max_address(struct ata_device *dev, u64 *max_sectors) 12321e999736SAlan Cox { 1233c728a914STejun Heo unsigned int err_mask; 12341e999736SAlan Cox struct ata_taskfile tf; 1235c728a914STejun Heo int lba48 = ata_id_has_lba48(dev->id); 12361e999736SAlan Cox 12371e999736SAlan Cox ata_tf_init(dev, &tf); 12381e999736SAlan Cox 1239c728a914STejun Heo /* always clear all address registers */ 12401e999736SAlan Cox tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR; 1241c728a914STejun Heo 1242c728a914STejun Heo if (lba48) { 1243c728a914STejun Heo tf.command = ATA_CMD_READ_NATIVE_MAX_EXT; 1244c728a914STejun Heo tf.flags |= ATA_TFLAG_LBA48; 1245c728a914STejun Heo } else 1246c728a914STejun Heo tf.command = ATA_CMD_READ_NATIVE_MAX; 1247c728a914STejun Heo 12481e999736SAlan Cox tf.protocol |= ATA_PROT_NODATA; 1249c728a914STejun Heo tf.device |= ATA_LBA; 12501e999736SAlan Cox 12512b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 1252c728a914STejun Heo if (err_mask) { 1253c728a914STejun Heo ata_dev_printk(dev, KERN_WARNING, "failed to read native " 1254c728a914STejun Heo "max address (err_mask=0x%x)\n", err_mask); 1255c728a914STejun Heo if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED)) 1256c728a914STejun Heo return -EACCES; 1257c728a914STejun Heo return -EIO; 1258c728a914STejun Heo } 1259c728a914STejun Heo 1260c728a914STejun Heo if (lba48) 1261a5987e0aSTejun Heo *max_sectors = ata_tf_to_lba48(&tf) + 1; 1262c728a914STejun Heo else 1263a5987e0aSTejun Heo *max_sectors = ata_tf_to_lba(&tf) + 1; 126493328e11SAlan Cox if (dev->horkage & ATA_HORKAGE_HPA_SIZE) 126593328e11SAlan Cox (*max_sectors)--; 12661e999736SAlan Cox return 0; 12671e999736SAlan Cox } 12681e999736SAlan Cox 12691e999736SAlan Cox /** 1270c728a914STejun Heo * ata_set_max_sectors - Set max sectors 1271c728a914STejun Heo * @dev: target device 12726b38d1d1SRandy Dunlap * @new_sectors: new max sectors value to set for the device 12731e999736SAlan Cox * 1274c728a914STejun Heo * Set max sectors of @dev to @new_sectors. 1275c728a914STejun Heo * 1276c728a914STejun Heo * RETURNS: 1277c728a914STejun Heo * 0 on success, -EACCES if command is aborted or denied (due to 1278c728a914STejun Heo * previous non-volatile SET_MAX) by the drive. -EIO on other 1279c728a914STejun Heo * errors. 12801e999736SAlan Cox */ 128105027adcSTejun Heo static int ata_set_max_sectors(struct ata_device *dev, u64 new_sectors) 12821e999736SAlan Cox { 1283c728a914STejun Heo unsigned int err_mask; 12841e999736SAlan Cox struct ata_taskfile tf; 1285c728a914STejun Heo int lba48 = ata_id_has_lba48(dev->id); 12861e999736SAlan Cox 12871e999736SAlan Cox new_sectors--; 12881e999736SAlan Cox 12891e999736SAlan Cox ata_tf_init(dev, &tf); 12901e999736SAlan Cox 1291c728a914STejun Heo tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR; 12921e999736SAlan Cox 1293c728a914STejun Heo if (lba48) { 1294c728a914STejun Heo tf.command = ATA_CMD_SET_MAX_EXT; 1295c728a914STejun Heo tf.flags |= ATA_TFLAG_LBA48; 12961e999736SAlan Cox 12971e999736SAlan Cox tf.hob_lbal = (new_sectors >> 24) & 0xff; 12981e999736SAlan Cox tf.hob_lbam = (new_sectors >> 32) & 0xff; 12991e999736SAlan Cox tf.hob_lbah = (new_sectors >> 40) & 0xff; 13001e582ba4STejun Heo } else { 13011e999736SAlan Cox tf.command = ATA_CMD_SET_MAX; 1302c728a914STejun Heo 13031e582ba4STejun Heo tf.device |= (new_sectors >> 24) & 0xf; 13041e582ba4STejun Heo } 13051e582ba4STejun Heo 13061e999736SAlan Cox tf.protocol |= ATA_PROT_NODATA; 1307c728a914STejun Heo tf.device |= ATA_LBA; 13081e999736SAlan Cox 13091e999736SAlan Cox tf.lbal = (new_sectors >> 0) & 0xff; 13101e999736SAlan Cox tf.lbam = (new_sectors >> 8) & 0xff; 13111e999736SAlan Cox tf.lbah = (new_sectors >> 16) & 0xff; 13121e999736SAlan Cox 13132b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 1314c728a914STejun Heo if (err_mask) { 1315c728a914STejun Heo ata_dev_printk(dev, KERN_WARNING, "failed to set " 1316c728a914STejun Heo "max address (err_mask=0x%x)\n", err_mask); 1317c728a914STejun Heo if (err_mask == AC_ERR_DEV && 1318c728a914STejun Heo (tf.feature & (ATA_ABORTED | ATA_IDNF))) 1319c728a914STejun Heo return -EACCES; 1320c728a914STejun Heo return -EIO; 1321c728a914STejun Heo } 1322c728a914STejun Heo 13231e999736SAlan Cox return 0; 13241e999736SAlan Cox } 13251e999736SAlan Cox 13261e999736SAlan Cox /** 13271e999736SAlan Cox * ata_hpa_resize - Resize a device with an HPA set 13281e999736SAlan Cox * @dev: Device to resize 13291e999736SAlan Cox * 13301e999736SAlan Cox * Read the size of an LBA28 or LBA48 disk with HPA features and resize 13311e999736SAlan Cox * it if required to the full size of the media. The caller must check 13321e999736SAlan Cox * the drive has the HPA feature set enabled. 133305027adcSTejun Heo * 133405027adcSTejun Heo * RETURNS: 133505027adcSTejun Heo * 0 on success, -errno on failure. 13361e999736SAlan Cox */ 133705027adcSTejun Heo static int ata_hpa_resize(struct ata_device *dev) 13381e999736SAlan Cox { 133905027adcSTejun Heo struct ata_eh_context *ehc = &dev->link->eh_context; 134005027adcSTejun Heo int print_info = ehc->i.flags & ATA_EHI_PRINTINFO; 134105027adcSTejun Heo u64 sectors = ata_id_n_sectors(dev->id); 134205027adcSTejun Heo u64 native_sectors; 1343c728a914STejun Heo int rc; 13441e999736SAlan Cox 134505027adcSTejun Heo /* do we need to do it? */ 134605027adcSTejun Heo if (dev->class != ATA_DEV_ATA || 134705027adcSTejun Heo !ata_id_has_lba(dev->id) || !ata_id_hpa_enabled(dev->id) || 134805027adcSTejun Heo (dev->horkage & ATA_HORKAGE_BROKEN_HPA)) 1349c728a914STejun Heo return 0; 13501e999736SAlan Cox 135105027adcSTejun Heo /* read native max address */ 135205027adcSTejun Heo rc = ata_read_native_max_address(dev, &native_sectors); 135305027adcSTejun Heo if (rc) { 1354dda7aba1STejun Heo /* If device aborted the command or HPA isn't going to 1355dda7aba1STejun Heo * be unlocked, skip HPA resizing. 135605027adcSTejun Heo */ 1357dda7aba1STejun Heo if (rc == -EACCES || !ata_ignore_hpa) { 135805027adcSTejun Heo ata_dev_printk(dev, KERN_WARNING, "HPA support seems " 1359dda7aba1STejun Heo "broken, skipping HPA handling\n"); 136005027adcSTejun Heo dev->horkage |= ATA_HORKAGE_BROKEN_HPA; 136105027adcSTejun Heo 136205027adcSTejun Heo /* we can continue if device aborted the command */ 136305027adcSTejun Heo if (rc == -EACCES) 136405027adcSTejun Heo rc = 0; 136505027adcSTejun Heo } 136605027adcSTejun Heo 136705027adcSTejun Heo return rc; 136805027adcSTejun Heo } 136905027adcSTejun Heo 137005027adcSTejun Heo /* nothing to do? */ 137105027adcSTejun Heo if (native_sectors <= sectors || !ata_ignore_hpa) { 137205027adcSTejun Heo if (!print_info || native_sectors == sectors) 137305027adcSTejun Heo return 0; 137405027adcSTejun Heo 137505027adcSTejun Heo if (native_sectors > sectors) 13761e999736SAlan Cox ata_dev_printk(dev, KERN_INFO, 137705027adcSTejun Heo "HPA detected: current %llu, native %llu\n", 137805027adcSTejun Heo (unsigned long long)sectors, 137905027adcSTejun Heo (unsigned long long)native_sectors); 138005027adcSTejun Heo else if (native_sectors < sectors) 138105027adcSTejun Heo ata_dev_printk(dev, KERN_WARNING, 138205027adcSTejun Heo "native sectors (%llu) is smaller than " 138305027adcSTejun Heo "sectors (%llu)\n", 138405027adcSTejun Heo (unsigned long long)native_sectors, 138505027adcSTejun Heo (unsigned long long)sectors); 138605027adcSTejun Heo return 0; 13871e999736SAlan Cox } 138837301a55STejun Heo 138905027adcSTejun Heo /* let's unlock HPA */ 139005027adcSTejun Heo rc = ata_set_max_sectors(dev, native_sectors); 139105027adcSTejun Heo if (rc == -EACCES) { 139205027adcSTejun Heo /* if device aborted the command, skip HPA resizing */ 139305027adcSTejun Heo ata_dev_printk(dev, KERN_WARNING, "device aborted resize " 139405027adcSTejun Heo "(%llu -> %llu), skipping HPA handling\n", 139505027adcSTejun Heo (unsigned long long)sectors, 139605027adcSTejun Heo (unsigned long long)native_sectors); 139705027adcSTejun Heo dev->horkage |= ATA_HORKAGE_BROKEN_HPA; 139805027adcSTejun Heo return 0; 139905027adcSTejun Heo } else if (rc) 140005027adcSTejun Heo return rc; 140105027adcSTejun Heo 140205027adcSTejun Heo /* re-read IDENTIFY data */ 140305027adcSTejun Heo rc = ata_dev_reread_id(dev, 0); 140405027adcSTejun Heo if (rc) { 140505027adcSTejun Heo ata_dev_printk(dev, KERN_ERR, "failed to re-read IDENTIFY " 140605027adcSTejun Heo "data after HPA resizing\n"); 140705027adcSTejun Heo return rc; 140805027adcSTejun Heo } 140905027adcSTejun Heo 141005027adcSTejun Heo if (print_info) { 141105027adcSTejun Heo u64 new_sectors = ata_id_n_sectors(dev->id); 141205027adcSTejun Heo ata_dev_printk(dev, KERN_INFO, 141305027adcSTejun Heo "HPA unlocked: %llu -> %llu, native %llu\n", 141405027adcSTejun Heo (unsigned long long)sectors, 141505027adcSTejun Heo (unsigned long long)new_sectors, 141605027adcSTejun Heo (unsigned long long)native_sectors); 141705027adcSTejun Heo } 141805027adcSTejun Heo 141905027adcSTejun Heo return 0; 14201e999736SAlan Cox } 14211e999736SAlan Cox 1422c6fd2807SJeff Garzik /** 1423c6fd2807SJeff Garzik * ata_dump_id - IDENTIFY DEVICE info debugging output 1424c6fd2807SJeff Garzik * @id: IDENTIFY DEVICE page to dump 1425c6fd2807SJeff Garzik * 1426c6fd2807SJeff Garzik * Dump selected 16-bit words from the given IDENTIFY DEVICE 1427c6fd2807SJeff Garzik * page. 1428c6fd2807SJeff Garzik * 1429c6fd2807SJeff Garzik * LOCKING: 1430c6fd2807SJeff Garzik * caller. 1431c6fd2807SJeff Garzik */ 1432c6fd2807SJeff Garzik 1433c6fd2807SJeff Garzik static inline void ata_dump_id(const u16 *id) 1434c6fd2807SJeff Garzik { 1435c6fd2807SJeff Garzik DPRINTK("49==0x%04x " 1436c6fd2807SJeff Garzik "53==0x%04x " 1437c6fd2807SJeff Garzik "63==0x%04x " 1438c6fd2807SJeff Garzik "64==0x%04x " 1439c6fd2807SJeff Garzik "75==0x%04x \n", 1440c6fd2807SJeff Garzik id[49], 1441c6fd2807SJeff Garzik id[53], 1442c6fd2807SJeff Garzik id[63], 1443c6fd2807SJeff Garzik id[64], 1444c6fd2807SJeff Garzik id[75]); 1445c6fd2807SJeff Garzik DPRINTK("80==0x%04x " 1446c6fd2807SJeff Garzik "81==0x%04x " 1447c6fd2807SJeff Garzik "82==0x%04x " 1448c6fd2807SJeff Garzik "83==0x%04x " 1449c6fd2807SJeff Garzik "84==0x%04x \n", 1450c6fd2807SJeff Garzik id[80], 1451c6fd2807SJeff Garzik id[81], 1452c6fd2807SJeff Garzik id[82], 1453c6fd2807SJeff Garzik id[83], 1454c6fd2807SJeff Garzik id[84]); 1455c6fd2807SJeff Garzik DPRINTK("88==0x%04x " 1456c6fd2807SJeff Garzik "93==0x%04x\n", 1457c6fd2807SJeff Garzik id[88], 1458c6fd2807SJeff Garzik id[93]); 1459c6fd2807SJeff Garzik } 1460c6fd2807SJeff Garzik 1461c6fd2807SJeff Garzik /** 1462c6fd2807SJeff Garzik * ata_id_xfermask - Compute xfermask from the given IDENTIFY data 1463c6fd2807SJeff Garzik * @id: IDENTIFY data to compute xfer mask from 1464c6fd2807SJeff Garzik * 1465c6fd2807SJeff Garzik * Compute the xfermask for this device. This is not as trivial 1466c6fd2807SJeff Garzik * as it seems if we must consider early devices correctly. 1467c6fd2807SJeff Garzik * 1468c6fd2807SJeff Garzik * FIXME: pre IDE drive timing (do we care ?). 1469c6fd2807SJeff Garzik * 1470c6fd2807SJeff Garzik * LOCKING: 1471c6fd2807SJeff Garzik * None. 1472c6fd2807SJeff Garzik * 1473c6fd2807SJeff Garzik * RETURNS: 1474c6fd2807SJeff Garzik * Computed xfermask 1475c6fd2807SJeff Garzik */ 14767dc951aeSTejun Heo unsigned long ata_id_xfermask(const u16 *id) 1477c6fd2807SJeff Garzik { 14787dc951aeSTejun Heo unsigned long pio_mask, mwdma_mask, udma_mask; 1479c6fd2807SJeff Garzik 1480c6fd2807SJeff Garzik /* Usual case. Word 53 indicates word 64 is valid */ 1481c6fd2807SJeff Garzik if (id[ATA_ID_FIELD_VALID] & (1 << 1)) { 1482c6fd2807SJeff Garzik pio_mask = id[ATA_ID_PIO_MODES] & 0x03; 1483c6fd2807SJeff Garzik pio_mask <<= 3; 1484c6fd2807SJeff Garzik pio_mask |= 0x7; 1485c6fd2807SJeff Garzik } else { 1486c6fd2807SJeff Garzik /* If word 64 isn't valid then Word 51 high byte holds 1487c6fd2807SJeff Garzik * the PIO timing number for the maximum. Turn it into 1488c6fd2807SJeff Garzik * a mask. 1489c6fd2807SJeff Garzik */ 14907a0f1c8aSLennert Buytenhek u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF; 149146767aebSAlan Cox if (mode < 5) /* Valid PIO range */ 149246767aebSAlan Cox pio_mask = (2 << mode) - 1; 149346767aebSAlan Cox else 149446767aebSAlan Cox pio_mask = 1; 1495c6fd2807SJeff Garzik 1496c6fd2807SJeff Garzik /* But wait.. there's more. Design your standards by 1497c6fd2807SJeff Garzik * committee and you too can get a free iordy field to 1498c6fd2807SJeff Garzik * process. However its the speeds not the modes that 1499c6fd2807SJeff Garzik * are supported... Note drivers using the timing API 1500c6fd2807SJeff Garzik * will get this right anyway 1501c6fd2807SJeff Garzik */ 1502c6fd2807SJeff Garzik } 1503c6fd2807SJeff Garzik 1504c6fd2807SJeff Garzik mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07; 1505c6fd2807SJeff Garzik 1506b352e57dSAlan Cox if (ata_id_is_cfa(id)) { 1507b352e57dSAlan Cox /* 1508b352e57dSAlan Cox * Process compact flash extended modes 1509b352e57dSAlan Cox */ 1510b352e57dSAlan Cox int pio = id[163] & 0x7; 1511b352e57dSAlan Cox int dma = (id[163] >> 3) & 7; 1512b352e57dSAlan Cox 1513b352e57dSAlan Cox if (pio) 1514b352e57dSAlan Cox pio_mask |= (1 << 5); 1515b352e57dSAlan Cox if (pio > 1) 1516b352e57dSAlan Cox pio_mask |= (1 << 6); 1517b352e57dSAlan Cox if (dma) 1518b352e57dSAlan Cox mwdma_mask |= (1 << 3); 1519b352e57dSAlan Cox if (dma > 1) 1520b352e57dSAlan Cox mwdma_mask |= (1 << 4); 1521b352e57dSAlan Cox } 1522b352e57dSAlan Cox 1523c6fd2807SJeff Garzik udma_mask = 0; 1524c6fd2807SJeff Garzik if (id[ATA_ID_FIELD_VALID] & (1 << 2)) 1525c6fd2807SJeff Garzik udma_mask = id[ATA_ID_UDMA_MODES] & 0xff; 1526c6fd2807SJeff Garzik 1527c6fd2807SJeff Garzik return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask); 1528c6fd2807SJeff Garzik } 1529c6fd2807SJeff Garzik 1530c6fd2807SJeff Garzik /** 1531442eacc3SJeff Garzik * ata_pio_queue_task - Queue port_task 1532c6fd2807SJeff Garzik * @ap: The ata_port to queue port_task for 1533c6fd2807SJeff Garzik * @fn: workqueue function to be scheduled 153465f27f38SDavid Howells * @data: data for @fn to use 1535341c2c95STejun Heo * @delay: delay time in msecs for workqueue function 1536c6fd2807SJeff Garzik * 1537c6fd2807SJeff Garzik * Schedule @fn(@data) for execution after @delay jiffies using 1538c6fd2807SJeff Garzik * port_task. There is one port_task per port and it's the 1539c6fd2807SJeff Garzik * user(low level driver)'s responsibility to make sure that only 1540c6fd2807SJeff Garzik * one task is active at any given time. 1541c6fd2807SJeff Garzik * 1542c6fd2807SJeff Garzik * libata core layer takes care of synchronization between 1543442eacc3SJeff Garzik * port_task and EH. ata_pio_queue_task() may be ignored for EH 1544c6fd2807SJeff Garzik * synchronization. 1545c6fd2807SJeff Garzik * 1546c6fd2807SJeff Garzik * LOCKING: 1547c6fd2807SJeff Garzik * Inherited from caller. 1548c6fd2807SJeff Garzik */ 1549624d5c51STejun Heo void ata_pio_queue_task(struct ata_port *ap, void *data, unsigned long delay) 1550c6fd2807SJeff Garzik { 155165f27f38SDavid Howells ap->port_task_data = data; 1552c6fd2807SJeff Garzik 155345a66c1cSOleg Nesterov /* may fail if ata_port_flush_task() in progress */ 1554341c2c95STejun Heo queue_delayed_work(ata_wq, &ap->port_task, msecs_to_jiffies(delay)); 1555c6fd2807SJeff Garzik } 1556c6fd2807SJeff Garzik 1557c6fd2807SJeff Garzik /** 1558c6fd2807SJeff Garzik * ata_port_flush_task - Flush port_task 1559c6fd2807SJeff Garzik * @ap: The ata_port to flush port_task for 1560c6fd2807SJeff Garzik * 1561c6fd2807SJeff Garzik * After this function completes, port_task is guranteed not to 1562c6fd2807SJeff Garzik * be running or scheduled. 1563c6fd2807SJeff Garzik * 1564c6fd2807SJeff Garzik * LOCKING: 1565c6fd2807SJeff Garzik * Kernel thread context (may sleep) 1566c6fd2807SJeff Garzik */ 1567c6fd2807SJeff Garzik void ata_port_flush_task(struct ata_port *ap) 1568c6fd2807SJeff Garzik { 1569c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 1570c6fd2807SJeff Garzik 157145a66c1cSOleg Nesterov cancel_rearming_delayed_work(&ap->port_task); 1572c6fd2807SJeff Garzik 1573c6fd2807SJeff Garzik if (ata_msg_ctl(ap)) 15747f5e4e8dSHarvey Harrison ata_port_printk(ap, KERN_DEBUG, "%s: EXIT\n", __func__); 1575c6fd2807SJeff Garzik } 1576c6fd2807SJeff Garzik 15777102d230SAdrian Bunk static void ata_qc_complete_internal(struct ata_queued_cmd *qc) 1578c6fd2807SJeff Garzik { 1579c6fd2807SJeff Garzik struct completion *waiting = qc->private_data; 1580c6fd2807SJeff Garzik 1581c6fd2807SJeff Garzik complete(waiting); 1582c6fd2807SJeff Garzik } 1583c6fd2807SJeff Garzik 1584c6fd2807SJeff Garzik /** 15852432697bSTejun Heo * ata_exec_internal_sg - execute libata internal command 1586c6fd2807SJeff Garzik * @dev: Device to which the command is sent 1587c6fd2807SJeff Garzik * @tf: Taskfile registers for the command and the result 1588c6fd2807SJeff Garzik * @cdb: CDB for packet command 1589c6fd2807SJeff Garzik * @dma_dir: Data tranfer direction of the command 15905c1ad8b3SRandy Dunlap * @sgl: sg list for the data buffer of the command 15912432697bSTejun Heo * @n_elem: Number of sg entries 15922b789108STejun Heo * @timeout: Timeout in msecs (0 for default) 1593c6fd2807SJeff Garzik * 1594c6fd2807SJeff Garzik * Executes libata internal command with timeout. @tf contains 1595c6fd2807SJeff Garzik * command on entry and result on return. Timeout and error 1596c6fd2807SJeff Garzik * conditions are reported via return value. No recovery action 1597c6fd2807SJeff Garzik * is taken after a command times out. It's caller's duty to 1598c6fd2807SJeff Garzik * clean up after timeout. 1599c6fd2807SJeff Garzik * 1600c6fd2807SJeff Garzik * LOCKING: 1601c6fd2807SJeff Garzik * None. Should be called with kernel context, might sleep. 1602c6fd2807SJeff Garzik * 1603c6fd2807SJeff Garzik * RETURNS: 1604c6fd2807SJeff Garzik * Zero on success, AC_ERR_* mask on failure 1605c6fd2807SJeff Garzik */ 16062432697bSTejun Heo unsigned ata_exec_internal_sg(struct ata_device *dev, 1607c6fd2807SJeff Garzik struct ata_taskfile *tf, const u8 *cdb, 160887260216SJens Axboe int dma_dir, struct scatterlist *sgl, 16092b789108STejun Heo unsigned int n_elem, unsigned long timeout) 1610c6fd2807SJeff Garzik { 16119af5c9c9STejun Heo struct ata_link *link = dev->link; 16129af5c9c9STejun Heo struct ata_port *ap = link->ap; 1613c6fd2807SJeff Garzik u8 command = tf->command; 1614c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 1615c6fd2807SJeff Garzik unsigned int tag, preempted_tag; 1616c6fd2807SJeff Garzik u32 preempted_sactive, preempted_qc_active; 1617da917d69STejun Heo int preempted_nr_active_links; 1618c6fd2807SJeff Garzik DECLARE_COMPLETION_ONSTACK(wait); 1619c6fd2807SJeff Garzik unsigned long flags; 1620c6fd2807SJeff Garzik unsigned int err_mask; 1621c6fd2807SJeff Garzik int rc; 1622c6fd2807SJeff Garzik 1623c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1624c6fd2807SJeff Garzik 1625c6fd2807SJeff Garzik /* no internal command while frozen */ 1626c6fd2807SJeff Garzik if (ap->pflags & ATA_PFLAG_FROZEN) { 1627c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1628c6fd2807SJeff Garzik return AC_ERR_SYSTEM; 1629c6fd2807SJeff Garzik } 1630c6fd2807SJeff Garzik 1631c6fd2807SJeff Garzik /* initialize internal qc */ 1632c6fd2807SJeff Garzik 1633c6fd2807SJeff Garzik /* XXX: Tag 0 is used for drivers with legacy EH as some 1634c6fd2807SJeff Garzik * drivers choke if any other tag is given. This breaks 1635c6fd2807SJeff Garzik * ata_tag_internal() test for those drivers. Don't use new 1636c6fd2807SJeff Garzik * EH stuff without converting to it. 1637c6fd2807SJeff Garzik */ 1638c6fd2807SJeff Garzik if (ap->ops->error_handler) 1639c6fd2807SJeff Garzik tag = ATA_TAG_INTERNAL; 1640c6fd2807SJeff Garzik else 1641c6fd2807SJeff Garzik tag = 0; 1642c6fd2807SJeff Garzik 1643c6fd2807SJeff Garzik if (test_and_set_bit(tag, &ap->qc_allocated)) 1644c6fd2807SJeff Garzik BUG(); 1645c6fd2807SJeff Garzik qc = __ata_qc_from_tag(ap, tag); 1646c6fd2807SJeff Garzik 1647c6fd2807SJeff Garzik qc->tag = tag; 1648c6fd2807SJeff Garzik qc->scsicmd = NULL; 1649c6fd2807SJeff Garzik qc->ap = ap; 1650c6fd2807SJeff Garzik qc->dev = dev; 1651c6fd2807SJeff Garzik ata_qc_reinit(qc); 1652c6fd2807SJeff Garzik 16539af5c9c9STejun Heo preempted_tag = link->active_tag; 16549af5c9c9STejun Heo preempted_sactive = link->sactive; 1655c6fd2807SJeff Garzik preempted_qc_active = ap->qc_active; 1656da917d69STejun Heo preempted_nr_active_links = ap->nr_active_links; 16579af5c9c9STejun Heo link->active_tag = ATA_TAG_POISON; 16589af5c9c9STejun Heo link->sactive = 0; 1659c6fd2807SJeff Garzik ap->qc_active = 0; 1660da917d69STejun Heo ap->nr_active_links = 0; 1661c6fd2807SJeff Garzik 1662c6fd2807SJeff Garzik /* prepare & issue qc */ 1663c6fd2807SJeff Garzik qc->tf = *tf; 1664c6fd2807SJeff Garzik if (cdb) 1665c6fd2807SJeff Garzik memcpy(qc->cdb, cdb, ATAPI_CDB_LEN); 1666c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_RESULT_TF; 1667c6fd2807SJeff Garzik qc->dma_dir = dma_dir; 1668c6fd2807SJeff Garzik if (dma_dir != DMA_NONE) { 16692432697bSTejun Heo unsigned int i, buflen = 0; 167087260216SJens Axboe struct scatterlist *sg; 16712432697bSTejun Heo 167287260216SJens Axboe for_each_sg(sgl, sg, n_elem, i) 167387260216SJens Axboe buflen += sg->length; 16742432697bSTejun Heo 167587260216SJens Axboe ata_sg_init(qc, sgl, n_elem); 167649c80429SBrian King qc->nbytes = buflen; 1677c6fd2807SJeff Garzik } 1678c6fd2807SJeff Garzik 1679c6fd2807SJeff Garzik qc->private_data = &wait; 1680c6fd2807SJeff Garzik qc->complete_fn = ata_qc_complete_internal; 1681c6fd2807SJeff Garzik 1682c6fd2807SJeff Garzik ata_qc_issue(qc); 1683c6fd2807SJeff Garzik 1684c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1685c6fd2807SJeff Garzik 16862b789108STejun Heo if (!timeout) 1687341c2c95STejun Heo timeout = ata_probe_timeout * 1000; 16882b789108STejun Heo 16892b789108STejun Heo rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout)); 1690c6fd2807SJeff Garzik 1691c6fd2807SJeff Garzik ata_port_flush_task(ap); 1692c6fd2807SJeff Garzik 1693c6fd2807SJeff Garzik if (!rc) { 1694c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1695c6fd2807SJeff Garzik 1696c6fd2807SJeff Garzik /* We're racing with irq here. If we lose, the 1697c6fd2807SJeff Garzik * following test prevents us from completing the qc 1698c6fd2807SJeff Garzik * twice. If we win, the port is frozen and will be 1699c6fd2807SJeff Garzik * cleaned up by ->post_internal_cmd(). 1700c6fd2807SJeff Garzik */ 1701c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_ACTIVE) { 1702c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_TIMEOUT; 1703c6fd2807SJeff Garzik 1704c6fd2807SJeff Garzik if (ap->ops->error_handler) 1705c6fd2807SJeff Garzik ata_port_freeze(ap); 1706c6fd2807SJeff Garzik else 1707c6fd2807SJeff Garzik ata_qc_complete(qc); 1708c6fd2807SJeff Garzik 1709c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 1710c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 1711c6fd2807SJeff Garzik "qc timeout (cmd 0x%x)\n", command); 1712c6fd2807SJeff Garzik } 1713c6fd2807SJeff Garzik 1714c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1715c6fd2807SJeff Garzik } 1716c6fd2807SJeff Garzik 1717c6fd2807SJeff Garzik /* do post_internal_cmd */ 1718c6fd2807SJeff Garzik if (ap->ops->post_internal_cmd) 1719c6fd2807SJeff Garzik ap->ops->post_internal_cmd(qc); 1720c6fd2807SJeff Garzik 1721a51d644aSTejun Heo /* perform minimal error analysis */ 1722a51d644aSTejun Heo if (qc->flags & ATA_QCFLAG_FAILED) { 1723a51d644aSTejun Heo if (qc->result_tf.command & (ATA_ERR | ATA_DF)) 1724a51d644aSTejun Heo qc->err_mask |= AC_ERR_DEV; 1725a51d644aSTejun Heo 1726a51d644aSTejun Heo if (!qc->err_mask) 1727c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_OTHER; 1728a51d644aSTejun Heo 1729a51d644aSTejun Heo if (qc->err_mask & ~AC_ERR_OTHER) 1730a51d644aSTejun Heo qc->err_mask &= ~AC_ERR_OTHER; 1731c6fd2807SJeff Garzik } 1732c6fd2807SJeff Garzik 1733c6fd2807SJeff Garzik /* finish up */ 1734c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 1735c6fd2807SJeff Garzik 1736c6fd2807SJeff Garzik *tf = qc->result_tf; 1737c6fd2807SJeff Garzik err_mask = qc->err_mask; 1738c6fd2807SJeff Garzik 1739c6fd2807SJeff Garzik ata_qc_free(qc); 17409af5c9c9STejun Heo link->active_tag = preempted_tag; 17419af5c9c9STejun Heo link->sactive = preempted_sactive; 1742c6fd2807SJeff Garzik ap->qc_active = preempted_qc_active; 1743da917d69STejun Heo ap->nr_active_links = preempted_nr_active_links; 1744c6fd2807SJeff Garzik 1745c6fd2807SJeff Garzik /* XXX - Some LLDDs (sata_mv) disable port on command failure. 1746c6fd2807SJeff Garzik * Until those drivers are fixed, we detect the condition 1747c6fd2807SJeff Garzik * here, fail the command with AC_ERR_SYSTEM and reenable the 1748c6fd2807SJeff Garzik * port. 1749c6fd2807SJeff Garzik * 1750c6fd2807SJeff Garzik * Note that this doesn't change any behavior as internal 1751c6fd2807SJeff Garzik * command failure results in disabling the device in the 1752c6fd2807SJeff Garzik * higher layer for LLDDs without new reset/EH callbacks. 1753c6fd2807SJeff Garzik * 1754c6fd2807SJeff Garzik * Kill the following code as soon as those drivers are fixed. 1755c6fd2807SJeff Garzik */ 1756c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_DISABLED) { 1757c6fd2807SJeff Garzik err_mask |= AC_ERR_SYSTEM; 1758c6fd2807SJeff Garzik ata_port_probe(ap); 1759c6fd2807SJeff Garzik } 1760c6fd2807SJeff Garzik 1761c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 1762c6fd2807SJeff Garzik 1763c6fd2807SJeff Garzik return err_mask; 1764c6fd2807SJeff Garzik } 1765c6fd2807SJeff Garzik 1766c6fd2807SJeff Garzik /** 176733480a0eSTejun Heo * ata_exec_internal - execute libata internal command 17682432697bSTejun Heo * @dev: Device to which the command is sent 17692432697bSTejun Heo * @tf: Taskfile registers for the command and the result 17702432697bSTejun Heo * @cdb: CDB for packet command 17712432697bSTejun Heo * @dma_dir: Data tranfer direction of the command 17722432697bSTejun Heo * @buf: Data buffer of the command 17732432697bSTejun Heo * @buflen: Length of data buffer 17742b789108STejun Heo * @timeout: Timeout in msecs (0 for default) 17752432697bSTejun Heo * 17762432697bSTejun Heo * Wrapper around ata_exec_internal_sg() which takes simple 17772432697bSTejun Heo * buffer instead of sg list. 17782432697bSTejun Heo * 17792432697bSTejun Heo * LOCKING: 17802432697bSTejun Heo * None. Should be called with kernel context, might sleep. 17812432697bSTejun Heo * 17822432697bSTejun Heo * RETURNS: 17832432697bSTejun Heo * Zero on success, AC_ERR_* mask on failure 17842432697bSTejun Heo */ 17852432697bSTejun Heo unsigned ata_exec_internal(struct ata_device *dev, 17862432697bSTejun Heo struct ata_taskfile *tf, const u8 *cdb, 17872b789108STejun Heo int dma_dir, void *buf, unsigned int buflen, 17882b789108STejun Heo unsigned long timeout) 17892432697bSTejun Heo { 179033480a0eSTejun Heo struct scatterlist *psg = NULL, sg; 179133480a0eSTejun Heo unsigned int n_elem = 0; 17922432697bSTejun Heo 179333480a0eSTejun Heo if (dma_dir != DMA_NONE) { 179433480a0eSTejun Heo WARN_ON(!buf); 17952432697bSTejun Heo sg_init_one(&sg, buf, buflen); 179633480a0eSTejun Heo psg = &sg; 179733480a0eSTejun Heo n_elem++; 179833480a0eSTejun Heo } 17992432697bSTejun Heo 18002b789108STejun Heo return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem, 18012b789108STejun Heo timeout); 18022432697bSTejun Heo } 18032432697bSTejun Heo 18042432697bSTejun Heo /** 1805c6fd2807SJeff Garzik * ata_do_simple_cmd - execute simple internal command 1806c6fd2807SJeff Garzik * @dev: Device to which the command is sent 1807c6fd2807SJeff Garzik * @cmd: Opcode to execute 1808c6fd2807SJeff Garzik * 1809c6fd2807SJeff Garzik * Execute a 'simple' command, that only consists of the opcode 1810c6fd2807SJeff Garzik * 'cmd' itself, without filling any other registers 1811c6fd2807SJeff Garzik * 1812c6fd2807SJeff Garzik * LOCKING: 1813c6fd2807SJeff Garzik * Kernel thread context (may sleep). 1814c6fd2807SJeff Garzik * 1815c6fd2807SJeff Garzik * RETURNS: 1816c6fd2807SJeff Garzik * Zero on success, AC_ERR_* mask on failure 1817c6fd2807SJeff Garzik */ 1818c6fd2807SJeff Garzik unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd) 1819c6fd2807SJeff Garzik { 1820c6fd2807SJeff Garzik struct ata_taskfile tf; 1821c6fd2807SJeff Garzik 1822c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 1823c6fd2807SJeff Garzik 1824c6fd2807SJeff Garzik tf.command = cmd; 1825c6fd2807SJeff Garzik tf.flags |= ATA_TFLAG_DEVICE; 1826c6fd2807SJeff Garzik tf.protocol = ATA_PROT_NODATA; 1827c6fd2807SJeff Garzik 18282b789108STejun Heo return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 1829c6fd2807SJeff Garzik } 1830c6fd2807SJeff Garzik 1831c6fd2807SJeff Garzik /** 1832c6fd2807SJeff Garzik * ata_pio_need_iordy - check if iordy needed 1833c6fd2807SJeff Garzik * @adev: ATA device 1834c6fd2807SJeff Garzik * 1835c6fd2807SJeff Garzik * Check if the current speed of the device requires IORDY. Used 1836c6fd2807SJeff Garzik * by various controllers for chip configuration. 1837c6fd2807SJeff Garzik */ 1838c6fd2807SJeff Garzik 1839c6fd2807SJeff Garzik unsigned int ata_pio_need_iordy(const struct ata_device *adev) 1840c6fd2807SJeff Garzik { 1841432729f0SAlan Cox /* Controller doesn't support IORDY. Probably a pointless check 1842432729f0SAlan Cox as the caller should know this */ 18439af5c9c9STejun Heo if (adev->link->ap->flags & ATA_FLAG_NO_IORDY) 1844c6fd2807SJeff Garzik return 0; 1845432729f0SAlan Cox /* PIO3 and higher it is mandatory */ 1846432729f0SAlan Cox if (adev->pio_mode > XFER_PIO_2) 1847c6fd2807SJeff Garzik return 1; 1848432729f0SAlan Cox /* We turn it on when possible */ 1849432729f0SAlan Cox if (ata_id_has_iordy(adev->id)) 1850432729f0SAlan Cox return 1; 1851432729f0SAlan Cox return 0; 1852432729f0SAlan Cox } 1853c6fd2807SJeff Garzik 1854432729f0SAlan Cox /** 1855432729f0SAlan Cox * ata_pio_mask_no_iordy - Return the non IORDY mask 1856432729f0SAlan Cox * @adev: ATA device 1857432729f0SAlan Cox * 1858432729f0SAlan Cox * Compute the highest mode possible if we are not using iordy. Return 1859432729f0SAlan Cox * -1 if no iordy mode is available. 1860432729f0SAlan Cox */ 1861432729f0SAlan Cox 1862432729f0SAlan Cox static u32 ata_pio_mask_no_iordy(const struct ata_device *adev) 1863432729f0SAlan Cox { 1864c6fd2807SJeff Garzik /* If we have no drive specific rule, then PIO 2 is non IORDY */ 1865c6fd2807SJeff Garzik if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */ 1866432729f0SAlan Cox u16 pio = adev->id[ATA_ID_EIDE_PIO]; 1867c6fd2807SJeff Garzik /* Is the speed faster than the drive allows non IORDY ? */ 1868c6fd2807SJeff Garzik if (pio) { 1869c6fd2807SJeff Garzik /* This is cycle times not frequency - watch the logic! */ 1870c6fd2807SJeff Garzik if (pio > 240) /* PIO2 is 240nS per cycle */ 1871432729f0SAlan Cox return 3 << ATA_SHIFT_PIO; 1872432729f0SAlan Cox return 7 << ATA_SHIFT_PIO; 1873c6fd2807SJeff Garzik } 1874c6fd2807SJeff Garzik } 1875432729f0SAlan Cox return 3 << ATA_SHIFT_PIO; 1876c6fd2807SJeff Garzik } 1877c6fd2807SJeff Garzik 1878c6fd2807SJeff Garzik /** 1879c6fd2807SJeff Garzik * ata_dev_read_id - Read ID data from the specified device 1880c6fd2807SJeff Garzik * @dev: target device 1881c6fd2807SJeff Garzik * @p_class: pointer to class of the target device (may be changed) 1882bff04647STejun Heo * @flags: ATA_READID_* flags 1883c6fd2807SJeff Garzik * @id: buffer to read IDENTIFY data into 1884c6fd2807SJeff Garzik * 1885c6fd2807SJeff Garzik * Read ID data from the specified device. ATA_CMD_ID_ATA is 1886c6fd2807SJeff Garzik * performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI 1887c6fd2807SJeff Garzik * devices. This function also issues ATA_CMD_INIT_DEV_PARAMS 1888c6fd2807SJeff Garzik * for pre-ATA4 drives. 1889c6fd2807SJeff Garzik * 189050a99018SAlan Cox * FIXME: ATA_CMD_ID_ATA is optional for early drives and right 189150a99018SAlan Cox * now we abort if we hit that case. 189250a99018SAlan Cox * 1893c6fd2807SJeff Garzik * LOCKING: 1894c6fd2807SJeff Garzik * Kernel thread context (may sleep) 1895c6fd2807SJeff Garzik * 1896c6fd2807SJeff Garzik * RETURNS: 1897c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 1898c6fd2807SJeff Garzik */ 1899c6fd2807SJeff Garzik int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class, 1900bff04647STejun Heo unsigned int flags, u16 *id) 1901c6fd2807SJeff Garzik { 19029af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 1903c6fd2807SJeff Garzik unsigned int class = *p_class; 1904c6fd2807SJeff Garzik struct ata_taskfile tf; 1905c6fd2807SJeff Garzik unsigned int err_mask = 0; 1906c6fd2807SJeff Garzik const char *reason; 190754936f8bSTejun Heo int may_fallback = 1, tried_spinup = 0; 1908c6fd2807SJeff Garzik int rc; 1909c6fd2807SJeff Garzik 1910c6fd2807SJeff Garzik if (ata_msg_ctl(ap)) 19117f5e4e8dSHarvey Harrison ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __func__); 1912c6fd2807SJeff Garzik 1913c6fd2807SJeff Garzik retry: 1914c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 1915c6fd2807SJeff Garzik 1916c6fd2807SJeff Garzik switch (class) { 1917c6fd2807SJeff Garzik case ATA_DEV_ATA: 1918c6fd2807SJeff Garzik tf.command = ATA_CMD_ID_ATA; 1919c6fd2807SJeff Garzik break; 1920c6fd2807SJeff Garzik case ATA_DEV_ATAPI: 1921c6fd2807SJeff Garzik tf.command = ATA_CMD_ID_ATAPI; 1922c6fd2807SJeff Garzik break; 1923c6fd2807SJeff Garzik default: 1924c6fd2807SJeff Garzik rc = -ENODEV; 1925c6fd2807SJeff Garzik reason = "unsupported class"; 1926c6fd2807SJeff Garzik goto err_out; 1927c6fd2807SJeff Garzik } 1928c6fd2807SJeff Garzik 1929c6fd2807SJeff Garzik tf.protocol = ATA_PROT_PIO; 193081afe893STejun Heo 193181afe893STejun Heo /* Some devices choke if TF registers contain garbage. Make 193281afe893STejun Heo * sure those are properly initialized. 193381afe893STejun Heo */ 193481afe893STejun Heo tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 193581afe893STejun Heo 193681afe893STejun Heo /* Device presence detection is unreliable on some 193781afe893STejun Heo * controllers. Always poll IDENTIFY if available. 193881afe893STejun Heo */ 193981afe893STejun Heo tf.flags |= ATA_TFLAG_POLLING; 1940c6fd2807SJeff Garzik 1941c6fd2807SJeff Garzik err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE, 19422b789108STejun Heo id, sizeof(id[0]) * ATA_ID_WORDS, 0); 1943c6fd2807SJeff Garzik if (err_mask) { 1944800b3996STejun Heo if (err_mask & AC_ERR_NODEV_HINT) { 19451ffc151fSTejun Heo ata_dev_printk(dev, KERN_DEBUG, 19461ffc151fSTejun Heo "NODEV after polling detection\n"); 194755a8e2c8STejun Heo return -ENOENT; 194855a8e2c8STejun Heo } 194955a8e2c8STejun Heo 19501ffc151fSTejun Heo if ((err_mask == AC_ERR_DEV) && (tf.feature & ATA_ABORTED)) { 19511ffc151fSTejun Heo /* Device or controller might have reported 19521ffc151fSTejun Heo * the wrong device class. Give a shot at the 19531ffc151fSTejun Heo * other IDENTIFY if the current one is 19541ffc151fSTejun Heo * aborted by the device. 195554936f8bSTejun Heo */ 19561ffc151fSTejun Heo if (may_fallback) { 195754936f8bSTejun Heo may_fallback = 0; 195854936f8bSTejun Heo 195954936f8bSTejun Heo if (class == ATA_DEV_ATA) 196054936f8bSTejun Heo class = ATA_DEV_ATAPI; 196154936f8bSTejun Heo else 196254936f8bSTejun Heo class = ATA_DEV_ATA; 196354936f8bSTejun Heo goto retry; 196454936f8bSTejun Heo } 196554936f8bSTejun Heo 19661ffc151fSTejun Heo /* Control reaches here iff the device aborted 19671ffc151fSTejun Heo * both flavors of IDENTIFYs which happens 19681ffc151fSTejun Heo * sometimes with phantom devices. 19691ffc151fSTejun Heo */ 19701ffc151fSTejun Heo ata_dev_printk(dev, KERN_DEBUG, 19711ffc151fSTejun Heo "both IDENTIFYs aborted, assuming NODEV\n"); 19721ffc151fSTejun Heo return -ENOENT; 19731ffc151fSTejun Heo } 19741ffc151fSTejun Heo 1975c6fd2807SJeff Garzik rc = -EIO; 1976c6fd2807SJeff Garzik reason = "I/O error"; 1977c6fd2807SJeff Garzik goto err_out; 1978c6fd2807SJeff Garzik } 1979c6fd2807SJeff Garzik 198054936f8bSTejun Heo /* Falling back doesn't make sense if ID data was read 198154936f8bSTejun Heo * successfully at least once. 198254936f8bSTejun Heo */ 198354936f8bSTejun Heo may_fallback = 0; 198454936f8bSTejun Heo 1985c6fd2807SJeff Garzik swap_buf_le16(id, ATA_ID_WORDS); 1986c6fd2807SJeff Garzik 1987c6fd2807SJeff Garzik /* sanity check */ 1988c6fd2807SJeff Garzik rc = -EINVAL; 19896070068bSAlan Cox reason = "device reports invalid type"; 19904a3381feSJeff Garzik 19914a3381feSJeff Garzik if (class == ATA_DEV_ATA) { 19924a3381feSJeff Garzik if (!ata_id_is_ata(id) && !ata_id_is_cfa(id)) 19934a3381feSJeff Garzik goto err_out; 19944a3381feSJeff Garzik } else { 19954a3381feSJeff Garzik if (ata_id_is_ata(id)) 1996c6fd2807SJeff Garzik goto err_out; 1997c6fd2807SJeff Garzik } 1998c6fd2807SJeff Garzik 1999169439c2SMark Lord if (!tried_spinup && (id[2] == 0x37c8 || id[2] == 0x738c)) { 2000169439c2SMark Lord tried_spinup = 1; 2001169439c2SMark Lord /* 2002169439c2SMark Lord * Drive powered-up in standby mode, and requires a specific 2003169439c2SMark Lord * SET_FEATURES spin-up subcommand before it will accept 2004169439c2SMark Lord * anything other than the original IDENTIFY command. 2005169439c2SMark Lord */ 2006218f3d30SJeff Garzik err_mask = ata_dev_set_feature(dev, SETFEATURES_SPINUP, 0); 2007fb0582f9SRyan Power if (err_mask && id[2] != 0x738c) { 2008169439c2SMark Lord rc = -EIO; 2009169439c2SMark Lord reason = "SPINUP failed"; 2010169439c2SMark Lord goto err_out; 2011169439c2SMark Lord } 2012169439c2SMark Lord /* 2013169439c2SMark Lord * If the drive initially returned incomplete IDENTIFY info, 2014169439c2SMark Lord * we now must reissue the IDENTIFY command. 2015169439c2SMark Lord */ 2016169439c2SMark Lord if (id[2] == 0x37c8) 2017169439c2SMark Lord goto retry; 2018169439c2SMark Lord } 2019169439c2SMark Lord 2020bff04647STejun Heo if ((flags & ATA_READID_POSTRESET) && class == ATA_DEV_ATA) { 2021c6fd2807SJeff Garzik /* 2022c6fd2807SJeff Garzik * The exact sequence expected by certain pre-ATA4 drives is: 2023c6fd2807SJeff Garzik * SRST RESET 202450a99018SAlan Cox * IDENTIFY (optional in early ATA) 202550a99018SAlan Cox * INITIALIZE DEVICE PARAMETERS (later IDE and ATA) 2026c6fd2807SJeff Garzik * anything else.. 2027c6fd2807SJeff Garzik * Some drives were very specific about that exact sequence. 202850a99018SAlan Cox * 202950a99018SAlan Cox * Note that ATA4 says lba is mandatory so the second check 203050a99018SAlan Cox * shoud never trigger. 2031c6fd2807SJeff Garzik */ 2032c6fd2807SJeff Garzik if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) { 2033c6fd2807SJeff Garzik err_mask = ata_dev_init_params(dev, id[3], id[6]); 2034c6fd2807SJeff Garzik if (err_mask) { 2035c6fd2807SJeff Garzik rc = -EIO; 2036c6fd2807SJeff Garzik reason = "INIT_DEV_PARAMS failed"; 2037c6fd2807SJeff Garzik goto err_out; 2038c6fd2807SJeff Garzik } 2039c6fd2807SJeff Garzik 2040c6fd2807SJeff Garzik /* current CHS translation info (id[53-58]) might be 2041c6fd2807SJeff Garzik * changed. reread the identify device info. 2042c6fd2807SJeff Garzik */ 2043bff04647STejun Heo flags &= ~ATA_READID_POSTRESET; 2044c6fd2807SJeff Garzik goto retry; 2045c6fd2807SJeff Garzik } 2046c6fd2807SJeff Garzik } 2047c6fd2807SJeff Garzik 2048c6fd2807SJeff Garzik *p_class = class; 2049c6fd2807SJeff Garzik 2050c6fd2807SJeff Garzik return 0; 2051c6fd2807SJeff Garzik 2052c6fd2807SJeff Garzik err_out: 2053c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 2054c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "failed to IDENTIFY " 2055c6fd2807SJeff Garzik "(%s, err_mask=0x%x)\n", reason, err_mask); 2056c6fd2807SJeff Garzik return rc; 2057c6fd2807SJeff Garzik } 2058c6fd2807SJeff Garzik 2059c6fd2807SJeff Garzik static inline u8 ata_dev_knobble(struct ata_device *dev) 2060c6fd2807SJeff Garzik { 20619af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 20629af5c9c9STejun Heo return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id))); 2063c6fd2807SJeff Garzik } 2064c6fd2807SJeff Garzik 2065c6fd2807SJeff Garzik static void ata_dev_config_ncq(struct ata_device *dev, 2066c6fd2807SJeff Garzik char *desc, size_t desc_sz) 2067c6fd2807SJeff Garzik { 20689af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 2069c6fd2807SJeff Garzik int hdepth = 0, ddepth = ata_id_queue_depth(dev->id); 2070c6fd2807SJeff Garzik 2071c6fd2807SJeff Garzik if (!ata_id_has_ncq(dev->id)) { 2072c6fd2807SJeff Garzik desc[0] = '\0'; 2073c6fd2807SJeff Garzik return; 2074c6fd2807SJeff Garzik } 207575683fe7STejun Heo if (dev->horkage & ATA_HORKAGE_NONCQ) { 20766919a0a6SAlan Cox snprintf(desc, desc_sz, "NCQ (not used)"); 20776919a0a6SAlan Cox return; 20786919a0a6SAlan Cox } 2079c6fd2807SJeff Garzik if (ap->flags & ATA_FLAG_NCQ) { 2080cca3974eSJeff Garzik hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE - 1); 2081c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_NCQ; 2082c6fd2807SJeff Garzik } 2083c6fd2807SJeff Garzik 2084c6fd2807SJeff Garzik if (hdepth >= ddepth) 2085c6fd2807SJeff Garzik snprintf(desc, desc_sz, "NCQ (depth %d)", ddepth); 2086c6fd2807SJeff Garzik else 2087c6fd2807SJeff Garzik snprintf(desc, desc_sz, "NCQ (depth %d/%d)", hdepth, ddepth); 2088c6fd2807SJeff Garzik } 2089c6fd2807SJeff Garzik 2090c6fd2807SJeff Garzik /** 2091c6fd2807SJeff Garzik * ata_dev_configure - Configure the specified ATA/ATAPI device 2092c6fd2807SJeff Garzik * @dev: Target device to configure 2093c6fd2807SJeff Garzik * 2094c6fd2807SJeff Garzik * Configure @dev according to @dev->id. Generic and low-level 2095c6fd2807SJeff Garzik * driver specific fixups are also applied. 2096c6fd2807SJeff Garzik * 2097c6fd2807SJeff Garzik * LOCKING: 2098c6fd2807SJeff Garzik * Kernel thread context (may sleep) 2099c6fd2807SJeff Garzik * 2100c6fd2807SJeff Garzik * RETURNS: 2101c6fd2807SJeff Garzik * 0 on success, -errno otherwise 2102c6fd2807SJeff Garzik */ 2103efdaedc4STejun Heo int ata_dev_configure(struct ata_device *dev) 2104c6fd2807SJeff Garzik { 21059af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 21069af5c9c9STejun Heo struct ata_eh_context *ehc = &dev->link->eh_context; 21076746544cSTejun Heo int print_info = ehc->i.flags & ATA_EHI_PRINTINFO; 2108c6fd2807SJeff Garzik const u16 *id = dev->id; 21097dc951aeSTejun Heo unsigned long xfer_mask; 2110b352e57dSAlan Cox char revbuf[7]; /* XYZ-99\0 */ 21113f64f565SEric D. Mudama char fwrevbuf[ATA_ID_FW_REV_LEN+1]; 21123f64f565SEric D. Mudama char modelbuf[ATA_ID_PROD_LEN+1]; 2113c6fd2807SJeff Garzik int rc; 2114c6fd2807SJeff Garzik 2115c6fd2807SJeff Garzik if (!ata_dev_enabled(dev) && ata_msg_info(ap)) { 211644877b4eSTejun Heo ata_dev_printk(dev, KERN_INFO, "%s: ENTER/EXIT -- nodev\n", 21177f5e4e8dSHarvey Harrison __func__); 2118c6fd2807SJeff Garzik return 0; 2119c6fd2807SJeff Garzik } 2120c6fd2807SJeff Garzik 2121c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 21227f5e4e8dSHarvey Harrison ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __func__); 2123c6fd2807SJeff Garzik 212475683fe7STejun Heo /* set horkage */ 212575683fe7STejun Heo dev->horkage |= ata_dev_blacklisted(dev); 212633267325STejun Heo ata_force_horkage(dev); 212775683fe7STejun Heo 212850af2fa1STejun Heo if (dev->horkage & ATA_HORKAGE_DISABLE) { 212950af2fa1STejun Heo ata_dev_printk(dev, KERN_INFO, 213050af2fa1STejun Heo "unsupported device, disabling\n"); 213150af2fa1STejun Heo ata_dev_disable(dev); 213250af2fa1STejun Heo return 0; 213350af2fa1STejun Heo } 213450af2fa1STejun Heo 21356746544cSTejun Heo /* let ACPI work its magic */ 21366746544cSTejun Heo rc = ata_acpi_on_devcfg(dev); 21376746544cSTejun Heo if (rc) 21386746544cSTejun Heo return rc; 213908573a86SKristen Carlson Accardi 214005027adcSTejun Heo /* massage HPA, do it early as it might change IDENTIFY data */ 214105027adcSTejun Heo rc = ata_hpa_resize(dev); 214205027adcSTejun Heo if (rc) 214305027adcSTejun Heo return rc; 214405027adcSTejun Heo 2145c6fd2807SJeff Garzik /* print device capabilities */ 2146c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 2147c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_DEBUG, 2148c6fd2807SJeff Garzik "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x " 2149c6fd2807SJeff Garzik "85:%04x 86:%04x 87:%04x 88:%04x\n", 21507f5e4e8dSHarvey Harrison __func__, 2151c6fd2807SJeff Garzik id[49], id[82], id[83], id[84], 2152c6fd2807SJeff Garzik id[85], id[86], id[87], id[88]); 2153c6fd2807SJeff Garzik 2154c6fd2807SJeff Garzik /* initialize to-be-configured parameters */ 2155c6fd2807SJeff Garzik dev->flags &= ~ATA_DFLAG_CFG_MASK; 2156c6fd2807SJeff Garzik dev->max_sectors = 0; 2157c6fd2807SJeff Garzik dev->cdb_len = 0; 2158c6fd2807SJeff Garzik dev->n_sectors = 0; 2159c6fd2807SJeff Garzik dev->cylinders = 0; 2160c6fd2807SJeff Garzik dev->heads = 0; 2161c6fd2807SJeff Garzik dev->sectors = 0; 2162c6fd2807SJeff Garzik 2163c6fd2807SJeff Garzik /* 2164c6fd2807SJeff Garzik * common ATA, ATAPI feature tests 2165c6fd2807SJeff Garzik */ 2166c6fd2807SJeff Garzik 2167c6fd2807SJeff Garzik /* find max transfer mode; for printk only */ 2168c6fd2807SJeff Garzik xfer_mask = ata_id_xfermask(id); 2169c6fd2807SJeff Garzik 2170c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 2171c6fd2807SJeff Garzik ata_dump_id(id); 2172c6fd2807SJeff Garzik 2173ef143d57SAlbert Lee /* SCSI only uses 4-char revisions, dump full 8 chars from ATA */ 2174ef143d57SAlbert Lee ata_id_c_string(dev->id, fwrevbuf, ATA_ID_FW_REV, 2175ef143d57SAlbert Lee sizeof(fwrevbuf)); 2176ef143d57SAlbert Lee 2177ef143d57SAlbert Lee ata_id_c_string(dev->id, modelbuf, ATA_ID_PROD, 2178ef143d57SAlbert Lee sizeof(modelbuf)); 2179ef143d57SAlbert Lee 2180c6fd2807SJeff Garzik /* ATA-specific feature tests */ 2181c6fd2807SJeff Garzik if (dev->class == ATA_DEV_ATA) { 2182b352e57dSAlan Cox if (ata_id_is_cfa(id)) { 2183b352e57dSAlan Cox if (id[162] & 1) /* CPRM may make this media unusable */ 218444877b4eSTejun Heo ata_dev_printk(dev, KERN_WARNING, 218544877b4eSTejun Heo "supports DRM functions and may " 218644877b4eSTejun Heo "not be fully accessable.\n"); 2187b352e57dSAlan Cox snprintf(revbuf, 7, "CFA"); 2188ae8d4ee7SAlan Cox } else { 2189b352e57dSAlan Cox snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id)); 2190ae8d4ee7SAlan Cox /* Warn the user if the device has TPM extensions */ 2191ae8d4ee7SAlan Cox if (ata_id_has_tpm(id)) 2192ae8d4ee7SAlan Cox ata_dev_printk(dev, KERN_WARNING, 2193ae8d4ee7SAlan Cox "supports DRM functions and may " 2194ae8d4ee7SAlan Cox "not be fully accessable.\n"); 2195ae8d4ee7SAlan Cox } 2196b352e57dSAlan Cox 2197c6fd2807SJeff Garzik dev->n_sectors = ata_id_n_sectors(id); 2198c6fd2807SJeff Garzik 21993f64f565SEric D. Mudama if (dev->id[59] & 0x100) 22003f64f565SEric D. Mudama dev->multi_count = dev->id[59] & 0xff; 22013f64f565SEric D. Mudama 2202c6fd2807SJeff Garzik if (ata_id_has_lba(id)) { 2203c6fd2807SJeff Garzik const char *lba_desc; 2204c6fd2807SJeff Garzik char ncq_desc[20]; 2205c6fd2807SJeff Garzik 2206c6fd2807SJeff Garzik lba_desc = "LBA"; 2207c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_LBA; 2208c6fd2807SJeff Garzik if (ata_id_has_lba48(id)) { 2209c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_LBA48; 2210c6fd2807SJeff Garzik lba_desc = "LBA48"; 22116fc49adbSTejun Heo 22126fc49adbSTejun Heo if (dev->n_sectors >= (1UL << 28) && 22136fc49adbSTejun Heo ata_id_has_flush_ext(id)) 22146fc49adbSTejun Heo dev->flags |= ATA_DFLAG_FLUSH_EXT; 2215c6fd2807SJeff Garzik } 2216c6fd2807SJeff Garzik 2217c6fd2807SJeff Garzik /* config NCQ */ 2218c6fd2807SJeff Garzik ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc)); 2219c6fd2807SJeff Garzik 2220c6fd2807SJeff Garzik /* print device info to dmesg */ 22213f64f565SEric D. Mudama if (ata_msg_drv(ap) && print_info) { 22223f64f565SEric D. Mudama ata_dev_printk(dev, KERN_INFO, 22233f64f565SEric D. Mudama "%s: %s, %s, max %s\n", 22243f64f565SEric D. Mudama revbuf, modelbuf, fwrevbuf, 22253f64f565SEric D. Mudama ata_mode_string(xfer_mask)); 22263f64f565SEric D. Mudama ata_dev_printk(dev, KERN_INFO, 22273f64f565SEric D. Mudama "%Lu sectors, multi %u: %s %s\n", 2228c6fd2807SJeff Garzik (unsigned long long)dev->n_sectors, 22293f64f565SEric D. Mudama dev->multi_count, lba_desc, ncq_desc); 22303f64f565SEric D. Mudama } 2231c6fd2807SJeff Garzik } else { 2232c6fd2807SJeff Garzik /* CHS */ 2233c6fd2807SJeff Garzik 2234c6fd2807SJeff Garzik /* Default translation */ 2235c6fd2807SJeff Garzik dev->cylinders = id[1]; 2236c6fd2807SJeff Garzik dev->heads = id[3]; 2237c6fd2807SJeff Garzik dev->sectors = id[6]; 2238c6fd2807SJeff Garzik 2239c6fd2807SJeff Garzik if (ata_id_current_chs_valid(id)) { 2240c6fd2807SJeff Garzik /* Current CHS translation is valid. */ 2241c6fd2807SJeff Garzik dev->cylinders = id[54]; 2242c6fd2807SJeff Garzik dev->heads = id[55]; 2243c6fd2807SJeff Garzik dev->sectors = id[56]; 2244c6fd2807SJeff Garzik } 2245c6fd2807SJeff Garzik 2246c6fd2807SJeff Garzik /* print device info to dmesg */ 22473f64f565SEric D. Mudama if (ata_msg_drv(ap) && print_info) { 2248c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, 22493f64f565SEric D. Mudama "%s: %s, %s, max %s\n", 22503f64f565SEric D. Mudama revbuf, modelbuf, fwrevbuf, 22513f64f565SEric D. Mudama ata_mode_string(xfer_mask)); 22523f64f565SEric D. Mudama ata_dev_printk(dev, KERN_INFO, 22533f64f565SEric D. Mudama "%Lu sectors, multi %u, CHS %u/%u/%u\n", 22543f64f565SEric D. Mudama (unsigned long long)dev->n_sectors, 22553f64f565SEric D. Mudama dev->multi_count, dev->cylinders, 22563f64f565SEric D. Mudama dev->heads, dev->sectors); 22573f64f565SEric D. Mudama } 2258c6fd2807SJeff Garzik } 2259c6fd2807SJeff Garzik 2260c6fd2807SJeff Garzik dev->cdb_len = 16; 2261c6fd2807SJeff Garzik } 2262c6fd2807SJeff Garzik 2263c6fd2807SJeff Garzik /* ATAPI-specific feature tests */ 2264c6fd2807SJeff Garzik else if (dev->class == ATA_DEV_ATAPI) { 2265854c73a2STejun Heo const char *cdb_intr_string = ""; 2266854c73a2STejun Heo const char *atapi_an_string = ""; 226791163006STejun Heo const char *dma_dir_string = ""; 22687d77b247STejun Heo u32 sntf; 2269c6fd2807SJeff Garzik 2270c6fd2807SJeff Garzik rc = atapi_cdb_len(id); 2271c6fd2807SJeff Garzik if ((rc < 12) || (rc > ATAPI_CDB_LEN)) { 2272c6fd2807SJeff Garzik if (ata_msg_warn(ap)) 2273c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 2274c6fd2807SJeff Garzik "unsupported CDB len\n"); 2275c6fd2807SJeff Garzik rc = -EINVAL; 2276c6fd2807SJeff Garzik goto err_out_nosup; 2277c6fd2807SJeff Garzik } 2278c6fd2807SJeff Garzik dev->cdb_len = (unsigned int) rc; 2279c6fd2807SJeff Garzik 22807d77b247STejun Heo /* Enable ATAPI AN if both the host and device have 22817d77b247STejun Heo * the support. If PMP is attached, SNTF is required 22827d77b247STejun Heo * to enable ATAPI AN to discern between PHY status 22837d77b247STejun Heo * changed notifications and ATAPI ANs. 22849f45cbd3SKristen Carlson Accardi */ 22857d77b247STejun Heo if ((ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) && 2286071f44b1STejun Heo (!sata_pmp_attached(ap) || 22877d77b247STejun Heo sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) { 2288854c73a2STejun Heo unsigned int err_mask; 2289854c73a2STejun Heo 22909f45cbd3SKristen Carlson Accardi /* issue SET feature command to turn this on */ 2291218f3d30SJeff Garzik err_mask = ata_dev_set_feature(dev, 2292218f3d30SJeff Garzik SETFEATURES_SATA_ENABLE, SATA_AN); 2293854c73a2STejun Heo if (err_mask) 22949f45cbd3SKristen Carlson Accardi ata_dev_printk(dev, KERN_ERR, 2295854c73a2STejun Heo "failed to enable ATAPI AN " 2296854c73a2STejun Heo "(err_mask=0x%x)\n", err_mask); 2297854c73a2STejun Heo else { 22989f45cbd3SKristen Carlson Accardi dev->flags |= ATA_DFLAG_AN; 2299854c73a2STejun Heo atapi_an_string = ", ATAPI AN"; 2300854c73a2STejun Heo } 23019f45cbd3SKristen Carlson Accardi } 23029f45cbd3SKristen Carlson Accardi 2303c6fd2807SJeff Garzik if (ata_id_cdb_intr(dev->id)) { 2304c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_CDB_INTR; 2305c6fd2807SJeff Garzik cdb_intr_string = ", CDB intr"; 2306c6fd2807SJeff Garzik } 2307c6fd2807SJeff Garzik 230891163006STejun Heo if (atapi_dmadir || atapi_id_dmadir(dev->id)) { 230991163006STejun Heo dev->flags |= ATA_DFLAG_DMADIR; 231091163006STejun Heo dma_dir_string = ", DMADIR"; 231191163006STejun Heo } 231291163006STejun Heo 2313c6fd2807SJeff Garzik /* print device info to dmesg */ 2314c6fd2807SJeff Garzik if (ata_msg_drv(ap) && print_info) 2315ef143d57SAlbert Lee ata_dev_printk(dev, KERN_INFO, 231691163006STejun Heo "ATAPI: %s, %s, max %s%s%s%s\n", 2317ef143d57SAlbert Lee modelbuf, fwrevbuf, 2318c6fd2807SJeff Garzik ata_mode_string(xfer_mask), 231991163006STejun Heo cdb_intr_string, atapi_an_string, 232091163006STejun Heo dma_dir_string); 2321c6fd2807SJeff Garzik } 2322c6fd2807SJeff Garzik 2323914ed354STejun Heo /* determine max_sectors */ 2324914ed354STejun Heo dev->max_sectors = ATA_MAX_SECTORS; 2325914ed354STejun Heo if (dev->flags & ATA_DFLAG_LBA48) 2326914ed354STejun Heo dev->max_sectors = ATA_MAX_SECTORS_LBA48; 2327914ed354STejun Heo 2328ca77329fSKristen Carlson Accardi if (!(dev->horkage & ATA_HORKAGE_IPM)) { 2329ca77329fSKristen Carlson Accardi if (ata_id_has_hipm(dev->id)) 2330ca77329fSKristen Carlson Accardi dev->flags |= ATA_DFLAG_HIPM; 2331ca77329fSKristen Carlson Accardi if (ata_id_has_dipm(dev->id)) 2332ca77329fSKristen Carlson Accardi dev->flags |= ATA_DFLAG_DIPM; 2333ca77329fSKristen Carlson Accardi } 2334ca77329fSKristen Carlson Accardi 2335c5038fc0SAlan Cox /* Limit PATA drive on SATA cable bridge transfers to udma5, 2336c5038fc0SAlan Cox 200 sectors */ 2337c6fd2807SJeff Garzik if (ata_dev_knobble(dev)) { 2338c6fd2807SJeff Garzik if (ata_msg_drv(ap) && print_info) 2339c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, 2340c6fd2807SJeff Garzik "applying bridge limits\n"); 2341c6fd2807SJeff Garzik dev->udma_mask &= ATA_UDMA5; 2342c6fd2807SJeff Garzik dev->max_sectors = ATA_MAX_SECTORS; 2343c6fd2807SJeff Garzik } 2344c6fd2807SJeff Garzik 2345f8d8e579STony Battersby if ((dev->class == ATA_DEV_ATAPI) && 2346f442cd86SAlbert Lee (atapi_command_packet_set(id) == TYPE_TAPE)) { 2347f8d8e579STony Battersby dev->max_sectors = ATA_MAX_SECTORS_TAPE; 2348f442cd86SAlbert Lee dev->horkage |= ATA_HORKAGE_STUCK_ERR; 2349f442cd86SAlbert Lee } 2350f8d8e579STony Battersby 235175683fe7STejun Heo if (dev->horkage & ATA_HORKAGE_MAX_SEC_128) 235203ec52deSTejun Heo dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128, 235303ec52deSTejun Heo dev->max_sectors); 235418d6e9d5SAlbert Lee 2355ca77329fSKristen Carlson Accardi if (ata_dev_blacklisted(dev) & ATA_HORKAGE_IPM) { 2356ca77329fSKristen Carlson Accardi dev->horkage |= ATA_HORKAGE_IPM; 2357ca77329fSKristen Carlson Accardi 2358ca77329fSKristen Carlson Accardi /* reset link pm_policy for this port to no pm */ 2359ca77329fSKristen Carlson Accardi ap->pm_policy = MAX_PERFORMANCE; 2360ca77329fSKristen Carlson Accardi } 2361ca77329fSKristen Carlson Accardi 2362c6fd2807SJeff Garzik if (ap->ops->dev_config) 2363cd0d3bbcSAlan ap->ops->dev_config(dev); 2364c6fd2807SJeff Garzik 2365c5038fc0SAlan Cox if (dev->horkage & ATA_HORKAGE_DIAGNOSTIC) { 2366c5038fc0SAlan Cox /* Let the user know. We don't want to disallow opens for 2367c5038fc0SAlan Cox rescue purposes, or in case the vendor is just a blithering 2368c5038fc0SAlan Cox idiot. Do this after the dev_config call as some controllers 2369c5038fc0SAlan Cox with buggy firmware may want to avoid reporting false device 2370c5038fc0SAlan Cox bugs */ 2371c5038fc0SAlan Cox 2372c5038fc0SAlan Cox if (print_info) { 2373c5038fc0SAlan Cox ata_dev_printk(dev, KERN_WARNING, 2374c5038fc0SAlan Cox "Drive reports diagnostics failure. This may indicate a drive\n"); 2375c5038fc0SAlan Cox ata_dev_printk(dev, KERN_WARNING, 2376c5038fc0SAlan Cox "fault or invalid emulation. Contact drive vendor for information.\n"); 2377c5038fc0SAlan Cox } 2378c5038fc0SAlan Cox } 2379c5038fc0SAlan Cox 2380c6fd2807SJeff Garzik return 0; 2381c6fd2807SJeff Garzik 2382c6fd2807SJeff Garzik err_out_nosup: 2383c6fd2807SJeff Garzik if (ata_msg_probe(ap)) 2384c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_DEBUG, 23857f5e4e8dSHarvey Harrison "%s: EXIT, err\n", __func__); 2386c6fd2807SJeff Garzik return rc; 2387c6fd2807SJeff Garzik } 2388c6fd2807SJeff Garzik 2389c6fd2807SJeff Garzik /** 23902e41e8e6SAlan Cox * ata_cable_40wire - return 40 wire cable type 2391be0d18dfSAlan Cox * @ap: port 2392be0d18dfSAlan Cox * 23932e41e8e6SAlan Cox * Helper method for drivers which want to hardwire 40 wire cable 2394be0d18dfSAlan Cox * detection. 2395be0d18dfSAlan Cox */ 2396be0d18dfSAlan Cox 2397be0d18dfSAlan Cox int ata_cable_40wire(struct ata_port *ap) 2398be0d18dfSAlan Cox { 2399be0d18dfSAlan Cox return ATA_CBL_PATA40; 2400be0d18dfSAlan Cox } 2401be0d18dfSAlan Cox 2402be0d18dfSAlan Cox /** 24032e41e8e6SAlan Cox * ata_cable_80wire - return 80 wire cable type 2404be0d18dfSAlan Cox * @ap: port 2405be0d18dfSAlan Cox * 24062e41e8e6SAlan Cox * Helper method for drivers which want to hardwire 80 wire cable 2407be0d18dfSAlan Cox * detection. 2408be0d18dfSAlan Cox */ 2409be0d18dfSAlan Cox 2410be0d18dfSAlan Cox int ata_cable_80wire(struct ata_port *ap) 2411be0d18dfSAlan Cox { 2412be0d18dfSAlan Cox return ATA_CBL_PATA80; 2413be0d18dfSAlan Cox } 2414be0d18dfSAlan Cox 2415be0d18dfSAlan Cox /** 2416be0d18dfSAlan Cox * ata_cable_unknown - return unknown PATA cable. 2417be0d18dfSAlan Cox * @ap: port 2418be0d18dfSAlan Cox * 2419be0d18dfSAlan Cox * Helper method for drivers which have no PATA cable detection. 2420be0d18dfSAlan Cox */ 2421be0d18dfSAlan Cox 2422be0d18dfSAlan Cox int ata_cable_unknown(struct ata_port *ap) 2423be0d18dfSAlan Cox { 2424be0d18dfSAlan Cox return ATA_CBL_PATA_UNK; 2425be0d18dfSAlan Cox } 2426be0d18dfSAlan Cox 2427be0d18dfSAlan Cox /** 2428c88f90c3STejun Heo * ata_cable_ignore - return ignored PATA cable. 2429c88f90c3STejun Heo * @ap: port 2430c88f90c3STejun Heo * 2431c88f90c3STejun Heo * Helper method for drivers which don't use cable type to limit 2432c88f90c3STejun Heo * transfer mode. 2433c88f90c3STejun Heo */ 2434c88f90c3STejun Heo int ata_cable_ignore(struct ata_port *ap) 2435c88f90c3STejun Heo { 2436c88f90c3STejun Heo return ATA_CBL_PATA_IGN; 2437c88f90c3STejun Heo } 2438c88f90c3STejun Heo 2439c88f90c3STejun Heo /** 2440be0d18dfSAlan Cox * ata_cable_sata - return SATA cable type 2441be0d18dfSAlan Cox * @ap: port 2442be0d18dfSAlan Cox * 2443be0d18dfSAlan Cox * Helper method for drivers which have SATA cables 2444be0d18dfSAlan Cox */ 2445be0d18dfSAlan Cox 2446be0d18dfSAlan Cox int ata_cable_sata(struct ata_port *ap) 2447be0d18dfSAlan Cox { 2448be0d18dfSAlan Cox return ATA_CBL_SATA; 2449be0d18dfSAlan Cox } 2450be0d18dfSAlan Cox 2451be0d18dfSAlan Cox /** 2452c6fd2807SJeff Garzik * ata_bus_probe - Reset and probe ATA bus 2453c6fd2807SJeff Garzik * @ap: Bus to probe 2454c6fd2807SJeff Garzik * 2455c6fd2807SJeff Garzik * Master ATA bus probing function. Initiates a hardware-dependent 2456c6fd2807SJeff Garzik * bus reset, then attempts to identify any devices found on 2457c6fd2807SJeff Garzik * the bus. 2458c6fd2807SJeff Garzik * 2459c6fd2807SJeff Garzik * LOCKING: 2460c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 2461c6fd2807SJeff Garzik * 2462c6fd2807SJeff Garzik * RETURNS: 2463c6fd2807SJeff Garzik * Zero on success, negative errno otherwise. 2464c6fd2807SJeff Garzik */ 2465c6fd2807SJeff Garzik 2466c6fd2807SJeff Garzik int ata_bus_probe(struct ata_port *ap) 2467c6fd2807SJeff Garzik { 2468c6fd2807SJeff Garzik unsigned int classes[ATA_MAX_DEVICES]; 2469c6fd2807SJeff Garzik int tries[ATA_MAX_DEVICES]; 2470f58229f8STejun Heo int rc; 2471c6fd2807SJeff Garzik struct ata_device *dev; 2472c6fd2807SJeff Garzik 2473c6fd2807SJeff Garzik ata_port_probe(ap); 2474c6fd2807SJeff Garzik 2475f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) 2476f58229f8STejun Heo tries[dev->devno] = ATA_PROBE_MAX_TRIES; 2477c6fd2807SJeff Garzik 2478c6fd2807SJeff Garzik retry: 2479cdeab114STejun Heo ata_link_for_each_dev(dev, &ap->link) { 2480cdeab114STejun Heo /* If we issue an SRST then an ATA drive (not ATAPI) 2481cdeab114STejun Heo * may change configuration and be in PIO0 timing. If 2482cdeab114STejun Heo * we do a hard reset (or are coming from power on) 2483cdeab114STejun Heo * this is true for ATA or ATAPI. Until we've set a 2484cdeab114STejun Heo * suitable controller mode we should not touch the 2485cdeab114STejun Heo * bus as we may be talking too fast. 2486cdeab114STejun Heo */ 2487cdeab114STejun Heo dev->pio_mode = XFER_PIO_0; 2488cdeab114STejun Heo 2489cdeab114STejun Heo /* If the controller has a pio mode setup function 2490cdeab114STejun Heo * then use it to set the chipset to rights. Don't 2491cdeab114STejun Heo * touch the DMA setup as that will be dealt with when 2492cdeab114STejun Heo * configuring devices. 2493cdeab114STejun Heo */ 2494cdeab114STejun Heo if (ap->ops->set_piomode) 2495cdeab114STejun Heo ap->ops->set_piomode(ap, dev); 2496cdeab114STejun Heo } 2497cdeab114STejun Heo 2498c6fd2807SJeff Garzik /* reset and determine device classes */ 2499c6fd2807SJeff Garzik ap->ops->phy_reset(ap); 2500c6fd2807SJeff Garzik 2501f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) { 2502c6fd2807SJeff Garzik if (!(ap->flags & ATA_FLAG_DISABLED) && 2503c6fd2807SJeff Garzik dev->class != ATA_DEV_UNKNOWN) 2504c6fd2807SJeff Garzik classes[dev->devno] = dev->class; 2505c6fd2807SJeff Garzik else 2506c6fd2807SJeff Garzik classes[dev->devno] = ATA_DEV_NONE; 2507c6fd2807SJeff Garzik 2508c6fd2807SJeff Garzik dev->class = ATA_DEV_UNKNOWN; 2509c6fd2807SJeff Garzik } 2510c6fd2807SJeff Garzik 2511c6fd2807SJeff Garzik ata_port_probe(ap); 2512c6fd2807SJeff Garzik 2513f31f0cc2SJeff Garzik /* read IDENTIFY page and configure devices. We have to do the identify 2514f31f0cc2SJeff Garzik specific sequence bass-ackwards so that PDIAG- is released by 2515f31f0cc2SJeff Garzik the slave device */ 2516f31f0cc2SJeff Garzik 2517a4ba7fe2SBartlomiej Zolnierkiewicz ata_link_for_each_dev_reverse(dev, &ap->link) { 2518f58229f8STejun Heo if (tries[dev->devno]) 2519f58229f8STejun Heo dev->class = classes[dev->devno]; 2520c6fd2807SJeff Garzik 2521c6fd2807SJeff Garzik if (!ata_dev_enabled(dev)) 2522c6fd2807SJeff Garzik continue; 2523c6fd2807SJeff Garzik 2524bff04647STejun Heo rc = ata_dev_read_id(dev, &dev->class, ATA_READID_POSTRESET, 2525bff04647STejun Heo dev->id); 2526c6fd2807SJeff Garzik if (rc) 2527c6fd2807SJeff Garzik goto fail; 2528f31f0cc2SJeff Garzik } 2529f31f0cc2SJeff Garzik 2530be0d18dfSAlan Cox /* Now ask for the cable type as PDIAG- should have been released */ 2531be0d18dfSAlan Cox if (ap->ops->cable_detect) 2532be0d18dfSAlan Cox ap->cbl = ap->ops->cable_detect(ap); 2533be0d18dfSAlan Cox 2534614fe29bSAlan Cox /* We may have SATA bridge glue hiding here irrespective of the 2535614fe29bSAlan Cox reported cable types and sensed types */ 2536614fe29bSAlan Cox ata_link_for_each_dev(dev, &ap->link) { 2537614fe29bSAlan Cox if (!ata_dev_enabled(dev)) 2538614fe29bSAlan Cox continue; 2539614fe29bSAlan Cox /* SATA drives indicate we have a bridge. We don't know which 2540614fe29bSAlan Cox end of the link the bridge is which is a problem */ 2541614fe29bSAlan Cox if (ata_id_is_sata(dev->id)) 2542614fe29bSAlan Cox ap->cbl = ATA_CBL_SATA; 2543614fe29bSAlan Cox } 2544614fe29bSAlan Cox 2545f31f0cc2SJeff Garzik /* After the identify sequence we can now set up the devices. We do 2546f31f0cc2SJeff Garzik this in the normal order so that the user doesn't get confused */ 2547f31f0cc2SJeff Garzik 2548f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) { 2549f31f0cc2SJeff Garzik if (!ata_dev_enabled(dev)) 2550f31f0cc2SJeff Garzik continue; 2551c6fd2807SJeff Garzik 25529af5c9c9STejun Heo ap->link.eh_context.i.flags |= ATA_EHI_PRINTINFO; 2553efdaedc4STejun Heo rc = ata_dev_configure(dev); 25549af5c9c9STejun Heo ap->link.eh_context.i.flags &= ~ATA_EHI_PRINTINFO; 2555c6fd2807SJeff Garzik if (rc) 2556c6fd2807SJeff Garzik goto fail; 2557c6fd2807SJeff Garzik } 2558c6fd2807SJeff Garzik 2559c6fd2807SJeff Garzik /* configure transfer mode */ 25600260731fSTejun Heo rc = ata_set_mode(&ap->link, &dev); 25614ae72a1eSTejun Heo if (rc) 2562c6fd2807SJeff Garzik goto fail; 2563c6fd2807SJeff Garzik 2564f58229f8STejun Heo ata_link_for_each_dev(dev, &ap->link) 2565f58229f8STejun Heo if (ata_dev_enabled(dev)) 2566c6fd2807SJeff Garzik return 0; 2567c6fd2807SJeff Garzik 2568c6fd2807SJeff Garzik /* no device present, disable port */ 2569c6fd2807SJeff Garzik ata_port_disable(ap); 2570c6fd2807SJeff Garzik return -ENODEV; 2571c6fd2807SJeff Garzik 2572c6fd2807SJeff Garzik fail: 25734ae72a1eSTejun Heo tries[dev->devno]--; 25744ae72a1eSTejun Heo 2575c6fd2807SJeff Garzik switch (rc) { 2576c6fd2807SJeff Garzik case -EINVAL: 25774ae72a1eSTejun Heo /* eeek, something went very wrong, give up */ 2578c6fd2807SJeff Garzik tries[dev->devno] = 0; 2579c6fd2807SJeff Garzik break; 25804ae72a1eSTejun Heo 25814ae72a1eSTejun Heo case -ENODEV: 25824ae72a1eSTejun Heo /* give it just one more chance */ 25834ae72a1eSTejun Heo tries[dev->devno] = min(tries[dev->devno], 1); 2584c6fd2807SJeff Garzik case -EIO: 25854ae72a1eSTejun Heo if (tries[dev->devno] == 1) { 25864ae72a1eSTejun Heo /* This is the last chance, better to slow 25874ae72a1eSTejun Heo * down than lose it. 25884ae72a1eSTejun Heo */ 2589936fd732STejun Heo sata_down_spd_limit(&ap->link); 25904ae72a1eSTejun Heo ata_down_xfermask_limit(dev, ATA_DNXFER_PIO); 25914ae72a1eSTejun Heo } 2592c6fd2807SJeff Garzik } 2593c6fd2807SJeff Garzik 25944ae72a1eSTejun Heo if (!tries[dev->devno]) 2595c6fd2807SJeff Garzik ata_dev_disable(dev); 2596c6fd2807SJeff Garzik 2597c6fd2807SJeff Garzik goto retry; 2598c6fd2807SJeff Garzik } 2599c6fd2807SJeff Garzik 2600c6fd2807SJeff Garzik /** 2601c6fd2807SJeff Garzik * ata_port_probe - Mark port as enabled 2602c6fd2807SJeff Garzik * @ap: Port for which we indicate enablement 2603c6fd2807SJeff Garzik * 2604c6fd2807SJeff Garzik * Modify @ap data structure such that the system 2605c6fd2807SJeff Garzik * thinks that the entire port is enabled. 2606c6fd2807SJeff Garzik * 2607cca3974eSJeff Garzik * LOCKING: host lock, or some other form of 2608c6fd2807SJeff Garzik * serialization. 2609c6fd2807SJeff Garzik */ 2610c6fd2807SJeff Garzik 2611c6fd2807SJeff Garzik void ata_port_probe(struct ata_port *ap) 2612c6fd2807SJeff Garzik { 2613c6fd2807SJeff Garzik ap->flags &= ~ATA_FLAG_DISABLED; 2614c6fd2807SJeff Garzik } 2615c6fd2807SJeff Garzik 2616c6fd2807SJeff Garzik /** 2617c6fd2807SJeff Garzik * sata_print_link_status - Print SATA link status 2618936fd732STejun Heo * @link: SATA link to printk link status about 2619c6fd2807SJeff Garzik * 2620c6fd2807SJeff Garzik * This function prints link speed and status of a SATA link. 2621c6fd2807SJeff Garzik * 2622c6fd2807SJeff Garzik * LOCKING: 2623c6fd2807SJeff Garzik * None. 2624c6fd2807SJeff Garzik */ 26256bdb4fc9SAdrian Bunk static void sata_print_link_status(struct ata_link *link) 2626c6fd2807SJeff Garzik { 2627c6fd2807SJeff Garzik u32 sstatus, scontrol, tmp; 2628c6fd2807SJeff Garzik 2629936fd732STejun Heo if (sata_scr_read(link, SCR_STATUS, &sstatus)) 2630c6fd2807SJeff Garzik return; 2631936fd732STejun Heo sata_scr_read(link, SCR_CONTROL, &scontrol); 2632c6fd2807SJeff Garzik 2633936fd732STejun Heo if (ata_link_online(link)) { 2634c6fd2807SJeff Garzik tmp = (sstatus >> 4) & 0xf; 2635936fd732STejun Heo ata_link_printk(link, KERN_INFO, 2636c6fd2807SJeff Garzik "SATA link up %s (SStatus %X SControl %X)\n", 2637c6fd2807SJeff Garzik sata_spd_string(tmp), sstatus, scontrol); 2638c6fd2807SJeff Garzik } else { 2639936fd732STejun Heo ata_link_printk(link, KERN_INFO, 2640c6fd2807SJeff Garzik "SATA link down (SStatus %X SControl %X)\n", 2641c6fd2807SJeff Garzik sstatus, scontrol); 2642c6fd2807SJeff Garzik } 2643c6fd2807SJeff Garzik } 2644c6fd2807SJeff Garzik 2645c6fd2807SJeff Garzik /** 2646c6fd2807SJeff Garzik * ata_dev_pair - return other device on cable 2647c6fd2807SJeff Garzik * @adev: device 2648c6fd2807SJeff Garzik * 2649c6fd2807SJeff Garzik * Obtain the other device on the same cable, or if none is 2650c6fd2807SJeff Garzik * present NULL is returned 2651c6fd2807SJeff Garzik */ 2652c6fd2807SJeff Garzik 2653c6fd2807SJeff Garzik struct ata_device *ata_dev_pair(struct ata_device *adev) 2654c6fd2807SJeff Garzik { 26559af5c9c9STejun Heo struct ata_link *link = adev->link; 26569af5c9c9STejun Heo struct ata_device *pair = &link->device[1 - adev->devno]; 2657c6fd2807SJeff Garzik if (!ata_dev_enabled(pair)) 2658c6fd2807SJeff Garzik return NULL; 2659c6fd2807SJeff Garzik return pair; 2660c6fd2807SJeff Garzik } 2661c6fd2807SJeff Garzik 2662c6fd2807SJeff Garzik /** 2663c6fd2807SJeff Garzik * ata_port_disable - Disable port. 2664c6fd2807SJeff Garzik * @ap: Port to be disabled. 2665c6fd2807SJeff Garzik * 2666c6fd2807SJeff Garzik * Modify @ap data structure such that the system 2667c6fd2807SJeff Garzik * thinks that the entire port is disabled, and should 2668c6fd2807SJeff Garzik * never attempt to probe or communicate with devices 2669c6fd2807SJeff Garzik * on this port. 2670c6fd2807SJeff Garzik * 2671cca3974eSJeff Garzik * LOCKING: host lock, or some other form of 2672c6fd2807SJeff Garzik * serialization. 2673c6fd2807SJeff Garzik */ 2674c6fd2807SJeff Garzik 2675c6fd2807SJeff Garzik void ata_port_disable(struct ata_port *ap) 2676c6fd2807SJeff Garzik { 26779af5c9c9STejun Heo ap->link.device[0].class = ATA_DEV_NONE; 26789af5c9c9STejun Heo ap->link.device[1].class = ATA_DEV_NONE; 2679c6fd2807SJeff Garzik ap->flags |= ATA_FLAG_DISABLED; 2680c6fd2807SJeff Garzik } 2681c6fd2807SJeff Garzik 2682c6fd2807SJeff Garzik /** 2683c6fd2807SJeff Garzik * sata_down_spd_limit - adjust SATA spd limit downward 2684936fd732STejun Heo * @link: Link to adjust SATA spd limit for 2685c6fd2807SJeff Garzik * 2686936fd732STejun Heo * Adjust SATA spd limit of @link downward. Note that this 2687c6fd2807SJeff Garzik * function only adjusts the limit. The change must be applied 2688c6fd2807SJeff Garzik * using sata_set_spd(). 2689c6fd2807SJeff Garzik * 2690c6fd2807SJeff Garzik * LOCKING: 2691c6fd2807SJeff Garzik * Inherited from caller. 2692c6fd2807SJeff Garzik * 2693c6fd2807SJeff Garzik * RETURNS: 2694c6fd2807SJeff Garzik * 0 on success, negative errno on failure 2695c6fd2807SJeff Garzik */ 2696936fd732STejun Heo int sata_down_spd_limit(struct ata_link *link) 2697c6fd2807SJeff Garzik { 2698c6fd2807SJeff Garzik u32 sstatus, spd, mask; 2699c6fd2807SJeff Garzik int rc, highbit; 2700c6fd2807SJeff Garzik 2701936fd732STejun Heo if (!sata_scr_valid(link)) 2702008a7896STejun Heo return -EOPNOTSUPP; 2703008a7896STejun Heo 2704008a7896STejun Heo /* If SCR can be read, use it to determine the current SPD. 2705936fd732STejun Heo * If not, use cached value in link->sata_spd. 2706008a7896STejun Heo */ 2707936fd732STejun Heo rc = sata_scr_read(link, SCR_STATUS, &sstatus); 2708008a7896STejun Heo if (rc == 0) 2709008a7896STejun Heo spd = (sstatus >> 4) & 0xf; 2710008a7896STejun Heo else 2711936fd732STejun Heo spd = link->sata_spd; 2712c6fd2807SJeff Garzik 2713936fd732STejun Heo mask = link->sata_spd_limit; 2714c6fd2807SJeff Garzik if (mask <= 1) 2715c6fd2807SJeff Garzik return -EINVAL; 2716008a7896STejun Heo 2717008a7896STejun Heo /* unconditionally mask off the highest bit */ 2718c6fd2807SJeff Garzik highbit = fls(mask) - 1; 2719c6fd2807SJeff Garzik mask &= ~(1 << highbit); 2720c6fd2807SJeff Garzik 2721008a7896STejun Heo /* Mask off all speeds higher than or equal to the current 2722008a7896STejun Heo * one. Force 1.5Gbps if current SPD is not available. 2723008a7896STejun Heo */ 2724008a7896STejun Heo if (spd > 1) 2725008a7896STejun Heo mask &= (1 << (spd - 1)) - 1; 2726008a7896STejun Heo else 2727008a7896STejun Heo mask &= 1; 2728008a7896STejun Heo 2729008a7896STejun Heo /* were we already at the bottom? */ 2730c6fd2807SJeff Garzik if (!mask) 2731c6fd2807SJeff Garzik return -EINVAL; 2732c6fd2807SJeff Garzik 2733936fd732STejun Heo link->sata_spd_limit = mask; 2734c6fd2807SJeff Garzik 2735936fd732STejun Heo ata_link_printk(link, KERN_WARNING, "limiting SATA link speed to %s\n", 2736c6fd2807SJeff Garzik sata_spd_string(fls(mask))); 2737c6fd2807SJeff Garzik 2738c6fd2807SJeff Garzik return 0; 2739c6fd2807SJeff Garzik } 2740c6fd2807SJeff Garzik 2741936fd732STejun Heo static int __sata_set_spd_needed(struct ata_link *link, u32 *scontrol) 2742c6fd2807SJeff Garzik { 27435270222fSTejun Heo struct ata_link *host_link = &link->ap->link; 27445270222fSTejun Heo u32 limit, target, spd; 2745c6fd2807SJeff Garzik 27465270222fSTejun Heo limit = link->sata_spd_limit; 27475270222fSTejun Heo 27485270222fSTejun Heo /* Don't configure downstream link faster than upstream link. 27495270222fSTejun Heo * It doesn't speed up anything and some PMPs choke on such 27505270222fSTejun Heo * configuration. 27515270222fSTejun Heo */ 27525270222fSTejun Heo if (!ata_is_host_link(link) && host_link->sata_spd) 27535270222fSTejun Heo limit &= (1 << host_link->sata_spd) - 1; 27545270222fSTejun Heo 27555270222fSTejun Heo if (limit == UINT_MAX) 27565270222fSTejun Heo target = 0; 2757c6fd2807SJeff Garzik else 27585270222fSTejun Heo target = fls(limit); 2759c6fd2807SJeff Garzik 2760c6fd2807SJeff Garzik spd = (*scontrol >> 4) & 0xf; 27615270222fSTejun Heo *scontrol = (*scontrol & ~0xf0) | ((target & 0xf) << 4); 2762c6fd2807SJeff Garzik 27635270222fSTejun Heo return spd != target; 2764c6fd2807SJeff Garzik } 2765c6fd2807SJeff Garzik 2766c6fd2807SJeff Garzik /** 2767c6fd2807SJeff Garzik * sata_set_spd_needed - is SATA spd configuration needed 2768936fd732STejun Heo * @link: Link in question 2769c6fd2807SJeff Garzik * 2770c6fd2807SJeff Garzik * Test whether the spd limit in SControl matches 2771936fd732STejun Heo * @link->sata_spd_limit. This function is used to determine 2772c6fd2807SJeff Garzik * whether hardreset is necessary to apply SATA spd 2773c6fd2807SJeff Garzik * configuration. 2774c6fd2807SJeff Garzik * 2775c6fd2807SJeff Garzik * LOCKING: 2776c6fd2807SJeff Garzik * Inherited from caller. 2777c6fd2807SJeff Garzik * 2778c6fd2807SJeff Garzik * RETURNS: 2779c6fd2807SJeff Garzik * 1 if SATA spd configuration is needed, 0 otherwise. 2780c6fd2807SJeff Garzik */ 27811dc55e87SAdrian Bunk static int sata_set_spd_needed(struct ata_link *link) 2782c6fd2807SJeff Garzik { 2783c6fd2807SJeff Garzik u32 scontrol; 2784c6fd2807SJeff Garzik 2785936fd732STejun Heo if (sata_scr_read(link, SCR_CONTROL, &scontrol)) 2786db64bcf3STejun Heo return 1; 2787c6fd2807SJeff Garzik 2788936fd732STejun Heo return __sata_set_spd_needed(link, &scontrol); 2789c6fd2807SJeff Garzik } 2790c6fd2807SJeff Garzik 2791c6fd2807SJeff Garzik /** 2792c6fd2807SJeff Garzik * sata_set_spd - set SATA spd according to spd limit 2793936fd732STejun Heo * @link: Link to set SATA spd for 2794c6fd2807SJeff Garzik * 2795936fd732STejun Heo * Set SATA spd of @link according to sata_spd_limit. 2796c6fd2807SJeff Garzik * 2797c6fd2807SJeff Garzik * LOCKING: 2798c6fd2807SJeff Garzik * Inherited from caller. 2799c6fd2807SJeff Garzik * 2800c6fd2807SJeff Garzik * RETURNS: 2801c6fd2807SJeff Garzik * 0 if spd doesn't need to be changed, 1 if spd has been 2802c6fd2807SJeff Garzik * changed. Negative errno if SCR registers are inaccessible. 2803c6fd2807SJeff Garzik */ 2804936fd732STejun Heo int sata_set_spd(struct ata_link *link) 2805c6fd2807SJeff Garzik { 2806c6fd2807SJeff Garzik u32 scontrol; 2807c6fd2807SJeff Garzik int rc; 2808c6fd2807SJeff Garzik 2809936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 2810c6fd2807SJeff Garzik return rc; 2811c6fd2807SJeff Garzik 2812936fd732STejun Heo if (!__sata_set_spd_needed(link, &scontrol)) 2813c6fd2807SJeff Garzik return 0; 2814c6fd2807SJeff Garzik 2815936fd732STejun Heo if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol))) 2816c6fd2807SJeff Garzik return rc; 2817c6fd2807SJeff Garzik 2818c6fd2807SJeff Garzik return 1; 2819c6fd2807SJeff Garzik } 2820c6fd2807SJeff Garzik 2821c6fd2807SJeff Garzik /* 2822c6fd2807SJeff Garzik * This mode timing computation functionality is ported over from 2823c6fd2807SJeff Garzik * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik 2824c6fd2807SJeff Garzik */ 2825c6fd2807SJeff Garzik /* 2826b352e57dSAlan Cox * PIO 0-4, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds). 2827c6fd2807SJeff Garzik * These were taken from ATA/ATAPI-6 standard, rev 0a, except 2828b352e57dSAlan Cox * for UDMA6, which is currently supported only by Maxtor drives. 2829b352e57dSAlan Cox * 2830b352e57dSAlan Cox * For PIO 5/6 MWDMA 3/4 see the CFA specification 3.0. 2831c6fd2807SJeff Garzik */ 2832c6fd2807SJeff Garzik 2833c6fd2807SJeff Garzik static const struct ata_timing ata_timing[] = { 283470cd071eSTejun Heo /* { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960, 0 }, */ 283570cd071eSTejun Heo { XFER_PIO_0, 70, 290, 240, 600, 165, 150, 600, 0 }, 283670cd071eSTejun Heo { XFER_PIO_1, 50, 290, 93, 383, 125, 100, 383, 0 }, 283770cd071eSTejun Heo { XFER_PIO_2, 30, 290, 40, 330, 100, 90, 240, 0 }, 283870cd071eSTejun Heo { XFER_PIO_3, 30, 80, 70, 180, 80, 70, 180, 0 }, 283970cd071eSTejun Heo { XFER_PIO_4, 25, 70, 25, 120, 70, 25, 120, 0 }, 284070cd071eSTejun Heo { XFER_PIO_5, 15, 65, 25, 100, 65, 25, 100, 0 }, 284170cd071eSTejun Heo { XFER_PIO_6, 10, 55, 20, 80, 55, 20, 80, 0 }, 2842c6fd2807SJeff Garzik 284370cd071eSTejun Heo { XFER_SW_DMA_0, 120, 0, 0, 0, 480, 480, 960, 0 }, 284470cd071eSTejun Heo { XFER_SW_DMA_1, 90, 0, 0, 0, 240, 240, 480, 0 }, 284570cd071eSTejun Heo { XFER_SW_DMA_2, 60, 0, 0, 0, 120, 120, 240, 0 }, 2846c6fd2807SJeff Garzik 284770cd071eSTejun Heo { XFER_MW_DMA_0, 60, 0, 0, 0, 215, 215, 480, 0 }, 284870cd071eSTejun Heo { XFER_MW_DMA_1, 45, 0, 0, 0, 80, 50, 150, 0 }, 284970cd071eSTejun Heo { XFER_MW_DMA_2, 25, 0, 0, 0, 70, 25, 120, 0 }, 2850b352e57dSAlan Cox { XFER_MW_DMA_3, 25, 0, 0, 0, 65, 25, 100, 0 }, 285170cd071eSTejun Heo { XFER_MW_DMA_4, 25, 0, 0, 0, 55, 20, 80, 0 }, 2852c6fd2807SJeff Garzik 2853c6fd2807SJeff Garzik /* { XFER_UDMA_SLOW, 0, 0, 0, 0, 0, 0, 0, 150 }, */ 285470cd071eSTejun Heo { XFER_UDMA_0, 0, 0, 0, 0, 0, 0, 0, 120 }, 285570cd071eSTejun Heo { XFER_UDMA_1, 0, 0, 0, 0, 0, 0, 0, 80 }, 285670cd071eSTejun Heo { XFER_UDMA_2, 0, 0, 0, 0, 0, 0, 0, 60 }, 285770cd071eSTejun Heo { XFER_UDMA_3, 0, 0, 0, 0, 0, 0, 0, 45 }, 285870cd071eSTejun Heo { XFER_UDMA_4, 0, 0, 0, 0, 0, 0, 0, 30 }, 285970cd071eSTejun Heo { XFER_UDMA_5, 0, 0, 0, 0, 0, 0, 0, 20 }, 286070cd071eSTejun Heo { XFER_UDMA_6, 0, 0, 0, 0, 0, 0, 0, 15 }, 2861c6fd2807SJeff Garzik 2862c6fd2807SJeff Garzik { 0xFF } 2863c6fd2807SJeff Garzik }; 2864c6fd2807SJeff Garzik 2865c6fd2807SJeff Garzik #define ENOUGH(v, unit) (((v)-1)/(unit)+1) 2866c6fd2807SJeff Garzik #define EZ(v, unit) ((v)?ENOUGH(v, unit):0) 2867c6fd2807SJeff Garzik 2868c6fd2807SJeff Garzik static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT) 2869c6fd2807SJeff Garzik { 2870c6fd2807SJeff Garzik q->setup = EZ(t->setup * 1000, T); 2871c6fd2807SJeff Garzik q->act8b = EZ(t->act8b * 1000, T); 2872c6fd2807SJeff Garzik q->rec8b = EZ(t->rec8b * 1000, T); 2873c6fd2807SJeff Garzik q->cyc8b = EZ(t->cyc8b * 1000, T); 2874c6fd2807SJeff Garzik q->active = EZ(t->active * 1000, T); 2875c6fd2807SJeff Garzik q->recover = EZ(t->recover * 1000, T); 2876c6fd2807SJeff Garzik q->cycle = EZ(t->cycle * 1000, T); 2877c6fd2807SJeff Garzik q->udma = EZ(t->udma * 1000, UT); 2878c6fd2807SJeff Garzik } 2879c6fd2807SJeff Garzik 2880c6fd2807SJeff Garzik void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b, 2881c6fd2807SJeff Garzik struct ata_timing *m, unsigned int what) 2882c6fd2807SJeff Garzik { 2883c6fd2807SJeff Garzik if (what & ATA_TIMING_SETUP ) m->setup = max(a->setup, b->setup); 2884c6fd2807SJeff Garzik if (what & ATA_TIMING_ACT8B ) m->act8b = max(a->act8b, b->act8b); 2885c6fd2807SJeff Garzik if (what & ATA_TIMING_REC8B ) m->rec8b = max(a->rec8b, b->rec8b); 2886c6fd2807SJeff Garzik if (what & ATA_TIMING_CYC8B ) m->cyc8b = max(a->cyc8b, b->cyc8b); 2887c6fd2807SJeff Garzik if (what & ATA_TIMING_ACTIVE ) m->active = max(a->active, b->active); 2888c6fd2807SJeff Garzik if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover); 2889c6fd2807SJeff Garzik if (what & ATA_TIMING_CYCLE ) m->cycle = max(a->cycle, b->cycle); 2890c6fd2807SJeff Garzik if (what & ATA_TIMING_UDMA ) m->udma = max(a->udma, b->udma); 2891c6fd2807SJeff Garzik } 2892c6fd2807SJeff Garzik 28936357357cSTejun Heo const struct ata_timing *ata_timing_find_mode(u8 xfer_mode) 2894c6fd2807SJeff Garzik { 289570cd071eSTejun Heo const struct ata_timing *t = ata_timing; 2896c6fd2807SJeff Garzik 289770cd071eSTejun Heo while (xfer_mode > t->mode) 289870cd071eSTejun Heo t++; 289970cd071eSTejun Heo 290070cd071eSTejun Heo if (xfer_mode == t->mode) 2901c6fd2807SJeff Garzik return t; 290270cd071eSTejun Heo return NULL; 2903c6fd2807SJeff Garzik } 2904c6fd2807SJeff Garzik 2905c6fd2807SJeff Garzik int ata_timing_compute(struct ata_device *adev, unsigned short speed, 2906c6fd2807SJeff Garzik struct ata_timing *t, int T, int UT) 2907c6fd2807SJeff Garzik { 2908c6fd2807SJeff Garzik const struct ata_timing *s; 2909c6fd2807SJeff Garzik struct ata_timing p; 2910c6fd2807SJeff Garzik 2911c6fd2807SJeff Garzik /* 2912c6fd2807SJeff Garzik * Find the mode. 2913c6fd2807SJeff Garzik */ 2914c6fd2807SJeff Garzik 2915c6fd2807SJeff Garzik if (!(s = ata_timing_find_mode(speed))) 2916c6fd2807SJeff Garzik return -EINVAL; 2917c6fd2807SJeff Garzik 2918c6fd2807SJeff Garzik memcpy(t, s, sizeof(*s)); 2919c6fd2807SJeff Garzik 2920c6fd2807SJeff Garzik /* 2921c6fd2807SJeff Garzik * If the drive is an EIDE drive, it can tell us it needs extended 2922c6fd2807SJeff Garzik * PIO/MW_DMA cycle timing. 2923c6fd2807SJeff Garzik */ 2924c6fd2807SJeff Garzik 2925c6fd2807SJeff Garzik if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */ 2926c6fd2807SJeff Garzik memset(&p, 0, sizeof(p)); 2927c6fd2807SJeff Garzik if (speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) { 2928c6fd2807SJeff Garzik if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO]; 2929c6fd2807SJeff Garzik else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY]; 2930c6fd2807SJeff Garzik } else if (speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) { 2931c6fd2807SJeff Garzik p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN]; 2932c6fd2807SJeff Garzik } 2933c6fd2807SJeff Garzik ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B); 2934c6fd2807SJeff Garzik } 2935c6fd2807SJeff Garzik 2936c6fd2807SJeff Garzik /* 2937c6fd2807SJeff Garzik * Convert the timing to bus clock counts. 2938c6fd2807SJeff Garzik */ 2939c6fd2807SJeff Garzik 2940c6fd2807SJeff Garzik ata_timing_quantize(t, t, T, UT); 2941c6fd2807SJeff Garzik 2942c6fd2807SJeff Garzik /* 2943c6fd2807SJeff Garzik * Even in DMA/UDMA modes we still use PIO access for IDENTIFY, 2944c6fd2807SJeff Garzik * S.M.A.R.T * and some other commands. We have to ensure that the 2945c6fd2807SJeff Garzik * DMA cycle timing is slower/equal than the fastest PIO timing. 2946c6fd2807SJeff Garzik */ 2947c6fd2807SJeff Garzik 2948fd3367afSAlan if (speed > XFER_PIO_6) { 2949c6fd2807SJeff Garzik ata_timing_compute(adev, adev->pio_mode, &p, T, UT); 2950c6fd2807SJeff Garzik ata_timing_merge(&p, t, t, ATA_TIMING_ALL); 2951c6fd2807SJeff Garzik } 2952c6fd2807SJeff Garzik 2953c6fd2807SJeff Garzik /* 2954c6fd2807SJeff Garzik * Lengthen active & recovery time so that cycle time is correct. 2955c6fd2807SJeff Garzik */ 2956c6fd2807SJeff Garzik 2957c6fd2807SJeff Garzik if (t->act8b + t->rec8b < t->cyc8b) { 2958c6fd2807SJeff Garzik t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2; 2959c6fd2807SJeff Garzik t->rec8b = t->cyc8b - t->act8b; 2960c6fd2807SJeff Garzik } 2961c6fd2807SJeff Garzik 2962c6fd2807SJeff Garzik if (t->active + t->recover < t->cycle) { 2963c6fd2807SJeff Garzik t->active += (t->cycle - (t->active + t->recover)) / 2; 2964c6fd2807SJeff Garzik t->recover = t->cycle - t->active; 2965c6fd2807SJeff Garzik } 29664f701d1eSAlan Cox 29674f701d1eSAlan Cox /* In a few cases quantisation may produce enough errors to 29684f701d1eSAlan Cox leave t->cycle too low for the sum of active and recovery 29694f701d1eSAlan Cox if so we must correct this */ 29704f701d1eSAlan Cox if (t->active + t->recover > t->cycle) 29714f701d1eSAlan Cox t->cycle = t->active + t->recover; 2972c6fd2807SJeff Garzik 2973c6fd2807SJeff Garzik return 0; 2974c6fd2807SJeff Garzik } 2975c6fd2807SJeff Garzik 2976c6fd2807SJeff Garzik /** 2977a0f79b92STejun Heo * ata_timing_cycle2mode - find xfer mode for the specified cycle duration 2978a0f79b92STejun Heo * @xfer_shift: ATA_SHIFT_* value for transfer type to examine. 2979a0f79b92STejun Heo * @cycle: cycle duration in ns 2980a0f79b92STejun Heo * 2981a0f79b92STejun Heo * Return matching xfer mode for @cycle. The returned mode is of 2982a0f79b92STejun Heo * the transfer type specified by @xfer_shift. If @cycle is too 2983a0f79b92STejun Heo * slow for @xfer_shift, 0xff is returned. If @cycle is faster 2984a0f79b92STejun Heo * than the fastest known mode, the fasted mode is returned. 2985a0f79b92STejun Heo * 2986a0f79b92STejun Heo * LOCKING: 2987a0f79b92STejun Heo * None. 2988a0f79b92STejun Heo * 2989a0f79b92STejun Heo * RETURNS: 2990a0f79b92STejun Heo * Matching xfer_mode, 0xff if no match found. 2991a0f79b92STejun Heo */ 2992a0f79b92STejun Heo u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle) 2993a0f79b92STejun Heo { 2994a0f79b92STejun Heo u8 base_mode = 0xff, last_mode = 0xff; 2995a0f79b92STejun Heo const struct ata_xfer_ent *ent; 2996a0f79b92STejun Heo const struct ata_timing *t; 2997a0f79b92STejun Heo 2998a0f79b92STejun Heo for (ent = ata_xfer_tbl; ent->shift >= 0; ent++) 2999a0f79b92STejun Heo if (ent->shift == xfer_shift) 3000a0f79b92STejun Heo base_mode = ent->base; 3001a0f79b92STejun Heo 3002a0f79b92STejun Heo for (t = ata_timing_find_mode(base_mode); 3003a0f79b92STejun Heo t && ata_xfer_mode2shift(t->mode) == xfer_shift; t++) { 3004a0f79b92STejun Heo unsigned short this_cycle; 3005a0f79b92STejun Heo 3006a0f79b92STejun Heo switch (xfer_shift) { 3007a0f79b92STejun Heo case ATA_SHIFT_PIO: 3008a0f79b92STejun Heo case ATA_SHIFT_MWDMA: 3009a0f79b92STejun Heo this_cycle = t->cycle; 3010a0f79b92STejun Heo break; 3011a0f79b92STejun Heo case ATA_SHIFT_UDMA: 3012a0f79b92STejun Heo this_cycle = t->udma; 3013a0f79b92STejun Heo break; 3014a0f79b92STejun Heo default: 3015a0f79b92STejun Heo return 0xff; 3016a0f79b92STejun Heo } 3017a0f79b92STejun Heo 3018a0f79b92STejun Heo if (cycle > this_cycle) 3019a0f79b92STejun Heo break; 3020a0f79b92STejun Heo 3021a0f79b92STejun Heo last_mode = t->mode; 3022a0f79b92STejun Heo } 3023a0f79b92STejun Heo 3024a0f79b92STejun Heo return last_mode; 3025a0f79b92STejun Heo } 3026a0f79b92STejun Heo 3027a0f79b92STejun Heo /** 3028c6fd2807SJeff Garzik * ata_down_xfermask_limit - adjust dev xfer masks downward 3029c6fd2807SJeff Garzik * @dev: Device to adjust xfer masks 3030458337dbSTejun Heo * @sel: ATA_DNXFER_* selector 3031c6fd2807SJeff Garzik * 3032c6fd2807SJeff Garzik * Adjust xfer masks of @dev downward. Note that this function 3033c6fd2807SJeff Garzik * does not apply the change. Invoking ata_set_mode() afterwards 3034c6fd2807SJeff Garzik * will apply the limit. 3035c6fd2807SJeff Garzik * 3036c6fd2807SJeff Garzik * LOCKING: 3037c6fd2807SJeff Garzik * Inherited from caller. 3038c6fd2807SJeff Garzik * 3039c6fd2807SJeff Garzik * RETURNS: 3040c6fd2807SJeff Garzik * 0 on success, negative errno on failure 3041c6fd2807SJeff Garzik */ 3042458337dbSTejun Heo int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel) 3043c6fd2807SJeff Garzik { 3044458337dbSTejun Heo char buf[32]; 30457dc951aeSTejun Heo unsigned long orig_mask, xfer_mask; 30467dc951aeSTejun Heo unsigned long pio_mask, mwdma_mask, udma_mask; 3047458337dbSTejun Heo int quiet, highbit; 3048c6fd2807SJeff Garzik 3049458337dbSTejun Heo quiet = !!(sel & ATA_DNXFER_QUIET); 3050458337dbSTejun Heo sel &= ~ATA_DNXFER_QUIET; 3051458337dbSTejun Heo 3052458337dbSTejun Heo xfer_mask = orig_mask = ata_pack_xfermask(dev->pio_mask, 3053458337dbSTejun Heo dev->mwdma_mask, 3054c6fd2807SJeff Garzik dev->udma_mask); 3055458337dbSTejun Heo ata_unpack_xfermask(xfer_mask, &pio_mask, &mwdma_mask, &udma_mask); 3056c6fd2807SJeff Garzik 3057458337dbSTejun Heo switch (sel) { 3058458337dbSTejun Heo case ATA_DNXFER_PIO: 3059458337dbSTejun Heo highbit = fls(pio_mask) - 1; 3060458337dbSTejun Heo pio_mask &= ~(1 << highbit); 3061458337dbSTejun Heo break; 3062458337dbSTejun Heo 3063458337dbSTejun Heo case ATA_DNXFER_DMA: 3064458337dbSTejun Heo if (udma_mask) { 3065458337dbSTejun Heo highbit = fls(udma_mask) - 1; 3066458337dbSTejun Heo udma_mask &= ~(1 << highbit); 3067458337dbSTejun Heo if (!udma_mask) 3068458337dbSTejun Heo return -ENOENT; 3069458337dbSTejun Heo } else if (mwdma_mask) { 3070458337dbSTejun Heo highbit = fls(mwdma_mask) - 1; 3071458337dbSTejun Heo mwdma_mask &= ~(1 << highbit); 3072458337dbSTejun Heo if (!mwdma_mask) 3073458337dbSTejun Heo return -ENOENT; 3074458337dbSTejun Heo } 3075458337dbSTejun Heo break; 3076458337dbSTejun Heo 3077458337dbSTejun Heo case ATA_DNXFER_40C: 3078458337dbSTejun Heo udma_mask &= ATA_UDMA_MASK_40C; 3079458337dbSTejun Heo break; 3080458337dbSTejun Heo 3081458337dbSTejun Heo case ATA_DNXFER_FORCE_PIO0: 3082458337dbSTejun Heo pio_mask &= 1; 3083458337dbSTejun Heo case ATA_DNXFER_FORCE_PIO: 3084458337dbSTejun Heo mwdma_mask = 0; 3085458337dbSTejun Heo udma_mask = 0; 3086458337dbSTejun Heo break; 3087458337dbSTejun Heo 3088458337dbSTejun Heo default: 3089458337dbSTejun Heo BUG(); 3090458337dbSTejun Heo } 3091458337dbSTejun Heo 3092458337dbSTejun Heo xfer_mask &= ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask); 3093458337dbSTejun Heo 3094458337dbSTejun Heo if (!(xfer_mask & ATA_MASK_PIO) || xfer_mask == orig_mask) 3095458337dbSTejun Heo return -ENOENT; 3096458337dbSTejun Heo 3097458337dbSTejun Heo if (!quiet) { 3098458337dbSTejun Heo if (xfer_mask & (ATA_MASK_MWDMA | ATA_MASK_UDMA)) 3099458337dbSTejun Heo snprintf(buf, sizeof(buf), "%s:%s", 3100458337dbSTejun Heo ata_mode_string(xfer_mask), 3101458337dbSTejun Heo ata_mode_string(xfer_mask & ATA_MASK_PIO)); 3102458337dbSTejun Heo else 3103458337dbSTejun Heo snprintf(buf, sizeof(buf), "%s", 3104458337dbSTejun Heo ata_mode_string(xfer_mask)); 3105458337dbSTejun Heo 3106458337dbSTejun Heo ata_dev_printk(dev, KERN_WARNING, 3107458337dbSTejun Heo "limiting speed to %s\n", buf); 3108458337dbSTejun Heo } 3109c6fd2807SJeff Garzik 3110c6fd2807SJeff Garzik ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask, 3111c6fd2807SJeff Garzik &dev->udma_mask); 3112c6fd2807SJeff Garzik 3113c6fd2807SJeff Garzik return 0; 3114c6fd2807SJeff Garzik } 3115c6fd2807SJeff Garzik 3116c6fd2807SJeff Garzik static int ata_dev_set_mode(struct ata_device *dev) 3117c6fd2807SJeff Garzik { 31189af5c9c9STejun Heo struct ata_eh_context *ehc = &dev->link->eh_context; 31194055dee7STejun Heo const char *dev_err_whine = ""; 31204055dee7STejun Heo int ign_dev_err = 0; 3121c6fd2807SJeff Garzik unsigned int err_mask; 3122c6fd2807SJeff Garzik int rc; 3123c6fd2807SJeff Garzik 3124c6fd2807SJeff Garzik dev->flags &= ~ATA_DFLAG_PIO; 3125c6fd2807SJeff Garzik if (dev->xfer_shift == ATA_SHIFT_PIO) 3126c6fd2807SJeff Garzik dev->flags |= ATA_DFLAG_PIO; 3127c6fd2807SJeff Garzik 3128c6fd2807SJeff Garzik err_mask = ata_dev_set_xfermode(dev); 31292dcb407eSJeff Garzik 31304055dee7STejun Heo if (err_mask & ~AC_ERR_DEV) 31314055dee7STejun Heo goto fail; 31322dcb407eSJeff Garzik 31334055dee7STejun Heo /* revalidate */ 3134baa1e78aSTejun Heo ehc->i.flags |= ATA_EHI_POST_SETMODE; 3135422c9daaSTejun Heo rc = ata_dev_revalidate(dev, ATA_DEV_UNKNOWN, 0); 3136baa1e78aSTejun Heo ehc->i.flags &= ~ATA_EHI_POST_SETMODE; 3137c6fd2807SJeff Garzik if (rc) 3138c6fd2807SJeff Garzik return rc; 3139c6fd2807SJeff Garzik 3140b93fda12SAlan Cox if (dev->xfer_shift == ATA_SHIFT_PIO) { 31414055dee7STejun Heo /* Old CFA may refuse this command, which is just fine */ 3142b93fda12SAlan Cox if (ata_id_is_cfa(dev->id)) 31434055dee7STejun Heo ign_dev_err = 1; 3144b93fda12SAlan Cox /* Catch several broken garbage emulations plus some pre 3145b93fda12SAlan Cox ATA devices */ 3146b93fda12SAlan Cox if (ata_id_major_version(dev->id) == 0 && 31474055dee7STejun Heo dev->pio_mode <= XFER_PIO_2) 31484055dee7STejun Heo ign_dev_err = 1; 3149b93fda12SAlan Cox /* Some very old devices and some bad newer ones fail 3150b93fda12SAlan Cox any kind of SET_XFERMODE request but support PIO0-2 3151b93fda12SAlan Cox timings and no IORDY */ 3152b93fda12SAlan Cox if (!ata_id_has_iordy(dev->id) && dev->pio_mode <= XFER_PIO_2) 3153b93fda12SAlan Cox ign_dev_err = 1; 3154b93fda12SAlan Cox } 31554055dee7STejun Heo /* Early MWDMA devices do DMA but don't allow DMA mode setting. 31564055dee7STejun Heo Don't fail an MWDMA0 set IFF the device indicates it is in MWDMA0 */ 31574055dee7STejun Heo if (dev->xfer_shift == ATA_SHIFT_MWDMA && 31584055dee7STejun Heo dev->dma_mode == XFER_MW_DMA_0 && 31594055dee7STejun Heo (dev->id[63] >> 8) & 1) 31604055dee7STejun Heo ign_dev_err = 1; 31614055dee7STejun Heo 31624055dee7STejun Heo /* if the device is actually configured correctly, ignore dev err */ 31634055dee7STejun Heo if (dev->xfer_mode == ata_xfer_mask2mode(ata_id_xfermask(dev->id))) 31644055dee7STejun Heo ign_dev_err = 1; 31654055dee7STejun Heo 31664055dee7STejun Heo if (err_mask & AC_ERR_DEV) { 31674055dee7STejun Heo if (!ign_dev_err) 31684055dee7STejun Heo goto fail; 31694055dee7STejun Heo else 31704055dee7STejun Heo dev_err_whine = " (device error ignored)"; 31714055dee7STejun Heo } 31724055dee7STejun Heo 3173c6fd2807SJeff Garzik DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n", 3174c6fd2807SJeff Garzik dev->xfer_shift, (int)dev->xfer_mode); 3175c6fd2807SJeff Garzik 31764055dee7STejun Heo ata_dev_printk(dev, KERN_INFO, "configured for %s%s\n", 31774055dee7STejun Heo ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)), 31784055dee7STejun Heo dev_err_whine); 31794055dee7STejun Heo 3180c6fd2807SJeff Garzik return 0; 31814055dee7STejun Heo 31824055dee7STejun Heo fail: 31834055dee7STejun Heo ata_dev_printk(dev, KERN_ERR, "failed to set xfermode " 31844055dee7STejun Heo "(err_mask=0x%x)\n", err_mask); 31854055dee7STejun Heo return -EIO; 3186c6fd2807SJeff Garzik } 3187c6fd2807SJeff Garzik 3188c6fd2807SJeff Garzik /** 318904351821SAlan * ata_do_set_mode - Program timings and issue SET FEATURES - XFER 31900260731fSTejun Heo * @link: link on which timings will be programmed 31911967b7ffSJoe Perches * @r_failed_dev: out parameter for failed device 3192c6fd2807SJeff Garzik * 319304351821SAlan * Standard implementation of the function used to tune and set 319404351821SAlan * ATA device disk transfer mode (PIO3, UDMA6, etc.). If 319504351821SAlan * ata_dev_set_mode() fails, pointer to the failing device is 3196c6fd2807SJeff Garzik * returned in @r_failed_dev. 3197c6fd2807SJeff Garzik * 3198c6fd2807SJeff Garzik * LOCKING: 3199c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 3200c6fd2807SJeff Garzik * 3201c6fd2807SJeff Garzik * RETURNS: 3202c6fd2807SJeff Garzik * 0 on success, negative errno otherwise 3203c6fd2807SJeff Garzik */ 320404351821SAlan 32050260731fSTejun Heo int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev) 3206c6fd2807SJeff Garzik { 32070260731fSTejun Heo struct ata_port *ap = link->ap; 3208c6fd2807SJeff Garzik struct ata_device *dev; 3209f58229f8STejun Heo int rc = 0, used_dma = 0, found = 0; 3210c6fd2807SJeff Garzik 3211c6fd2807SJeff Garzik /* step 1: calculate xfer_mask */ 3212f58229f8STejun Heo ata_link_for_each_dev(dev, link) { 32137dc951aeSTejun Heo unsigned long pio_mask, dma_mask; 3214b3a70601SAlan Cox unsigned int mode_mask; 3215c6fd2807SJeff Garzik 3216c6fd2807SJeff Garzik if (!ata_dev_enabled(dev)) 3217c6fd2807SJeff Garzik continue; 3218c6fd2807SJeff Garzik 3219b3a70601SAlan Cox mode_mask = ATA_DMA_MASK_ATA; 3220b3a70601SAlan Cox if (dev->class == ATA_DEV_ATAPI) 3221b3a70601SAlan Cox mode_mask = ATA_DMA_MASK_ATAPI; 3222b3a70601SAlan Cox else if (ata_id_is_cfa(dev->id)) 3223b3a70601SAlan Cox mode_mask = ATA_DMA_MASK_CFA; 3224b3a70601SAlan Cox 3225c6fd2807SJeff Garzik ata_dev_xfermask(dev); 322633267325STejun Heo ata_force_xfermask(dev); 3227c6fd2807SJeff Garzik 3228c6fd2807SJeff Garzik pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0); 3229c6fd2807SJeff Garzik dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask); 3230b3a70601SAlan Cox 3231b3a70601SAlan Cox if (libata_dma_mask & mode_mask) 3232b3a70601SAlan Cox dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask); 3233b3a70601SAlan Cox else 3234b3a70601SAlan Cox dma_mask = 0; 3235b3a70601SAlan Cox 3236c6fd2807SJeff Garzik dev->pio_mode = ata_xfer_mask2mode(pio_mask); 3237c6fd2807SJeff Garzik dev->dma_mode = ata_xfer_mask2mode(dma_mask); 3238c6fd2807SJeff Garzik 3239c6fd2807SJeff Garzik found = 1; 324070cd071eSTejun Heo if (dev->dma_mode != 0xff) 3241c6fd2807SJeff Garzik used_dma = 1; 3242c6fd2807SJeff Garzik } 3243c6fd2807SJeff Garzik if (!found) 3244c6fd2807SJeff Garzik goto out; 3245c6fd2807SJeff Garzik 3246c6fd2807SJeff Garzik /* step 2: always set host PIO timings */ 3247f58229f8STejun Heo ata_link_for_each_dev(dev, link) { 3248c6fd2807SJeff Garzik if (!ata_dev_enabled(dev)) 3249c6fd2807SJeff Garzik continue; 3250c6fd2807SJeff Garzik 325170cd071eSTejun Heo if (dev->pio_mode == 0xff) { 3252c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "no PIO support\n"); 3253c6fd2807SJeff Garzik rc = -EINVAL; 3254c6fd2807SJeff Garzik goto out; 3255c6fd2807SJeff Garzik } 3256c6fd2807SJeff Garzik 3257c6fd2807SJeff Garzik dev->xfer_mode = dev->pio_mode; 3258c6fd2807SJeff Garzik dev->xfer_shift = ATA_SHIFT_PIO; 3259c6fd2807SJeff Garzik if (ap->ops->set_piomode) 3260c6fd2807SJeff Garzik ap->ops->set_piomode(ap, dev); 3261c6fd2807SJeff Garzik } 3262c6fd2807SJeff Garzik 3263c6fd2807SJeff Garzik /* step 3: set host DMA timings */ 3264f58229f8STejun Heo ata_link_for_each_dev(dev, link) { 326570cd071eSTejun Heo if (!ata_dev_enabled(dev) || dev->dma_mode == 0xff) 3266c6fd2807SJeff Garzik continue; 3267c6fd2807SJeff Garzik 3268c6fd2807SJeff Garzik dev->xfer_mode = dev->dma_mode; 3269c6fd2807SJeff Garzik dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode); 3270c6fd2807SJeff Garzik if (ap->ops->set_dmamode) 3271c6fd2807SJeff Garzik ap->ops->set_dmamode(ap, dev); 3272c6fd2807SJeff Garzik } 3273c6fd2807SJeff Garzik 3274c6fd2807SJeff Garzik /* step 4: update devices' xfer mode */ 3275f58229f8STejun Heo ata_link_for_each_dev(dev, link) { 327618d90debSAlan /* don't update suspended devices' xfer mode */ 32779666f400STejun Heo if (!ata_dev_enabled(dev)) 3278c6fd2807SJeff Garzik continue; 3279c6fd2807SJeff Garzik 3280c6fd2807SJeff Garzik rc = ata_dev_set_mode(dev); 3281c6fd2807SJeff Garzik if (rc) 3282c6fd2807SJeff Garzik goto out; 3283c6fd2807SJeff Garzik } 3284c6fd2807SJeff Garzik 3285c6fd2807SJeff Garzik /* Record simplex status. If we selected DMA then the other 3286c6fd2807SJeff Garzik * host channels are not permitted to do so. 3287c6fd2807SJeff Garzik */ 3288cca3974eSJeff Garzik if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX)) 3289032af1ceSAlan ap->host->simplex_claimed = ap; 3290c6fd2807SJeff Garzik 3291c6fd2807SJeff Garzik out: 3292c6fd2807SJeff Garzik if (rc) 3293c6fd2807SJeff Garzik *r_failed_dev = dev; 3294c6fd2807SJeff Garzik return rc; 3295c6fd2807SJeff Garzik } 3296c6fd2807SJeff Garzik 3297c6fd2807SJeff Garzik /** 3298aa2731adSTejun Heo * ata_wait_ready - wait for link to become ready 3299aa2731adSTejun Heo * @link: link to be waited on 3300aa2731adSTejun Heo * @deadline: deadline jiffies for the operation 3301aa2731adSTejun Heo * @check_ready: callback to check link readiness 3302aa2731adSTejun Heo * 3303aa2731adSTejun Heo * Wait for @link to become ready. @check_ready should return 3304aa2731adSTejun Heo * positive number if @link is ready, 0 if it isn't, -ENODEV if 3305aa2731adSTejun Heo * link doesn't seem to be occupied, other errno for other error 3306aa2731adSTejun Heo * conditions. 3307aa2731adSTejun Heo * 3308aa2731adSTejun Heo * Transient -ENODEV conditions are allowed for 3309aa2731adSTejun Heo * ATA_TMOUT_FF_WAIT. 3310aa2731adSTejun Heo * 3311aa2731adSTejun Heo * LOCKING: 3312aa2731adSTejun Heo * EH context. 3313aa2731adSTejun Heo * 3314aa2731adSTejun Heo * RETURNS: 3315aa2731adSTejun Heo * 0 if @linke is ready before @deadline; otherwise, -errno. 3316aa2731adSTejun Heo */ 3317aa2731adSTejun Heo int ata_wait_ready(struct ata_link *link, unsigned long deadline, 3318aa2731adSTejun Heo int (*check_ready)(struct ata_link *link)) 3319aa2731adSTejun Heo { 3320aa2731adSTejun Heo unsigned long start = jiffies; 3321341c2c95STejun Heo unsigned long nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT); 3322aa2731adSTejun Heo int warned = 0; 3323aa2731adSTejun Heo 3324aa2731adSTejun Heo if (time_after(nodev_deadline, deadline)) 3325aa2731adSTejun Heo nodev_deadline = deadline; 3326aa2731adSTejun Heo 3327aa2731adSTejun Heo while (1) { 3328aa2731adSTejun Heo unsigned long now = jiffies; 3329aa2731adSTejun Heo int ready, tmp; 3330aa2731adSTejun Heo 3331aa2731adSTejun Heo ready = tmp = check_ready(link); 3332aa2731adSTejun Heo if (ready > 0) 3333aa2731adSTejun Heo return 0; 3334aa2731adSTejun Heo 3335aa2731adSTejun Heo /* -ENODEV could be transient. Ignore -ENODEV if link 3336aa2731adSTejun Heo * is online. Also, some SATA devices take a long 3337aa2731adSTejun Heo * time to clear 0xff after reset. For example, 3338aa2731adSTejun Heo * HHD424020F7SV00 iVDR needs >= 800ms while Quantum 3339aa2731adSTejun Heo * GoVault needs even more than that. Wait for 3340aa2731adSTejun Heo * ATA_TMOUT_FF_WAIT on -ENODEV if link isn't offline. 3341aa2731adSTejun Heo * 3342aa2731adSTejun Heo * Note that some PATA controllers (pata_ali) explode 3343aa2731adSTejun Heo * if status register is read more than once when 3344aa2731adSTejun Heo * there's no device attached. 3345aa2731adSTejun Heo */ 3346aa2731adSTejun Heo if (ready == -ENODEV) { 3347aa2731adSTejun Heo if (ata_link_online(link)) 3348aa2731adSTejun Heo ready = 0; 3349aa2731adSTejun Heo else if ((link->ap->flags & ATA_FLAG_SATA) && 3350aa2731adSTejun Heo !ata_link_offline(link) && 3351aa2731adSTejun Heo time_before(now, nodev_deadline)) 3352aa2731adSTejun Heo ready = 0; 3353aa2731adSTejun Heo } 3354aa2731adSTejun Heo 3355aa2731adSTejun Heo if (ready) 3356aa2731adSTejun Heo return ready; 3357aa2731adSTejun Heo if (time_after(now, deadline)) 3358aa2731adSTejun Heo return -EBUSY; 3359aa2731adSTejun Heo 3360aa2731adSTejun Heo if (!warned && time_after(now, start + 5 * HZ) && 3361aa2731adSTejun Heo (deadline - now > 3 * HZ)) { 3362aa2731adSTejun Heo ata_link_printk(link, KERN_WARNING, 3363aa2731adSTejun Heo "link is slow to respond, please be patient " 3364aa2731adSTejun Heo "(ready=%d)\n", tmp); 3365aa2731adSTejun Heo warned = 1; 3366aa2731adSTejun Heo } 3367aa2731adSTejun Heo 3368aa2731adSTejun Heo msleep(50); 3369aa2731adSTejun Heo } 3370aa2731adSTejun Heo } 3371aa2731adSTejun Heo 3372aa2731adSTejun Heo /** 3373aa2731adSTejun Heo * ata_wait_after_reset - wait for link to become ready after reset 3374aa2731adSTejun Heo * @link: link to be waited on 3375aa2731adSTejun Heo * @deadline: deadline jiffies for the operation 3376aa2731adSTejun Heo * @check_ready: callback to check link readiness 3377aa2731adSTejun Heo * 3378aa2731adSTejun Heo * Wait for @link to become ready after reset. 3379aa2731adSTejun Heo * 3380aa2731adSTejun Heo * LOCKING: 3381aa2731adSTejun Heo * EH context. 3382aa2731adSTejun Heo * 3383aa2731adSTejun Heo * RETURNS: 3384aa2731adSTejun Heo * 0 if @linke is ready before @deadline; otherwise, -errno. 3385aa2731adSTejun Heo */ 33862b4221bbSHarvey Harrison int ata_wait_after_reset(struct ata_link *link, unsigned long deadline, 3387aa2731adSTejun Heo int (*check_ready)(struct ata_link *link)) 3388aa2731adSTejun Heo { 3389341c2c95STejun Heo msleep(ATA_WAIT_AFTER_RESET); 3390aa2731adSTejun Heo 3391aa2731adSTejun Heo return ata_wait_ready(link, deadline, check_ready); 3392aa2731adSTejun Heo } 3393aa2731adSTejun Heo 3394aa2731adSTejun Heo /** 3395936fd732STejun Heo * sata_link_debounce - debounce SATA phy status 3396936fd732STejun Heo * @link: ATA link to debounce SATA phy status for 3397c6fd2807SJeff Garzik * @params: timing parameters { interval, duratinon, timeout } in msec 3398d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3399c6fd2807SJeff Garzik * 3400936fd732STejun Heo * Make sure SStatus of @link reaches stable state, determined by 3401c6fd2807SJeff Garzik * holding the same value where DET is not 1 for @duration polled 3402c6fd2807SJeff Garzik * every @interval, before @timeout. Timeout constraints the 3403d4b2bab4STejun Heo * beginning of the stable state. Because DET gets stuck at 1 on 3404d4b2bab4STejun Heo * some controllers after hot unplugging, this functions waits 3405c6fd2807SJeff Garzik * until timeout then returns 0 if DET is stable at 1. 3406c6fd2807SJeff Garzik * 3407d4b2bab4STejun Heo * @timeout is further limited by @deadline. The sooner of the 3408d4b2bab4STejun Heo * two is used. 3409d4b2bab4STejun Heo * 3410c6fd2807SJeff Garzik * LOCKING: 3411c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3412c6fd2807SJeff Garzik * 3413c6fd2807SJeff Garzik * RETURNS: 3414c6fd2807SJeff Garzik * 0 on success, -errno on failure. 3415c6fd2807SJeff Garzik */ 3416936fd732STejun Heo int sata_link_debounce(struct ata_link *link, const unsigned long *params, 3417d4b2bab4STejun Heo unsigned long deadline) 3418c6fd2807SJeff Garzik { 3419341c2c95STejun Heo unsigned long interval = params[0]; 3420341c2c95STejun Heo unsigned long duration = params[1]; 3421d4b2bab4STejun Heo unsigned long last_jiffies, t; 3422c6fd2807SJeff Garzik u32 last, cur; 3423c6fd2807SJeff Garzik int rc; 3424c6fd2807SJeff Garzik 3425341c2c95STejun Heo t = ata_deadline(jiffies, params[2]); 3426d4b2bab4STejun Heo if (time_before(t, deadline)) 3427d4b2bab4STejun Heo deadline = t; 3428d4b2bab4STejun Heo 3429936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_STATUS, &cur))) 3430c6fd2807SJeff Garzik return rc; 3431c6fd2807SJeff Garzik cur &= 0xf; 3432c6fd2807SJeff Garzik 3433c6fd2807SJeff Garzik last = cur; 3434c6fd2807SJeff Garzik last_jiffies = jiffies; 3435c6fd2807SJeff Garzik 3436c6fd2807SJeff Garzik while (1) { 3437341c2c95STejun Heo msleep(interval); 3438936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_STATUS, &cur))) 3439c6fd2807SJeff Garzik return rc; 3440c6fd2807SJeff Garzik cur &= 0xf; 3441c6fd2807SJeff Garzik 3442c6fd2807SJeff Garzik /* DET stable? */ 3443c6fd2807SJeff Garzik if (cur == last) { 3444d4b2bab4STejun Heo if (cur == 1 && time_before(jiffies, deadline)) 3445c6fd2807SJeff Garzik continue; 3446341c2c95STejun Heo if (time_after(jiffies, 3447341c2c95STejun Heo ata_deadline(last_jiffies, duration))) 3448c6fd2807SJeff Garzik return 0; 3449c6fd2807SJeff Garzik continue; 3450c6fd2807SJeff Garzik } 3451c6fd2807SJeff Garzik 3452c6fd2807SJeff Garzik /* unstable, start over */ 3453c6fd2807SJeff Garzik last = cur; 3454c6fd2807SJeff Garzik last_jiffies = jiffies; 3455c6fd2807SJeff Garzik 3456f1545154STejun Heo /* Check deadline. If debouncing failed, return 3457f1545154STejun Heo * -EPIPE to tell upper layer to lower link speed. 3458f1545154STejun Heo */ 3459d4b2bab4STejun Heo if (time_after(jiffies, deadline)) 3460f1545154STejun Heo return -EPIPE; 3461c6fd2807SJeff Garzik } 3462c6fd2807SJeff Garzik } 3463c6fd2807SJeff Garzik 3464c6fd2807SJeff Garzik /** 3465936fd732STejun Heo * sata_link_resume - resume SATA link 3466936fd732STejun Heo * @link: ATA link to resume SATA 3467c6fd2807SJeff Garzik * @params: timing parameters { interval, duratinon, timeout } in msec 3468d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3469c6fd2807SJeff Garzik * 3470936fd732STejun Heo * Resume SATA phy @link and debounce it. 3471c6fd2807SJeff Garzik * 3472c6fd2807SJeff Garzik * LOCKING: 3473c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3474c6fd2807SJeff Garzik * 3475c6fd2807SJeff Garzik * RETURNS: 3476c6fd2807SJeff Garzik * 0 on success, -errno on failure. 3477c6fd2807SJeff Garzik */ 3478936fd732STejun Heo int sata_link_resume(struct ata_link *link, const unsigned long *params, 3479d4b2bab4STejun Heo unsigned long deadline) 3480c6fd2807SJeff Garzik { 3481ac371987STejun Heo u32 scontrol, serror; 3482c6fd2807SJeff Garzik int rc; 3483c6fd2807SJeff Garzik 3484936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 3485c6fd2807SJeff Garzik return rc; 3486c6fd2807SJeff Garzik 3487c6fd2807SJeff Garzik scontrol = (scontrol & 0x0f0) | 0x300; 3488c6fd2807SJeff Garzik 3489936fd732STejun Heo if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol))) 3490c6fd2807SJeff Garzik return rc; 3491c6fd2807SJeff Garzik 3492c6fd2807SJeff Garzik /* Some PHYs react badly if SStatus is pounded immediately 3493c6fd2807SJeff Garzik * after resuming. Delay 200ms before debouncing. 3494c6fd2807SJeff Garzik */ 3495c6fd2807SJeff Garzik msleep(200); 3496c6fd2807SJeff Garzik 3497ac371987STejun Heo if ((rc = sata_link_debounce(link, params, deadline))) 3498ac371987STejun Heo return rc; 3499ac371987STejun Heo 3500f046519fSTejun Heo /* clear SError, some PHYs require this even for SRST to work */ 3501ac371987STejun Heo if (!(rc = sata_scr_read(link, SCR_ERROR, &serror))) 3502ac371987STejun Heo rc = sata_scr_write(link, SCR_ERROR, serror); 3503ac371987STejun Heo 3504f046519fSTejun Heo return rc != -EINVAL ? rc : 0; 3505c6fd2807SJeff Garzik } 3506c6fd2807SJeff Garzik 3507c6fd2807SJeff Garzik /** 35080aa1113dSTejun Heo * ata_std_prereset - prepare for reset 3509cc0680a5STejun Heo * @link: ATA link to be reset 3510d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 3511c6fd2807SJeff Garzik * 3512cc0680a5STejun Heo * @link is about to be reset. Initialize it. Failure from 3513b8cffc6aSTejun Heo * prereset makes libata abort whole reset sequence and give up 3514b8cffc6aSTejun Heo * that port, so prereset should be best-effort. It does its 3515b8cffc6aSTejun Heo * best to prepare for reset sequence but if things go wrong, it 3516b8cffc6aSTejun Heo * should just whine, not fail. 3517c6fd2807SJeff Garzik * 3518c6fd2807SJeff Garzik * LOCKING: 3519c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3520c6fd2807SJeff Garzik * 3521c6fd2807SJeff Garzik * RETURNS: 3522c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 3523c6fd2807SJeff Garzik */ 35240aa1113dSTejun Heo int ata_std_prereset(struct ata_link *link, unsigned long deadline) 3525c6fd2807SJeff Garzik { 3526cc0680a5STejun Heo struct ata_port *ap = link->ap; 3527936fd732STejun Heo struct ata_eh_context *ehc = &link->eh_context; 3528c6fd2807SJeff Garzik const unsigned long *timing = sata_ehc_deb_timing(ehc); 3529c6fd2807SJeff Garzik int rc; 3530c6fd2807SJeff Garzik 3531c6fd2807SJeff Garzik /* if we're about to do hardreset, nothing more to do */ 3532c6fd2807SJeff Garzik if (ehc->i.action & ATA_EH_HARDRESET) 3533c6fd2807SJeff Garzik return 0; 3534c6fd2807SJeff Garzik 3535936fd732STejun Heo /* if SATA, resume link */ 3536a16abc0bSTejun Heo if (ap->flags & ATA_FLAG_SATA) { 3537936fd732STejun Heo rc = sata_link_resume(link, timing, deadline); 3538b8cffc6aSTejun Heo /* whine about phy resume failure but proceed */ 3539b8cffc6aSTejun Heo if (rc && rc != -EOPNOTSUPP) 3540cc0680a5STejun Heo ata_link_printk(link, KERN_WARNING, "failed to resume " 3541c6fd2807SJeff Garzik "link for reset (errno=%d)\n", rc); 3542c6fd2807SJeff Garzik } 3543c6fd2807SJeff Garzik 354445db2f6cSTejun Heo /* no point in trying softreset on offline link */ 354545db2f6cSTejun Heo if (ata_link_offline(link)) 354645db2f6cSTejun Heo ehc->i.action &= ~ATA_EH_SOFTRESET; 354745db2f6cSTejun Heo 3548c6fd2807SJeff Garzik return 0; 3549c6fd2807SJeff Garzik } 3550c6fd2807SJeff Garzik 3551c6fd2807SJeff Garzik /** 3552cc0680a5STejun Heo * sata_link_hardreset - reset link via SATA phy reset 3553cc0680a5STejun Heo * @link: link to reset 3554b6103f6dSTejun Heo * @timing: timing parameters { interval, duratinon, timeout } in msec 3555d4b2bab4STejun Heo * @deadline: deadline jiffies for the operation 35569dadd45bSTejun Heo * @online: optional out parameter indicating link onlineness 35579dadd45bSTejun Heo * @check_ready: optional callback to check link readiness 3558c6fd2807SJeff Garzik * 3559cc0680a5STejun Heo * SATA phy-reset @link using DET bits of SControl register. 35609dadd45bSTejun Heo * After hardreset, link readiness is waited upon using 35619dadd45bSTejun Heo * ata_wait_ready() if @check_ready is specified. LLDs are 35629dadd45bSTejun Heo * allowed to not specify @check_ready and wait itself after this 35639dadd45bSTejun Heo * function returns. Device classification is LLD's 35649dadd45bSTejun Heo * responsibility. 35659dadd45bSTejun Heo * 35669dadd45bSTejun Heo * *@online is set to one iff reset succeeded and @link is online 35679dadd45bSTejun Heo * after reset. 3568c6fd2807SJeff Garzik * 3569c6fd2807SJeff Garzik * LOCKING: 3570c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3571c6fd2807SJeff Garzik * 3572c6fd2807SJeff Garzik * RETURNS: 3573c6fd2807SJeff Garzik * 0 on success, -errno otherwise. 3574c6fd2807SJeff Garzik */ 3575cc0680a5STejun Heo int sata_link_hardreset(struct ata_link *link, const unsigned long *timing, 35769dadd45bSTejun Heo unsigned long deadline, 35779dadd45bSTejun Heo bool *online, int (*check_ready)(struct ata_link *)) 3578c6fd2807SJeff Garzik { 3579c6fd2807SJeff Garzik u32 scontrol; 3580c6fd2807SJeff Garzik int rc; 3581c6fd2807SJeff Garzik 3582c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 3583c6fd2807SJeff Garzik 35849dadd45bSTejun Heo if (online) 35859dadd45bSTejun Heo *online = false; 35869dadd45bSTejun Heo 3587936fd732STejun Heo if (sata_set_spd_needed(link)) { 3588c6fd2807SJeff Garzik /* SATA spec says nothing about how to reconfigure 3589c6fd2807SJeff Garzik * spd. To be on the safe side, turn off phy during 3590c6fd2807SJeff Garzik * reconfiguration. This works for at least ICH7 AHCI 3591c6fd2807SJeff Garzik * and Sil3124. 3592c6fd2807SJeff Garzik */ 3593936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 3594b6103f6dSTejun Heo goto out; 3595c6fd2807SJeff Garzik 3596cea0d336SJeff Garzik scontrol = (scontrol & 0x0f0) | 0x304; 3597c6fd2807SJeff Garzik 3598936fd732STejun Heo if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol))) 3599b6103f6dSTejun Heo goto out; 3600c6fd2807SJeff Garzik 3601936fd732STejun Heo sata_set_spd(link); 3602c6fd2807SJeff Garzik } 3603c6fd2807SJeff Garzik 3604c6fd2807SJeff Garzik /* issue phy wake/reset */ 3605936fd732STejun Heo if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) 3606b6103f6dSTejun Heo goto out; 3607c6fd2807SJeff Garzik 3608c6fd2807SJeff Garzik scontrol = (scontrol & 0x0f0) | 0x301; 3609c6fd2807SJeff Garzik 3610936fd732STejun Heo if ((rc = sata_scr_write_flush(link, SCR_CONTROL, scontrol))) 3611b6103f6dSTejun Heo goto out; 3612c6fd2807SJeff Garzik 3613c6fd2807SJeff Garzik /* Couldn't find anything in SATA I/II specs, but AHCI-1.1 3614c6fd2807SJeff Garzik * 10.4.2 says at least 1 ms. 3615c6fd2807SJeff Garzik */ 3616c6fd2807SJeff Garzik msleep(1); 3617c6fd2807SJeff Garzik 3618936fd732STejun Heo /* bring link back */ 3619936fd732STejun Heo rc = sata_link_resume(link, timing, deadline); 36209dadd45bSTejun Heo if (rc) 36219dadd45bSTejun Heo goto out; 36229dadd45bSTejun Heo /* if link is offline nothing more to do */ 36239dadd45bSTejun Heo if (ata_link_offline(link)) 36249dadd45bSTejun Heo goto out; 36259dadd45bSTejun Heo 36269dadd45bSTejun Heo /* Link is online. From this point, -ENODEV too is an error. */ 36279dadd45bSTejun Heo if (online) 36289dadd45bSTejun Heo *online = true; 36299dadd45bSTejun Heo 3630071f44b1STejun Heo if (sata_pmp_supported(link->ap) && ata_is_host_link(link)) { 36319dadd45bSTejun Heo /* If PMP is supported, we have to do follow-up SRST. 36329dadd45bSTejun Heo * Some PMPs don't send D2H Reg FIS after hardreset if 36339dadd45bSTejun Heo * the first port is empty. Wait only for 36349dadd45bSTejun Heo * ATA_TMOUT_PMP_SRST_WAIT. 36359dadd45bSTejun Heo */ 36369dadd45bSTejun Heo if (check_ready) { 36379dadd45bSTejun Heo unsigned long pmp_deadline; 36389dadd45bSTejun Heo 3639341c2c95STejun Heo pmp_deadline = ata_deadline(jiffies, 3640341c2c95STejun Heo ATA_TMOUT_PMP_SRST_WAIT); 36419dadd45bSTejun Heo if (time_after(pmp_deadline, deadline)) 36429dadd45bSTejun Heo pmp_deadline = deadline; 36439dadd45bSTejun Heo ata_wait_ready(link, pmp_deadline, check_ready); 36449dadd45bSTejun Heo } 36459dadd45bSTejun Heo rc = -EAGAIN; 36469dadd45bSTejun Heo goto out; 36479dadd45bSTejun Heo } 36489dadd45bSTejun Heo 36499dadd45bSTejun Heo rc = 0; 36509dadd45bSTejun Heo if (check_ready) 36519dadd45bSTejun Heo rc = ata_wait_ready(link, deadline, check_ready); 3652b6103f6dSTejun Heo out: 36530cbf0711STejun Heo if (rc && rc != -EAGAIN) { 36540cbf0711STejun Heo /* online is set iff link is online && reset succeeded */ 36550cbf0711STejun Heo if (online) 36560cbf0711STejun Heo *online = false; 36579dadd45bSTejun Heo ata_link_printk(link, KERN_ERR, 36589dadd45bSTejun Heo "COMRESET failed (errno=%d)\n", rc); 36590cbf0711STejun Heo } 3660b6103f6dSTejun Heo DPRINTK("EXIT, rc=%d\n", rc); 3661b6103f6dSTejun Heo return rc; 3662b6103f6dSTejun Heo } 3663b6103f6dSTejun Heo 3664b6103f6dSTejun Heo /** 366557c9efdfSTejun Heo * sata_std_hardreset - COMRESET w/o waiting or classification 366657c9efdfSTejun Heo * @link: link to reset 366757c9efdfSTejun Heo * @class: resulting class of attached device 366857c9efdfSTejun Heo * @deadline: deadline jiffies for the operation 366957c9efdfSTejun Heo * 367057c9efdfSTejun Heo * Standard SATA COMRESET w/o waiting or classification. 367157c9efdfSTejun Heo * 367257c9efdfSTejun Heo * LOCKING: 367357c9efdfSTejun Heo * Kernel thread context (may sleep) 367457c9efdfSTejun Heo * 367557c9efdfSTejun Heo * RETURNS: 367657c9efdfSTejun Heo * 0 if link offline, -EAGAIN if link online, -errno on errors. 367757c9efdfSTejun Heo */ 367857c9efdfSTejun Heo int sata_std_hardreset(struct ata_link *link, unsigned int *class, 367957c9efdfSTejun Heo unsigned long deadline) 368057c9efdfSTejun Heo { 368157c9efdfSTejun Heo const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context); 368257c9efdfSTejun Heo bool online; 368357c9efdfSTejun Heo int rc; 368457c9efdfSTejun Heo 368557c9efdfSTejun Heo /* do hardreset */ 368657c9efdfSTejun Heo rc = sata_link_hardreset(link, timing, deadline, &online, NULL); 368757c9efdfSTejun Heo return online ? -EAGAIN : rc; 368857c9efdfSTejun Heo } 368957c9efdfSTejun Heo 369057c9efdfSTejun Heo /** 3691203c75b8STejun Heo * ata_std_postreset - standard postreset callback 3692cc0680a5STejun Heo * @link: the target ata_link 3693c6fd2807SJeff Garzik * @classes: classes of attached devices 3694c6fd2807SJeff Garzik * 3695c6fd2807SJeff Garzik * This function is invoked after a successful reset. Note that 3696c6fd2807SJeff Garzik * the device might have been reset more than once using 3697c6fd2807SJeff Garzik * different reset methods before postreset is invoked. 3698c6fd2807SJeff Garzik * 3699c6fd2807SJeff Garzik * LOCKING: 3700c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3701c6fd2807SJeff Garzik */ 3702203c75b8STejun Heo void ata_std_postreset(struct ata_link *link, unsigned int *classes) 3703c6fd2807SJeff Garzik { 3704f046519fSTejun Heo u32 serror; 3705f046519fSTejun Heo 3706c6fd2807SJeff Garzik DPRINTK("ENTER\n"); 3707c6fd2807SJeff Garzik 3708f046519fSTejun Heo /* reset complete, clear SError */ 3709f046519fSTejun Heo if (!sata_scr_read(link, SCR_ERROR, &serror)) 3710f046519fSTejun Heo sata_scr_write(link, SCR_ERROR, serror); 3711f046519fSTejun Heo 3712c6fd2807SJeff Garzik /* print link status */ 3713936fd732STejun Heo sata_print_link_status(link); 3714c6fd2807SJeff Garzik 3715c6fd2807SJeff Garzik DPRINTK("EXIT\n"); 3716c6fd2807SJeff Garzik } 3717c6fd2807SJeff Garzik 3718c6fd2807SJeff Garzik /** 3719c6fd2807SJeff Garzik * ata_dev_same_device - Determine whether new ID matches configured device 3720c6fd2807SJeff Garzik * @dev: device to compare against 3721c6fd2807SJeff Garzik * @new_class: class of the new device 3722c6fd2807SJeff Garzik * @new_id: IDENTIFY page of the new device 3723c6fd2807SJeff Garzik * 3724c6fd2807SJeff Garzik * Compare @new_class and @new_id against @dev and determine 3725c6fd2807SJeff Garzik * whether @dev is the device indicated by @new_class and 3726c6fd2807SJeff Garzik * @new_id. 3727c6fd2807SJeff Garzik * 3728c6fd2807SJeff Garzik * LOCKING: 3729c6fd2807SJeff Garzik * None. 3730c6fd2807SJeff Garzik * 3731c6fd2807SJeff Garzik * RETURNS: 3732c6fd2807SJeff Garzik * 1 if @dev matches @new_class and @new_id, 0 otherwise. 3733c6fd2807SJeff Garzik */ 3734c6fd2807SJeff Garzik static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class, 3735c6fd2807SJeff Garzik const u16 *new_id) 3736c6fd2807SJeff Garzik { 3737c6fd2807SJeff Garzik const u16 *old_id = dev->id; 3738a0cf733bSTejun Heo unsigned char model[2][ATA_ID_PROD_LEN + 1]; 3739a0cf733bSTejun Heo unsigned char serial[2][ATA_ID_SERNO_LEN + 1]; 3740c6fd2807SJeff Garzik 3741c6fd2807SJeff Garzik if (dev->class != new_class) { 3742c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "class mismatch %d != %d\n", 3743c6fd2807SJeff Garzik dev->class, new_class); 3744c6fd2807SJeff Garzik return 0; 3745c6fd2807SJeff Garzik } 3746c6fd2807SJeff Garzik 3747a0cf733bSTejun Heo ata_id_c_string(old_id, model[0], ATA_ID_PROD, sizeof(model[0])); 3748a0cf733bSTejun Heo ata_id_c_string(new_id, model[1], ATA_ID_PROD, sizeof(model[1])); 3749a0cf733bSTejun Heo ata_id_c_string(old_id, serial[0], ATA_ID_SERNO, sizeof(serial[0])); 3750a0cf733bSTejun Heo ata_id_c_string(new_id, serial[1], ATA_ID_SERNO, sizeof(serial[1])); 3751c6fd2807SJeff Garzik 3752c6fd2807SJeff Garzik if (strcmp(model[0], model[1])) { 3753c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "model number mismatch " 3754c6fd2807SJeff Garzik "'%s' != '%s'\n", model[0], model[1]); 3755c6fd2807SJeff Garzik return 0; 3756c6fd2807SJeff Garzik } 3757c6fd2807SJeff Garzik 3758c6fd2807SJeff Garzik if (strcmp(serial[0], serial[1])) { 3759c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_INFO, "serial number mismatch " 3760c6fd2807SJeff Garzik "'%s' != '%s'\n", serial[0], serial[1]); 3761c6fd2807SJeff Garzik return 0; 3762c6fd2807SJeff Garzik } 3763c6fd2807SJeff Garzik 3764c6fd2807SJeff Garzik return 1; 3765c6fd2807SJeff Garzik } 3766c6fd2807SJeff Garzik 3767c6fd2807SJeff Garzik /** 3768fe30911bSTejun Heo * ata_dev_reread_id - Re-read IDENTIFY data 37693fae450cSHenrik Kretzschmar * @dev: target ATA device 3770bff04647STejun Heo * @readid_flags: read ID flags 3771c6fd2807SJeff Garzik * 3772c6fd2807SJeff Garzik * Re-read IDENTIFY page and make sure @dev is still attached to 3773c6fd2807SJeff Garzik * the port. 3774c6fd2807SJeff Garzik * 3775c6fd2807SJeff Garzik * LOCKING: 3776c6fd2807SJeff Garzik * Kernel thread context (may sleep) 3777c6fd2807SJeff Garzik * 3778c6fd2807SJeff Garzik * RETURNS: 3779c6fd2807SJeff Garzik * 0 on success, negative errno otherwise 3780c6fd2807SJeff Garzik */ 3781fe30911bSTejun Heo int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags) 3782c6fd2807SJeff Garzik { 3783c6fd2807SJeff Garzik unsigned int class = dev->class; 37849af5c9c9STejun Heo u16 *id = (void *)dev->link->ap->sector_buf; 3785c6fd2807SJeff Garzik int rc; 3786c6fd2807SJeff Garzik 3787c6fd2807SJeff Garzik /* read ID data */ 3788bff04647STejun Heo rc = ata_dev_read_id(dev, &class, readid_flags, id); 3789c6fd2807SJeff Garzik if (rc) 3790fe30911bSTejun Heo return rc; 3791c6fd2807SJeff Garzik 3792c6fd2807SJeff Garzik /* is the device still there? */ 3793fe30911bSTejun Heo if (!ata_dev_same_device(dev, class, id)) 3794fe30911bSTejun Heo return -ENODEV; 3795c6fd2807SJeff Garzik 3796c6fd2807SJeff Garzik memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS); 3797fe30911bSTejun Heo return 0; 3798fe30911bSTejun Heo } 3799fe30911bSTejun Heo 3800fe30911bSTejun Heo /** 3801fe30911bSTejun Heo * ata_dev_revalidate - Revalidate ATA device 3802fe30911bSTejun Heo * @dev: device to revalidate 3803422c9daaSTejun Heo * @new_class: new class code 3804fe30911bSTejun Heo * @readid_flags: read ID flags 3805fe30911bSTejun Heo * 3806fe30911bSTejun Heo * Re-read IDENTIFY page, make sure @dev is still attached to the 3807fe30911bSTejun Heo * port and reconfigure it according to the new IDENTIFY page. 3808fe30911bSTejun Heo * 3809fe30911bSTejun Heo * LOCKING: 3810fe30911bSTejun Heo * Kernel thread context (may sleep) 3811fe30911bSTejun Heo * 3812fe30911bSTejun Heo * RETURNS: 3813fe30911bSTejun Heo * 0 on success, negative errno otherwise 3814fe30911bSTejun Heo */ 3815422c9daaSTejun Heo int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class, 3816422c9daaSTejun Heo unsigned int readid_flags) 3817fe30911bSTejun Heo { 38186ddcd3b0STejun Heo u64 n_sectors = dev->n_sectors; 3819fe30911bSTejun Heo int rc; 3820fe30911bSTejun Heo 3821fe30911bSTejun Heo if (!ata_dev_enabled(dev)) 3822fe30911bSTejun Heo return -ENODEV; 3823fe30911bSTejun Heo 3824422c9daaSTejun Heo /* fail early if !ATA && !ATAPI to avoid issuing [P]IDENTIFY to PMP */ 3825422c9daaSTejun Heo if (ata_class_enabled(new_class) && 3826422c9daaSTejun Heo new_class != ATA_DEV_ATA && new_class != ATA_DEV_ATAPI) { 3827422c9daaSTejun Heo ata_dev_printk(dev, KERN_INFO, "class mismatch %u != %u\n", 3828422c9daaSTejun Heo dev->class, new_class); 3829422c9daaSTejun Heo rc = -ENODEV; 3830422c9daaSTejun Heo goto fail; 3831422c9daaSTejun Heo } 3832422c9daaSTejun Heo 3833fe30911bSTejun Heo /* re-read ID */ 3834fe30911bSTejun Heo rc = ata_dev_reread_id(dev, readid_flags); 3835fe30911bSTejun Heo if (rc) 3836fe30911bSTejun Heo goto fail; 3837c6fd2807SJeff Garzik 3838c6fd2807SJeff Garzik /* configure device according to the new ID */ 3839efdaedc4STejun Heo rc = ata_dev_configure(dev); 38406ddcd3b0STejun Heo if (rc) 38416ddcd3b0STejun Heo goto fail; 38426ddcd3b0STejun Heo 38436ddcd3b0STejun Heo /* verify n_sectors hasn't changed */ 3844b54eebd6STejun Heo if (dev->class == ATA_DEV_ATA && n_sectors && 3845b54eebd6STejun Heo dev->n_sectors != n_sectors) { 38466ddcd3b0STejun Heo ata_dev_printk(dev, KERN_INFO, "n_sectors mismatch " 38476ddcd3b0STejun Heo "%llu != %llu\n", 38486ddcd3b0STejun Heo (unsigned long long)n_sectors, 38496ddcd3b0STejun Heo (unsigned long long)dev->n_sectors); 38508270bec4STejun Heo 38518270bec4STejun Heo /* restore original n_sectors */ 38528270bec4STejun Heo dev->n_sectors = n_sectors; 38538270bec4STejun Heo 38546ddcd3b0STejun Heo rc = -ENODEV; 38556ddcd3b0STejun Heo goto fail; 38566ddcd3b0STejun Heo } 38576ddcd3b0STejun Heo 3858c6fd2807SJeff Garzik return 0; 3859c6fd2807SJeff Garzik 3860c6fd2807SJeff Garzik fail: 3861c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_ERR, "revalidation failed (errno=%d)\n", rc); 3862c6fd2807SJeff Garzik return rc; 3863c6fd2807SJeff Garzik } 3864c6fd2807SJeff Garzik 38656919a0a6SAlan Cox struct ata_blacklist_entry { 38666919a0a6SAlan Cox const char *model_num; 38676919a0a6SAlan Cox const char *model_rev; 38686919a0a6SAlan Cox unsigned long horkage; 38696919a0a6SAlan Cox }; 38706919a0a6SAlan Cox 38716919a0a6SAlan Cox static const struct ata_blacklist_entry ata_device_blacklist [] = { 38726919a0a6SAlan Cox /* Devices with DMA related problems under Linux */ 38736919a0a6SAlan Cox { "WDC AC11000H", NULL, ATA_HORKAGE_NODMA }, 38746919a0a6SAlan Cox { "WDC AC22100H", NULL, ATA_HORKAGE_NODMA }, 38756919a0a6SAlan Cox { "WDC AC32500H", NULL, ATA_HORKAGE_NODMA }, 38766919a0a6SAlan Cox { "WDC AC33100H", NULL, ATA_HORKAGE_NODMA }, 38776919a0a6SAlan Cox { "WDC AC31600H", NULL, ATA_HORKAGE_NODMA }, 38786919a0a6SAlan Cox { "WDC AC32100H", "24.09P07", ATA_HORKAGE_NODMA }, 38796919a0a6SAlan Cox { "WDC AC23200L", "21.10N21", ATA_HORKAGE_NODMA }, 38806919a0a6SAlan Cox { "Compaq CRD-8241B", NULL, ATA_HORKAGE_NODMA }, 38816919a0a6SAlan Cox { "CRD-8400B", NULL, ATA_HORKAGE_NODMA }, 38826919a0a6SAlan Cox { "CRD-8480B", NULL, ATA_HORKAGE_NODMA }, 38836919a0a6SAlan Cox { "CRD-8482B", NULL, ATA_HORKAGE_NODMA }, 38846919a0a6SAlan Cox { "CRD-84", NULL, ATA_HORKAGE_NODMA }, 38856919a0a6SAlan Cox { "SanDisk SDP3B", NULL, ATA_HORKAGE_NODMA }, 38866919a0a6SAlan Cox { "SanDisk SDP3B-64", NULL, ATA_HORKAGE_NODMA }, 38876919a0a6SAlan Cox { "SANYO CD-ROM CRD", NULL, ATA_HORKAGE_NODMA }, 38886919a0a6SAlan Cox { "HITACHI CDR-8", NULL, ATA_HORKAGE_NODMA }, 38896919a0a6SAlan Cox { "HITACHI CDR-8335", NULL, ATA_HORKAGE_NODMA }, 38906919a0a6SAlan Cox { "HITACHI CDR-8435", NULL, ATA_HORKAGE_NODMA }, 38916919a0a6SAlan Cox { "Toshiba CD-ROM XM-6202B", NULL, ATA_HORKAGE_NODMA }, 38926919a0a6SAlan Cox { "TOSHIBA CD-ROM XM-1702BC", NULL, ATA_HORKAGE_NODMA }, 38936919a0a6SAlan Cox { "CD-532E-A", NULL, ATA_HORKAGE_NODMA }, 38946919a0a6SAlan Cox { "E-IDE CD-ROM CR-840",NULL, ATA_HORKAGE_NODMA }, 38956919a0a6SAlan Cox { "CD-ROM Drive/F5A", NULL, ATA_HORKAGE_NODMA }, 38966919a0a6SAlan Cox { "WPI CDD-820", NULL, ATA_HORKAGE_NODMA }, 38976919a0a6SAlan Cox { "SAMSUNG CD-ROM SC-148C", NULL, ATA_HORKAGE_NODMA }, 38986919a0a6SAlan Cox { "SAMSUNG CD-ROM SC", NULL, ATA_HORKAGE_NODMA }, 38996919a0a6SAlan Cox { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA }, 39006919a0a6SAlan Cox { "_NEC DV5800A", NULL, ATA_HORKAGE_NODMA }, 39016919a0a6SAlan Cox { "SAMSUNG CD-ROM SN-124", "N001", ATA_HORKAGE_NODMA }, 390239f19886SDave Jones { "Seagate STT20000A", NULL, ATA_HORKAGE_NODMA }, 39033af9a77aSTejun Heo /* Odd clown on sil3726/4726 PMPs */ 390450af2fa1STejun Heo { "Config Disk", NULL, ATA_HORKAGE_DISABLE }, 39056919a0a6SAlan Cox 390618d6e9d5SAlbert Lee /* Weird ATAPI devices */ 390740a1d531STejun Heo { "TORiSAN DVD-ROM DRD-N216", NULL, ATA_HORKAGE_MAX_SEC_128 }, 390818d6e9d5SAlbert Lee 39096919a0a6SAlan Cox /* Devices we expect to fail diagnostics */ 39106919a0a6SAlan Cox 39116919a0a6SAlan Cox /* Devices where NCQ should be avoided */ 39126919a0a6SAlan Cox /* NCQ is slow */ 39136919a0a6SAlan Cox { "WDC WD740ADFD-00", NULL, ATA_HORKAGE_NONCQ }, 3914459ad688STejun Heo { "WDC WD740ADFD-00NLR1", NULL, ATA_HORKAGE_NONCQ, }, 391509125ea6STejun Heo /* http://thread.gmane.org/gmane.linux.ide/14907 */ 391609125ea6STejun Heo { "FUJITSU MHT2060BH", NULL, ATA_HORKAGE_NONCQ }, 39177acfaf30SPaul Rolland /* NCQ is broken */ 3918539cc7c7SJeff Garzik { "Maxtor *", "BANC*", ATA_HORKAGE_NONCQ }, 39190e3dbc01SAlan Cox { "Maxtor 7V300F0", "VA111630", ATA_HORKAGE_NONCQ }, 3920da6f0ec2SPaolo Ornati { "ST380817AS", "3.42", ATA_HORKAGE_NONCQ }, 3921e41bd3e8STejun Heo { "ST3160023AS", "3.42", ATA_HORKAGE_NONCQ }, 3922539cc7c7SJeff Garzik 392336e337d0SRobert Hancock /* Blacklist entries taken from Silicon Image 3124/3132 392436e337d0SRobert Hancock Windows driver .inf file - also several Linux problem reports */ 392536e337d0SRobert Hancock { "HTS541060G9SA00", "MB3OC60D", ATA_HORKAGE_NONCQ, }, 392636e337d0SRobert Hancock { "HTS541080G9SA00", "MB4OC60D", ATA_HORKAGE_NONCQ, }, 392736e337d0SRobert Hancock { "HTS541010G9SA00", "MBZOC60D", ATA_HORKAGE_NONCQ, }, 39286919a0a6SAlan Cox 392916c55b03STejun Heo /* devices which puke on READ_NATIVE_MAX */ 393016c55b03STejun Heo { "HDS724040KLSA80", "KFAOA20N", ATA_HORKAGE_BROKEN_HPA, }, 393116c55b03STejun Heo { "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_HORKAGE_BROKEN_HPA }, 393216c55b03STejun Heo { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA }, 393316c55b03STejun Heo { "MAXTOR 6L080L4", "A93.0500", ATA_HORKAGE_BROKEN_HPA }, 39346919a0a6SAlan Cox 393593328e11SAlan Cox /* Devices which report 1 sector over size HPA */ 393693328e11SAlan Cox { "ST340823A", NULL, ATA_HORKAGE_HPA_SIZE, }, 393793328e11SAlan Cox { "ST320413A", NULL, ATA_HORKAGE_HPA_SIZE, }, 3938b152fcd3SMikko Rapeli { "ST310211A", NULL, ATA_HORKAGE_HPA_SIZE, }, 393993328e11SAlan Cox 39406bbfd53dSAlan Cox /* Devices which get the IVB wrong */ 39416bbfd53dSAlan Cox { "QUANTUM FIREBALLlct10 05", "A03.0900", ATA_HORKAGE_IVB, }, 3942a79067e5SAlan Cox /* Maybe we should just blacklist TSSTcorp... */ 3943a79067e5SAlan Cox { "TSSTcorp CDDVDW SH-S202H", "SB00", ATA_HORKAGE_IVB, }, 3944a79067e5SAlan Cox { "TSSTcorp CDDVDW SH-S202H", "SB01", ATA_HORKAGE_IVB, }, 39456bbfd53dSAlan Cox { "TSSTcorp CDDVDW SH-S202J", "SB00", ATA_HORKAGE_IVB, }, 3946e9f33406SPeter Missel { "TSSTcorp CDDVDW SH-S202J", "SB01", ATA_HORKAGE_IVB, }, 3947e9f33406SPeter Missel { "TSSTcorp CDDVDW SH-S202N", "SB00", ATA_HORKAGE_IVB, }, 3948e9f33406SPeter Missel { "TSSTcorp CDDVDW SH-S202N", "SB01", ATA_HORKAGE_IVB, }, 39496bbfd53dSAlan Cox 39506919a0a6SAlan Cox /* End Marker */ 39516919a0a6SAlan Cox { } 3952c6fd2807SJeff Garzik }; 3953c6fd2807SJeff Garzik 3954741b7763SAdrian Bunk static int strn_pattern_cmp(const char *patt, const char *name, int wildchar) 3955539cc7c7SJeff Garzik { 3956539cc7c7SJeff Garzik const char *p; 3957539cc7c7SJeff Garzik int len; 3958539cc7c7SJeff Garzik 3959539cc7c7SJeff Garzik /* 3960539cc7c7SJeff Garzik * check for trailing wildcard: *\0 3961539cc7c7SJeff Garzik */ 3962539cc7c7SJeff Garzik p = strchr(patt, wildchar); 3963539cc7c7SJeff Garzik if (p && ((*(p + 1)) == 0)) 3964539cc7c7SJeff Garzik len = p - patt; 3965317b50b8SAndrew Paprocki else { 3966539cc7c7SJeff Garzik len = strlen(name); 3967317b50b8SAndrew Paprocki if (!len) { 3968317b50b8SAndrew Paprocki if (!*patt) 3969317b50b8SAndrew Paprocki return 0; 3970317b50b8SAndrew Paprocki return -1; 3971317b50b8SAndrew Paprocki } 3972317b50b8SAndrew Paprocki } 3973539cc7c7SJeff Garzik 3974539cc7c7SJeff Garzik return strncmp(patt, name, len); 3975539cc7c7SJeff Garzik } 3976539cc7c7SJeff Garzik 397775683fe7STejun Heo static unsigned long ata_dev_blacklisted(const struct ata_device *dev) 3978c6fd2807SJeff Garzik { 39798bfa79fcSTejun Heo unsigned char model_num[ATA_ID_PROD_LEN + 1]; 39808bfa79fcSTejun Heo unsigned char model_rev[ATA_ID_FW_REV_LEN + 1]; 39816919a0a6SAlan Cox const struct ata_blacklist_entry *ad = ata_device_blacklist; 3982c6fd2807SJeff Garzik 39838bfa79fcSTejun Heo ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num)); 39848bfa79fcSTejun Heo ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev)); 3985c6fd2807SJeff Garzik 39866919a0a6SAlan Cox while (ad->model_num) { 3987539cc7c7SJeff Garzik if (!strn_pattern_cmp(ad->model_num, model_num, '*')) { 39886919a0a6SAlan Cox if (ad->model_rev == NULL) 39896919a0a6SAlan Cox return ad->horkage; 3990539cc7c7SJeff Garzik if (!strn_pattern_cmp(ad->model_rev, model_rev, '*')) 39916919a0a6SAlan Cox return ad->horkage; 3992c6fd2807SJeff Garzik } 39936919a0a6SAlan Cox ad++; 3994c6fd2807SJeff Garzik } 3995c6fd2807SJeff Garzik return 0; 3996c6fd2807SJeff Garzik } 3997c6fd2807SJeff Garzik 39986919a0a6SAlan Cox static int ata_dma_blacklisted(const struct ata_device *dev) 39996919a0a6SAlan Cox { 40006919a0a6SAlan Cox /* We don't support polling DMA. 40016919a0a6SAlan Cox * DMA blacklist those ATAPI devices with CDB-intr (and use PIO) 40026919a0a6SAlan Cox * if the LLDD handles only interrupts in the HSM_ST_LAST state. 40036919a0a6SAlan Cox */ 40049af5c9c9STejun Heo if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) && 40056919a0a6SAlan Cox (dev->flags & ATA_DFLAG_CDB_INTR)) 40066919a0a6SAlan Cox return 1; 400775683fe7STejun Heo return (dev->horkage & ATA_HORKAGE_NODMA) ? 1 : 0; 40086919a0a6SAlan Cox } 40096919a0a6SAlan Cox 4010c6fd2807SJeff Garzik /** 40116bbfd53dSAlan Cox * ata_is_40wire - check drive side detection 40126bbfd53dSAlan Cox * @dev: device 40136bbfd53dSAlan Cox * 40146bbfd53dSAlan Cox * Perform drive side detection decoding, allowing for device vendors 40156bbfd53dSAlan Cox * who can't follow the documentation. 40166bbfd53dSAlan Cox */ 40176bbfd53dSAlan Cox 40186bbfd53dSAlan Cox static int ata_is_40wire(struct ata_device *dev) 40196bbfd53dSAlan Cox { 40206bbfd53dSAlan Cox if (dev->horkage & ATA_HORKAGE_IVB) 40216bbfd53dSAlan Cox return ata_drive_40wire_relaxed(dev->id); 40226bbfd53dSAlan Cox return ata_drive_40wire(dev->id); 40236bbfd53dSAlan Cox } 40246bbfd53dSAlan Cox 40256bbfd53dSAlan Cox /** 402615a5551cSAlan Cox * cable_is_40wire - 40/80/SATA decider 402715a5551cSAlan Cox * @ap: port to consider 402815a5551cSAlan Cox * 402915a5551cSAlan Cox * This function encapsulates the policy for speed management 403015a5551cSAlan Cox * in one place. At the moment we don't cache the result but 403115a5551cSAlan Cox * there is a good case for setting ap->cbl to the result when 403215a5551cSAlan Cox * we are called with unknown cables (and figuring out if it 403315a5551cSAlan Cox * impacts hotplug at all). 403415a5551cSAlan Cox * 403515a5551cSAlan Cox * Return 1 if the cable appears to be 40 wire. 403615a5551cSAlan Cox */ 403715a5551cSAlan Cox 403815a5551cSAlan Cox static int cable_is_40wire(struct ata_port *ap) 403915a5551cSAlan Cox { 404015a5551cSAlan Cox struct ata_link *link; 404115a5551cSAlan Cox struct ata_device *dev; 404215a5551cSAlan Cox 404315a5551cSAlan Cox /* If the controller thinks we are 40 wire, we are */ 404415a5551cSAlan Cox if (ap->cbl == ATA_CBL_PATA40) 404515a5551cSAlan Cox return 1; 404615a5551cSAlan Cox /* If the controller thinks we are 80 wire, we are */ 404715a5551cSAlan Cox if (ap->cbl == ATA_CBL_PATA80 || ap->cbl == ATA_CBL_SATA) 404815a5551cSAlan Cox return 0; 4049f792068eSAlan Cox /* If the system is known to be 40 wire short cable (eg laptop), 4050f792068eSAlan Cox then we allow 80 wire modes even if the drive isn't sure */ 4051f792068eSAlan Cox if (ap->cbl == ATA_CBL_PATA40_SHORT) 4052f792068eSAlan Cox return 0; 405315a5551cSAlan Cox /* If the controller doesn't know we scan 405415a5551cSAlan Cox 405515a5551cSAlan Cox - Note: We look for all 40 wire detects at this point. 405615a5551cSAlan Cox Any 80 wire detect is taken to be 80 wire cable 405715a5551cSAlan Cox because 405815a5551cSAlan Cox - In many setups only the one drive (slave if present) 405915a5551cSAlan Cox will give a valid detect 406015a5551cSAlan Cox - If you have a non detect capable drive you don't 406115a5551cSAlan Cox want it to colour the choice 406215a5551cSAlan Cox */ 406315a5551cSAlan Cox ata_port_for_each_link(link, ap) { 406415a5551cSAlan Cox ata_link_for_each_dev(dev, link) { 406515a5551cSAlan Cox if (!ata_is_40wire(dev)) 406615a5551cSAlan Cox return 0; 406715a5551cSAlan Cox } 406815a5551cSAlan Cox } 406915a5551cSAlan Cox return 1; 407015a5551cSAlan Cox } 407115a5551cSAlan Cox 407215a5551cSAlan Cox /** 4073c6fd2807SJeff Garzik * ata_dev_xfermask - Compute supported xfermask of the given device 4074c6fd2807SJeff Garzik * @dev: Device to compute xfermask for 4075c6fd2807SJeff Garzik * 4076c6fd2807SJeff Garzik * Compute supported xfermask of @dev and store it in 4077c6fd2807SJeff Garzik * dev->*_mask. This function is responsible for applying all 4078c6fd2807SJeff Garzik * known limits including host controller limits, device 4079c6fd2807SJeff Garzik * blacklist, etc... 4080c6fd2807SJeff Garzik * 4081c6fd2807SJeff Garzik * LOCKING: 4082c6fd2807SJeff Garzik * None. 4083c6fd2807SJeff Garzik */ 4084c6fd2807SJeff Garzik static void ata_dev_xfermask(struct ata_device *dev) 4085c6fd2807SJeff Garzik { 40869af5c9c9STejun Heo struct ata_link *link = dev->link; 40879af5c9c9STejun Heo struct ata_port *ap = link->ap; 4088cca3974eSJeff Garzik struct ata_host *host = ap->host; 4089c6fd2807SJeff Garzik unsigned long xfer_mask; 4090c6fd2807SJeff Garzik 4091c6fd2807SJeff Garzik /* controller modes available */ 4092c6fd2807SJeff Garzik xfer_mask = ata_pack_xfermask(ap->pio_mask, 4093c6fd2807SJeff Garzik ap->mwdma_mask, ap->udma_mask); 4094c6fd2807SJeff Garzik 40958343f889SRobert Hancock /* drive modes available */ 4096c6fd2807SJeff Garzik xfer_mask &= ata_pack_xfermask(dev->pio_mask, 4097c6fd2807SJeff Garzik dev->mwdma_mask, dev->udma_mask); 4098c6fd2807SJeff Garzik xfer_mask &= ata_id_xfermask(dev->id); 4099c6fd2807SJeff Garzik 4100b352e57dSAlan Cox /* 4101b352e57dSAlan Cox * CFA Advanced TrueIDE timings are not allowed on a shared 4102b352e57dSAlan Cox * cable 4103b352e57dSAlan Cox */ 4104b352e57dSAlan Cox if (ata_dev_pair(dev)) { 4105b352e57dSAlan Cox /* No PIO5 or PIO6 */ 4106b352e57dSAlan Cox xfer_mask &= ~(0x03 << (ATA_SHIFT_PIO + 5)); 4107b352e57dSAlan Cox /* No MWDMA3 or MWDMA 4 */ 4108b352e57dSAlan Cox xfer_mask &= ~(0x03 << (ATA_SHIFT_MWDMA + 3)); 4109b352e57dSAlan Cox } 4110b352e57dSAlan Cox 4111c6fd2807SJeff Garzik if (ata_dma_blacklisted(dev)) { 4112c6fd2807SJeff Garzik xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA); 4113c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, 4114c6fd2807SJeff Garzik "device is on DMA blacklist, disabling DMA\n"); 4115c6fd2807SJeff Garzik } 4116c6fd2807SJeff Garzik 411714d66ab7SPetr Vandrovec if ((host->flags & ATA_HOST_SIMPLEX) && 411814d66ab7SPetr Vandrovec host->simplex_claimed && host->simplex_claimed != ap) { 4119c6fd2807SJeff Garzik xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA); 4120c6fd2807SJeff Garzik ata_dev_printk(dev, KERN_WARNING, "simplex DMA is claimed by " 4121c6fd2807SJeff Garzik "other device, disabling DMA\n"); 4122c6fd2807SJeff Garzik } 4123c6fd2807SJeff Garzik 4124e424675fSJeff Garzik if (ap->flags & ATA_FLAG_NO_IORDY) 4125e424675fSJeff Garzik xfer_mask &= ata_pio_mask_no_iordy(dev); 4126e424675fSJeff Garzik 4127c6fd2807SJeff Garzik if (ap->ops->mode_filter) 4128a76b62caSAlan Cox xfer_mask = ap->ops->mode_filter(dev, xfer_mask); 4129c6fd2807SJeff Garzik 41308343f889SRobert Hancock /* Apply cable rule here. Don't apply it early because when 41318343f889SRobert Hancock * we handle hot plug the cable type can itself change. 41328343f889SRobert Hancock * Check this last so that we know if the transfer rate was 41338343f889SRobert Hancock * solely limited by the cable. 41348343f889SRobert Hancock * Unknown or 80 wire cables reported host side are checked 41358343f889SRobert Hancock * drive side as well. Cases where we know a 40wire cable 41368343f889SRobert Hancock * is used safely for 80 are not checked here. 41378343f889SRobert Hancock */ 41388343f889SRobert Hancock if (xfer_mask & (0xF8 << ATA_SHIFT_UDMA)) 41398343f889SRobert Hancock /* UDMA/44 or higher would be available */ 414015a5551cSAlan Cox if (cable_is_40wire(ap)) { 41418343f889SRobert Hancock ata_dev_printk(dev, KERN_WARNING, 41428343f889SRobert Hancock "limited to UDMA/33 due to 40-wire cable\n"); 41438343f889SRobert Hancock xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA); 41448343f889SRobert Hancock } 41458343f889SRobert Hancock 4146c6fd2807SJeff Garzik ata_unpack_xfermask(xfer_mask, &dev->pio_mask, 4147c6fd2807SJeff Garzik &dev->mwdma_mask, &dev->udma_mask); 4148c6fd2807SJeff Garzik } 4149c6fd2807SJeff Garzik 4150c6fd2807SJeff Garzik /** 4151c6fd2807SJeff Garzik * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command 4152c6fd2807SJeff Garzik * @dev: Device to which command will be sent 4153c6fd2807SJeff Garzik * 4154c6fd2807SJeff Garzik * Issue SET FEATURES - XFER MODE command to device @dev 4155c6fd2807SJeff Garzik * on port @ap. 4156c6fd2807SJeff Garzik * 4157c6fd2807SJeff Garzik * LOCKING: 4158c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 4159c6fd2807SJeff Garzik * 4160c6fd2807SJeff Garzik * RETURNS: 4161c6fd2807SJeff Garzik * 0 on success, AC_ERR_* mask otherwise. 4162c6fd2807SJeff Garzik */ 4163c6fd2807SJeff Garzik 4164c6fd2807SJeff Garzik static unsigned int ata_dev_set_xfermode(struct ata_device *dev) 4165c6fd2807SJeff Garzik { 4166c6fd2807SJeff Garzik struct ata_taskfile tf; 4167c6fd2807SJeff Garzik unsigned int err_mask; 4168c6fd2807SJeff Garzik 4169c6fd2807SJeff Garzik /* set up set-features taskfile */ 4170c6fd2807SJeff Garzik DPRINTK("set features - xfer mode\n"); 4171c6fd2807SJeff Garzik 4172464cf177STejun Heo /* Some controllers and ATAPI devices show flaky interrupt 4173464cf177STejun Heo * behavior after setting xfer mode. Use polling instead. 4174464cf177STejun Heo */ 4175c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 4176c6fd2807SJeff Garzik tf.command = ATA_CMD_SET_FEATURES; 4177c6fd2807SJeff Garzik tf.feature = SETFEATURES_XFER; 4178464cf177STejun Heo tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_POLLING; 4179c6fd2807SJeff Garzik tf.protocol = ATA_PROT_NODATA; 4180b9f8ab2dSAlan Cox /* If we are using IORDY we must send the mode setting command */ 4181b9f8ab2dSAlan Cox if (ata_pio_need_iordy(dev)) 4182c6fd2807SJeff Garzik tf.nsect = dev->xfer_mode; 4183b9f8ab2dSAlan Cox /* If the device has IORDY and the controller does not - turn it off */ 4184b9f8ab2dSAlan Cox else if (ata_id_has_iordy(dev->id)) 4185b9f8ab2dSAlan Cox tf.nsect = 0x01; 4186b9f8ab2dSAlan Cox else /* In the ancient relic department - skip all of this */ 4187b9f8ab2dSAlan Cox return 0; 4188c6fd2807SJeff Garzik 41892b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 4190c6fd2807SJeff Garzik 4191c6fd2807SJeff Garzik DPRINTK("EXIT, err_mask=%x\n", err_mask); 4192c6fd2807SJeff Garzik return err_mask; 4193c6fd2807SJeff Garzik } 4194c6fd2807SJeff Garzik /** 4195218f3d30SJeff Garzik * ata_dev_set_feature - Issue SET FEATURES - SATA FEATURES 41969f45cbd3SKristen Carlson Accardi * @dev: Device to which command will be sent 41979f45cbd3SKristen Carlson Accardi * @enable: Whether to enable or disable the feature 4198218f3d30SJeff Garzik * @feature: The sector count represents the feature to set 41999f45cbd3SKristen Carlson Accardi * 42009f45cbd3SKristen Carlson Accardi * Issue SET FEATURES - SATA FEATURES command to device @dev 4201218f3d30SJeff Garzik * on port @ap with sector count 42029f45cbd3SKristen Carlson Accardi * 42039f45cbd3SKristen Carlson Accardi * LOCKING: 42049f45cbd3SKristen Carlson Accardi * PCI/etc. bus probe sem. 42059f45cbd3SKristen Carlson Accardi * 42069f45cbd3SKristen Carlson Accardi * RETURNS: 42079f45cbd3SKristen Carlson Accardi * 0 on success, AC_ERR_* mask otherwise. 42089f45cbd3SKristen Carlson Accardi */ 4209218f3d30SJeff Garzik static unsigned int ata_dev_set_feature(struct ata_device *dev, u8 enable, 4210218f3d30SJeff Garzik u8 feature) 42119f45cbd3SKristen Carlson Accardi { 42129f45cbd3SKristen Carlson Accardi struct ata_taskfile tf; 42139f45cbd3SKristen Carlson Accardi unsigned int err_mask; 42149f45cbd3SKristen Carlson Accardi 42159f45cbd3SKristen Carlson Accardi /* set up set-features taskfile */ 42169f45cbd3SKristen Carlson Accardi DPRINTK("set features - SATA features\n"); 42179f45cbd3SKristen Carlson Accardi 42189f45cbd3SKristen Carlson Accardi ata_tf_init(dev, &tf); 42199f45cbd3SKristen Carlson Accardi tf.command = ATA_CMD_SET_FEATURES; 42209f45cbd3SKristen Carlson Accardi tf.feature = enable; 42219f45cbd3SKristen Carlson Accardi tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 42229f45cbd3SKristen Carlson Accardi tf.protocol = ATA_PROT_NODATA; 4223218f3d30SJeff Garzik tf.nsect = feature; 42249f45cbd3SKristen Carlson Accardi 42252b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 42269f45cbd3SKristen Carlson Accardi 42279f45cbd3SKristen Carlson Accardi DPRINTK("EXIT, err_mask=%x\n", err_mask); 42289f45cbd3SKristen Carlson Accardi return err_mask; 42299f45cbd3SKristen Carlson Accardi } 42309f45cbd3SKristen Carlson Accardi 42319f45cbd3SKristen Carlson Accardi /** 4232c6fd2807SJeff Garzik * ata_dev_init_params - Issue INIT DEV PARAMS command 4233c6fd2807SJeff Garzik * @dev: Device to which command will be sent 4234c6fd2807SJeff Garzik * @heads: Number of heads (taskfile parameter) 4235c6fd2807SJeff Garzik * @sectors: Number of sectors (taskfile parameter) 4236c6fd2807SJeff Garzik * 4237c6fd2807SJeff Garzik * LOCKING: 4238c6fd2807SJeff Garzik * Kernel thread context (may sleep) 4239c6fd2807SJeff Garzik * 4240c6fd2807SJeff Garzik * RETURNS: 4241c6fd2807SJeff Garzik * 0 on success, AC_ERR_* mask otherwise. 4242c6fd2807SJeff Garzik */ 4243c6fd2807SJeff Garzik static unsigned int ata_dev_init_params(struct ata_device *dev, 4244c6fd2807SJeff Garzik u16 heads, u16 sectors) 4245c6fd2807SJeff Garzik { 4246c6fd2807SJeff Garzik struct ata_taskfile tf; 4247c6fd2807SJeff Garzik unsigned int err_mask; 4248c6fd2807SJeff Garzik 4249c6fd2807SJeff Garzik /* Number of sectors per track 1-255. Number of heads 1-16 */ 4250c6fd2807SJeff Garzik if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16) 4251c6fd2807SJeff Garzik return AC_ERR_INVALID; 4252c6fd2807SJeff Garzik 4253c6fd2807SJeff Garzik /* set up init dev params taskfile */ 4254c6fd2807SJeff Garzik DPRINTK("init dev params \n"); 4255c6fd2807SJeff Garzik 4256c6fd2807SJeff Garzik ata_tf_init(dev, &tf); 4257c6fd2807SJeff Garzik tf.command = ATA_CMD_INIT_DEV_PARAMS; 4258c6fd2807SJeff Garzik tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 4259c6fd2807SJeff Garzik tf.protocol = ATA_PROT_NODATA; 4260c6fd2807SJeff Garzik tf.nsect = sectors; 4261c6fd2807SJeff Garzik tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */ 4262c6fd2807SJeff Garzik 42632b789108STejun Heo err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 426418b2466cSAlan Cox /* A clean abort indicates an original or just out of spec drive 426518b2466cSAlan Cox and we should continue as we issue the setup based on the 426618b2466cSAlan Cox drive reported working geometry */ 426718b2466cSAlan Cox if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED)) 426818b2466cSAlan Cox err_mask = 0; 4269c6fd2807SJeff Garzik 4270c6fd2807SJeff Garzik DPRINTK("EXIT, err_mask=%x\n", err_mask); 4271c6fd2807SJeff Garzik return err_mask; 4272c6fd2807SJeff Garzik } 4273c6fd2807SJeff Garzik 4274c6fd2807SJeff Garzik /** 4275c6fd2807SJeff Garzik * ata_sg_clean - Unmap DMA memory associated with command 4276c6fd2807SJeff Garzik * @qc: Command containing DMA memory to be released 4277c6fd2807SJeff Garzik * 4278c6fd2807SJeff Garzik * Unmap all mapped DMA memory associated with this command. 4279c6fd2807SJeff Garzik * 4280c6fd2807SJeff Garzik * LOCKING: 4281cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4282c6fd2807SJeff Garzik */ 428370e6ad0cSTejun Heo void ata_sg_clean(struct ata_queued_cmd *qc) 4284c6fd2807SJeff Garzik { 4285c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4286ff2aeb1eSTejun Heo struct scatterlist *sg = qc->sg; 4287c6fd2807SJeff Garzik int dir = qc->dma_dir; 4288c6fd2807SJeff Garzik 4289c6fd2807SJeff Garzik WARN_ON(sg == NULL); 4290c6fd2807SJeff Garzik 4291dde20207SJames Bottomley VPRINTK("unmapping %u sg elements\n", qc->n_elem); 4292c6fd2807SJeff Garzik 4293dde20207SJames Bottomley if (qc->n_elem) 4294dde20207SJames Bottomley dma_unmap_sg(ap->dev, sg, qc->n_elem, dir); 4295c6fd2807SJeff Garzik 4296c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_DMAMAP; 4297ff2aeb1eSTejun Heo qc->sg = NULL; 4298c6fd2807SJeff Garzik } 4299c6fd2807SJeff Garzik 4300c6fd2807SJeff Garzik /** 43015895ef9aSTejun Heo * atapi_check_dma - Check whether ATAPI DMA can be supported 4302c6fd2807SJeff Garzik * @qc: Metadata associated with taskfile to check 4303c6fd2807SJeff Garzik * 4304c6fd2807SJeff Garzik * Allow low-level driver to filter ATA PACKET commands, returning 4305c6fd2807SJeff Garzik * a status indicating whether or not it is OK to use DMA for the 4306c6fd2807SJeff Garzik * supplied PACKET command. 4307c6fd2807SJeff Garzik * 4308c6fd2807SJeff Garzik * LOCKING: 4309cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4310c6fd2807SJeff Garzik * 4311c6fd2807SJeff Garzik * RETURNS: 0 when ATAPI DMA can be used 4312c6fd2807SJeff Garzik * nonzero otherwise 4313c6fd2807SJeff Garzik */ 43145895ef9aSTejun Heo int atapi_check_dma(struct ata_queued_cmd *qc) 4315c6fd2807SJeff Garzik { 4316c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4317c6fd2807SJeff Garzik 4318b9a4197eSTejun Heo /* Don't allow DMA if it isn't multiple of 16 bytes. Quite a 4319b9a4197eSTejun Heo * few ATAPI devices choke on such DMA requests. 4320b9a4197eSTejun Heo */ 4321b9a4197eSTejun Heo if (unlikely(qc->nbytes & 15)) 43226f23a31dSAlbert Lee return 1; 43236f23a31dSAlbert Lee 4324c6fd2807SJeff Garzik if (ap->ops->check_atapi_dma) 4325b9a4197eSTejun Heo return ap->ops->check_atapi_dma(qc); 4326c6fd2807SJeff Garzik 4327b9a4197eSTejun Heo return 0; 4328c6fd2807SJeff Garzik } 4329b9a4197eSTejun Heo 4330c6fd2807SJeff Garzik /** 433131cc23b3STejun Heo * ata_std_qc_defer - Check whether a qc needs to be deferred 433231cc23b3STejun Heo * @qc: ATA command in question 433331cc23b3STejun Heo * 433431cc23b3STejun Heo * Non-NCQ commands cannot run with any other command, NCQ or 433531cc23b3STejun Heo * not. As upper layer only knows the queue depth, we are 433631cc23b3STejun Heo * responsible for maintaining exclusion. This function checks 433731cc23b3STejun Heo * whether a new command @qc can be issued. 433831cc23b3STejun Heo * 433931cc23b3STejun Heo * LOCKING: 434031cc23b3STejun Heo * spin_lock_irqsave(host lock) 434131cc23b3STejun Heo * 434231cc23b3STejun Heo * RETURNS: 434331cc23b3STejun Heo * ATA_DEFER_* if deferring is needed, 0 otherwise. 434431cc23b3STejun Heo */ 434531cc23b3STejun Heo int ata_std_qc_defer(struct ata_queued_cmd *qc) 434631cc23b3STejun Heo { 434731cc23b3STejun Heo struct ata_link *link = qc->dev->link; 434831cc23b3STejun Heo 434931cc23b3STejun Heo if (qc->tf.protocol == ATA_PROT_NCQ) { 435031cc23b3STejun Heo if (!ata_tag_valid(link->active_tag)) 435131cc23b3STejun Heo return 0; 435231cc23b3STejun Heo } else { 435331cc23b3STejun Heo if (!ata_tag_valid(link->active_tag) && !link->sactive) 435431cc23b3STejun Heo return 0; 435531cc23b3STejun Heo } 435631cc23b3STejun Heo 435731cc23b3STejun Heo return ATA_DEFER_LINK; 435831cc23b3STejun Heo } 435931cc23b3STejun Heo 4360c6fd2807SJeff Garzik void ata_noop_qc_prep(struct ata_queued_cmd *qc) { } 4361c6fd2807SJeff Garzik 4362c6fd2807SJeff Garzik /** 4363c6fd2807SJeff Garzik * ata_sg_init - Associate command with scatter-gather table. 4364c6fd2807SJeff Garzik * @qc: Command to be associated 4365c6fd2807SJeff Garzik * @sg: Scatter-gather table. 4366c6fd2807SJeff Garzik * @n_elem: Number of elements in s/g table. 4367c6fd2807SJeff Garzik * 4368c6fd2807SJeff Garzik * Initialize the data-related elements of queued_cmd @qc 4369c6fd2807SJeff Garzik * to point to a scatter-gather table @sg, containing @n_elem 4370c6fd2807SJeff Garzik * elements. 4371c6fd2807SJeff Garzik * 4372c6fd2807SJeff Garzik * LOCKING: 4373cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4374c6fd2807SJeff Garzik */ 4375c6fd2807SJeff Garzik void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg, 4376c6fd2807SJeff Garzik unsigned int n_elem) 4377c6fd2807SJeff Garzik { 4378ff2aeb1eSTejun Heo qc->sg = sg; 4379c6fd2807SJeff Garzik qc->n_elem = n_elem; 4380ff2aeb1eSTejun Heo qc->cursg = qc->sg; 4381ff2aeb1eSTejun Heo } 4382ff2aeb1eSTejun Heo 4383c6fd2807SJeff Garzik /** 4384c6fd2807SJeff Garzik * ata_sg_setup - DMA-map the scatter-gather table associated with a command. 4385c6fd2807SJeff Garzik * @qc: Command with scatter-gather table to be mapped. 4386c6fd2807SJeff Garzik * 4387c6fd2807SJeff Garzik * DMA-map the scatter-gather table associated with queued_cmd @qc. 4388c6fd2807SJeff Garzik * 4389c6fd2807SJeff Garzik * LOCKING: 4390cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4391c6fd2807SJeff Garzik * 4392c6fd2807SJeff Garzik * RETURNS: 4393c6fd2807SJeff Garzik * Zero on success, negative on error. 4394c6fd2807SJeff Garzik * 4395c6fd2807SJeff Garzik */ 4396c6fd2807SJeff Garzik static int ata_sg_setup(struct ata_queued_cmd *qc) 4397c6fd2807SJeff Garzik { 4398c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4399dde20207SJames Bottomley unsigned int n_elem; 4400c6fd2807SJeff Garzik 440144877b4eSTejun Heo VPRINTK("ENTER, ata%u\n", ap->print_id); 4402c6fd2807SJeff Garzik 4403dde20207SJames Bottomley n_elem = dma_map_sg(ap->dev, qc->sg, qc->n_elem, qc->dma_dir); 4404dde20207SJames Bottomley if (n_elem < 1) 4405c6fd2807SJeff Garzik return -1; 4406c6fd2807SJeff Garzik 4407dde20207SJames Bottomley DPRINTK("%d sg elements mapped\n", n_elem); 4408dde20207SJames Bottomley 4409dde20207SJames Bottomley qc->n_elem = n_elem; 4410f92a2636STejun Heo qc->flags |= ATA_QCFLAG_DMAMAP; 4411c6fd2807SJeff Garzik 4412c6fd2807SJeff Garzik return 0; 4413c6fd2807SJeff Garzik } 4414c6fd2807SJeff Garzik 4415c6fd2807SJeff Garzik /** 4416c6fd2807SJeff Garzik * swap_buf_le16 - swap halves of 16-bit words in place 4417c6fd2807SJeff Garzik * @buf: Buffer to swap 4418c6fd2807SJeff Garzik * @buf_words: Number of 16-bit words in buffer. 4419c6fd2807SJeff Garzik * 4420c6fd2807SJeff Garzik * Swap halves of 16-bit words if needed to convert from 4421c6fd2807SJeff Garzik * little-endian byte order to native cpu byte order, or 4422c6fd2807SJeff Garzik * vice-versa. 4423c6fd2807SJeff Garzik * 4424c6fd2807SJeff Garzik * LOCKING: 4425c6fd2807SJeff Garzik * Inherited from caller. 4426c6fd2807SJeff Garzik */ 4427c6fd2807SJeff Garzik void swap_buf_le16(u16 *buf, unsigned int buf_words) 4428c6fd2807SJeff Garzik { 4429c6fd2807SJeff Garzik #ifdef __BIG_ENDIAN 4430c6fd2807SJeff Garzik unsigned int i; 4431c6fd2807SJeff Garzik 4432c6fd2807SJeff Garzik for (i = 0; i < buf_words; i++) 4433c6fd2807SJeff Garzik buf[i] = le16_to_cpu(buf[i]); 4434c6fd2807SJeff Garzik #endif /* __BIG_ENDIAN */ 4435c6fd2807SJeff Garzik } 4436c6fd2807SJeff Garzik 4437c6fd2807SJeff Garzik /** 4438c6fd2807SJeff Garzik * ata_qc_new - Request an available ATA command, for queueing 4439c6fd2807SJeff Garzik * @ap: Port associated with device @dev 4440c6fd2807SJeff Garzik * @dev: Device from whom we request an available command structure 4441c6fd2807SJeff Garzik * 4442c6fd2807SJeff Garzik * LOCKING: 4443c6fd2807SJeff Garzik * None. 4444c6fd2807SJeff Garzik */ 4445c6fd2807SJeff Garzik 4446c6fd2807SJeff Garzik static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap) 4447c6fd2807SJeff Garzik { 4448c6fd2807SJeff Garzik struct ata_queued_cmd *qc = NULL; 4449c6fd2807SJeff Garzik unsigned int i; 4450c6fd2807SJeff Garzik 4451c6fd2807SJeff Garzik /* no command while frozen */ 4452c6fd2807SJeff Garzik if (unlikely(ap->pflags & ATA_PFLAG_FROZEN)) 4453c6fd2807SJeff Garzik return NULL; 4454c6fd2807SJeff Garzik 4455c6fd2807SJeff Garzik /* the last tag is reserved for internal command. */ 4456c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_QUEUE - 1; i++) 4457c6fd2807SJeff Garzik if (!test_and_set_bit(i, &ap->qc_allocated)) { 4458c6fd2807SJeff Garzik qc = __ata_qc_from_tag(ap, i); 4459c6fd2807SJeff Garzik break; 4460c6fd2807SJeff Garzik } 4461c6fd2807SJeff Garzik 4462c6fd2807SJeff Garzik if (qc) 4463c6fd2807SJeff Garzik qc->tag = i; 4464c6fd2807SJeff Garzik 4465c6fd2807SJeff Garzik return qc; 4466c6fd2807SJeff Garzik } 4467c6fd2807SJeff Garzik 4468c6fd2807SJeff Garzik /** 4469c6fd2807SJeff Garzik * ata_qc_new_init - Request an available ATA command, and initialize it 4470c6fd2807SJeff Garzik * @dev: Device from whom we request an available command structure 4471c6fd2807SJeff Garzik * 4472c6fd2807SJeff Garzik * LOCKING: 4473c6fd2807SJeff Garzik * None. 4474c6fd2807SJeff Garzik */ 4475c6fd2807SJeff Garzik 4476c6fd2807SJeff Garzik struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev) 4477c6fd2807SJeff Garzik { 44789af5c9c9STejun Heo struct ata_port *ap = dev->link->ap; 4479c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 4480c6fd2807SJeff Garzik 4481c6fd2807SJeff Garzik qc = ata_qc_new(ap); 4482c6fd2807SJeff Garzik if (qc) { 4483c6fd2807SJeff Garzik qc->scsicmd = NULL; 4484c6fd2807SJeff Garzik qc->ap = ap; 4485c6fd2807SJeff Garzik qc->dev = dev; 4486c6fd2807SJeff Garzik 4487c6fd2807SJeff Garzik ata_qc_reinit(qc); 4488c6fd2807SJeff Garzik } 4489c6fd2807SJeff Garzik 4490c6fd2807SJeff Garzik return qc; 4491c6fd2807SJeff Garzik } 4492c6fd2807SJeff Garzik 4493c6fd2807SJeff Garzik /** 4494c6fd2807SJeff Garzik * ata_qc_free - free unused ata_queued_cmd 4495c6fd2807SJeff Garzik * @qc: Command to complete 4496c6fd2807SJeff Garzik * 4497c6fd2807SJeff Garzik * Designed to free unused ata_queued_cmd object 4498c6fd2807SJeff Garzik * in case something prevents using it. 4499c6fd2807SJeff Garzik * 4500c6fd2807SJeff Garzik * LOCKING: 4501cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4502c6fd2807SJeff Garzik */ 4503c6fd2807SJeff Garzik void ata_qc_free(struct ata_queued_cmd *qc) 4504c6fd2807SJeff Garzik { 4505c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4506c6fd2807SJeff Garzik unsigned int tag; 4507c6fd2807SJeff Garzik 4508c6fd2807SJeff Garzik WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */ 4509c6fd2807SJeff Garzik 4510c6fd2807SJeff Garzik qc->flags = 0; 4511c6fd2807SJeff Garzik tag = qc->tag; 4512c6fd2807SJeff Garzik if (likely(ata_tag_valid(tag))) { 4513c6fd2807SJeff Garzik qc->tag = ATA_TAG_POISON; 4514c6fd2807SJeff Garzik clear_bit(tag, &ap->qc_allocated); 4515c6fd2807SJeff Garzik } 4516c6fd2807SJeff Garzik } 4517c6fd2807SJeff Garzik 4518c6fd2807SJeff Garzik void __ata_qc_complete(struct ata_queued_cmd *qc) 4519c6fd2807SJeff Garzik { 4520c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 45219af5c9c9STejun Heo struct ata_link *link = qc->dev->link; 4522c6fd2807SJeff Garzik 4523c6fd2807SJeff Garzik WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */ 4524c6fd2807SJeff Garzik WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE)); 4525c6fd2807SJeff Garzik 4526c6fd2807SJeff Garzik if (likely(qc->flags & ATA_QCFLAG_DMAMAP)) 4527c6fd2807SJeff Garzik ata_sg_clean(qc); 4528c6fd2807SJeff Garzik 4529c6fd2807SJeff Garzik /* command should be marked inactive atomically with qc completion */ 4530da917d69STejun Heo if (qc->tf.protocol == ATA_PROT_NCQ) { 45319af5c9c9STejun Heo link->sactive &= ~(1 << qc->tag); 4532da917d69STejun Heo if (!link->sactive) 4533da917d69STejun Heo ap->nr_active_links--; 4534da917d69STejun Heo } else { 45359af5c9c9STejun Heo link->active_tag = ATA_TAG_POISON; 4536da917d69STejun Heo ap->nr_active_links--; 4537da917d69STejun Heo } 4538da917d69STejun Heo 4539da917d69STejun Heo /* clear exclusive status */ 4540da917d69STejun Heo if (unlikely(qc->flags & ATA_QCFLAG_CLEAR_EXCL && 4541da917d69STejun Heo ap->excl_link == link)) 4542da917d69STejun Heo ap->excl_link = NULL; 4543c6fd2807SJeff Garzik 4544c6fd2807SJeff Garzik /* atapi: mark qc as inactive to prevent the interrupt handler 4545c6fd2807SJeff Garzik * from completing the command twice later, before the error handler 4546c6fd2807SJeff Garzik * is called. (when rc != 0 and atapi request sense is needed) 4547c6fd2807SJeff Garzik */ 4548c6fd2807SJeff Garzik qc->flags &= ~ATA_QCFLAG_ACTIVE; 4549c6fd2807SJeff Garzik ap->qc_active &= ~(1 << qc->tag); 4550c6fd2807SJeff Garzik 4551c6fd2807SJeff Garzik /* call completion callback */ 4552c6fd2807SJeff Garzik qc->complete_fn(qc); 4553c6fd2807SJeff Garzik } 4554c6fd2807SJeff Garzik 455539599a53STejun Heo static void fill_result_tf(struct ata_queued_cmd *qc) 455639599a53STejun Heo { 455739599a53STejun Heo struct ata_port *ap = qc->ap; 455839599a53STejun Heo 455939599a53STejun Heo qc->result_tf.flags = qc->tf.flags; 456022183bf5STejun Heo ap->ops->qc_fill_rtf(qc); 456139599a53STejun Heo } 456239599a53STejun Heo 456300115e0fSTejun Heo static void ata_verify_xfer(struct ata_queued_cmd *qc) 456400115e0fSTejun Heo { 456500115e0fSTejun Heo struct ata_device *dev = qc->dev; 456600115e0fSTejun Heo 456700115e0fSTejun Heo if (ata_tag_internal(qc->tag)) 456800115e0fSTejun Heo return; 456900115e0fSTejun Heo 457000115e0fSTejun Heo if (ata_is_nodata(qc->tf.protocol)) 457100115e0fSTejun Heo return; 457200115e0fSTejun Heo 457300115e0fSTejun Heo if ((dev->mwdma_mask || dev->udma_mask) && ata_is_pio(qc->tf.protocol)) 457400115e0fSTejun Heo return; 457500115e0fSTejun Heo 457600115e0fSTejun Heo dev->flags &= ~ATA_DFLAG_DUBIOUS_XFER; 457700115e0fSTejun Heo } 457800115e0fSTejun Heo 4579c6fd2807SJeff Garzik /** 4580c6fd2807SJeff Garzik * ata_qc_complete - Complete an active ATA command 4581c6fd2807SJeff Garzik * @qc: Command to complete 4582c6fd2807SJeff Garzik * @err_mask: ATA Status register contents 4583c6fd2807SJeff Garzik * 4584c6fd2807SJeff Garzik * Indicate to the mid and upper layers that an ATA 4585c6fd2807SJeff Garzik * command has completed, with either an ok or not-ok status. 4586c6fd2807SJeff Garzik * 4587c6fd2807SJeff Garzik * LOCKING: 4588cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4589c6fd2807SJeff Garzik */ 4590c6fd2807SJeff Garzik void ata_qc_complete(struct ata_queued_cmd *qc) 4591c6fd2807SJeff Garzik { 4592c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 4593c6fd2807SJeff Garzik 4594c6fd2807SJeff Garzik /* XXX: New EH and old EH use different mechanisms to 4595c6fd2807SJeff Garzik * synchronize EH with regular execution path. 4596c6fd2807SJeff Garzik * 4597c6fd2807SJeff Garzik * In new EH, a failed qc is marked with ATA_QCFLAG_FAILED. 4598c6fd2807SJeff Garzik * Normal execution path is responsible for not accessing a 4599c6fd2807SJeff Garzik * failed qc. libata core enforces the rule by returning NULL 4600c6fd2807SJeff Garzik * from ata_qc_from_tag() for failed qcs. 4601c6fd2807SJeff Garzik * 4602c6fd2807SJeff Garzik * Old EH depends on ata_qc_complete() nullifying completion 4603c6fd2807SJeff Garzik * requests if ATA_QCFLAG_EH_SCHEDULED is set. Old EH does 4604c6fd2807SJeff Garzik * not synchronize with interrupt handler. Only PIO task is 4605c6fd2807SJeff Garzik * taken care of. 4606c6fd2807SJeff Garzik */ 4607c6fd2807SJeff Garzik if (ap->ops->error_handler) { 46084dbfa39bSTejun Heo struct ata_device *dev = qc->dev; 46094dbfa39bSTejun Heo struct ata_eh_info *ehi = &dev->link->eh_info; 46104dbfa39bSTejun Heo 4611c6fd2807SJeff Garzik WARN_ON(ap->pflags & ATA_PFLAG_FROZEN); 4612c6fd2807SJeff Garzik 4613c6fd2807SJeff Garzik if (unlikely(qc->err_mask)) 4614c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_FAILED; 4615c6fd2807SJeff Garzik 4616c6fd2807SJeff Garzik if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) { 4617c6fd2807SJeff Garzik if (!ata_tag_internal(qc->tag)) { 4618c6fd2807SJeff Garzik /* always fill result TF for failed qc */ 461939599a53STejun Heo fill_result_tf(qc); 4620c6fd2807SJeff Garzik ata_qc_schedule_eh(qc); 4621c6fd2807SJeff Garzik return; 4622c6fd2807SJeff Garzik } 4623c6fd2807SJeff Garzik } 4624c6fd2807SJeff Garzik 4625c6fd2807SJeff Garzik /* read result TF if requested */ 4626c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_RESULT_TF) 462739599a53STejun Heo fill_result_tf(qc); 4628c6fd2807SJeff Garzik 46294dbfa39bSTejun Heo /* Some commands need post-processing after successful 46304dbfa39bSTejun Heo * completion. 46314dbfa39bSTejun Heo */ 46324dbfa39bSTejun Heo switch (qc->tf.command) { 46334dbfa39bSTejun Heo case ATA_CMD_SET_FEATURES: 46344dbfa39bSTejun Heo if (qc->tf.feature != SETFEATURES_WC_ON && 46354dbfa39bSTejun Heo qc->tf.feature != SETFEATURES_WC_OFF) 46364dbfa39bSTejun Heo break; 46374dbfa39bSTejun Heo /* fall through */ 46384dbfa39bSTejun Heo case ATA_CMD_INIT_DEV_PARAMS: /* CHS translation changed */ 46394dbfa39bSTejun Heo case ATA_CMD_SET_MULTI: /* multi_count changed */ 46404dbfa39bSTejun Heo /* revalidate device */ 46414dbfa39bSTejun Heo ehi->dev_action[dev->devno] |= ATA_EH_REVALIDATE; 46424dbfa39bSTejun Heo ata_port_schedule_eh(ap); 46434dbfa39bSTejun Heo break; 4644054a5fbaSTejun Heo 4645054a5fbaSTejun Heo case ATA_CMD_SLEEP: 4646054a5fbaSTejun Heo dev->flags |= ATA_DFLAG_SLEEPING; 4647054a5fbaSTejun Heo break; 46484dbfa39bSTejun Heo } 46494dbfa39bSTejun Heo 465000115e0fSTejun Heo if (unlikely(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) 465100115e0fSTejun Heo ata_verify_xfer(qc); 465200115e0fSTejun Heo 4653c6fd2807SJeff Garzik __ata_qc_complete(qc); 4654c6fd2807SJeff Garzik } else { 4655c6fd2807SJeff Garzik if (qc->flags & ATA_QCFLAG_EH_SCHEDULED) 4656c6fd2807SJeff Garzik return; 4657c6fd2807SJeff Garzik 4658c6fd2807SJeff Garzik /* read result TF if failed or requested */ 4659c6fd2807SJeff Garzik if (qc->err_mask || qc->flags & ATA_QCFLAG_RESULT_TF) 466039599a53STejun Heo fill_result_tf(qc); 4661c6fd2807SJeff Garzik 4662c6fd2807SJeff Garzik __ata_qc_complete(qc); 4663c6fd2807SJeff Garzik } 4664c6fd2807SJeff Garzik } 4665c6fd2807SJeff Garzik 4666c6fd2807SJeff Garzik /** 4667c6fd2807SJeff Garzik * ata_qc_complete_multiple - Complete multiple qcs successfully 4668c6fd2807SJeff Garzik * @ap: port in question 4669c6fd2807SJeff Garzik * @qc_active: new qc_active mask 4670c6fd2807SJeff Garzik * 4671c6fd2807SJeff Garzik * Complete in-flight commands. This functions is meant to be 4672c6fd2807SJeff Garzik * called from low-level driver's interrupt routine to complete 4673c6fd2807SJeff Garzik * requests normally. ap->qc_active and @qc_active is compared 4674c6fd2807SJeff Garzik * and commands are completed accordingly. 4675c6fd2807SJeff Garzik * 4676c6fd2807SJeff Garzik * LOCKING: 4677cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4678c6fd2807SJeff Garzik * 4679c6fd2807SJeff Garzik * RETURNS: 4680c6fd2807SJeff Garzik * Number of completed commands on success, -errno otherwise. 4681c6fd2807SJeff Garzik */ 468279f97dadSTejun Heo int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active) 4683c6fd2807SJeff Garzik { 4684c6fd2807SJeff Garzik int nr_done = 0; 4685c6fd2807SJeff Garzik u32 done_mask; 4686c6fd2807SJeff Garzik int i; 4687c6fd2807SJeff Garzik 4688c6fd2807SJeff Garzik done_mask = ap->qc_active ^ qc_active; 4689c6fd2807SJeff Garzik 4690c6fd2807SJeff Garzik if (unlikely(done_mask & qc_active)) { 4691c6fd2807SJeff Garzik ata_port_printk(ap, KERN_ERR, "illegal qc_active transition " 4692c6fd2807SJeff Garzik "(%08x->%08x)\n", ap->qc_active, qc_active); 4693c6fd2807SJeff Garzik return -EINVAL; 4694c6fd2807SJeff Garzik } 4695c6fd2807SJeff Garzik 4696c6fd2807SJeff Garzik for (i = 0; i < ATA_MAX_QUEUE; i++) { 4697c6fd2807SJeff Garzik struct ata_queued_cmd *qc; 4698c6fd2807SJeff Garzik 4699c6fd2807SJeff Garzik if (!(done_mask & (1 << i))) 4700c6fd2807SJeff Garzik continue; 4701c6fd2807SJeff Garzik 4702c6fd2807SJeff Garzik if ((qc = ata_qc_from_tag(ap, i))) { 4703c6fd2807SJeff Garzik ata_qc_complete(qc); 4704c6fd2807SJeff Garzik nr_done++; 4705c6fd2807SJeff Garzik } 4706c6fd2807SJeff Garzik } 4707c6fd2807SJeff Garzik 4708c6fd2807SJeff Garzik return nr_done; 4709c6fd2807SJeff Garzik } 4710c6fd2807SJeff Garzik 4711c6fd2807SJeff Garzik /** 4712c6fd2807SJeff Garzik * ata_qc_issue - issue taskfile to device 4713c6fd2807SJeff Garzik * @qc: command to issue to device 4714c6fd2807SJeff Garzik * 4715c6fd2807SJeff Garzik * Prepare an ATA command to submission to device. 4716c6fd2807SJeff Garzik * This includes mapping the data into a DMA-able 4717c6fd2807SJeff Garzik * area, filling in the S/G table, and finally 4718c6fd2807SJeff Garzik * writing the taskfile to hardware, starting the command. 4719c6fd2807SJeff Garzik * 4720c6fd2807SJeff Garzik * LOCKING: 4721cca3974eSJeff Garzik * spin_lock_irqsave(host lock) 4722c6fd2807SJeff Garzik */ 4723c6fd2807SJeff Garzik void ata_qc_issue(struct ata_queued_cmd *qc) 4724c6fd2807SJeff Garzik { 4725c6fd2807SJeff Garzik struct ata_port *ap = qc->ap; 47269af5c9c9STejun Heo struct ata_link *link = qc->dev->link; 4727405e66b3STejun Heo u8 prot = qc->tf.protocol; 4728c6fd2807SJeff Garzik 4729c6fd2807SJeff Garzik /* Make sure only one non-NCQ command is outstanding. The 4730c6fd2807SJeff Garzik * check is skipped for old EH because it reuses active qc to 4731c6fd2807SJeff Garzik * request ATAPI sense. 4732c6fd2807SJeff Garzik */ 47339af5c9c9STejun Heo WARN_ON(ap->ops->error_handler && ata_tag_valid(link->active_tag)); 4734c6fd2807SJeff Garzik 47351973a023STejun Heo if (ata_is_ncq(prot)) { 47369af5c9c9STejun Heo WARN_ON(link->sactive & (1 << qc->tag)); 4737da917d69STejun Heo 4738da917d69STejun Heo if (!link->sactive) 4739da917d69STejun Heo ap->nr_active_links++; 47409af5c9c9STejun Heo link->sactive |= 1 << qc->tag; 4741c6fd2807SJeff Garzik } else { 47429af5c9c9STejun Heo WARN_ON(link->sactive); 4743da917d69STejun Heo 4744da917d69STejun Heo ap->nr_active_links++; 47459af5c9c9STejun Heo link->active_tag = qc->tag; 4746c6fd2807SJeff Garzik } 4747c6fd2807SJeff Garzik 4748c6fd2807SJeff Garzik qc->flags |= ATA_QCFLAG_ACTIVE; 4749c6fd2807SJeff Garzik ap->qc_active |= 1 << qc->tag; 4750c6fd2807SJeff Garzik 4751f92a2636STejun Heo /* We guarantee to LLDs that they will have at least one 4752f92a2636STejun Heo * non-zero sg if the command is a data command. 4753f92a2636STejun Heo */ 4754ff2aeb1eSTejun Heo BUG_ON(ata_is_data(prot) && (!qc->sg || !qc->n_elem || !qc->nbytes)); 4755f92a2636STejun Heo 4756405e66b3STejun Heo if (ata_is_dma(prot) || (ata_is_pio(prot) && 4757f92a2636STejun Heo (ap->flags & ATA_FLAG_PIO_DMA))) 4758c6fd2807SJeff Garzik if (ata_sg_setup(qc)) 4759c6fd2807SJeff Garzik goto sg_err; 4760c6fd2807SJeff Garzik 4761cf480626STejun Heo /* if device is sleeping, schedule reset and abort the link */ 4762054a5fbaSTejun Heo if (unlikely(qc->dev->flags & ATA_DFLAG_SLEEPING)) { 4763cf480626STejun Heo link->eh_info.action |= ATA_EH_RESET; 4764054a5fbaSTejun Heo ata_ehi_push_desc(&link->eh_info, "waking up from sleep"); 4765054a5fbaSTejun Heo ata_link_abort(link); 4766054a5fbaSTejun Heo return; 4767054a5fbaSTejun Heo } 4768054a5fbaSTejun Heo 4769c6fd2807SJeff Garzik ap->ops->qc_prep(qc); 4770c6fd2807SJeff Garzik 4771c6fd2807SJeff Garzik qc->err_mask |= ap->ops->qc_issue(qc); 4772c6fd2807SJeff Garzik if (unlikely(qc->err_mask)) 4773c6fd2807SJeff Garzik goto err; 4774c6fd2807SJeff Garzik return; 4775c6fd2807SJeff Garzik 4776c6fd2807SJeff Garzik sg_err: 4777c6fd2807SJeff Garzik qc->err_mask |= AC_ERR_SYSTEM; 4778c6fd2807SJeff Garzik err: 4779c6fd2807SJeff Garzik ata_qc_complete(qc); 4780c6fd2807SJeff Garzik } 4781c6fd2807SJeff Garzik 4782c6fd2807SJeff Garzik /** 4783c6fd2807SJeff Garzik * sata_scr_valid - test whether SCRs are accessible 4784936fd732STejun Heo * @link: ATA link to test SCR accessibility for 4785c6fd2807SJeff Garzik * 4786936fd732STejun Heo * Test whether SCRs are accessible for @link. 4787c6fd2807SJeff Garzik * 4788c6fd2807SJeff Garzik * LOCKING: 4789c6fd2807SJeff Garzik * None. 4790c6fd2807SJeff Garzik * 4791c6fd2807SJeff Garzik * RETURNS: 4792c6fd2807SJeff Garzik * 1 if SCRs are accessible, 0 otherwise. 4793c6fd2807SJeff Garzik */ 4794936fd732STejun Heo int sata_scr_valid(struct ata_link *link) 4795c6fd2807SJeff Garzik { 4796936fd732STejun Heo struct ata_port *ap = link->ap; 4797936fd732STejun Heo 4798a16abc0bSTejun Heo return (ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read; 4799c6fd2807SJeff Garzik } 4800c6fd2807SJeff Garzik 4801c6fd2807SJeff Garzik /** 4802c6fd2807SJeff Garzik * sata_scr_read - read SCR register of the specified port 4803936fd732STejun Heo * @link: ATA link to read SCR for 4804c6fd2807SJeff Garzik * @reg: SCR to read 4805c6fd2807SJeff Garzik * @val: Place to store read value 4806c6fd2807SJeff Garzik * 4807936fd732STejun Heo * Read SCR register @reg of @link into *@val. This function is 4808633273a3STejun Heo * guaranteed to succeed if @link is ap->link, the cable type of 4809633273a3STejun Heo * the port is SATA and the port implements ->scr_read. 4810c6fd2807SJeff Garzik * 4811c6fd2807SJeff Garzik * LOCKING: 4812633273a3STejun Heo * None if @link is ap->link. Kernel thread context otherwise. 4813c6fd2807SJeff Garzik * 4814c6fd2807SJeff Garzik * RETURNS: 4815c6fd2807SJeff Garzik * 0 on success, negative errno on failure. 4816c6fd2807SJeff Garzik */ 4817936fd732STejun Heo int sata_scr_read(struct ata_link *link, int reg, u32 *val) 4818c6fd2807SJeff Garzik { 4819633273a3STejun Heo if (ata_is_host_link(link)) { 4820936fd732STejun Heo struct ata_port *ap = link->ap; 4821936fd732STejun Heo 4822936fd732STejun Heo if (sata_scr_valid(link)) 4823da3dbb17STejun Heo return ap->ops->scr_read(ap, reg, val); 4824c6fd2807SJeff Garzik return -EOPNOTSUPP; 4825c6fd2807SJeff Garzik } 4826c6fd2807SJeff Garzik 4827633273a3STejun Heo return sata_pmp_scr_read(link, reg, val); 4828633273a3STejun Heo } 4829633273a3STejun Heo 4830c6fd2807SJeff Garzik /** 4831c6fd2807SJeff Garzik * sata_scr_write - write SCR register of the specified port 4832936fd732STejun Heo * @link: ATA link to write SCR for 4833c6fd2807SJeff Garzik * @reg: SCR to write 4834c6fd2807SJeff Garzik * @val: value to write 4835c6fd2807SJeff Garzik * 4836936fd732STejun Heo * Write @val to SCR register @reg of @link. This function is 4837633273a3STejun Heo * guaranteed to succeed if @link is ap->link, the cable type of 4838633273a3STejun Heo * the port is SATA and the port implements ->scr_read. 4839c6fd2807SJeff Garzik * 4840c6fd2807SJeff Garzik * LOCKING: 4841633273a3STejun Heo * None if @link is ap->link. Kernel thread context otherwise. 4842c6fd2807SJeff Garzik * 4843c6fd2807SJeff Garzik * RETURNS: 4844c6fd2807SJeff Garzik * 0 on success, negative errno on failure. 4845c6fd2807SJeff Garzik */ 4846936fd732STejun Heo int sata_scr_write(struct ata_link *link, int reg, u32 val) 4847c6fd2807SJeff Garzik { 4848633273a3STejun Heo if (ata_is_host_link(link)) { 4849936fd732STejun Heo struct ata_port *ap = link->ap; 4850936fd732STejun Heo 4851936fd732STejun Heo if (sata_scr_valid(link)) 4852da3dbb17STejun Heo return ap->ops->scr_write(ap, reg, val); 4853c6fd2807SJeff Garzik return -EOPNOTSUPP; 4854c6fd2807SJeff Garzik } 4855c6fd2807SJeff Garzik 4856633273a3STejun Heo return sata_pmp_scr_write(link, reg, val); 4857633273a3STejun Heo } 4858633273a3STejun Heo 4859c6fd2807SJeff Garzik /** 4860c6fd2807SJeff Garzik * sata_scr_write_flush - write SCR register of the specified port and flush 4861936fd732STejun Heo * @link: ATA link to write SCR for 4862c6fd2807SJeff Garzik * @reg: SCR to write 4863c6fd2807SJeff Garzik * @val: value to write 4864c6fd2807SJeff Garzik * 4865c6fd2807SJeff Garzik * This function is identical to sata_scr_write() except that this 4866c6fd2807SJeff Garzik * function performs flush after writing to the register. 4867c6fd2807SJeff Garzik * 4868c6fd2807SJeff Garzik * LOCKING: 4869633273a3STejun Heo * None if @link is ap->link. Kernel thread context otherwise. 4870c6fd2807SJeff Garzik * 4871c6fd2807SJeff Garzik * RETURNS: 4872c6fd2807SJeff Garzik * 0 on success, negative errno on failure. 4873c6fd2807SJeff Garzik */ 4874936fd732STejun Heo int sata_scr_write_flush(struct ata_link *link, int reg, u32 val) 4875c6fd2807SJeff Garzik { 4876633273a3STejun Heo if (ata_is_host_link(link)) { 4877936fd732STejun Heo struct ata_port *ap = link->ap; 4878da3dbb17STejun Heo int rc; 4879da3dbb17STejun Heo 4880936fd732STejun Heo if (sata_scr_valid(link)) { 4881da3dbb17STejun Heo rc = ap->ops->scr_write(ap, reg, val); 4882da3dbb17STejun Heo if (rc == 0) 4883da3dbb17STejun Heo rc = ap->ops->scr_read(ap, reg, &val); 4884da3dbb17STejun Heo return rc; 4885c6fd2807SJeff Garzik } 4886c6fd2807SJeff Garzik return -EOPNOTSUPP; 4887c6fd2807SJeff Garzik } 4888c6fd2807SJeff Garzik 4889633273a3STejun Heo return sata_pmp_scr_write(link, reg, val); 4890633273a3STejun Heo } 4891633273a3STejun Heo 4892c6fd2807SJeff Garzik /** 4893936fd732STejun Heo * ata_link_online - test whether the given link is online 4894936fd732STejun Heo * @link: ATA link to test 4895c6fd2807SJeff Garzik * 4896936fd732STejun Heo * Test whether @link is online. Note that this function returns 4897936fd732STejun Heo * 0 if online status of @link cannot be obtained, so 4898936fd732STejun Heo * ata_link_online(link) != !ata_link_offline(link). 4899c6fd2807SJeff Garzik * 4900c6fd2807SJeff Garzik * LOCKING: 4901c6fd2807SJeff Garzik * None. 4902c6fd2807SJeff Garzik * 4903c6fd2807SJeff Garzik * RETURNS: 4904c6fd2807SJeff Garzik * 1 if the port online status is available and online. 4905c6fd2807SJeff Garzik */ 4906936fd732STejun Heo int ata_link_online(struct ata_link *link) 4907c6fd2807SJeff Garzik { 4908c6fd2807SJeff Garzik u32 sstatus; 4909c6fd2807SJeff Garzik 4910936fd732STejun Heo if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 && 4911936fd732STejun Heo (sstatus & 0xf) == 0x3) 4912c6fd2807SJeff Garzik return 1; 4913c6fd2807SJeff Garzik return 0; 4914c6fd2807SJeff Garzik } 4915c6fd2807SJeff Garzik 4916c6fd2807SJeff Garzik /** 4917936fd732STejun Heo * ata_link_offline - test whether the given link is offline 4918936fd732STejun Heo * @link: ATA link to test 4919c6fd2807SJeff Garzik * 4920936fd732STejun Heo * Test whether @link is offline. Note that this function 4921936fd732STejun Heo * returns 0 if offline status of @link cannot be obtained, so 4922936fd732STejun Heo * ata_link_online(link) != !ata_link_offline(link). 4923c6fd2807SJeff Garzik * 4924c6fd2807SJeff Garzik * LOCKING: 4925c6fd2807SJeff Garzik * None. 4926c6fd2807SJeff Garzik * 4927c6fd2807SJeff Garzik * RETURNS: 4928c6fd2807SJeff Garzik * 1 if the port offline status is available and offline. 4929c6fd2807SJeff Garzik */ 4930936fd732STejun Heo int ata_link_offline(struct ata_link *link) 4931c6fd2807SJeff Garzik { 4932c6fd2807SJeff Garzik u32 sstatus; 4933c6fd2807SJeff Garzik 4934936fd732STejun Heo if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 && 4935936fd732STejun Heo (sstatus & 0xf) != 0x3) 4936c6fd2807SJeff Garzik return 1; 4937c6fd2807SJeff Garzik return 0; 4938c6fd2807SJeff Garzik } 4939c6fd2807SJeff Garzik 49406ffa01d8STejun Heo #ifdef CONFIG_PM 4941cca3974eSJeff Garzik static int ata_host_request_pm(struct ata_host *host, pm_message_t mesg, 4942cca3974eSJeff Garzik unsigned int action, unsigned int ehi_flags, 4943cca3974eSJeff Garzik int wait) 4944c6fd2807SJeff Garzik { 4945c6fd2807SJeff Garzik unsigned long flags; 4946c6fd2807SJeff Garzik int i, rc; 4947c6fd2807SJeff Garzik 4948cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 4949cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 4950e3667ebfSTejun Heo struct ata_link *link; 4951c6fd2807SJeff Garzik 4952c6fd2807SJeff Garzik /* Previous resume operation might still be in 4953c6fd2807SJeff Garzik * progress. Wait for PM_PENDING to clear. 4954c6fd2807SJeff Garzik */ 4955c6fd2807SJeff Garzik if (ap->pflags & ATA_PFLAG_PM_PENDING) { 4956c6fd2807SJeff Garzik ata_port_wait_eh(ap); 4957c6fd2807SJeff Garzik WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING); 4958c6fd2807SJeff Garzik } 4959c6fd2807SJeff Garzik 4960c6fd2807SJeff Garzik /* request PM ops to EH */ 4961c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 4962c6fd2807SJeff Garzik 4963c6fd2807SJeff Garzik ap->pm_mesg = mesg; 4964c6fd2807SJeff Garzik if (wait) { 4965c6fd2807SJeff Garzik rc = 0; 4966c6fd2807SJeff Garzik ap->pm_result = &rc; 4967c6fd2807SJeff Garzik } 4968c6fd2807SJeff Garzik 4969c6fd2807SJeff Garzik ap->pflags |= ATA_PFLAG_PM_PENDING; 4970e3667ebfSTejun Heo __ata_port_for_each_link(link, ap) { 4971e3667ebfSTejun Heo link->eh_info.action |= action; 4972e3667ebfSTejun Heo link->eh_info.flags |= ehi_flags; 4973e3667ebfSTejun Heo } 4974c6fd2807SJeff Garzik 4975c6fd2807SJeff Garzik ata_port_schedule_eh(ap); 4976c6fd2807SJeff Garzik 4977c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 4978c6fd2807SJeff Garzik 4979c6fd2807SJeff Garzik /* wait and check result */ 4980c6fd2807SJeff Garzik if (wait) { 4981c6fd2807SJeff Garzik ata_port_wait_eh(ap); 4982c6fd2807SJeff Garzik WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING); 4983c6fd2807SJeff Garzik if (rc) 4984c6fd2807SJeff Garzik return rc; 4985c6fd2807SJeff Garzik } 4986c6fd2807SJeff Garzik } 4987c6fd2807SJeff Garzik 4988c6fd2807SJeff Garzik return 0; 4989c6fd2807SJeff Garzik } 4990c6fd2807SJeff Garzik 4991c6fd2807SJeff Garzik /** 4992cca3974eSJeff Garzik * ata_host_suspend - suspend host 4993cca3974eSJeff Garzik * @host: host to suspend 4994c6fd2807SJeff Garzik * @mesg: PM message 4995c6fd2807SJeff Garzik * 4996cca3974eSJeff Garzik * Suspend @host. Actual operation is performed by EH. This 4997c6fd2807SJeff Garzik * function requests EH to perform PM operations and waits for EH 4998c6fd2807SJeff Garzik * to finish. 4999c6fd2807SJeff Garzik * 5000c6fd2807SJeff Garzik * LOCKING: 5001c6fd2807SJeff Garzik * Kernel thread context (may sleep). 5002c6fd2807SJeff Garzik * 5003c6fd2807SJeff Garzik * RETURNS: 5004c6fd2807SJeff Garzik * 0 on success, -errno on failure. 5005c6fd2807SJeff Garzik */ 5006cca3974eSJeff Garzik int ata_host_suspend(struct ata_host *host, pm_message_t mesg) 5007c6fd2807SJeff Garzik { 50089666f400STejun Heo int rc; 5009c6fd2807SJeff Garzik 5010ca77329fSKristen Carlson Accardi /* 5011ca77329fSKristen Carlson Accardi * disable link pm on all ports before requesting 5012ca77329fSKristen Carlson Accardi * any pm activity 5013ca77329fSKristen Carlson Accardi */ 5014ca77329fSKristen Carlson Accardi ata_lpm_enable(host); 5015ca77329fSKristen Carlson Accardi 5016cca3974eSJeff Garzik rc = ata_host_request_pm(host, mesg, 0, ATA_EHI_QUIET, 1); 501772ad6ec4SJeff Garzik if (rc == 0) 501872ad6ec4SJeff Garzik host->dev->power.power_state = mesg; 5019c6fd2807SJeff Garzik return rc; 5020c6fd2807SJeff Garzik } 5021c6fd2807SJeff Garzik 5022c6fd2807SJeff Garzik /** 5023cca3974eSJeff Garzik * ata_host_resume - resume host 5024cca3974eSJeff Garzik * @host: host to resume 5025c6fd2807SJeff Garzik * 5026cca3974eSJeff Garzik * Resume @host. Actual operation is performed by EH. This 5027c6fd2807SJeff Garzik * function requests EH to perform PM operations and returns. 5028c6fd2807SJeff Garzik * Note that all resume operations are performed parallely. 5029c6fd2807SJeff Garzik * 5030c6fd2807SJeff Garzik * LOCKING: 5031c6fd2807SJeff Garzik * Kernel thread context (may sleep). 5032c6fd2807SJeff Garzik */ 5033cca3974eSJeff Garzik void ata_host_resume(struct ata_host *host) 5034c6fd2807SJeff Garzik { 5035cf480626STejun Heo ata_host_request_pm(host, PMSG_ON, ATA_EH_RESET, 5036c6fd2807SJeff Garzik ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET, 0); 503772ad6ec4SJeff Garzik host->dev->power.power_state = PMSG_ON; 5038ca77329fSKristen Carlson Accardi 5039ca77329fSKristen Carlson Accardi /* reenable link pm */ 5040ca77329fSKristen Carlson Accardi ata_lpm_disable(host); 5041c6fd2807SJeff Garzik } 50426ffa01d8STejun Heo #endif 5043c6fd2807SJeff Garzik 5044c6fd2807SJeff Garzik /** 5045c6fd2807SJeff Garzik * ata_port_start - Set port up for dma. 5046c6fd2807SJeff Garzik * @ap: Port to initialize 5047c6fd2807SJeff Garzik * 5048c6fd2807SJeff Garzik * Called just after data structures for each port are 5049c6fd2807SJeff Garzik * initialized. Allocates space for PRD table. 5050c6fd2807SJeff Garzik * 5051c6fd2807SJeff Garzik * May be used as the port_start() entry in ata_port_operations. 5052c6fd2807SJeff Garzik * 5053c6fd2807SJeff Garzik * LOCKING: 5054c6fd2807SJeff Garzik * Inherited from caller. 5055c6fd2807SJeff Garzik */ 5056c6fd2807SJeff Garzik int ata_port_start(struct ata_port *ap) 5057c6fd2807SJeff Garzik { 5058c6fd2807SJeff Garzik struct device *dev = ap->dev; 5059c6fd2807SJeff Garzik 5060f0d36efdSTejun Heo ap->prd = dmam_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, 5061f0d36efdSTejun Heo GFP_KERNEL); 5062c6fd2807SJeff Garzik if (!ap->prd) 5063c6fd2807SJeff Garzik return -ENOMEM; 5064c6fd2807SJeff Garzik 5065c6fd2807SJeff Garzik return 0; 5066c6fd2807SJeff Garzik } 5067c6fd2807SJeff Garzik 5068c6fd2807SJeff Garzik /** 5069c6fd2807SJeff Garzik * ata_dev_init - Initialize an ata_device structure 5070c6fd2807SJeff Garzik * @dev: Device structure to initialize 5071c6fd2807SJeff Garzik * 5072c6fd2807SJeff Garzik * Initialize @dev in preparation for probing. 5073c6fd2807SJeff Garzik * 5074c6fd2807SJeff Garzik * LOCKING: 5075c6fd2807SJeff Garzik * Inherited from caller. 5076c6fd2807SJeff Garzik */ 5077c6fd2807SJeff Garzik void ata_dev_init(struct ata_device *dev) 5078c6fd2807SJeff Garzik { 50799af5c9c9STejun Heo struct ata_link *link = dev->link; 50809af5c9c9STejun Heo struct ata_port *ap = link->ap; 5081c6fd2807SJeff Garzik unsigned long flags; 5082c6fd2807SJeff Garzik 5083c6fd2807SJeff Garzik /* SATA spd limit is bound to the first device */ 50849af5c9c9STejun Heo link->sata_spd_limit = link->hw_sata_spd_limit; 50859af5c9c9STejun Heo link->sata_spd = 0; 5086c6fd2807SJeff Garzik 5087c6fd2807SJeff Garzik /* High bits of dev->flags are used to record warm plug 5088c6fd2807SJeff Garzik * requests which occur asynchronously. Synchronize using 5089cca3974eSJeff Garzik * host lock. 5090c6fd2807SJeff Garzik */ 5091c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 5092c6fd2807SJeff Garzik dev->flags &= ~ATA_DFLAG_INIT_MASK; 50933dcc323fSTejun Heo dev->horkage = 0; 5094c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5095c6fd2807SJeff Garzik 5096c6fd2807SJeff Garzik memset((void *)dev + ATA_DEVICE_CLEAR_OFFSET, 0, 5097c6fd2807SJeff Garzik sizeof(*dev) - ATA_DEVICE_CLEAR_OFFSET); 5098c6fd2807SJeff Garzik dev->pio_mask = UINT_MAX; 5099c6fd2807SJeff Garzik dev->mwdma_mask = UINT_MAX; 5100c6fd2807SJeff Garzik dev->udma_mask = UINT_MAX; 5101c6fd2807SJeff Garzik } 5102c6fd2807SJeff Garzik 5103c6fd2807SJeff Garzik /** 51044fb37a25STejun Heo * ata_link_init - Initialize an ata_link structure 51054fb37a25STejun Heo * @ap: ATA port link is attached to 51064fb37a25STejun Heo * @link: Link structure to initialize 51078989805dSTejun Heo * @pmp: Port multiplier port number 51084fb37a25STejun Heo * 51094fb37a25STejun Heo * Initialize @link. 51104fb37a25STejun Heo * 51114fb37a25STejun Heo * LOCKING: 51124fb37a25STejun Heo * Kernel thread context (may sleep) 51134fb37a25STejun Heo */ 5114fb7fd614STejun Heo void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp) 51154fb37a25STejun Heo { 51164fb37a25STejun Heo int i; 51174fb37a25STejun Heo 51184fb37a25STejun Heo /* clear everything except for devices */ 51194fb37a25STejun Heo memset(link, 0, offsetof(struct ata_link, device[0])); 51204fb37a25STejun Heo 51214fb37a25STejun Heo link->ap = ap; 51228989805dSTejun Heo link->pmp = pmp; 51234fb37a25STejun Heo link->active_tag = ATA_TAG_POISON; 51244fb37a25STejun Heo link->hw_sata_spd_limit = UINT_MAX; 51254fb37a25STejun Heo 51264fb37a25STejun Heo /* can't use iterator, ap isn't initialized yet */ 51274fb37a25STejun Heo for (i = 0; i < ATA_MAX_DEVICES; i++) { 51284fb37a25STejun Heo struct ata_device *dev = &link->device[i]; 51294fb37a25STejun Heo 51304fb37a25STejun Heo dev->link = link; 51314fb37a25STejun Heo dev->devno = dev - link->device; 51324fb37a25STejun Heo ata_dev_init(dev); 51334fb37a25STejun Heo } 51344fb37a25STejun Heo } 51354fb37a25STejun Heo 51364fb37a25STejun Heo /** 51374fb37a25STejun Heo * sata_link_init_spd - Initialize link->sata_spd_limit 51384fb37a25STejun Heo * @link: Link to configure sata_spd_limit for 51394fb37a25STejun Heo * 51404fb37a25STejun Heo * Initialize @link->[hw_]sata_spd_limit to the currently 51414fb37a25STejun Heo * configured value. 51424fb37a25STejun Heo * 51434fb37a25STejun Heo * LOCKING: 51444fb37a25STejun Heo * Kernel thread context (may sleep). 51454fb37a25STejun Heo * 51464fb37a25STejun Heo * RETURNS: 51474fb37a25STejun Heo * 0 on success, -errno on failure. 51484fb37a25STejun Heo */ 5149fb7fd614STejun Heo int sata_link_init_spd(struct ata_link *link) 51504fb37a25STejun Heo { 515133267325STejun Heo u32 scontrol; 515233267325STejun Heo u8 spd; 51534fb37a25STejun Heo int rc; 51544fb37a25STejun Heo 51554fb37a25STejun Heo rc = sata_scr_read(link, SCR_CONTROL, &scontrol); 51564fb37a25STejun Heo if (rc) 51574fb37a25STejun Heo return rc; 51584fb37a25STejun Heo 51594fb37a25STejun Heo spd = (scontrol >> 4) & 0xf; 51604fb37a25STejun Heo if (spd) 51614fb37a25STejun Heo link->hw_sata_spd_limit &= (1 << spd) - 1; 51624fb37a25STejun Heo 516333267325STejun Heo ata_force_spd_limit(link); 516433267325STejun Heo 51654fb37a25STejun Heo link->sata_spd_limit = link->hw_sata_spd_limit; 51664fb37a25STejun Heo 51674fb37a25STejun Heo return 0; 51684fb37a25STejun Heo } 51694fb37a25STejun Heo 51704fb37a25STejun Heo /** 5171f3187195STejun Heo * ata_port_alloc - allocate and initialize basic ATA port resources 5172f3187195STejun Heo * @host: ATA host this allocated port belongs to 5173c6fd2807SJeff Garzik * 5174f3187195STejun Heo * Allocate and initialize basic ATA port resources. 5175f3187195STejun Heo * 5176f3187195STejun Heo * RETURNS: 5177f3187195STejun Heo * Allocate ATA port on success, NULL on failure. 5178c6fd2807SJeff Garzik * 5179c6fd2807SJeff Garzik * LOCKING: 5180f3187195STejun Heo * Inherited from calling layer (may sleep). 5181c6fd2807SJeff Garzik */ 5182f3187195STejun Heo struct ata_port *ata_port_alloc(struct ata_host *host) 5183c6fd2807SJeff Garzik { 5184f3187195STejun Heo struct ata_port *ap; 5185c6fd2807SJeff Garzik 5186f3187195STejun Heo DPRINTK("ENTER\n"); 5187f3187195STejun Heo 5188f3187195STejun Heo ap = kzalloc(sizeof(*ap), GFP_KERNEL); 5189f3187195STejun Heo if (!ap) 5190f3187195STejun Heo return NULL; 5191f3187195STejun Heo 5192f4d6d004STejun Heo ap->pflags |= ATA_PFLAG_INITIALIZING; 5193cca3974eSJeff Garzik ap->lock = &host->lock; 5194c6fd2807SJeff Garzik ap->flags = ATA_FLAG_DISABLED; 5195f3187195STejun Heo ap->print_id = -1; 5196c6fd2807SJeff Garzik ap->ctl = ATA_DEVCTL_OBS; 5197cca3974eSJeff Garzik ap->host = host; 5198f3187195STejun Heo ap->dev = host->dev; 5199c6fd2807SJeff Garzik ap->last_ctl = 0xFF; 5200c6fd2807SJeff Garzik 5201c6fd2807SJeff Garzik #if defined(ATA_VERBOSE_DEBUG) 5202c6fd2807SJeff Garzik /* turn on all debugging levels */ 5203c6fd2807SJeff Garzik ap->msg_enable = 0x00FF; 5204c6fd2807SJeff Garzik #elif defined(ATA_DEBUG) 5205c6fd2807SJeff Garzik ap->msg_enable = ATA_MSG_DRV | ATA_MSG_INFO | ATA_MSG_CTL | ATA_MSG_WARN | ATA_MSG_ERR; 5206c6fd2807SJeff Garzik #else 5207c6fd2807SJeff Garzik ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR | ATA_MSG_WARN; 5208c6fd2807SJeff Garzik #endif 5209c6fd2807SJeff Garzik 5210127102aeSTejun Heo #ifdef CONFIG_ATA_SFF 5211442eacc3SJeff Garzik INIT_DELAYED_WORK(&ap->port_task, ata_pio_task); 5212127102aeSTejun Heo #endif 521365f27f38SDavid Howells INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug); 521465f27f38SDavid Howells INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan); 5215c6fd2807SJeff Garzik INIT_LIST_HEAD(&ap->eh_done_q); 5216c6fd2807SJeff Garzik init_waitqueue_head(&ap->eh_wait_q); 52175ddf24c5STejun Heo init_timer_deferrable(&ap->fastdrain_timer); 52185ddf24c5STejun Heo ap->fastdrain_timer.function = ata_eh_fastdrain_timerfn; 52195ddf24c5STejun Heo ap->fastdrain_timer.data = (unsigned long)ap; 5220c6fd2807SJeff Garzik 5221c6fd2807SJeff Garzik ap->cbl = ATA_CBL_NONE; 5222c6fd2807SJeff Garzik 52238989805dSTejun Heo ata_link_init(ap, &ap->link, 0); 5224c6fd2807SJeff Garzik 5225c6fd2807SJeff Garzik #ifdef ATA_IRQ_TRAP 5226c6fd2807SJeff Garzik ap->stats.unhandled_irq = 1; 5227c6fd2807SJeff Garzik ap->stats.idle_irq = 1; 5228c6fd2807SJeff Garzik #endif 5229c6fd2807SJeff Garzik return ap; 5230c6fd2807SJeff Garzik } 5231c6fd2807SJeff Garzik 5232f0d36efdSTejun Heo static void ata_host_release(struct device *gendev, void *res) 5233f0d36efdSTejun Heo { 5234f0d36efdSTejun Heo struct ata_host *host = dev_get_drvdata(gendev); 5235f0d36efdSTejun Heo int i; 5236f0d36efdSTejun Heo 5237f0d36efdSTejun Heo for (i = 0; i < host->n_ports; i++) { 5238f0d36efdSTejun Heo struct ata_port *ap = host->ports[i]; 5239f0d36efdSTejun Heo 5240ecef7253STejun Heo if (!ap) 5241ecef7253STejun Heo continue; 5242ecef7253STejun Heo 52434911487aSTejun Heo if (ap->scsi_host) 52441aa506e4STejun Heo scsi_host_put(ap->scsi_host); 52451aa506e4STejun Heo 5246633273a3STejun Heo kfree(ap->pmp_link); 52474911487aSTejun Heo kfree(ap); 52481aa506e4STejun Heo host->ports[i] = NULL; 52491aa506e4STejun Heo } 52501aa506e4STejun Heo 52511aa56ccaSTejun Heo dev_set_drvdata(gendev, NULL); 5252f0d36efdSTejun Heo } 5253f0d36efdSTejun Heo 5254c6fd2807SJeff Garzik /** 5255f3187195STejun Heo * ata_host_alloc - allocate and init basic ATA host resources 5256f3187195STejun Heo * @dev: generic device this host is associated with 5257f3187195STejun Heo * @max_ports: maximum number of ATA ports associated with this host 5258f3187195STejun Heo * 5259f3187195STejun Heo * Allocate and initialize basic ATA host resources. LLD calls 5260f3187195STejun Heo * this function to allocate a host, initializes it fully and 5261f3187195STejun Heo * attaches it using ata_host_register(). 5262f3187195STejun Heo * 5263f3187195STejun Heo * @max_ports ports are allocated and host->n_ports is 5264f3187195STejun Heo * initialized to @max_ports. The caller is allowed to decrease 5265f3187195STejun Heo * host->n_ports before calling ata_host_register(). The unused 5266f3187195STejun Heo * ports will be automatically freed on registration. 5267f3187195STejun Heo * 5268f3187195STejun Heo * RETURNS: 5269f3187195STejun Heo * Allocate ATA host on success, NULL on failure. 5270f3187195STejun Heo * 5271f3187195STejun Heo * LOCKING: 5272f3187195STejun Heo * Inherited from calling layer (may sleep). 5273f3187195STejun Heo */ 5274f3187195STejun Heo struct ata_host *ata_host_alloc(struct device *dev, int max_ports) 5275f3187195STejun Heo { 5276f3187195STejun Heo struct ata_host *host; 5277f3187195STejun Heo size_t sz; 5278f3187195STejun Heo int i; 5279f3187195STejun Heo 5280f3187195STejun Heo DPRINTK("ENTER\n"); 5281f3187195STejun Heo 5282f3187195STejun Heo if (!devres_open_group(dev, NULL, GFP_KERNEL)) 5283f3187195STejun Heo return NULL; 5284f3187195STejun Heo 5285f3187195STejun Heo /* alloc a container for our list of ATA ports (buses) */ 5286f3187195STejun Heo sz = sizeof(struct ata_host) + (max_ports + 1) * sizeof(void *); 5287f3187195STejun Heo /* alloc a container for our list of ATA ports (buses) */ 5288f3187195STejun Heo host = devres_alloc(ata_host_release, sz, GFP_KERNEL); 5289f3187195STejun Heo if (!host) 5290f3187195STejun Heo goto err_out; 5291f3187195STejun Heo 5292f3187195STejun Heo devres_add(dev, host); 5293f3187195STejun Heo dev_set_drvdata(dev, host); 5294f3187195STejun Heo 5295f3187195STejun Heo spin_lock_init(&host->lock); 5296f3187195STejun Heo host->dev = dev; 5297f3187195STejun Heo host->n_ports = max_ports; 5298f3187195STejun Heo 5299f3187195STejun Heo /* allocate ports bound to this host */ 5300f3187195STejun Heo for (i = 0; i < max_ports; i++) { 5301f3187195STejun Heo struct ata_port *ap; 5302f3187195STejun Heo 5303f3187195STejun Heo ap = ata_port_alloc(host); 5304f3187195STejun Heo if (!ap) 5305f3187195STejun Heo goto err_out; 5306f3187195STejun Heo 5307f3187195STejun Heo ap->port_no = i; 5308f3187195STejun Heo host->ports[i] = ap; 5309f3187195STejun Heo } 5310f3187195STejun Heo 5311f3187195STejun Heo devres_remove_group(dev, NULL); 5312f3187195STejun Heo return host; 5313f3187195STejun Heo 5314f3187195STejun Heo err_out: 5315f3187195STejun Heo devres_release_group(dev, NULL); 5316f3187195STejun Heo return NULL; 5317f3187195STejun Heo } 5318f3187195STejun Heo 5319f3187195STejun Heo /** 5320f5cda257STejun Heo * ata_host_alloc_pinfo - alloc host and init with port_info array 5321f5cda257STejun Heo * @dev: generic device this host is associated with 5322f5cda257STejun Heo * @ppi: array of ATA port_info to initialize host with 5323f5cda257STejun Heo * @n_ports: number of ATA ports attached to this host 5324f5cda257STejun Heo * 5325f5cda257STejun Heo * Allocate ATA host and initialize with info from @ppi. If NULL 5326f5cda257STejun Heo * terminated, @ppi may contain fewer entries than @n_ports. The 5327f5cda257STejun Heo * last entry will be used for the remaining ports. 5328f5cda257STejun Heo * 5329f5cda257STejun Heo * RETURNS: 5330f5cda257STejun Heo * Allocate ATA host on success, NULL on failure. 5331f5cda257STejun Heo * 5332f5cda257STejun Heo * LOCKING: 5333f5cda257STejun Heo * Inherited from calling layer (may sleep). 5334f5cda257STejun Heo */ 5335f5cda257STejun Heo struct ata_host *ata_host_alloc_pinfo(struct device *dev, 5336f5cda257STejun Heo const struct ata_port_info * const * ppi, 5337f5cda257STejun Heo int n_ports) 5338f5cda257STejun Heo { 5339f5cda257STejun Heo const struct ata_port_info *pi; 5340f5cda257STejun Heo struct ata_host *host; 5341f5cda257STejun Heo int i, j; 5342f5cda257STejun Heo 5343f5cda257STejun Heo host = ata_host_alloc(dev, n_ports); 5344f5cda257STejun Heo if (!host) 5345f5cda257STejun Heo return NULL; 5346f5cda257STejun Heo 5347f5cda257STejun Heo for (i = 0, j = 0, pi = NULL; i < host->n_ports; i++) { 5348f5cda257STejun Heo struct ata_port *ap = host->ports[i]; 5349f5cda257STejun Heo 5350f5cda257STejun Heo if (ppi[j]) 5351f5cda257STejun Heo pi = ppi[j++]; 5352f5cda257STejun Heo 5353f5cda257STejun Heo ap->pio_mask = pi->pio_mask; 5354f5cda257STejun Heo ap->mwdma_mask = pi->mwdma_mask; 5355f5cda257STejun Heo ap->udma_mask = pi->udma_mask; 5356f5cda257STejun Heo ap->flags |= pi->flags; 53570c88758bSTejun Heo ap->link.flags |= pi->link_flags; 5358f5cda257STejun Heo ap->ops = pi->port_ops; 5359f5cda257STejun Heo 5360f5cda257STejun Heo if (!host->ops && (pi->port_ops != &ata_dummy_port_ops)) 5361f5cda257STejun Heo host->ops = pi->port_ops; 5362f5cda257STejun Heo } 5363f5cda257STejun Heo 5364f5cda257STejun Heo return host; 5365f5cda257STejun Heo } 5366f5cda257STejun Heo 536732ebbc0cSTejun Heo static void ata_host_stop(struct device *gendev, void *res) 536832ebbc0cSTejun Heo { 536932ebbc0cSTejun Heo struct ata_host *host = dev_get_drvdata(gendev); 537032ebbc0cSTejun Heo int i; 537132ebbc0cSTejun Heo 537232ebbc0cSTejun Heo WARN_ON(!(host->flags & ATA_HOST_STARTED)); 537332ebbc0cSTejun Heo 537432ebbc0cSTejun Heo for (i = 0; i < host->n_ports; i++) { 537532ebbc0cSTejun Heo struct ata_port *ap = host->ports[i]; 537632ebbc0cSTejun Heo 537732ebbc0cSTejun Heo if (ap->ops->port_stop) 537832ebbc0cSTejun Heo ap->ops->port_stop(ap); 537932ebbc0cSTejun Heo } 538032ebbc0cSTejun Heo 538132ebbc0cSTejun Heo if (host->ops->host_stop) 538232ebbc0cSTejun Heo host->ops->host_stop(host); 538332ebbc0cSTejun Heo } 538432ebbc0cSTejun Heo 5385f5cda257STejun Heo /** 5386029cfd6bSTejun Heo * ata_finalize_port_ops - finalize ata_port_operations 5387029cfd6bSTejun Heo * @ops: ata_port_operations to finalize 5388029cfd6bSTejun Heo * 5389029cfd6bSTejun Heo * An ata_port_operations can inherit from another ops and that 5390029cfd6bSTejun Heo * ops can again inherit from another. This can go on as many 5391029cfd6bSTejun Heo * times as necessary as long as there is no loop in the 5392029cfd6bSTejun Heo * inheritance chain. 5393029cfd6bSTejun Heo * 5394029cfd6bSTejun Heo * Ops tables are finalized when the host is started. NULL or 5395029cfd6bSTejun Heo * unspecified entries are inherited from the closet ancestor 5396029cfd6bSTejun Heo * which has the method and the entry is populated with it. 5397029cfd6bSTejun Heo * After finalization, the ops table directly points to all the 5398029cfd6bSTejun Heo * methods and ->inherits is no longer necessary and cleared. 5399029cfd6bSTejun Heo * 5400029cfd6bSTejun Heo * Using ATA_OP_NULL, inheriting ops can force a method to NULL. 5401029cfd6bSTejun Heo * 5402029cfd6bSTejun Heo * LOCKING: 5403029cfd6bSTejun Heo * None. 5404029cfd6bSTejun Heo */ 5405029cfd6bSTejun Heo static void ata_finalize_port_ops(struct ata_port_operations *ops) 5406029cfd6bSTejun Heo { 54072da67659SPradeep Singh Rautela static DEFINE_SPINLOCK(lock); 5408029cfd6bSTejun Heo const struct ata_port_operations *cur; 5409029cfd6bSTejun Heo void **begin = (void **)ops; 5410029cfd6bSTejun Heo void **end = (void **)&ops->inherits; 5411029cfd6bSTejun Heo void **pp; 5412029cfd6bSTejun Heo 5413029cfd6bSTejun Heo if (!ops || !ops->inherits) 5414029cfd6bSTejun Heo return; 5415029cfd6bSTejun Heo 5416029cfd6bSTejun Heo spin_lock(&lock); 5417029cfd6bSTejun Heo 5418029cfd6bSTejun Heo for (cur = ops->inherits; cur; cur = cur->inherits) { 5419029cfd6bSTejun Heo void **inherit = (void **)cur; 5420029cfd6bSTejun Heo 5421029cfd6bSTejun Heo for (pp = begin; pp < end; pp++, inherit++) 5422029cfd6bSTejun Heo if (!*pp) 5423029cfd6bSTejun Heo *pp = *inherit; 5424029cfd6bSTejun Heo } 5425029cfd6bSTejun Heo 5426029cfd6bSTejun Heo for (pp = begin; pp < end; pp++) 5427029cfd6bSTejun Heo if (IS_ERR(*pp)) 5428029cfd6bSTejun Heo *pp = NULL; 5429029cfd6bSTejun Heo 5430029cfd6bSTejun Heo ops->inherits = NULL; 5431029cfd6bSTejun Heo 5432029cfd6bSTejun Heo spin_unlock(&lock); 5433029cfd6bSTejun Heo } 5434029cfd6bSTejun Heo 5435029cfd6bSTejun Heo /** 5436ecef7253STejun Heo * ata_host_start - start and freeze ports of an ATA host 5437ecef7253STejun Heo * @host: ATA host to start ports for 5438ecef7253STejun Heo * 5439ecef7253STejun Heo * Start and then freeze ports of @host. Started status is 5440ecef7253STejun Heo * recorded in host->flags, so this function can be called 5441ecef7253STejun Heo * multiple times. Ports are guaranteed to get started only 5442f3187195STejun Heo * once. If host->ops isn't initialized yet, its set to the 5443f3187195STejun Heo * first non-dummy port ops. 5444ecef7253STejun Heo * 5445ecef7253STejun Heo * LOCKING: 5446ecef7253STejun Heo * Inherited from calling layer (may sleep). 5447ecef7253STejun Heo * 5448ecef7253STejun Heo * RETURNS: 5449ecef7253STejun Heo * 0 if all ports are started successfully, -errno otherwise. 5450ecef7253STejun Heo */ 5451ecef7253STejun Heo int ata_host_start(struct ata_host *host) 5452ecef7253STejun Heo { 545332ebbc0cSTejun Heo int have_stop = 0; 545432ebbc0cSTejun Heo void *start_dr = NULL; 5455ecef7253STejun Heo int i, rc; 5456ecef7253STejun Heo 5457ecef7253STejun Heo if (host->flags & ATA_HOST_STARTED) 5458ecef7253STejun Heo return 0; 5459ecef7253STejun Heo 5460029cfd6bSTejun Heo ata_finalize_port_ops(host->ops); 5461029cfd6bSTejun Heo 5462ecef7253STejun Heo for (i = 0; i < host->n_ports; i++) { 5463ecef7253STejun Heo struct ata_port *ap = host->ports[i]; 5464ecef7253STejun Heo 5465029cfd6bSTejun Heo ata_finalize_port_ops(ap->ops); 5466029cfd6bSTejun Heo 5467f3187195STejun Heo if (!host->ops && !ata_port_is_dummy(ap)) 5468f3187195STejun Heo host->ops = ap->ops; 5469f3187195STejun Heo 547032ebbc0cSTejun Heo if (ap->ops->port_stop) 547132ebbc0cSTejun Heo have_stop = 1; 547232ebbc0cSTejun Heo } 547332ebbc0cSTejun Heo 547432ebbc0cSTejun Heo if (host->ops->host_stop) 547532ebbc0cSTejun Heo have_stop = 1; 547632ebbc0cSTejun Heo 547732ebbc0cSTejun Heo if (have_stop) { 547832ebbc0cSTejun Heo start_dr = devres_alloc(ata_host_stop, 0, GFP_KERNEL); 547932ebbc0cSTejun Heo if (!start_dr) 548032ebbc0cSTejun Heo return -ENOMEM; 548132ebbc0cSTejun Heo } 548232ebbc0cSTejun Heo 548332ebbc0cSTejun Heo for (i = 0; i < host->n_ports; i++) { 548432ebbc0cSTejun Heo struct ata_port *ap = host->ports[i]; 548532ebbc0cSTejun Heo 5486ecef7253STejun Heo if (ap->ops->port_start) { 5487ecef7253STejun Heo rc = ap->ops->port_start(ap); 5488ecef7253STejun Heo if (rc) { 54890f9fe9b7SAlan Cox if (rc != -ENODEV) 54900f757743SAndrew Morton dev_printk(KERN_ERR, host->dev, 54910f757743SAndrew Morton "failed to start port %d " 54920f757743SAndrew Morton "(errno=%d)\n", i, rc); 5493ecef7253STejun Heo goto err_out; 5494ecef7253STejun Heo } 5495ecef7253STejun Heo } 5496ecef7253STejun Heo ata_eh_freeze_port(ap); 5497ecef7253STejun Heo } 5498ecef7253STejun Heo 549932ebbc0cSTejun Heo if (start_dr) 550032ebbc0cSTejun Heo devres_add(host->dev, start_dr); 5501ecef7253STejun Heo host->flags |= ATA_HOST_STARTED; 5502ecef7253STejun Heo return 0; 5503ecef7253STejun Heo 5504ecef7253STejun Heo err_out: 5505ecef7253STejun Heo while (--i >= 0) { 5506ecef7253STejun Heo struct ata_port *ap = host->ports[i]; 5507ecef7253STejun Heo 5508ecef7253STejun Heo if (ap->ops->port_stop) 5509ecef7253STejun Heo ap->ops->port_stop(ap); 5510ecef7253STejun Heo } 551132ebbc0cSTejun Heo devres_free(start_dr); 5512ecef7253STejun Heo return rc; 5513ecef7253STejun Heo } 5514ecef7253STejun Heo 5515ecef7253STejun Heo /** 5516cca3974eSJeff Garzik * ata_sas_host_init - Initialize a host struct 5517cca3974eSJeff Garzik * @host: host to initialize 5518cca3974eSJeff Garzik * @dev: device host is attached to 5519cca3974eSJeff Garzik * @flags: host flags 5520c6fd2807SJeff Garzik * @ops: port_ops 5521c6fd2807SJeff Garzik * 5522c6fd2807SJeff Garzik * LOCKING: 5523c6fd2807SJeff Garzik * PCI/etc. bus probe sem. 5524c6fd2807SJeff Garzik * 5525c6fd2807SJeff Garzik */ 5526f3187195STejun Heo /* KILLME - the only user left is ipr */ 5527cca3974eSJeff Garzik void ata_host_init(struct ata_host *host, struct device *dev, 5528029cfd6bSTejun Heo unsigned long flags, struct ata_port_operations *ops) 5529c6fd2807SJeff Garzik { 5530cca3974eSJeff Garzik spin_lock_init(&host->lock); 5531cca3974eSJeff Garzik host->dev = dev; 5532cca3974eSJeff Garzik host->flags = flags; 5533cca3974eSJeff Garzik host->ops = ops; 5534c6fd2807SJeff Garzik } 5535c6fd2807SJeff Garzik 5536c6fd2807SJeff Garzik /** 5537f3187195STejun Heo * ata_host_register - register initialized ATA host 5538f3187195STejun Heo * @host: ATA host to register 5539f3187195STejun Heo * @sht: template for SCSI host 5540c6fd2807SJeff Garzik * 5541f3187195STejun Heo * Register initialized ATA host. @host is allocated using 5542f3187195STejun Heo * ata_host_alloc() and fully initialized by LLD. This function 5543f3187195STejun Heo * starts ports, registers @host with ATA and SCSI layers and 5544f3187195STejun Heo * probe registered devices. 5545c6fd2807SJeff Garzik * 5546c6fd2807SJeff Garzik * LOCKING: 5547f3187195STejun Heo * Inherited from calling layer (may sleep). 5548c6fd2807SJeff Garzik * 5549c6fd2807SJeff Garzik * RETURNS: 5550f3187195STejun Heo * 0 on success, -errno otherwise. 5551c6fd2807SJeff Garzik */ 5552f3187195STejun Heo int ata_host_register(struct ata_host *host, struct scsi_host_template *sht) 5553c6fd2807SJeff Garzik { 5554f3187195STejun Heo int i, rc; 5555c6fd2807SJeff Garzik 5556f3187195STejun Heo /* host must have been started */ 5557f3187195STejun Heo if (!(host->flags & ATA_HOST_STARTED)) { 5558f3187195STejun Heo dev_printk(KERN_ERR, host->dev, 5559f3187195STejun Heo "BUG: trying to register unstarted host\n"); 5560f3187195STejun Heo WARN_ON(1); 5561f3187195STejun Heo return -EINVAL; 556202f076aaSAlan Cox } 5563f0d36efdSTejun Heo 5564f3187195STejun Heo /* Blow away unused ports. This happens when LLD can't 5565f3187195STejun Heo * determine the exact number of ports to allocate at 5566f3187195STejun Heo * allocation time. 5567f3187195STejun Heo */ 5568f3187195STejun Heo for (i = host->n_ports; host->ports[i]; i++) 5569f3187195STejun Heo kfree(host->ports[i]); 5570f0d36efdSTejun Heo 5571f3187195STejun Heo /* give ports names and add SCSI hosts */ 5572f3187195STejun Heo for (i = 0; i < host->n_ports; i++) 5573f3187195STejun Heo host->ports[i]->print_id = ata_print_id++; 5574c6fd2807SJeff Garzik 5575f3187195STejun Heo rc = ata_scsi_add_hosts(host, sht); 5576ecef7253STejun Heo if (rc) 5577f3187195STejun Heo return rc; 5578ecef7253STejun Heo 5579fafbae87STejun Heo /* associate with ACPI nodes */ 5580fafbae87STejun Heo ata_acpi_associate(host); 5581fafbae87STejun Heo 5582f3187195STejun Heo /* set cable, sata_spd_limit and report */ 5583cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 5584cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 5585f3187195STejun Heo unsigned long xfer_mask; 5586f3187195STejun Heo 5587f3187195STejun Heo /* set SATA cable type if still unset */ 5588f3187195STejun Heo if (ap->cbl == ATA_CBL_NONE && (ap->flags & ATA_FLAG_SATA)) 5589f3187195STejun Heo ap->cbl = ATA_CBL_SATA; 5590c6fd2807SJeff Garzik 5591c6fd2807SJeff Garzik /* init sata_spd_limit to the current value */ 55924fb37a25STejun Heo sata_link_init_spd(&ap->link); 5593c6fd2807SJeff Garzik 5594cbcdd875STejun Heo /* print per-port info to dmesg */ 5595f3187195STejun Heo xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask, 5596f3187195STejun Heo ap->udma_mask); 5597f3187195STejun Heo 5598abf6e8edSTejun Heo if (!ata_port_is_dummy(ap)) { 5599cbcdd875STejun Heo ata_port_printk(ap, KERN_INFO, 5600cbcdd875STejun Heo "%cATA max %s %s\n", 5601a16abc0bSTejun Heo (ap->flags & ATA_FLAG_SATA) ? 'S' : 'P', 5602f3187195STejun Heo ata_mode_string(xfer_mask), 5603cbcdd875STejun Heo ap->link.eh_info.desc); 5604abf6e8edSTejun Heo ata_ehi_clear_desc(&ap->link.eh_info); 5605abf6e8edSTejun Heo } else 5606f3187195STejun Heo ata_port_printk(ap, KERN_INFO, "DUMMY\n"); 5607c6fd2807SJeff Garzik } 5608c6fd2807SJeff Garzik 5609f3187195STejun Heo /* perform each probe synchronously */ 5610f3187195STejun Heo DPRINTK("probe begin\n"); 5611f3187195STejun Heo for (i = 0; i < host->n_ports; i++) { 5612f3187195STejun Heo struct ata_port *ap = host->ports[i]; 5613f3187195STejun Heo 5614f3187195STejun Heo /* probe */ 5615c6fd2807SJeff Garzik if (ap->ops->error_handler) { 56169af5c9c9STejun Heo struct ata_eh_info *ehi = &ap->link.eh_info; 5617c6fd2807SJeff Garzik unsigned long flags; 5618c6fd2807SJeff Garzik 5619c6fd2807SJeff Garzik ata_port_probe(ap); 5620c6fd2807SJeff Garzik 5621c6fd2807SJeff Garzik /* kick EH for boot probing */ 5622c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 5623c6fd2807SJeff Garzik 5624b558edddSTejun Heo ehi->probe_mask |= ATA_ALL_DEVICES; 5625391191c1STejun Heo ehi->action |= ATA_EH_RESET | ATA_EH_LPM; 5626c6fd2807SJeff Garzik ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET; 5627c6fd2807SJeff Garzik 5628f4d6d004STejun Heo ap->pflags &= ~ATA_PFLAG_INITIALIZING; 5629c6fd2807SJeff Garzik ap->pflags |= ATA_PFLAG_LOADING; 5630c6fd2807SJeff Garzik ata_port_schedule_eh(ap); 5631c6fd2807SJeff Garzik 5632c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5633c6fd2807SJeff Garzik 5634c6fd2807SJeff Garzik /* wait for EH to finish */ 5635c6fd2807SJeff Garzik ata_port_wait_eh(ap); 5636c6fd2807SJeff Garzik } else { 563744877b4eSTejun Heo DPRINTK("ata%u: bus probe begin\n", ap->print_id); 5638c6fd2807SJeff Garzik rc = ata_bus_probe(ap); 563944877b4eSTejun Heo DPRINTK("ata%u: bus probe end\n", ap->print_id); 5640c6fd2807SJeff Garzik 5641c6fd2807SJeff Garzik if (rc) { 5642c6fd2807SJeff Garzik /* FIXME: do something useful here? 5643c6fd2807SJeff Garzik * Current libata behavior will 5644c6fd2807SJeff Garzik * tear down everything when 5645c6fd2807SJeff Garzik * the module is removed 5646c6fd2807SJeff Garzik * or the h/w is unplugged. 5647c6fd2807SJeff Garzik */ 5648c6fd2807SJeff Garzik } 5649c6fd2807SJeff Garzik } 5650c6fd2807SJeff Garzik } 5651c6fd2807SJeff Garzik 5652c6fd2807SJeff Garzik /* probes are done, now scan each port's disk(s) */ 5653c6fd2807SJeff Garzik DPRINTK("host probe begin\n"); 5654cca3974eSJeff Garzik for (i = 0; i < host->n_ports; i++) { 5655cca3974eSJeff Garzik struct ata_port *ap = host->ports[i]; 5656c6fd2807SJeff Garzik 56571ae46317STejun Heo ata_scsi_scan_host(ap, 1); 5658c6fd2807SJeff Garzik } 5659c6fd2807SJeff Garzik 5660f3187195STejun Heo return 0; 5661f3187195STejun Heo } 5662f3187195STejun Heo 5663f3187195STejun Heo /** 5664f5cda257STejun Heo * ata_host_activate - start host, request IRQ and register it 5665f5cda257STejun Heo * @host: target ATA host 5666f5cda257STejun Heo * @irq: IRQ to request 5667f5cda257STejun Heo * @irq_handler: irq_handler used when requesting IRQ 5668f5cda257STejun Heo * @irq_flags: irq_flags used when requesting IRQ 5669f5cda257STejun Heo * @sht: scsi_host_template to use when registering the host 5670f5cda257STejun Heo * 5671f5cda257STejun Heo * After allocating an ATA host and initializing it, most libata 5672f5cda257STejun Heo * LLDs perform three steps to activate the host - start host, 5673f5cda257STejun Heo * request IRQ and register it. This helper takes necessasry 5674f5cda257STejun Heo * arguments and performs the three steps in one go. 5675f5cda257STejun Heo * 56763d46b2e2SPaul Mundt * An invalid IRQ skips the IRQ registration and expects the host to 56773d46b2e2SPaul Mundt * have set polling mode on the port. In this case, @irq_handler 56783d46b2e2SPaul Mundt * should be NULL. 56793d46b2e2SPaul Mundt * 5680f5cda257STejun Heo * LOCKING: 5681f5cda257STejun Heo * Inherited from calling layer (may sleep). 5682f5cda257STejun Heo * 5683f5cda257STejun Heo * RETURNS: 5684f5cda257STejun Heo * 0 on success, -errno otherwise. 5685f5cda257STejun Heo */ 5686f5cda257STejun Heo int ata_host_activate(struct ata_host *host, int irq, 5687f5cda257STejun Heo irq_handler_t irq_handler, unsigned long irq_flags, 5688f5cda257STejun Heo struct scsi_host_template *sht) 5689f5cda257STejun Heo { 5690cbcdd875STejun Heo int i, rc; 5691f5cda257STejun Heo 5692f5cda257STejun Heo rc = ata_host_start(host); 5693f5cda257STejun Heo if (rc) 5694f5cda257STejun Heo return rc; 5695f5cda257STejun Heo 56963d46b2e2SPaul Mundt /* Special case for polling mode */ 56973d46b2e2SPaul Mundt if (!irq) { 56983d46b2e2SPaul Mundt WARN_ON(irq_handler); 56993d46b2e2SPaul Mundt return ata_host_register(host, sht); 57003d46b2e2SPaul Mundt } 57013d46b2e2SPaul Mundt 5702f5cda257STejun Heo rc = devm_request_irq(host->dev, irq, irq_handler, irq_flags, 5703f5cda257STejun Heo dev_driver_string(host->dev), host); 5704f5cda257STejun Heo if (rc) 5705f5cda257STejun Heo return rc; 5706f5cda257STejun Heo 5707cbcdd875STejun Heo for (i = 0; i < host->n_ports; i++) 5708cbcdd875STejun Heo ata_port_desc(host->ports[i], "irq %d", irq); 57094031826bSTejun Heo 5710f5cda257STejun Heo rc = ata_host_register(host, sht); 5711f5cda257STejun Heo /* if failed, just free the IRQ and leave ports alone */ 5712f5cda257STejun Heo if (rc) 5713f5cda257STejun Heo devm_free_irq(host->dev, irq, host); 5714f5cda257STejun Heo 5715f5cda257STejun Heo return rc; 5716f5cda257STejun Heo } 5717f5cda257STejun Heo 5718f5cda257STejun Heo /** 5719c6fd2807SJeff Garzik * ata_port_detach - Detach ATA port in prepration of device removal 5720c6fd2807SJeff Garzik * @ap: ATA port to be detached 5721c6fd2807SJeff Garzik * 5722c6fd2807SJeff Garzik * Detach all ATA devices and the associated SCSI devices of @ap; 5723c6fd2807SJeff Garzik * then, remove the associated SCSI host. @ap is guaranteed to 5724c6fd2807SJeff Garzik * be quiescent on return from this function. 5725c6fd2807SJeff Garzik * 5726c6fd2807SJeff Garzik * LOCKING: 5727c6fd2807SJeff Garzik * Kernel thread context (may sleep). 5728c6fd2807SJeff Garzik */ 5729741b7763SAdrian Bunk static void ata_port_detach(struct ata_port *ap) 5730c6fd2807SJeff Garzik { 5731c6fd2807SJeff Garzik unsigned long flags; 573241bda9c9STejun Heo struct ata_link *link; 5733f58229f8STejun Heo struct ata_device *dev; 5734c6fd2807SJeff Garzik 5735c6fd2807SJeff Garzik if (!ap->ops->error_handler) 5736c6fd2807SJeff Garzik goto skip_eh; 5737c6fd2807SJeff Garzik 5738c6fd2807SJeff Garzik /* tell EH we're leaving & flush EH */ 5739c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 5740c6fd2807SJeff Garzik ap->pflags |= ATA_PFLAG_UNLOADING; 5741c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5742c6fd2807SJeff Garzik 5743c6fd2807SJeff Garzik ata_port_wait_eh(ap); 5744c6fd2807SJeff Garzik 57457f9ad9b8STejun Heo /* EH is now guaranteed to see UNLOADING - EH context belongs 57467f9ad9b8STejun Heo * to us. Disable all existing devices. 5747c6fd2807SJeff Garzik */ 574841bda9c9STejun Heo ata_port_for_each_link(link, ap) { 574941bda9c9STejun Heo ata_link_for_each_dev(dev, link) 5750f58229f8STejun Heo ata_dev_disable(dev); 575141bda9c9STejun Heo } 5752c6fd2807SJeff Garzik 5753c6fd2807SJeff Garzik /* Final freeze & EH. All in-flight commands are aborted. EH 5754c6fd2807SJeff Garzik * will be skipped and retrials will be terminated with bad 5755c6fd2807SJeff Garzik * target. 5756c6fd2807SJeff Garzik */ 5757c6fd2807SJeff Garzik spin_lock_irqsave(ap->lock, flags); 5758c6fd2807SJeff Garzik ata_port_freeze(ap); /* won't be thawed */ 5759c6fd2807SJeff Garzik spin_unlock_irqrestore(ap->lock, flags); 5760c6fd2807SJeff Garzik 5761c6fd2807SJeff Garzik ata_port_wait_eh(ap); 576245a66c1cSOleg Nesterov cancel_rearming_delayed_work(&ap->hotplug_task); 5763c6fd2807SJeff Garzik 5764c6fd2807SJeff Garzik skip_eh: 5765c6fd2807SJeff Garzik /* remove the associated SCSI host */ 5766cca3974eSJeff Garzik scsi_remove_host(ap->scsi_host); 5767c6fd2807SJeff Garzik } 5768c6fd2807SJeff Garzik 5769c6fd2807SJeff Garzik /** 57700529c159STejun Heo * ata_host_detach - Detach all ports of an ATA host 57710529c159STejun Heo * @host: Host to detach 57720529c159STejun Heo * 57730529c159STejun Heo * Detach all ports of @host. 57740529c159STejun Heo * 57750529c159STejun Heo * LOCKING: 57760529c159STejun Heo * Kernel thread context (may sleep). 57770529c159STejun Heo */ 57780529c159STejun Heo void ata_host_detach(struct ata_host *host) 57790529c159STejun Heo { 57800529c159STejun Heo int i; 57810529c159STejun Heo 57820529c159STejun Heo for (i = 0; i < host->n_ports; i++) 57830529c159STejun Heo ata_port_detach(host->ports[i]); 5784562f0c2dSTejun Heo 5785562f0c2dSTejun Heo /* the host is dead now, dissociate ACPI */ 5786562f0c2dSTejun Heo ata_acpi_dissociate(host); 57870529c159STejun Heo } 57880529c159STejun Heo 5789c6fd2807SJeff Garzik #ifdef CONFIG_PCI 5790c6fd2807SJeff Garzik 5791c6fd2807SJeff Garzik /** 5792c6fd2807SJeff Garzik * ata_pci_remove_one - PCI layer callback for device removal 5793c6fd2807SJeff Garzik * @pdev: PCI device that was removed 5794c6fd2807SJeff Garzik * 5795b878ca5dSTejun Heo * PCI layer indicates to libata via this hook that hot-unplug or 5796b878ca5dSTejun Heo * module unload event has occurred. Detach all ports. Resource 5797b878ca5dSTejun Heo * release is handled via devres. 5798c6fd2807SJeff Garzik * 5799c6fd2807SJeff Garzik * LOCKING: 5800c6fd2807SJeff Garzik * Inherited from PCI layer (may sleep). 5801c6fd2807SJeff Garzik */ 5802c6fd2807SJeff Garzik void ata_pci_remove_one(struct pci_dev *pdev) 5803c6fd2807SJeff Garzik { 58042855568bSJeff Garzik struct device *dev = &pdev->dev; 5805cca3974eSJeff Garzik struct ata_host *host = dev_get_drvdata(dev); 5806c6fd2807SJeff Garzik 5807f0d36efdSTejun Heo ata_host_detach(host); 5808c6fd2807SJeff Garzik } 5809c6fd2807SJeff Garzik 5810c6fd2807SJeff Garzik /* move to PCI subsystem */ 5811c6fd2807SJeff Garzik int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits) 5812c6fd2807SJeff Garzik { 5813c6fd2807SJeff Garzik unsigned long tmp = 0; 5814c6fd2807SJeff Garzik 5815c6fd2807SJeff Garzik switch (bits->width) { 5816c6fd2807SJeff Garzik case 1: { 5817c6fd2807SJeff Garzik u8 tmp8 = 0; 5818c6fd2807SJeff Garzik pci_read_config_byte(pdev, bits->reg, &tmp8); 5819c6fd2807SJeff Garzik tmp = tmp8; 5820c6fd2807SJeff Garzik break; 5821c6fd2807SJeff Garzik } 5822c6fd2807SJeff Garzik case 2: { 5823c6fd2807SJeff Garzik u16 tmp16 = 0; 5824c6fd2807SJeff Garzik pci_read_config_word(pdev, bits->reg, &tmp16); 5825c6fd2807SJeff Garzik tmp = tmp16; 5826c6fd2807SJeff Garzik break; 5827c6fd2807SJeff Garzik } 5828c6fd2807SJeff Garzik case 4: { 5829c6fd2807SJeff Garzik u32 tmp32 = 0; 5830c6fd2807SJeff Garzik pci_read_config_dword(pdev, bits->reg, &tmp32); 5831c6fd2807SJeff Garzik tmp = tmp32; 5832c6fd2807SJeff Garzik break; 5833c6fd2807SJeff Garzik } 5834c6fd2807SJeff Garzik 5835c6fd2807SJeff Garzik default: 5836c6fd2807SJeff Garzik return -EINVAL; 5837c6fd2807SJeff Garzik } 5838c6fd2807SJeff Garzik 5839c6fd2807SJeff Garzik tmp &= bits->mask; 5840c6fd2807SJeff Garzik 5841c6fd2807SJeff Garzik return (tmp == bits->val) ? 1 : 0; 5842c6fd2807SJeff Garzik } 5843c6fd2807SJeff Garzik 58446ffa01d8STejun Heo #ifdef CONFIG_PM 5845c6fd2807SJeff Garzik void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg) 5846c6fd2807SJeff Garzik { 5847c6fd2807SJeff Garzik pci_save_state(pdev); 5848c6fd2807SJeff Garzik pci_disable_device(pdev); 58494c90d971STejun Heo 58503a2d5b70SRafael J. Wysocki if (mesg.event & PM_EVENT_SLEEP) 5851c6fd2807SJeff Garzik pci_set_power_state(pdev, PCI_D3hot); 5852c6fd2807SJeff Garzik } 5853c6fd2807SJeff Garzik 5854553c4aa6STejun Heo int ata_pci_device_do_resume(struct pci_dev *pdev) 5855c6fd2807SJeff Garzik { 5856553c4aa6STejun Heo int rc; 5857553c4aa6STejun Heo 5858c6fd2807SJeff Garzik pci_set_power_state(pdev, PCI_D0); 5859c6fd2807SJeff Garzik pci_restore_state(pdev); 5860553c4aa6STejun Heo 5861f0d36efdSTejun Heo rc = pcim_enable_device(pdev); 5862553c4aa6STejun Heo if (rc) { 5863553c4aa6STejun Heo dev_printk(KERN_ERR, &pdev->dev, 5864553c4aa6STejun Heo "failed to enable device after resume (%d)\n", rc); 5865553c4aa6STejun Heo return rc; 5866553c4aa6STejun Heo } 5867553c4aa6STejun Heo 5868c6fd2807SJeff Garzik pci_set_master(pdev); 5869553c4aa6STejun Heo return 0; 5870c6fd2807SJeff Garzik } 5871c6fd2807SJeff Garzik 5872c6fd2807SJeff Garzik int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg) 5873c6fd2807SJeff Garzik { 5874cca3974eSJeff Garzik struct ata_host *host = dev_get_drvdata(&pdev->dev); 5875c6fd2807SJeff Garzik int rc = 0; 5876c6fd2807SJeff Garzik 5877cca3974eSJeff Garzik rc = ata_host_suspend(host, mesg); 5878c6fd2807SJeff Garzik if (rc) 5879c6fd2807SJeff Garzik return rc; 5880c6fd2807SJeff Garzik 5881c6fd2807SJeff Garzik ata_pci_device_do_suspend(pdev, mesg); 5882c6fd2807SJeff Garzik 5883c6fd2807SJeff Garzik return 0; 5884c6fd2807SJeff Garzik } 5885c6fd2807SJeff Garzik 5886c6fd2807SJeff Garzik int ata_pci_device_resume(struct pci_dev *pdev) 5887c6fd2807SJeff Garzik { 5888cca3974eSJeff Garzik struct ata_host *host = dev_get_drvdata(&pdev->dev); 5889553c4aa6STejun Heo int rc; 5890c6fd2807SJeff Garzik 5891553c4aa6STejun Heo rc = ata_pci_device_do_resume(pdev); 5892553c4aa6STejun Heo if (rc == 0) 5893cca3974eSJeff Garzik ata_host_resume(host); 5894553c4aa6STejun Heo return rc; 5895c6fd2807SJeff Garzik } 58966ffa01d8STejun Heo #endif /* CONFIG_PM */ 58976ffa01d8STejun Heo 5898c6fd2807SJeff Garzik #endif /* CONFIG_PCI */ 5899c6fd2807SJeff Garzik 590033267325STejun Heo static int __init ata_parse_force_one(char **cur, 590133267325STejun Heo struct ata_force_ent *force_ent, 590233267325STejun Heo const char **reason) 590333267325STejun Heo { 590433267325STejun Heo /* FIXME: Currently, there's no way to tag init const data and 590533267325STejun Heo * using __initdata causes build failure on some versions of 590633267325STejun Heo * gcc. Once __initdataconst is implemented, add const to the 590733267325STejun Heo * following structure. 590833267325STejun Heo */ 590933267325STejun Heo static struct ata_force_param force_tbl[] __initdata = { 591033267325STejun Heo { "40c", .cbl = ATA_CBL_PATA40 }, 591133267325STejun Heo { "80c", .cbl = ATA_CBL_PATA80 }, 591233267325STejun Heo { "short40c", .cbl = ATA_CBL_PATA40_SHORT }, 591333267325STejun Heo { "unk", .cbl = ATA_CBL_PATA_UNK }, 591433267325STejun Heo { "ign", .cbl = ATA_CBL_PATA_IGN }, 591533267325STejun Heo { "sata", .cbl = ATA_CBL_SATA }, 591633267325STejun Heo { "1.5Gbps", .spd_limit = 1 }, 591733267325STejun Heo { "3.0Gbps", .spd_limit = 2 }, 591833267325STejun Heo { "noncq", .horkage_on = ATA_HORKAGE_NONCQ }, 591933267325STejun Heo { "ncq", .horkage_off = ATA_HORKAGE_NONCQ }, 592033267325STejun Heo { "pio0", .xfer_mask = 1 << (ATA_SHIFT_PIO + 0) }, 592133267325STejun Heo { "pio1", .xfer_mask = 1 << (ATA_SHIFT_PIO + 1) }, 592233267325STejun Heo { "pio2", .xfer_mask = 1 << (ATA_SHIFT_PIO + 2) }, 592333267325STejun Heo { "pio3", .xfer_mask = 1 << (ATA_SHIFT_PIO + 3) }, 592433267325STejun Heo { "pio4", .xfer_mask = 1 << (ATA_SHIFT_PIO + 4) }, 592533267325STejun Heo { "pio5", .xfer_mask = 1 << (ATA_SHIFT_PIO + 5) }, 592633267325STejun Heo { "pio6", .xfer_mask = 1 << (ATA_SHIFT_PIO + 6) }, 592733267325STejun Heo { "mwdma0", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 0) }, 592833267325STejun Heo { "mwdma1", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 1) }, 592933267325STejun Heo { "mwdma2", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 2) }, 593033267325STejun Heo { "mwdma3", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 3) }, 593133267325STejun Heo { "mwdma4", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 4) }, 593233267325STejun Heo { "udma0", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 0) }, 593333267325STejun Heo { "udma16", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 0) }, 593433267325STejun Heo { "udma/16", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 0) }, 593533267325STejun Heo { "udma1", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 1) }, 593633267325STejun Heo { "udma25", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 1) }, 593733267325STejun Heo { "udma/25", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 1) }, 593833267325STejun Heo { "udma2", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 2) }, 593933267325STejun Heo { "udma33", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 2) }, 594033267325STejun Heo { "udma/33", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 2) }, 594133267325STejun Heo { "udma3", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 3) }, 594233267325STejun Heo { "udma44", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 3) }, 594333267325STejun Heo { "udma/44", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 3) }, 594433267325STejun Heo { "udma4", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 4) }, 594533267325STejun Heo { "udma66", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 4) }, 594633267325STejun Heo { "udma/66", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 4) }, 594733267325STejun Heo { "udma5", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 5) }, 594833267325STejun Heo { "udma100", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 5) }, 594933267325STejun Heo { "udma/100", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 5) }, 595033267325STejun Heo { "udma6", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 6) }, 595133267325STejun Heo { "udma133", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 6) }, 595233267325STejun Heo { "udma/133", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 6) }, 595333267325STejun Heo { "udma7", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 7) }, 595433267325STejun Heo }; 595533267325STejun Heo char *start = *cur, *p = *cur; 595633267325STejun Heo char *id, *val, *endp; 595733267325STejun Heo const struct ata_force_param *match_fp = NULL; 595833267325STejun Heo int nr_matches = 0, i; 595933267325STejun Heo 596033267325STejun Heo /* find where this param ends and update *cur */ 596133267325STejun Heo while (*p != '\0' && *p != ',') 596233267325STejun Heo p++; 596333267325STejun Heo 596433267325STejun Heo if (*p == '\0') 596533267325STejun Heo *cur = p; 596633267325STejun Heo else 596733267325STejun Heo *cur = p + 1; 596833267325STejun Heo 596933267325STejun Heo *p = '\0'; 597033267325STejun Heo 597133267325STejun Heo /* parse */ 597233267325STejun Heo p = strchr(start, ':'); 597333267325STejun Heo if (!p) { 597433267325STejun Heo val = strstrip(start); 597533267325STejun Heo goto parse_val; 597633267325STejun Heo } 597733267325STejun Heo *p = '\0'; 597833267325STejun Heo 597933267325STejun Heo id = strstrip(start); 598033267325STejun Heo val = strstrip(p + 1); 598133267325STejun Heo 598233267325STejun Heo /* parse id */ 598333267325STejun Heo p = strchr(id, '.'); 598433267325STejun Heo if (p) { 598533267325STejun Heo *p++ = '\0'; 598633267325STejun Heo force_ent->device = simple_strtoul(p, &endp, 10); 598733267325STejun Heo if (p == endp || *endp != '\0') { 598833267325STejun Heo *reason = "invalid device"; 598933267325STejun Heo return -EINVAL; 599033267325STejun Heo } 599133267325STejun Heo } 599233267325STejun Heo 599333267325STejun Heo force_ent->port = simple_strtoul(id, &endp, 10); 599433267325STejun Heo if (p == endp || *endp != '\0') { 599533267325STejun Heo *reason = "invalid port/link"; 599633267325STejun Heo return -EINVAL; 599733267325STejun Heo } 599833267325STejun Heo 599933267325STejun Heo parse_val: 600033267325STejun Heo /* parse val, allow shortcuts so that both 1.5 and 1.5Gbps work */ 600133267325STejun Heo for (i = 0; i < ARRAY_SIZE(force_tbl); i++) { 600233267325STejun Heo const struct ata_force_param *fp = &force_tbl[i]; 600333267325STejun Heo 600433267325STejun Heo if (strncasecmp(val, fp->name, strlen(val))) 600533267325STejun Heo continue; 600633267325STejun Heo 600733267325STejun Heo nr_matches++; 600833267325STejun Heo match_fp = fp; 600933267325STejun Heo 601033267325STejun Heo if (strcasecmp(val, fp->name) == 0) { 601133267325STejun Heo nr_matches = 1; 601233267325STejun Heo break; 601333267325STejun Heo } 601433267325STejun Heo } 601533267325STejun Heo 601633267325STejun Heo if (!nr_matches) { 601733267325STejun Heo *reason = "unknown value"; 601833267325STejun Heo return -EINVAL; 601933267325STejun Heo } 602033267325STejun Heo if (nr_matches > 1) { 602133267325STejun Heo *reason = "ambigious value"; 602233267325STejun Heo return -EINVAL; 602333267325STejun Heo } 602433267325STejun Heo 602533267325STejun Heo force_ent->param = *match_fp; 602633267325STejun Heo 602733267325STejun Heo return 0; 602833267325STejun Heo } 602933267325STejun Heo 603033267325STejun Heo static void __init ata_parse_force_param(void) 603133267325STejun Heo { 603233267325STejun Heo int idx = 0, size = 1; 603333267325STejun Heo int last_port = -1, last_device = -1; 603433267325STejun Heo char *p, *cur, *next; 603533267325STejun Heo 603633267325STejun Heo /* calculate maximum number of params and allocate force_tbl */ 603733267325STejun Heo for (p = ata_force_param_buf; *p; p++) 603833267325STejun Heo if (*p == ',') 603933267325STejun Heo size++; 604033267325STejun Heo 604133267325STejun Heo ata_force_tbl = kzalloc(sizeof(ata_force_tbl[0]) * size, GFP_KERNEL); 604233267325STejun Heo if (!ata_force_tbl) { 604333267325STejun Heo printk(KERN_WARNING "ata: failed to extend force table, " 604433267325STejun Heo "libata.force ignored\n"); 604533267325STejun Heo return; 604633267325STejun Heo } 604733267325STejun Heo 604833267325STejun Heo /* parse and populate the table */ 604933267325STejun Heo for (cur = ata_force_param_buf; *cur != '\0'; cur = next) { 605033267325STejun Heo const char *reason = ""; 605133267325STejun Heo struct ata_force_ent te = { .port = -1, .device = -1 }; 605233267325STejun Heo 605333267325STejun Heo next = cur; 605433267325STejun Heo if (ata_parse_force_one(&next, &te, &reason)) { 605533267325STejun Heo printk(KERN_WARNING "ata: failed to parse force " 605633267325STejun Heo "parameter \"%s\" (%s)\n", 605733267325STejun Heo cur, reason); 605833267325STejun Heo continue; 605933267325STejun Heo } 606033267325STejun Heo 606133267325STejun Heo if (te.port == -1) { 606233267325STejun Heo te.port = last_port; 606333267325STejun Heo te.device = last_device; 606433267325STejun Heo } 606533267325STejun Heo 606633267325STejun Heo ata_force_tbl[idx++] = te; 606733267325STejun Heo 606833267325STejun Heo last_port = te.port; 606933267325STejun Heo last_device = te.device; 607033267325STejun Heo } 607133267325STejun Heo 607233267325STejun Heo ata_force_tbl_size = idx; 607333267325STejun Heo } 6074c6fd2807SJeff Garzik 6075c6fd2807SJeff Garzik static int __init ata_init(void) 6076c6fd2807SJeff Garzik { 607733267325STejun Heo ata_parse_force_param(); 607833267325STejun Heo 6079c6fd2807SJeff Garzik ata_wq = create_workqueue("ata"); 6080c6fd2807SJeff Garzik if (!ata_wq) 6081c6fd2807SJeff Garzik return -ENOMEM; 6082c6fd2807SJeff Garzik 6083c6fd2807SJeff Garzik ata_aux_wq = create_singlethread_workqueue("ata_aux"); 6084c6fd2807SJeff Garzik if (!ata_aux_wq) { 6085c6fd2807SJeff Garzik destroy_workqueue(ata_wq); 6086c6fd2807SJeff Garzik return -ENOMEM; 6087c6fd2807SJeff Garzik } 6088c6fd2807SJeff Garzik 6089c6fd2807SJeff Garzik printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n"); 6090c6fd2807SJeff Garzik return 0; 6091c6fd2807SJeff Garzik } 6092c6fd2807SJeff Garzik 6093c6fd2807SJeff Garzik static void __exit ata_exit(void) 6094c6fd2807SJeff Garzik { 609533267325STejun Heo kfree(ata_force_tbl); 6096c6fd2807SJeff Garzik destroy_workqueue(ata_wq); 6097c6fd2807SJeff Garzik destroy_workqueue(ata_aux_wq); 6098c6fd2807SJeff Garzik } 6099c6fd2807SJeff Garzik 6100a4625085SBrian King subsys_initcall(ata_init); 6101c6fd2807SJeff Garzik module_exit(ata_exit); 6102c6fd2807SJeff Garzik 6103c6fd2807SJeff Garzik static unsigned long ratelimit_time; 6104c6fd2807SJeff Garzik static DEFINE_SPINLOCK(ata_ratelimit_lock); 6105c6fd2807SJeff Garzik 6106c6fd2807SJeff Garzik int ata_ratelimit(void) 6107c6fd2807SJeff Garzik { 6108c6fd2807SJeff Garzik int rc; 6109c6fd2807SJeff Garzik unsigned long flags; 6110c6fd2807SJeff Garzik 6111c6fd2807SJeff Garzik spin_lock_irqsave(&ata_ratelimit_lock, flags); 6112c6fd2807SJeff Garzik 6113c6fd2807SJeff Garzik if (time_after(jiffies, ratelimit_time)) { 6114c6fd2807SJeff Garzik rc = 1; 6115c6fd2807SJeff Garzik ratelimit_time = jiffies + (HZ/5); 6116c6fd2807SJeff Garzik } else 6117c6fd2807SJeff Garzik rc = 0; 6118c6fd2807SJeff Garzik 6119c6fd2807SJeff Garzik spin_unlock_irqrestore(&ata_ratelimit_lock, flags); 6120c6fd2807SJeff Garzik 6121c6fd2807SJeff Garzik return rc; 6122c6fd2807SJeff Garzik } 6123c6fd2807SJeff Garzik 6124c6fd2807SJeff Garzik /** 6125c6fd2807SJeff Garzik * ata_wait_register - wait until register value changes 6126c6fd2807SJeff Garzik * @reg: IO-mapped register 6127c6fd2807SJeff Garzik * @mask: Mask to apply to read register value 6128c6fd2807SJeff Garzik * @val: Wait condition 6129341c2c95STejun Heo * @interval: polling interval in milliseconds 6130341c2c95STejun Heo * @timeout: timeout in milliseconds 6131c6fd2807SJeff Garzik * 6132c6fd2807SJeff Garzik * Waiting for some bits of register to change is a common 6133c6fd2807SJeff Garzik * operation for ATA controllers. This function reads 32bit LE 6134c6fd2807SJeff Garzik * IO-mapped register @reg and tests for the following condition. 6135c6fd2807SJeff Garzik * 6136c6fd2807SJeff Garzik * (*@reg & mask) != val 6137c6fd2807SJeff Garzik * 6138c6fd2807SJeff Garzik * If the condition is met, it returns; otherwise, the process is 6139c6fd2807SJeff Garzik * repeated after @interval_msec until timeout. 6140c6fd2807SJeff Garzik * 6141c6fd2807SJeff Garzik * LOCKING: 6142c6fd2807SJeff Garzik * Kernel thread context (may sleep) 6143c6fd2807SJeff Garzik * 6144c6fd2807SJeff Garzik * RETURNS: 6145c6fd2807SJeff Garzik * The final register value. 6146c6fd2807SJeff Garzik */ 6147c6fd2807SJeff Garzik u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val, 6148341c2c95STejun Heo unsigned long interval, unsigned long timeout) 6149c6fd2807SJeff Garzik { 6150341c2c95STejun Heo unsigned long deadline; 6151c6fd2807SJeff Garzik u32 tmp; 6152c6fd2807SJeff Garzik 6153c6fd2807SJeff Garzik tmp = ioread32(reg); 6154c6fd2807SJeff Garzik 6155c6fd2807SJeff Garzik /* Calculate timeout _after_ the first read to make sure 6156c6fd2807SJeff Garzik * preceding writes reach the controller before starting to 6157c6fd2807SJeff Garzik * eat away the timeout. 6158c6fd2807SJeff Garzik */ 6159341c2c95STejun Heo deadline = ata_deadline(jiffies, timeout); 6160c6fd2807SJeff Garzik 6161341c2c95STejun Heo while ((tmp & mask) == val && time_before(jiffies, deadline)) { 6162341c2c95STejun Heo msleep(interval); 6163c6fd2807SJeff Garzik tmp = ioread32(reg); 6164c6fd2807SJeff Garzik } 6165c6fd2807SJeff Garzik 6166c6fd2807SJeff Garzik return tmp; 6167c6fd2807SJeff Garzik } 6168c6fd2807SJeff Garzik 6169c6fd2807SJeff Garzik /* 6170c6fd2807SJeff Garzik * Dummy port_ops 6171c6fd2807SJeff Garzik */ 6172c6fd2807SJeff Garzik static unsigned int ata_dummy_qc_issue(struct ata_queued_cmd *qc) 6173c6fd2807SJeff Garzik { 6174c6fd2807SJeff Garzik return AC_ERR_SYSTEM; 6175c6fd2807SJeff Garzik } 6176c6fd2807SJeff Garzik 6177182d7bbaSTejun Heo static void ata_dummy_error_handler(struct ata_port *ap) 6178182d7bbaSTejun Heo { 6179182d7bbaSTejun Heo /* truly dummy */ 6180182d7bbaSTejun Heo } 6181182d7bbaSTejun Heo 6182029cfd6bSTejun Heo struct ata_port_operations ata_dummy_port_ops = { 6183c6fd2807SJeff Garzik .qc_prep = ata_noop_qc_prep, 6184c6fd2807SJeff Garzik .qc_issue = ata_dummy_qc_issue, 6185182d7bbaSTejun Heo .error_handler = ata_dummy_error_handler, 6186c6fd2807SJeff Garzik }; 6187c6fd2807SJeff Garzik 618821b0ad4fSTejun Heo const struct ata_port_info ata_dummy_port_info = { 618921b0ad4fSTejun Heo .port_ops = &ata_dummy_port_ops, 619021b0ad4fSTejun Heo }; 619121b0ad4fSTejun Heo 6192c6fd2807SJeff Garzik /* 6193c6fd2807SJeff Garzik * libata is essentially a library of internal helper functions for 6194c6fd2807SJeff Garzik * low-level ATA host controller drivers. As such, the API/ABI is 6195c6fd2807SJeff Garzik * likely to change as new drivers are added and updated. 6196c6fd2807SJeff Garzik * Do not depend on ABI/API stability. 6197c6fd2807SJeff Garzik */ 6198c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_deb_timing_normal); 6199c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_deb_timing_hotplug); 6200c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_deb_timing_long); 6201029cfd6bSTejun Heo EXPORT_SYMBOL_GPL(ata_base_port_ops); 6202029cfd6bSTejun Heo EXPORT_SYMBOL_GPL(sata_port_ops); 6203c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_dummy_port_ops); 620421b0ad4fSTejun Heo EXPORT_SYMBOL_GPL(ata_dummy_port_info); 6205c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_std_bios_param); 6206cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_init); 6207f3187195STejun Heo EXPORT_SYMBOL_GPL(ata_host_alloc); 6208f5cda257STejun Heo EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo); 6209ecef7253STejun Heo EXPORT_SYMBOL_GPL(ata_host_start); 6210f3187195STejun Heo EXPORT_SYMBOL_GPL(ata_host_register); 6211f5cda257STejun Heo EXPORT_SYMBOL_GPL(ata_host_activate); 62120529c159STejun Heo EXPORT_SYMBOL_GPL(ata_host_detach); 6213c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_sg_init); 6214c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_complete); 6215c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_qc_complete_multiple); 6216436d34b3STejun Heo EXPORT_SYMBOL_GPL(atapi_cmd_type); 6217c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_to_fis); 6218c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_tf_from_fis); 62196357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_pack_xfermask); 62206357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_unpack_xfermask); 62216357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_xfer_mask2mode); 62226357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_xfer_mode2mask); 62236357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_xfer_mode2shift); 62246357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_mode_string); 62256357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_id_xfermask); 6226c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_start); 622704351821SAlan EXPORT_SYMBOL_GPL(ata_do_set_mode); 622831cc23b3STejun Heo EXPORT_SYMBOL_GPL(ata_std_qc_defer); 6229c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_noop_qc_prep); 6230c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_probe); 623110305f0fSAlan EXPORT_SYMBOL_GPL(ata_dev_disable); 6232c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_set_spd); 6233aa2731adSTejun Heo EXPORT_SYMBOL_GPL(ata_wait_after_reset); 6234936fd732STejun Heo EXPORT_SYMBOL_GPL(sata_link_debounce); 6235936fd732STejun Heo EXPORT_SYMBOL_GPL(sata_link_resume); 62360aa1113dSTejun Heo EXPORT_SYMBOL_GPL(ata_std_prereset); 6237cc0680a5STejun Heo EXPORT_SYMBOL_GPL(sata_link_hardreset); 623857c9efdfSTejun Heo EXPORT_SYMBOL_GPL(sata_std_hardreset); 6239203c75b8STejun Heo EXPORT_SYMBOL_GPL(ata_std_postreset); 6240c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_dev_classify); 6241c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_dev_pair); 6242c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_disable); 6243c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_ratelimit); 6244c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_wait_register); 6245c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_ioctl); 6246c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_queuecmd); 6247c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_slave_config); 6248c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_slave_destroy); 6249c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth); 6250c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_valid); 6251c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_read); 6252c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_write); 6253c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(sata_scr_write_flush); 6254936fd732STejun Heo EXPORT_SYMBOL_GPL(ata_link_online); 6255936fd732STejun Heo EXPORT_SYMBOL_GPL(ata_link_offline); 62566ffa01d8STejun Heo #ifdef CONFIG_PM 6257cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_suspend); 6258cca3974eSJeff Garzik EXPORT_SYMBOL_GPL(ata_host_resume); 62596ffa01d8STejun Heo #endif /* CONFIG_PM */ 6260c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_id_string); 6261c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_id_c_string); 6262c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_scsi_simulate); 6263c6fd2807SJeff Garzik 6264c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pio_need_iordy); 62656357357cSTejun Heo EXPORT_SYMBOL_GPL(ata_timing_find_mode); 6266c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_timing_compute); 6267c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_timing_merge); 6268a0f79b92STejun Heo EXPORT_SYMBOL_GPL(ata_timing_cycle2mode); 6269c6fd2807SJeff Garzik 6270c6fd2807SJeff Garzik #ifdef CONFIG_PCI 6271c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(pci_test_config_bits); 6272c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_remove_one); 62736ffa01d8STejun Heo #ifdef CONFIG_PM 6274c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_do_suspend); 6275c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_do_resume); 6276c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_suspend); 6277c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_pci_device_resume); 62786ffa01d8STejun Heo #endif /* CONFIG_PM */ 6279c6fd2807SJeff Garzik #endif /* CONFIG_PCI */ 6280c6fd2807SJeff Garzik 6281b64bbc39STejun Heo EXPORT_SYMBOL_GPL(__ata_ehi_push_desc); 6282b64bbc39STejun Heo EXPORT_SYMBOL_GPL(ata_ehi_push_desc); 6283b64bbc39STejun Heo EXPORT_SYMBOL_GPL(ata_ehi_clear_desc); 6284cbcdd875STejun Heo EXPORT_SYMBOL_GPL(ata_port_desc); 6285cbcdd875STejun Heo #ifdef CONFIG_PCI 6286cbcdd875STejun Heo EXPORT_SYMBOL_GPL(ata_port_pbar_desc); 6287cbcdd875STejun Heo #endif /* CONFIG_PCI */ 6288c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_schedule_eh); 6289dbd82616STejun Heo EXPORT_SYMBOL_GPL(ata_link_abort); 6290c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_abort); 6291c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_port_freeze); 62927d77b247STejun Heo EXPORT_SYMBOL_GPL(sata_async_notification); 6293c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_freeze_port); 6294c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_thaw_port); 6295c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_qc_complete); 6296c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_eh_qc_retry); 629710acf3b0SMark Lord EXPORT_SYMBOL_GPL(ata_eh_analyze_ncq_error); 6298c6fd2807SJeff Garzik EXPORT_SYMBOL_GPL(ata_do_eh); 6299a1efdabaSTejun Heo EXPORT_SYMBOL_GPL(ata_std_error_handler); 6300be0d18dfSAlan Cox 6301be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_40wire); 6302be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_80wire); 6303be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_unknown); 6304c88f90c3STejun Heo EXPORT_SYMBOL_GPL(ata_cable_ignore); 6305be0d18dfSAlan Cox EXPORT_SYMBOL_GPL(ata_cable_sata); 6306