mirror of
https://github.com/linux-msm/laptops-kernel.git
synced 2026-08-13 14:19:53 -07:00
Merge tag 'ata-6.20-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/libata/linux
Pull ATA updates from Damien Le Moal: - Cleanup IRQ masking in the handling of completed report zones commands (Niklas) - Improve the handling of Thunderbolt attached devices to speed up device removal (Henry) - Several patches to generalize the existing max_sec quirks to facilitates quirking the maximum command size of buggy drives, many of which have recently showed up with the recent increase of the default max_sectors block limit (Niklas) - Cleanup the ahci-platform and sata dt-bindings schema (Rob, Manivannan) - Improve device node scan in the ahci-dwc driver (Krzysztof) - Remove clang W=1 warnings with the ahci-imx and ahci-xgene drivers (Krzysztof) - Fix a long standing potential command starvation situation with non-NCQ commands issued when NCQ commands are on-going (me) - Limit max_sectors to 8191 on the INTEL SSDSC2KG480G8 SSD (Niklas) - Remove Vesa Local Bus (VLB) support in the pata_legacy driver (Ethan) - Simple fixes in the pata_cypress (typo) and pata_ftide010 (timing) drivers (Ethan, Linus W) * tag 'ata-6.20-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/libata/linux: ata: pata_ftide010: Fix some DMA timings ata: pata_cypress: fix typo in error message ata: pata_legacy: remove VLB support ata: libata-core: Quirk INTEL SSDSC2KG480G8 max_sectors dt-bindings: ata: sata: Document the graph port ata: libata-scsi: avoid Non-NCQ command starvation ata: libata-scsi: refactor ata_scsi_translate() ata: ahci-xgene: Fix Wvoid-pointer-to-enum-cast warning ata: ahci-imx: Fix Wvoid-pointer-to-enum-cast warning ata: ahci-dwc: Simplify with scoped for each OF child loop dt-bindings: ata: ahci-platform: Drop unnecessary select schema ata: libata: Allow more quirks ata: libata: Add libata.force parameter max_sec ata: libata: Add support to parse equal sign in libata.force ata: libata: Change libata.force to use the generic ATA_QUIRK_MAX_SEC quirk ata: libata: Add ata_force_get_fe_for_dev() helper ata: libata: Add ATA_QUIRK_MAX_SEC and convert all device quirks ata: libata: avoid long timeouts on hot-unplugged SATA DAS ata: libata-scsi: Remove superfluous local_irq_save()
This commit is contained in:
Linus Torvalds
@@ -3468,6 +3468,11 @@ Kernel parameters
|
||||
* [no]logdir: Enable or disable access to the general
|
||||
purpose log directory.
|
||||
|
||||
* max_sec=<sectors>: Set the transfer size limit, in
|
||||
number of 512-byte sectors, to the value specified in
|
||||
<sectors>. The value specified in <sectors> has to be
|
||||
a non-zero positive integer.
|
||||
|
||||
* max_sec_128: Set transfer size limit to 128 sectors.
|
||||
|
||||
* max_sec_1024: Set or clear transfer size limit to
|
||||
|
||||
@@ -18,26 +18,6 @@ maintainers:
|
||||
- Hans de Goede <hdegoede@redhat.com>
|
||||
- Jens Axboe <axboe@kernel.dk>
|
||||
|
||||
select:
|
||||
properties:
|
||||
compatible:
|
||||
contains:
|
||||
enum:
|
||||
- brcm,iproc-ahci
|
||||
- cavium,octeon-7130-ahci
|
||||
- hisilicon,hisi-ahci
|
||||
- ibm,476gtr-ahci
|
||||
- marvell,armada-3700-ahci
|
||||
- marvell,armada-8k-ahci
|
||||
- marvell,berlin2q-ahci
|
||||
- qcom,apq8064-ahci
|
||||
- qcom,ipq806x-ahci
|
||||
- socionext,uniphier-pro4-ahci
|
||||
- socionext,uniphier-pxs2-ahci
|
||||
- socionext,uniphier-pxs3-ahci
|
||||
required:
|
||||
- compatible
|
||||
|
||||
properties:
|
||||
compatible:
|
||||
oneOf:
|
||||
|
||||
@@ -54,4 +54,7 @@ $defs:
|
||||
each port can have a Port Multiplier attached thus allowing to
|
||||
access more than one drive by means of a single SATA port.
|
||||
|
||||
port:
|
||||
$ref: /schemas/graph.yaml#/properties/port
|
||||
|
||||
...
|
||||
|
||||
+1
-16
@@ -1127,13 +1127,6 @@ config PATA_OF_PLATFORM
|
||||
|
||||
If unsure, say N.
|
||||
|
||||
config PATA_QDI
|
||||
tristate "QDI VLB PATA support"
|
||||
depends on ISA
|
||||
select PATA_LEGACY
|
||||
help
|
||||
Support for QDI 6500 and 6580 PATA controllers on VESA local bus.
|
||||
|
||||
config PATA_RB532
|
||||
tristate "RouterBoard 532 PATA CompactFlash support"
|
||||
depends on MIKROTIK_RB532
|
||||
@@ -1152,14 +1145,6 @@ config PATA_RZ1000
|
||||
|
||||
If unsure, say N.
|
||||
|
||||
config PATA_WINBOND_VLB
|
||||
tristate "Winbond W83759A VLB PATA support (Experimental)"
|
||||
depends on ISA
|
||||
select PATA_LEGACY
|
||||
help
|
||||
Support for the Winbond W83759A controller on Vesa Local Bus
|
||||
systems.
|
||||
|
||||
config PATA_PARPORT
|
||||
tristate "Parallel port IDE device support"
|
||||
depends on PARPORT_PC
|
||||
@@ -1201,7 +1186,7 @@ config PATA_LEGACY
|
||||
depends on (ISA || PCI) && HAS_IOPORT
|
||||
select PATA_TIMINGS
|
||||
help
|
||||
This option enables support for ISA/VLB/PCI bus legacy PATA
|
||||
This option enables support for ISA/PCI bus legacy PATA
|
||||
ports and allows them to be accessed via the new ATA layer.
|
||||
|
||||
If unsure, say N.
|
||||
|
||||
@@ -260,7 +260,6 @@ static void ahci_dwc_init_timer(struct ahci_host_priv *hpriv)
|
||||
static int ahci_dwc_init_dmacr(struct ahci_host_priv *hpriv)
|
||||
{
|
||||
struct ahci_dwc_host_priv *dpriv = hpriv->plat_data;
|
||||
struct device_node *child;
|
||||
void __iomem *port_mmio;
|
||||
u32 port, dmacr, ts;
|
||||
|
||||
@@ -271,14 +270,9 @@ static int ahci_dwc_init_dmacr(struct ahci_host_priv *hpriv)
|
||||
* the HBA global reset so we can freely initialize it once until the
|
||||
* next system reset.
|
||||
*/
|
||||
for_each_child_of_node(dpriv->pdev->dev.of_node, child) {
|
||||
if (!of_device_is_available(child))
|
||||
continue;
|
||||
|
||||
if (of_property_read_u32(child, "reg", &port)) {
|
||||
of_node_put(child);
|
||||
for_each_available_child_of_node_scoped(dpriv->pdev->dev.of_node, child) {
|
||||
if (of_property_read_u32(child, "reg", &port))
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
port_mmio = __ahci_port_base(hpriv, port);
|
||||
dmacr = readl(port_mmio + AHCI_DWC_PORT_DMACR);
|
||||
|
||||
@@ -869,7 +869,7 @@ static int imx_ahci_probe(struct platform_device *pdev)
|
||||
imxpriv->ahci_pdev = pdev;
|
||||
imxpriv->no_device = false;
|
||||
imxpriv->first_time = true;
|
||||
imxpriv->type = (enum ahci_imx_type)device_get_match_data(dev);
|
||||
imxpriv->type = (unsigned long)device_get_match_data(dev);
|
||||
|
||||
imxpriv->sata_clk = devm_clk_get(dev, "sata");
|
||||
if (IS_ERR(imxpriv->sata_clk)) {
|
||||
|
||||
@@ -773,7 +773,7 @@ static int xgene_ahci_probe(struct platform_device *pdev)
|
||||
}
|
||||
|
||||
if (dev->of_node) {
|
||||
version = (enum xgene_ahci_version)of_device_get_match_data(dev);
|
||||
version = (unsigned long)of_device_get_match_data(dev);
|
||||
}
|
||||
#ifdef CONFIG_ACPI
|
||||
else {
|
||||
|
||||
+187
-54
@@ -76,18 +76,20 @@ static unsigned int ata_dev_init_params(struct ata_device *dev,
|
||||
u16 heads, u16 sectors);
|
||||
static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
|
||||
static void ata_dev_xfermask(struct ata_device *dev);
|
||||
static unsigned int ata_dev_quirks(const struct ata_device *dev);
|
||||
static u64 ata_dev_quirks(const struct ata_device *dev);
|
||||
static u64 ata_dev_get_quirk_value(struct ata_device *dev, u64 quirk);
|
||||
|
||||
static DEFINE_IDA(ata_ida);
|
||||
|
||||
#ifdef CONFIG_ATA_FORCE
|
||||
struct ata_force_param {
|
||||
const char *name;
|
||||
u64 value;
|
||||
u8 cbl;
|
||||
u8 spd_limit;
|
||||
unsigned int xfer_mask;
|
||||
unsigned int quirk_on;
|
||||
unsigned int quirk_off;
|
||||
u64 quirk_on;
|
||||
u64 quirk_off;
|
||||
unsigned int pflags_on;
|
||||
u16 lflags_on;
|
||||
u16 lflags_off;
|
||||
@@ -473,6 +475,33 @@ static void ata_force_xfermask(struct ata_device *dev)
|
||||
}
|
||||
}
|
||||
|
||||
static const struct ata_force_ent *
|
||||
ata_force_get_fe_for_dev(struct ata_device *dev)
|
||||
{
|
||||
const struct ata_force_ent *fe;
|
||||
int devno = dev->link->pmp + dev->devno;
|
||||
int alt_devno = devno;
|
||||
int i;
|
||||
|
||||
/* allow n.15/16 for devices attached to host port */
|
||||
if (ata_is_host_link(dev->link))
|
||||
alt_devno += 15;
|
||||
|
||||
for (i = 0; i < ata_force_tbl_size; i++) {
|
||||
fe = &ata_force_tbl[i];
|
||||
if (fe->port != -1 && fe->port != dev->link->ap->print_id)
|
||||
continue;
|
||||
|
||||
if (fe->device != -1 && fe->device != devno &&
|
||||
fe->device != alt_devno)
|
||||
continue;
|
||||
|
||||
return fe;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* ata_force_quirks - force quirks according to libata.force
|
||||
* @dev: ATA device of interest
|
||||
@@ -486,34 +515,19 @@ static void ata_force_xfermask(struct ata_device *dev)
|
||||
*/
|
||||
static void ata_force_quirks(struct ata_device *dev)
|
||||
{
|
||||
int devno = dev->link->pmp + dev->devno;
|
||||
int alt_devno = devno;
|
||||
int i;
|
||||
const struct ata_force_ent *fe = ata_force_get_fe_for_dev(dev);
|
||||
|
||||
/* allow n.15/16 for devices attached to host port */
|
||||
if (ata_is_host_link(dev->link))
|
||||
alt_devno += 15;
|
||||
if (!fe)
|
||||
return;
|
||||
|
||||
for (i = 0; i < ata_force_tbl_size; i++) {
|
||||
const struct ata_force_ent *fe = &ata_force_tbl[i];
|
||||
if (!(~dev->quirks & fe->param.quirk_on) &&
|
||||
!(dev->quirks & fe->param.quirk_off))
|
||||
return;
|
||||
|
||||
if (fe->port != -1 && fe->port != dev->link->ap->print_id)
|
||||
continue;
|
||||
dev->quirks |= fe->param.quirk_on;
|
||||
dev->quirks &= ~fe->param.quirk_off;
|
||||
|
||||
if (fe->device != -1 && fe->device != devno &&
|
||||
fe->device != alt_devno)
|
||||
continue;
|
||||
|
||||
if (!(~dev->quirks & fe->param.quirk_on) &&
|
||||
!(dev->quirks & fe->param.quirk_off))
|
||||
continue;
|
||||
|
||||
dev->quirks |= fe->param.quirk_on;
|
||||
dev->quirks &= ~fe->param.quirk_off;
|
||||
|
||||
ata_dev_notice(dev, "FORCE: modified (%s)\n",
|
||||
fe->param.name);
|
||||
}
|
||||
ata_dev_notice(dev, "FORCE: modified (%s)\n", fe->param.name);
|
||||
}
|
||||
#else
|
||||
static inline void ata_force_pflags(struct ata_port *ap) { }
|
||||
@@ -2358,6 +2372,24 @@ static bool ata_dev_check_adapter(struct ata_device *dev,
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ata_adapter_is_online(struct ata_port *ap)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
if (!ap || !ap->host)
|
||||
return false;
|
||||
|
||||
dev = ap->host->dev;
|
||||
if (!dev)
|
||||
return false;
|
||||
|
||||
if (dev_is_pci(dev) &&
|
||||
pci_channel_offline(to_pci_dev(dev)))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static int ata_dev_config_ncq(struct ata_device *dev,
|
||||
char *desc, size_t desc_sz)
|
||||
{
|
||||
@@ -3144,17 +3176,10 @@ int ata_dev_configure(struct ata_device *dev)
|
||||
dev->quirks |= ATA_QUIRK_STUCK_ERR;
|
||||
}
|
||||
|
||||
if (dev->quirks & ATA_QUIRK_MAX_SEC_128)
|
||||
dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128,
|
||||
dev->max_sectors);
|
||||
|
||||
if (dev->quirks & ATA_QUIRK_MAX_SEC_1024)
|
||||
dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_1024,
|
||||
dev->max_sectors);
|
||||
|
||||
if (dev->quirks & ATA_QUIRK_MAX_SEC_8191)
|
||||
dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_8191,
|
||||
dev->max_sectors);
|
||||
if (dev->quirks & ATA_QUIRK_MAX_SEC)
|
||||
dev->max_sectors = min_t(unsigned int, dev->max_sectors,
|
||||
ata_dev_get_quirk_value(dev,
|
||||
ATA_QUIRK_MAX_SEC));
|
||||
|
||||
if (dev->quirks & ATA_QUIRK_MAX_SEC_LBA48)
|
||||
dev->max_sectors = ATA_MAX_SECTORS_LBA48;
|
||||
@@ -3986,7 +4011,6 @@ static const char * const ata_quirk_names[] = {
|
||||
[__ATA_QUIRK_DIAGNOSTIC] = "diagnostic",
|
||||
[__ATA_QUIRK_NODMA] = "nodma",
|
||||
[__ATA_QUIRK_NONCQ] = "noncq",
|
||||
[__ATA_QUIRK_MAX_SEC_128] = "maxsec128",
|
||||
[__ATA_QUIRK_BROKEN_HPA] = "brokenhpa",
|
||||
[__ATA_QUIRK_DISABLE] = "disable",
|
||||
[__ATA_QUIRK_HPA_SIZE] = "hpasize",
|
||||
@@ -4007,8 +4031,7 @@ static const char * const ata_quirk_names[] = {
|
||||
[__ATA_QUIRK_ZERO_AFTER_TRIM] = "zeroaftertrim",
|
||||
[__ATA_QUIRK_NO_DMA_LOG] = "nodmalog",
|
||||
[__ATA_QUIRK_NOTRIM] = "notrim",
|
||||
[__ATA_QUIRK_MAX_SEC_1024] = "maxsec1024",
|
||||
[__ATA_QUIRK_MAX_SEC_8191] = "maxsec8191",
|
||||
[__ATA_QUIRK_MAX_SEC] = "maxsec",
|
||||
[__ATA_QUIRK_MAX_TRIM_128M] = "maxtrim128m",
|
||||
[__ATA_QUIRK_NO_NCQ_ON_ATI] = "noncqonati",
|
||||
[__ATA_QUIRK_NO_LPM_ON_ATI] = "nolpmonati",
|
||||
@@ -4053,10 +4076,26 @@ static void ata_dev_print_quirks(const struct ata_device *dev,
|
||||
kfree(str);
|
||||
}
|
||||
|
||||
struct ata_dev_quirk_value {
|
||||
const char *model_num;
|
||||
const char *model_rev;
|
||||
u64 val;
|
||||
};
|
||||
|
||||
static const struct ata_dev_quirk_value __ata_dev_max_sec_quirks[] = {
|
||||
{ "TORiSAN DVD-ROM DRD-N216", NULL, 128 },
|
||||
{ "ST380013AS", "3.20", 1024 },
|
||||
{ "LITEON CX1-JB*-HP", NULL, 1024 },
|
||||
{ "LITEON EP1-*", NULL, 1024 },
|
||||
{ "DELLBOSS VD", "MV.R00-0", 8191 },
|
||||
{ "INTEL SSDSC2KG480G8", "XCV10120", 8191 },
|
||||
{ },
|
||||
};
|
||||
|
||||
struct ata_dev_quirks_entry {
|
||||
const char *model_num;
|
||||
const char *model_rev;
|
||||
unsigned int quirks;
|
||||
u64 quirks;
|
||||
};
|
||||
|
||||
static const struct ata_dev_quirks_entry __ata_dev_quirks[] = {
|
||||
@@ -4097,7 +4136,7 @@ static const struct ata_dev_quirks_entry __ata_dev_quirks[] = {
|
||||
{ "ASMT109x- Config", NULL, ATA_QUIRK_DISABLE },
|
||||
|
||||
/* Weird ATAPI devices */
|
||||
{ "TORiSAN DVD-ROM DRD-N216", NULL, ATA_QUIRK_MAX_SEC_128 },
|
||||
{ "TORiSAN DVD-ROM DRD-N216", NULL, ATA_QUIRK_MAX_SEC },
|
||||
{ "QUANTUM DAT DAT72-000", NULL, ATA_QUIRK_ATAPI_MOD16_DMA },
|
||||
{ "Slimtype DVD A DS8A8SH", NULL, ATA_QUIRK_MAX_SEC_LBA48 },
|
||||
{ "Slimtype DVD A DS8A9SH", NULL, ATA_QUIRK_MAX_SEC_LBA48 },
|
||||
@@ -4106,20 +4145,20 @@ static const struct ata_dev_quirks_entry __ata_dev_quirks[] = {
|
||||
* Causes silent data corruption with higher max sects.
|
||||
* http://lkml.kernel.org/g/x49wpy40ysk.fsf@segfault.boston.devel.redhat.com
|
||||
*/
|
||||
{ "ST380013AS", "3.20", ATA_QUIRK_MAX_SEC_1024 },
|
||||
{ "ST380013AS", "3.20", ATA_QUIRK_MAX_SEC },
|
||||
|
||||
/*
|
||||
* These devices time out with higher max sects.
|
||||
* https://bugzilla.kernel.org/show_bug.cgi?id=121671
|
||||
*/
|
||||
{ "LITEON CX1-JB*-HP", NULL, ATA_QUIRK_MAX_SEC_1024 },
|
||||
{ "LITEON EP1-*", NULL, ATA_QUIRK_MAX_SEC_1024 },
|
||||
{ "LITEON CX1-JB*-HP", NULL, ATA_QUIRK_MAX_SEC },
|
||||
{ "LITEON EP1-*", NULL, ATA_QUIRK_MAX_SEC },
|
||||
|
||||
/*
|
||||
* These devices time out with higher max sects.
|
||||
* https://bugzilla.kernel.org/show_bug.cgi?id=220693
|
||||
*/
|
||||
{ "DELLBOSS VD", "MV.R00-0", ATA_QUIRK_MAX_SEC_8191 },
|
||||
{ "DELLBOSS VD", "MV.R00-0", ATA_QUIRK_MAX_SEC },
|
||||
|
||||
/* Devices we expect to fail diagnostics */
|
||||
|
||||
@@ -4307,6 +4346,8 @@ static const struct ata_dev_quirks_entry __ata_dev_quirks[] = {
|
||||
|
||||
{ "Micron*", NULL, ATA_QUIRK_ZERO_AFTER_TRIM },
|
||||
{ "Crucial*", NULL, ATA_QUIRK_ZERO_AFTER_TRIM },
|
||||
{ "INTEL SSDSC2KG480G8", "XCV10120", ATA_QUIRK_ZERO_AFTER_TRIM |
|
||||
ATA_QUIRK_MAX_SEC },
|
||||
{ "INTEL*SSD*", NULL, ATA_QUIRK_ZERO_AFTER_TRIM },
|
||||
{ "SSD*INTEL*", NULL, ATA_QUIRK_ZERO_AFTER_TRIM },
|
||||
{ "Samsung*SSD*", NULL, ATA_QUIRK_ZERO_AFTER_TRIM },
|
||||
@@ -4348,14 +4389,14 @@ static const struct ata_dev_quirks_entry __ata_dev_quirks[] = {
|
||||
{ }
|
||||
};
|
||||
|
||||
static unsigned int ata_dev_quirks(const struct ata_device *dev)
|
||||
static u64 ata_dev_quirks(const struct ata_device *dev)
|
||||
{
|
||||
unsigned char model_num[ATA_ID_PROD_LEN + 1];
|
||||
unsigned char model_rev[ATA_ID_FW_REV_LEN + 1];
|
||||
const struct ata_dev_quirks_entry *ad = __ata_dev_quirks;
|
||||
|
||||
/* dev->quirks is an unsigned int. */
|
||||
BUILD_BUG_ON(__ATA_QUIRK_MAX > 32);
|
||||
/* dev->quirks is an u64. */
|
||||
BUILD_BUG_ON(__ATA_QUIRK_MAX > 64);
|
||||
|
||||
ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num));
|
||||
ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev));
|
||||
@@ -4372,6 +4413,48 @@ static unsigned int ata_dev_quirks(const struct ata_device *dev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static u64 ata_dev_get_max_sec_quirk_value(struct ata_device *dev)
|
||||
{
|
||||
unsigned char model_num[ATA_ID_PROD_LEN + 1];
|
||||
unsigned char model_rev[ATA_ID_FW_REV_LEN + 1];
|
||||
const struct ata_dev_quirk_value *ad = __ata_dev_max_sec_quirks;
|
||||
u64 val = 0;
|
||||
|
||||
#ifdef CONFIG_ATA_FORCE
|
||||
const struct ata_force_ent *fe = ata_force_get_fe_for_dev(dev);
|
||||
if (fe && (fe->param.quirk_on & ATA_QUIRK_MAX_SEC) && fe->param.value)
|
||||
val = fe->param.value;
|
||||
#endif
|
||||
if (val)
|
||||
goto out;
|
||||
|
||||
ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num));
|
||||
ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev));
|
||||
|
||||
while (ad->model_num) {
|
||||
if (glob_match(ad->model_num, model_num) &&
|
||||
(!ad->model_rev || glob_match(ad->model_rev, model_rev))) {
|
||||
val = ad->val;
|
||||
break;
|
||||
}
|
||||
ad++;
|
||||
}
|
||||
|
||||
out:
|
||||
ata_dev_warn(dev, "%s quirk is using value: %llu\n",
|
||||
ata_quirk_names[__ATA_QUIRK_MAX_SEC], val);
|
||||
|
||||
return val;
|
||||
}
|
||||
|
||||
static u64 ata_dev_get_quirk_value(struct ata_device *dev, u64 quirk)
|
||||
{
|
||||
if (quirk == ATA_QUIRK_MAX_SEC)
|
||||
return ata_dev_get_max_sec_quirk_value(dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool ata_dev_nodma(const struct ata_device *dev)
|
||||
{
|
||||
/*
|
||||
@@ -5082,6 +5165,12 @@ void ata_qc_issue(struct ata_queued_cmd *qc)
|
||||
qc->flags |= ATA_QCFLAG_ACTIVE;
|
||||
ap->qc_active |= 1ULL << qc->tag;
|
||||
|
||||
/* Make sure the device is still accessible. */
|
||||
if (!ata_adapter_is_online(ap)) {
|
||||
qc->err_mask |= AC_ERR_HOST_BUS;
|
||||
goto sys_err;
|
||||
}
|
||||
|
||||
/*
|
||||
* We guarantee to LLDs that they will have at least one
|
||||
* non-zero sg if the command is a data command.
|
||||
@@ -5567,6 +5656,7 @@ struct ata_port *ata_port_alloc(struct ata_host *host)
|
||||
mutex_init(&ap->scsi_scan_mutex);
|
||||
INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug);
|
||||
INIT_DELAYED_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan);
|
||||
INIT_WORK(&ap->deferred_qc_work, ata_scsi_deferred_qc_work);
|
||||
INIT_LIST_HEAD(&ap->eh_done_q);
|
||||
init_waitqueue_head(&ap->eh_wait_q);
|
||||
init_completion(&ap->park_req_pending);
|
||||
@@ -6179,6 +6269,10 @@ static void ata_port_detach(struct ata_port *ap)
|
||||
}
|
||||
}
|
||||
|
||||
/* Make sure the deferred qc work finished. */
|
||||
cancel_work_sync(&ap->deferred_qc_work);
|
||||
WARN_ON(ap->deferred_qc);
|
||||
|
||||
/* Tell EH to disable all devices */
|
||||
ap->pflags |= ATA_PFLAG_UNLOADING;
|
||||
ata_port_schedule_eh(ap);
|
||||
@@ -6405,10 +6499,21 @@ EXPORT_SYMBOL_GPL(ata_platform_remove_one);
|
||||
#define force_quirk_on(name, flag) \
|
||||
{ #name, .quirk_on = (flag) }
|
||||
|
||||
#define force_quirk_val(name, flag, val) \
|
||||
{ #name, .quirk_on = (flag), \
|
||||
.value = (val) }
|
||||
|
||||
#define force_quirk_onoff(name, flag) \
|
||||
{ "no" #name, .quirk_on = (flag) }, \
|
||||
{ #name, .quirk_off = (flag) }
|
||||
|
||||
/*
|
||||
* If the ata_force_param struct member 'name' ends with '=', then the value
|
||||
* after the equal sign will be parsed as an u64, and will be saved in the
|
||||
* ata_force_param struct member 'value'. This works because each libata.force
|
||||
* entry (struct ata_force_ent) is separated by commas, so each entry represents
|
||||
* a single quirk, and can thus only have a single value.
|
||||
*/
|
||||
static const struct ata_force_param force_tbl[] __initconst = {
|
||||
force_cbl(40c, ATA_CBL_PATA40),
|
||||
force_cbl(80c, ATA_CBL_PATA80),
|
||||
@@ -6479,8 +6584,9 @@ static const struct ata_force_param force_tbl[] __initconst = {
|
||||
force_quirk_onoff(iddevlog, ATA_QUIRK_NO_ID_DEV_LOG),
|
||||
force_quirk_onoff(logdir, ATA_QUIRK_NO_LOG_DIR),
|
||||
|
||||
force_quirk_on(max_sec_128, ATA_QUIRK_MAX_SEC_128),
|
||||
force_quirk_on(max_sec_1024, ATA_QUIRK_MAX_SEC_1024),
|
||||
force_quirk_val(max_sec_128, ATA_QUIRK_MAX_SEC, 128),
|
||||
force_quirk_val(max_sec_1024, ATA_QUIRK_MAX_SEC, 1024),
|
||||
force_quirk_on(max_sec=, ATA_QUIRK_MAX_SEC),
|
||||
force_quirk_on(max_sec_lba48, ATA_QUIRK_MAX_SEC_LBA48),
|
||||
|
||||
force_quirk_onoff(lpm, ATA_QUIRK_NOLPM),
|
||||
@@ -6496,8 +6602,9 @@ static int __init ata_parse_force_one(char **cur,
|
||||
const char **reason)
|
||||
{
|
||||
char *start = *cur, *p = *cur;
|
||||
char *id, *val, *endp;
|
||||
char *id, *val, *endp, *equalsign, *char_after_equalsign;
|
||||
const struct ata_force_param *match_fp = NULL;
|
||||
u64 val_after_equalsign;
|
||||
int nr_matches = 0, i;
|
||||
|
||||
/* find where this param ends and update *cur */
|
||||
@@ -6540,10 +6647,36 @@ static int __init ata_parse_force_one(char **cur,
|
||||
}
|
||||
|
||||
parse_val:
|
||||
/* parse val, allow shortcuts so that both 1.5 and 1.5Gbps work */
|
||||
equalsign = strchr(val, '=');
|
||||
if (equalsign) {
|
||||
char_after_equalsign = equalsign + 1;
|
||||
if (!strlen(char_after_equalsign) ||
|
||||
kstrtoull(char_after_equalsign, 10, &val_after_equalsign)) {
|
||||
*reason = "invalid value after equal sign";
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
/* Parse the parameter value. */
|
||||
for (i = 0; i < ARRAY_SIZE(force_tbl); i++) {
|
||||
const struct ata_force_param *fp = &force_tbl[i];
|
||||
|
||||
/*
|
||||
* If val contains equal sign, match has to be exact, i.e.
|
||||
* shortcuts are not supported.
|
||||
*/
|
||||
if (equalsign &&
|
||||
(strncasecmp(val, fp->name,
|
||||
char_after_equalsign - val) == 0)) {
|
||||
force_ent->param = *fp;
|
||||
force_ent->param.value = val_after_equalsign;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* If val does not contain equal sign, allow shortcuts so that
|
||||
* both 1.5 and 1.5Gbps work.
|
||||
*/
|
||||
if (strncasecmp(val, fp->name, strlen(val)))
|
||||
continue;
|
||||
|
||||
|
||||
@@ -736,7 +736,8 @@ void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap)
|
||||
spin_unlock_irqrestore(ap->lock, flags);
|
||||
|
||||
/* invoke EH, skip if unloading or suspended */
|
||||
if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED)))
|
||||
if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED)) &&
|
||||
ata_adapter_is_online(ap))
|
||||
ap->ops->error_handler(ap);
|
||||
else {
|
||||
/* if unloading, commence suicide */
|
||||
@@ -917,6 +918,12 @@ static void ata_eh_set_pending(struct ata_port *ap, bool fastdrain)
|
||||
|
||||
ap->pflags |= ATA_PFLAG_EH_PENDING;
|
||||
|
||||
/*
|
||||
* If we have a deferred qc, requeue it so that it is retried once EH
|
||||
* completes.
|
||||
*/
|
||||
ata_scsi_requeue_deferred_qc(ap);
|
||||
|
||||
if (!fastdrain)
|
||||
return;
|
||||
|
||||
|
||||
+148
-34
@@ -1658,8 +1658,77 @@ static void ata_qc_done(struct ata_queued_cmd *qc)
|
||||
done(cmd);
|
||||
}
|
||||
|
||||
void ata_scsi_deferred_qc_work(struct work_struct *work)
|
||||
{
|
||||
struct ata_port *ap =
|
||||
container_of(work, struct ata_port, deferred_qc_work);
|
||||
struct ata_queued_cmd *qc;
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(ap->lock, flags);
|
||||
|
||||
/*
|
||||
* If we still have a deferred qc and we are not in EH, issue it. In
|
||||
* such case, we should not need any more deferring the qc, so warn if
|
||||
* qc_defer() says otherwise.
|
||||
*/
|
||||
qc = ap->deferred_qc;
|
||||
if (qc && !ata_port_eh_scheduled(ap)) {
|
||||
WARN_ON_ONCE(ap->ops->qc_defer(qc));
|
||||
ap->deferred_qc = NULL;
|
||||
ata_qc_issue(qc);
|
||||
}
|
||||
|
||||
spin_unlock_irqrestore(ap->lock, flags);
|
||||
}
|
||||
|
||||
void ata_scsi_requeue_deferred_qc(struct ata_port *ap)
|
||||
{
|
||||
struct ata_queued_cmd *qc = ap->deferred_qc;
|
||||
struct scsi_cmnd *scmd;
|
||||
|
||||
lockdep_assert_held(ap->lock);
|
||||
|
||||
/*
|
||||
* If we have a deferred qc when a reset occurs or NCQ commands fail,
|
||||
* do not try to be smart about what to do with this deferred command
|
||||
* and simply retry it by completing it with DID_SOFT_ERROR.
|
||||
*/
|
||||
if (!qc)
|
||||
return;
|
||||
|
||||
scmd = qc->scsicmd;
|
||||
ap->deferred_qc = NULL;
|
||||
ata_qc_free(qc);
|
||||
scmd->result = (DID_SOFT_ERROR << 16);
|
||||
scsi_done(scmd);
|
||||
}
|
||||
|
||||
static void ata_scsi_schedule_deferred_qc(struct ata_port *ap)
|
||||
{
|
||||
struct ata_queued_cmd *qc = ap->deferred_qc;
|
||||
|
||||
lockdep_assert_held(ap->lock);
|
||||
|
||||
/*
|
||||
* If we have a deferred qc, then qc_defer() is defined and we can use
|
||||
* this callback to determine if this qc is good to go, unless EH has
|
||||
* been scheduled.
|
||||
*/
|
||||
if (!qc)
|
||||
return;
|
||||
|
||||
if (ata_port_eh_scheduled(ap)) {
|
||||
ata_scsi_requeue_deferred_qc(ap);
|
||||
return;
|
||||
}
|
||||
if (!ap->ops->qc_defer(qc))
|
||||
queue_work(system_highpri_wq, &ap->deferred_qc_work);
|
||||
}
|
||||
|
||||
static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
|
||||
{
|
||||
struct ata_port *ap = qc->ap;
|
||||
struct scsi_cmnd *cmd = qc->scsicmd;
|
||||
u8 *cdb = cmd->cmnd;
|
||||
bool have_sense = qc->flags & ATA_QCFLAG_SENSE_VALID;
|
||||
@@ -1689,6 +1758,66 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
|
||||
}
|
||||
|
||||
ata_qc_done(qc);
|
||||
|
||||
ata_scsi_schedule_deferred_qc(ap);
|
||||
}
|
||||
|
||||
static int ata_scsi_qc_issue(struct ata_port *ap, struct ata_queued_cmd *qc)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (!ap->ops->qc_defer)
|
||||
goto issue;
|
||||
|
||||
/*
|
||||
* If we already have a deferred qc, then rely on the SCSI layer to
|
||||
* requeue and defer all incoming commands until the deferred qc is
|
||||
* processed, once all on-going commands complete.
|
||||
*/
|
||||
if (ap->deferred_qc) {
|
||||
ata_qc_free(qc);
|
||||
return SCSI_MLQUEUE_DEVICE_BUSY;
|
||||
}
|
||||
|
||||
/* Check if the command needs to be deferred. */
|
||||
ret = ap->ops->qc_defer(qc);
|
||||
switch (ret) {
|
||||
case 0:
|
||||
break;
|
||||
case ATA_DEFER_LINK:
|
||||
ret = SCSI_MLQUEUE_DEVICE_BUSY;
|
||||
break;
|
||||
case ATA_DEFER_PORT:
|
||||
ret = SCSI_MLQUEUE_HOST_BUSY;
|
||||
break;
|
||||
default:
|
||||
WARN_ON_ONCE(1);
|
||||
ret = SCSI_MLQUEUE_HOST_BUSY;
|
||||
break;
|
||||
}
|
||||
|
||||
if (ret) {
|
||||
/*
|
||||
* We must defer this qc: if this is not an NCQ command, keep
|
||||
* this qc as a deferred one and report to the SCSI layer that
|
||||
* we issued it so that it is not requeued. The deferred qc will
|
||||
* be issued with the port deferred_qc_work once all on-going
|
||||
* commands complete.
|
||||
*/
|
||||
if (!ata_is_ncq(qc->tf.protocol)) {
|
||||
ap->deferred_qc = qc;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Force a requeue of the command to defer its execution. */
|
||||
ata_qc_free(qc);
|
||||
return ret;
|
||||
}
|
||||
|
||||
issue:
|
||||
ata_qc_issue(qc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -1714,66 +1843,49 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
|
||||
* spin_lock_irqsave(host lock)
|
||||
*
|
||||
* RETURNS:
|
||||
* 0 on success, SCSI_ML_QUEUE_DEVICE_BUSY if the command
|
||||
* needs to be deferred.
|
||||
* 0 on success, SCSI_ML_QUEUE_DEVICE_BUSY or SCSI_MLQUEUE_HOST_BUSY if the
|
||||
* command needs to be deferred.
|
||||
*/
|
||||
static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
|
||||
ata_xlat_func_t xlat_func)
|
||||
{
|
||||
struct ata_port *ap = dev->link->ap;
|
||||
struct ata_queued_cmd *qc;
|
||||
int rc;
|
||||
|
||||
lockdep_assert_held(ap->lock);
|
||||
|
||||
/*
|
||||
* ata_scsi_qc_new() calls scsi_done(cmd) in case of failure. So we
|
||||
* have nothing further to do when allocating a qc fails.
|
||||
*/
|
||||
qc = ata_scsi_qc_new(dev, cmd);
|
||||
if (!qc)
|
||||
goto err_mem;
|
||||
return 0;
|
||||
|
||||
/* data is present; dma-map it */
|
||||
if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
|
||||
cmd->sc_data_direction == DMA_TO_DEVICE) {
|
||||
if (unlikely(scsi_bufflen(cmd) < 1)) {
|
||||
ata_dev_warn(dev, "WARNING: zero len r/w req\n");
|
||||
goto err_did;
|
||||
cmd->result = (DID_ERROR << 16);
|
||||
goto done;
|
||||
}
|
||||
|
||||
ata_sg_init(qc, scsi_sglist(cmd), scsi_sg_count(cmd));
|
||||
|
||||
qc->dma_dir = cmd->sc_data_direction;
|
||||
}
|
||||
|
||||
qc->complete_fn = ata_scsi_qc_complete;
|
||||
|
||||
if (xlat_func(qc))
|
||||
goto early_finish;
|
||||
goto done;
|
||||
|
||||
if (ap->ops->qc_defer) {
|
||||
if ((rc = ap->ops->qc_defer(qc)))
|
||||
goto defer;
|
||||
}
|
||||
return ata_scsi_qc_issue(ap, qc);
|
||||
|
||||
/* select device, send command to hardware */
|
||||
ata_qc_issue(qc);
|
||||
|
||||
return 0;
|
||||
|
||||
early_finish:
|
||||
done:
|
||||
ata_qc_free(qc);
|
||||
scsi_done(cmd);
|
||||
return 0;
|
||||
|
||||
err_did:
|
||||
ata_qc_free(qc);
|
||||
cmd->result = (DID_ERROR << 16);
|
||||
scsi_done(cmd);
|
||||
err_mem:
|
||||
return 0;
|
||||
|
||||
defer:
|
||||
ata_qc_free(qc);
|
||||
if (rc == ATA_DEFER_LINK)
|
||||
return SCSI_MLQUEUE_DEVICE_BUSY;
|
||||
else
|
||||
return SCSI_MLQUEUE_HOST_BUSY;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -2982,6 +3094,9 @@ ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev)
|
||||
{
|
||||
struct ata_device *dev = __ata_scsi_find_dev(ap, scsidev);
|
||||
|
||||
if (!ata_adapter_is_online(ap))
|
||||
return NULL;
|
||||
|
||||
if (unlikely(!dev || !ata_dev_enabled(dev)))
|
||||
return NULL;
|
||||
|
||||
@@ -3573,13 +3688,13 @@ static void ata_scsi_report_zones_complete(struct ata_queued_cmd *qc)
|
||||
{
|
||||
struct scsi_cmnd *scmd = qc->scsicmd;
|
||||
struct sg_mapping_iter miter;
|
||||
unsigned long flags;
|
||||
unsigned int bytes = 0;
|
||||
|
||||
lockdep_assert_held(qc->ap->lock);
|
||||
|
||||
sg_miter_start(&miter, scsi_sglist(scmd), scsi_sg_count(scmd),
|
||||
SG_MITER_TO_SG | SG_MITER_ATOMIC);
|
||||
|
||||
local_irq_save(flags);
|
||||
while (sg_miter_next(&miter)) {
|
||||
unsigned int offset = 0;
|
||||
|
||||
@@ -3627,7 +3742,6 @@ static void ata_scsi_report_zones_complete(struct ata_queued_cmd *qc)
|
||||
}
|
||||
}
|
||||
sg_miter_stop(&miter);
|
||||
local_irq_restore(flags);
|
||||
|
||||
ata_scsi_qc_complete(qc);
|
||||
}
|
||||
|
||||
@@ -94,6 +94,7 @@ extern int atapi_check_dma(struct ata_queued_cmd *qc);
|
||||
extern void swap_buf_le16(u16 *buf, unsigned int buf_words);
|
||||
extern bool ata_phys_link_online(struct ata_link *link);
|
||||
extern bool ata_phys_link_offline(struct ata_link *link);
|
||||
bool ata_adapter_is_online(struct ata_port *ap);
|
||||
extern void ata_dev_init(struct ata_device *dev);
|
||||
extern void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp);
|
||||
extern int sata_link_init_spd(struct ata_link *link);
|
||||
@@ -166,6 +167,8 @@ int ata_scsi_dev_config(struct scsi_device *sdev, struct queue_limits *lim,
|
||||
struct ata_device *dev);
|
||||
enum scsi_qc_status __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
|
||||
struct ata_device *dev);
|
||||
void ata_scsi_deferred_qc_work(struct work_struct *work);
|
||||
void ata_scsi_requeue_deferred_qc(struct ata_port *ap);
|
||||
|
||||
/* libata-eh.c */
|
||||
extern unsigned int ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd);
|
||||
|
||||
@@ -62,7 +62,7 @@ static void cy82c693_set_piomode(struct ata_port *ap, struct ata_device *adev)
|
||||
u32 addr;
|
||||
|
||||
if (ata_timing_compute(adev, adev->pio_mode, &t, T, 1) < 0) {
|
||||
ata_dev_err(adev, DRV_NAME ": mome computation failed.\n");
|
||||
ata_dev_err(adev, DRV_NAME ": mode computation failed.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@@ -122,10 +122,10 @@ static const u8 mwdma_50_active_time[3] = {6, 2, 2};
|
||||
static const u8 mwdma_50_recovery_time[3] = {6, 2, 1};
|
||||
static const u8 mwdma_66_active_time[3] = {8, 3, 3};
|
||||
static const u8 mwdma_66_recovery_time[3] = {8, 2, 1};
|
||||
static const u8 udma_50_setup_time[6] = {3, 3, 2, 2, 1, 1};
|
||||
static const u8 udma_50_setup_time[6] = {3, 3, 2, 2, 1, 9};
|
||||
static const u8 udma_50_hold_time[6] = {3, 1, 1, 1, 1, 1};
|
||||
static const u8 udma_66_setup_time[7] = {4, 4, 3, 2, };
|
||||
static const u8 udma_66_hold_time[7] = {};
|
||||
static const u8 udma_66_setup_time[7] = {4, 4, 3, 2, 1, 9, 9};
|
||||
static const u8 udma_66_hold_time[7] = {4, 2, 1, 1, 1, 1, 1};
|
||||
|
||||
/*
|
||||
* We set 66 MHz for all MWDMA modes
|
||||
|
||||
+5
-862
File diff suppressed because it is too large
Load Diff
@@ -26,10 +26,7 @@ enum {
|
||||
ATA_MAX_DEVICES = 2, /* per bus/port */
|
||||
ATA_MAX_PRD = 256, /* we could make these 256/256 */
|
||||
ATA_SECT_SIZE = 512,
|
||||
ATA_MAX_SECTORS_128 = 128,
|
||||
ATA_MAX_SECTORS = 256,
|
||||
ATA_MAX_SECTORS_1024 = 1024,
|
||||
ATA_MAX_SECTORS_8191 = 8191,
|
||||
ATA_MAX_SECTORS_LBA48 = 65535,/* avoid count to be 0000h */
|
||||
ATA_MAX_SECTORS_TAPE = 65535,
|
||||
ATA_MAX_TRIM_RNUM = 64, /* 512-byte payload / (6-byte LBA + 2-byte range per entry) */
|
||||
|
||||
+36
-37
@@ -46,13 +46,12 @@
|
||||
|
||||
/*
|
||||
* Quirk flags bits.
|
||||
* ata_device->quirks is an unsigned int, so __ATA_QUIRK_MAX must not exceed 32.
|
||||
* ata_device->quirks is an u64, so __ATA_QUIRK_MAX must not exceed 64.
|
||||
*/
|
||||
enum ata_quirks {
|
||||
__ATA_QUIRK_DIAGNOSTIC, /* Failed boot diag */
|
||||
__ATA_QUIRK_NODMA, /* DMA problems */
|
||||
__ATA_QUIRK_NONCQ, /* Don't use NCQ */
|
||||
__ATA_QUIRK_MAX_SEC_128, /* Limit max sects to 128 */
|
||||
__ATA_QUIRK_BROKEN_HPA, /* Broken HPA */
|
||||
__ATA_QUIRK_DISABLE, /* Disable it */
|
||||
__ATA_QUIRK_HPA_SIZE, /* Native size off by one */
|
||||
@@ -74,8 +73,7 @@ enum ata_quirks {
|
||||
__ATA_QUIRK_ZERO_AFTER_TRIM, /* Guarantees zero after trim */
|
||||
__ATA_QUIRK_NO_DMA_LOG, /* Do not use DMA for log read */
|
||||
__ATA_QUIRK_NOTRIM, /* Do not use TRIM */
|
||||
__ATA_QUIRK_MAX_SEC_1024, /* Limit max sects to 1024 */
|
||||
__ATA_QUIRK_MAX_SEC_8191, /* Limit max sects to 8191 */
|
||||
__ATA_QUIRK_MAX_SEC, /* Limit max sectors */
|
||||
__ATA_QUIRK_MAX_TRIM_128M, /* Limit max trim size to 128M */
|
||||
__ATA_QUIRK_NO_NCQ_ON_ATI, /* Disable NCQ on ATI chipset */
|
||||
__ATA_QUIRK_NO_LPM_ON_ATI, /* Disable LPM on ATI chipset */
|
||||
@@ -91,38 +89,36 @@ enum ata_quirks {
|
||||
* Some quirks may be drive/controller pair dependent.
|
||||
*/
|
||||
enum {
|
||||
ATA_QUIRK_DIAGNOSTIC = (1U << __ATA_QUIRK_DIAGNOSTIC),
|
||||
ATA_QUIRK_NODMA = (1U << __ATA_QUIRK_NODMA),
|
||||
ATA_QUIRK_NONCQ = (1U << __ATA_QUIRK_NONCQ),
|
||||
ATA_QUIRK_MAX_SEC_128 = (1U << __ATA_QUIRK_MAX_SEC_128),
|
||||
ATA_QUIRK_BROKEN_HPA = (1U << __ATA_QUIRK_BROKEN_HPA),
|
||||
ATA_QUIRK_DISABLE = (1U << __ATA_QUIRK_DISABLE),
|
||||
ATA_QUIRK_HPA_SIZE = (1U << __ATA_QUIRK_HPA_SIZE),
|
||||
ATA_QUIRK_IVB = (1U << __ATA_QUIRK_IVB),
|
||||
ATA_QUIRK_STUCK_ERR = (1U << __ATA_QUIRK_STUCK_ERR),
|
||||
ATA_QUIRK_BRIDGE_OK = (1U << __ATA_QUIRK_BRIDGE_OK),
|
||||
ATA_QUIRK_ATAPI_MOD16_DMA = (1U << __ATA_QUIRK_ATAPI_MOD16_DMA),
|
||||
ATA_QUIRK_FIRMWARE_WARN = (1U << __ATA_QUIRK_FIRMWARE_WARN),
|
||||
ATA_QUIRK_1_5_GBPS = (1U << __ATA_QUIRK_1_5_GBPS),
|
||||
ATA_QUIRK_NOSETXFER = (1U << __ATA_QUIRK_NOSETXFER),
|
||||
ATA_QUIRK_BROKEN_FPDMA_AA = (1U << __ATA_QUIRK_BROKEN_FPDMA_AA),
|
||||
ATA_QUIRK_DUMP_ID = (1U << __ATA_QUIRK_DUMP_ID),
|
||||
ATA_QUIRK_MAX_SEC_LBA48 = (1U << __ATA_QUIRK_MAX_SEC_LBA48),
|
||||
ATA_QUIRK_ATAPI_DMADIR = (1U << __ATA_QUIRK_ATAPI_DMADIR),
|
||||
ATA_QUIRK_NO_NCQ_TRIM = (1U << __ATA_QUIRK_NO_NCQ_TRIM),
|
||||
ATA_QUIRK_NOLPM = (1U << __ATA_QUIRK_NOLPM),
|
||||
ATA_QUIRK_WD_BROKEN_LPM = (1U << __ATA_QUIRK_WD_BROKEN_LPM),
|
||||
ATA_QUIRK_ZERO_AFTER_TRIM = (1U << __ATA_QUIRK_ZERO_AFTER_TRIM),
|
||||
ATA_QUIRK_NO_DMA_LOG = (1U << __ATA_QUIRK_NO_DMA_LOG),
|
||||
ATA_QUIRK_NOTRIM = (1U << __ATA_QUIRK_NOTRIM),
|
||||
ATA_QUIRK_MAX_SEC_1024 = (1U << __ATA_QUIRK_MAX_SEC_1024),
|
||||
ATA_QUIRK_MAX_SEC_8191 = (1U << __ATA_QUIRK_MAX_SEC_8191),
|
||||
ATA_QUIRK_MAX_TRIM_128M = (1U << __ATA_QUIRK_MAX_TRIM_128M),
|
||||
ATA_QUIRK_NO_NCQ_ON_ATI = (1U << __ATA_QUIRK_NO_NCQ_ON_ATI),
|
||||
ATA_QUIRK_NO_LPM_ON_ATI = (1U << __ATA_QUIRK_NO_LPM_ON_ATI),
|
||||
ATA_QUIRK_NO_ID_DEV_LOG = (1U << __ATA_QUIRK_NO_ID_DEV_LOG),
|
||||
ATA_QUIRK_NO_LOG_DIR = (1U << __ATA_QUIRK_NO_LOG_DIR),
|
||||
ATA_QUIRK_NO_FUA = (1U << __ATA_QUIRK_NO_FUA),
|
||||
ATA_QUIRK_DIAGNOSTIC = BIT_ULL(__ATA_QUIRK_DIAGNOSTIC),
|
||||
ATA_QUIRK_NODMA = BIT_ULL(__ATA_QUIRK_NODMA),
|
||||
ATA_QUIRK_NONCQ = BIT_ULL(__ATA_QUIRK_NONCQ),
|
||||
ATA_QUIRK_BROKEN_HPA = BIT_ULL(__ATA_QUIRK_BROKEN_HPA),
|
||||
ATA_QUIRK_DISABLE = BIT_ULL(__ATA_QUIRK_DISABLE),
|
||||
ATA_QUIRK_HPA_SIZE = BIT_ULL(__ATA_QUIRK_HPA_SIZE),
|
||||
ATA_QUIRK_IVB = BIT_ULL(__ATA_QUIRK_IVB),
|
||||
ATA_QUIRK_STUCK_ERR = BIT_ULL(__ATA_QUIRK_STUCK_ERR),
|
||||
ATA_QUIRK_BRIDGE_OK = BIT_ULL(__ATA_QUIRK_BRIDGE_OK),
|
||||
ATA_QUIRK_ATAPI_MOD16_DMA = BIT_ULL(__ATA_QUIRK_ATAPI_MOD16_DMA),
|
||||
ATA_QUIRK_FIRMWARE_WARN = BIT_ULL(__ATA_QUIRK_FIRMWARE_WARN),
|
||||
ATA_QUIRK_1_5_GBPS = BIT_ULL(__ATA_QUIRK_1_5_GBPS),
|
||||
ATA_QUIRK_NOSETXFER = BIT_ULL(__ATA_QUIRK_NOSETXFER),
|
||||
ATA_QUIRK_BROKEN_FPDMA_AA = BIT_ULL(__ATA_QUIRK_BROKEN_FPDMA_AA),
|
||||
ATA_QUIRK_DUMP_ID = BIT_ULL(__ATA_QUIRK_DUMP_ID),
|
||||
ATA_QUIRK_MAX_SEC_LBA48 = BIT_ULL(__ATA_QUIRK_MAX_SEC_LBA48),
|
||||
ATA_QUIRK_ATAPI_DMADIR = BIT_ULL(__ATA_QUIRK_ATAPI_DMADIR),
|
||||
ATA_QUIRK_NO_NCQ_TRIM = BIT_ULL(__ATA_QUIRK_NO_NCQ_TRIM),
|
||||
ATA_QUIRK_NOLPM = BIT_ULL(__ATA_QUIRK_NOLPM),
|
||||
ATA_QUIRK_WD_BROKEN_LPM = BIT_ULL(__ATA_QUIRK_WD_BROKEN_LPM),
|
||||
ATA_QUIRK_ZERO_AFTER_TRIM = BIT_ULL(__ATA_QUIRK_ZERO_AFTER_TRIM),
|
||||
ATA_QUIRK_NO_DMA_LOG = BIT_ULL(__ATA_QUIRK_NO_DMA_LOG),
|
||||
ATA_QUIRK_NOTRIM = BIT_ULL(__ATA_QUIRK_NOTRIM),
|
||||
ATA_QUIRK_MAX_SEC = BIT_ULL(__ATA_QUIRK_MAX_SEC),
|
||||
ATA_QUIRK_MAX_TRIM_128M = BIT_ULL(__ATA_QUIRK_MAX_TRIM_128M),
|
||||
ATA_QUIRK_NO_NCQ_ON_ATI = BIT_ULL(__ATA_QUIRK_NO_NCQ_ON_ATI),
|
||||
ATA_QUIRK_NO_LPM_ON_ATI = BIT_ULL(__ATA_QUIRK_NO_LPM_ON_ATI),
|
||||
ATA_QUIRK_NO_ID_DEV_LOG = BIT_ULL(__ATA_QUIRK_NO_ID_DEV_LOG),
|
||||
ATA_QUIRK_NO_LOG_DIR = BIT_ULL(__ATA_QUIRK_NO_LOG_DIR),
|
||||
ATA_QUIRK_NO_FUA = BIT_ULL(__ATA_QUIRK_NO_FUA),
|
||||
};
|
||||
|
||||
enum {
|
||||
@@ -723,7 +719,7 @@ struct ata_cdl {
|
||||
struct ata_device {
|
||||
struct ata_link *link;
|
||||
unsigned int devno; /* 0 or 1 */
|
||||
unsigned int quirks; /* List of broken features */
|
||||
u64 quirks; /* List of broken features */
|
||||
unsigned long flags; /* ATA_DFLAG_xxx */
|
||||
struct scsi_device *sdev; /* attached SCSI device */
|
||||
void *private_data;
|
||||
@@ -903,6 +899,9 @@ struct ata_port {
|
||||
u64 qc_active;
|
||||
int nr_active_links; /* #links with active qcs */
|
||||
|
||||
struct work_struct deferred_qc_work;
|
||||
struct ata_queued_cmd *deferred_qc;
|
||||
|
||||
struct ata_link link; /* host default link */
|
||||
struct ata_link *slave_link; /* see ata_slave_link_init() */
|
||||
|
||||
|
||||
Reference in New Issue
Block a user