ata: libata: Use QUIRK instead of HORKAGE

+245 -245

drivers/ata/libata-core.c

··· 84 84 u16 heads, u16 sectors); 85 85 static unsigned int ata_dev_set_xfermode(struct ata_device *dev); 86 86 static void ata_dev_xfermask(struct ata_device *dev); 87 - static unsigned long ata_dev_blacklisted(const struct ata_device *dev); 87 + static unsigned int ata_dev_quirks(const struct ata_device *dev); 88 88 89 89 static DEFINE_IDA(ata_ida); 90 90 ··· 94 94 u8 cbl; 95 95 u8 spd_limit; 96 96 unsigned int xfer_mask; 97 - unsigned int horkage_on; 98 - unsigned int horkage_off; 97 + unsigned int quirk_on; 98 + unsigned int quirk_off; 99 99 u16 lflags_on; 100 100 u16 lflags_off; 101 101 }; ··· 457 457 } 458 458 459 459 /** 460 - * ata_force_horkage - force horkage according to libata.force 460 + * ata_force_quirks - force quirks according to libata.force 461 461 * @dev: ATA device of interest 462 462 * 463 - * Force horkage according to libata.force and whine about it. 463 + * Force quirks according to libata.force and whine about it. 464 464 * For consistency with link selection, device number 15 selects 465 465 * the first device connected to the host link. 466 466 * 467 467 * LOCKING: 468 468 * EH context. 469 469 */ 470 - static void ata_force_horkage(struct ata_device *dev) 470 + static void ata_force_quirks(struct ata_device *dev) 471 471 { 472 472 int devno = dev->link->pmp + dev->devno; 473 473 int alt_devno = devno; ··· 487 487 fe->device != alt_devno) 488 488 continue; 489 489 490 - if (!(~dev->horkage & fe->param.horkage_on) && 491 - !(dev->horkage & fe->param.horkage_off)) 490 + if (!(~dev->quirks & fe->param.quirk_on) && 491 + !(dev->quirks & fe->param.quirk_off)) 492 492 continue; 493 493 494 - dev->horkage |= fe->param.horkage_on; 495 - dev->horkage &= ~fe->param.horkage_off; 494 + dev->quirks |= fe->param.quirk_on; 495 + dev->quirks &= ~fe->param.quirk_off; 496 496 497 - ata_dev_notice(dev, "FORCE: horkage modified (%s)\n", 497 + ata_dev_notice(dev, "FORCE: modified (%s)\n", 498 498 fe->param.name); 499 499 } 500 500 } 501 501 #else 502 502 static inline void ata_force_link_limits(struct ata_link *link) { } 503 503 static inline void ata_force_xfermask(struct ata_device *dev) { } 504 - static inline void ata_force_horkage(struct ata_device *dev) { } 504 + static inline void ata_force_quirks(struct ata_device *dev) { } 505 505 #endif 506 506 507 507 /** ··· 1221 1221 *max_sectors = ata_tf_to_lba48(&tf) + 1; 1222 1222 else 1223 1223 *max_sectors = ata_tf_to_lba(&tf) + 1; 1224 - if (dev->horkage & ATA_HORKAGE_HPA_SIZE) 1224 + if (dev->quirks & ATA_QUIRK_HPA_SIZE) 1225 1225 (*max_sectors)--; 1226 1226 return 0; 1227 1227 } ··· 1306 1306 /* do we need to do it? */ 1307 1307 if ((dev->class != ATA_DEV_ATA && dev->class != ATA_DEV_ZAC) || 1308 1308 !ata_id_has_lba(dev->id) || !ata_id_hpa_enabled(dev->id) || 1309 - (dev->horkage & ATA_HORKAGE_BROKEN_HPA)) 1309 + (dev->quirks & ATA_QUIRK_BROKEN_HPA)) 1310 1310 return 0; 1311 1311 1312 1312 /* read native max address */ ··· 1318 1318 if (rc == -EACCES || !unlock_hpa) { 1319 1319 ata_dev_warn(dev, 1320 1320 "HPA support seems broken, skipping HPA handling\n"); 1321 - dev->horkage |= ATA_HORKAGE_BROKEN_HPA; 1321 + dev->quirks |= ATA_QUIRK_BROKEN_HPA; 1322 1322 1323 1323 /* we can continue if device aborted the command */ 1324 1324 if (rc == -EACCES) ··· 1355 1355 "device aborted resize (%llu -> %llu), skipping HPA handling\n", 1356 1356 (unsigned long long)sectors, 1357 1357 (unsigned long long)native_sectors); 1358 - dev->horkage |= ATA_HORKAGE_BROKEN_HPA; 1358 + dev->quirks |= ATA_QUIRK_BROKEN_HPA; 1359 1359 return 0; 1360 1360 } else if (rc) 1361 1361 return rc; ··· 1835 1835 goto err_out; 1836 1836 } 1837 1837 1838 - if (dev->horkage & ATA_HORKAGE_DUMP_ID) { 1838 + if (dev->quirks & ATA_QUIRK_DUMP_ID) { 1839 1839 ata_dev_info(dev, "dumping IDENTIFY data, " 1840 1840 "class=%d may_fallback=%d tried_spinup=%d\n", 1841 1841 class, may_fallback, tried_spinup); ··· 2104 2104 retry: 2105 2105 ata_tf_init(dev, &tf); 2106 2106 if (ata_dma_enabled(dev) && ata_id_has_read_log_dma_ext(dev->id) && 2107 - !(dev->horkage & ATA_HORKAGE_NO_DMA_LOG)) { 2107 + !(dev->quirks & ATA_QUIRK_NO_DMA_LOG)) { 2108 2108 tf.command = ATA_CMD_READ_LOG_DMA_EXT; 2109 2109 tf.protocol = ATA_PROT_DMA; 2110 2110 dma = true; ··· 2124 2124 2125 2125 if (err_mask) { 2126 2126 if (dma) { 2127 - dev->horkage |= ATA_HORKAGE_NO_DMA_LOG; 2127 + dev->quirks |= ATA_QUIRK_NO_DMA_LOG; 2128 2128 if (!ata_port_is_frozen(dev->link->ap)) 2129 2129 goto retry; 2130 2130 } ··· 2140 2140 { 2141 2141 struct ata_port *ap = dev->link->ap; 2142 2142 2143 - if (dev->horkage & ATA_HORKAGE_NO_LOG_DIR) 2143 + if (dev->quirks & ATA_QUIRK_NO_LOG_DIR) 2144 2144 return 0; 2145 2145 2146 2146 if (ata_read_log_page(dev, ATA_LOG_DIRECTORY, 0, ap->sector_buf, 1)) ··· 2153 2153 struct ata_port *ap = dev->link->ap; 2154 2154 unsigned int err, i; 2155 2155 2156 - if (dev->horkage & ATA_HORKAGE_NO_ID_DEV_LOG) 2156 + if (dev->quirks & ATA_QUIRK_NO_ID_DEV_LOG) 2157 2157 return false; 2158 2158 2159 2159 if (!ata_log_supported(dev, ATA_LOG_IDENTIFY_DEVICE)) { ··· 2165 2165 if (ata_id_major_version(dev->id) >= 10) 2166 2166 ata_dev_warn(dev, 2167 2167 "ATA Identify Device Log not supported\n"); 2168 - dev->horkage |= ATA_HORKAGE_NO_ID_DEV_LOG; 2168 + dev->quirks |= ATA_QUIRK_NO_ID_DEV_LOG; 2169 2169 return false; 2170 2170 } 2171 2171 ··· 2186 2186 return false; 2187 2187 } 2188 2188 2189 - static int ata_do_link_spd_horkage(struct ata_device *dev) 2189 + static int ata_do_link_spd_quirk(struct ata_device *dev) 2190 2190 { 2191 2191 struct ata_link *plink = ata_dev_phys_link(dev); 2192 2192 u32 target, target_limit; ··· 2194 2194 if (!sata_scr_valid(plink)) 2195 2195 return 0; 2196 2196 2197 - if (dev->horkage & ATA_HORKAGE_1_5_GBPS) 2197 + if (dev->quirks & ATA_QUIRK_1_5_GBPS) 2198 2198 target = 1; 2199 2199 else 2200 2200 return 0; ··· 2212 2212 * guaranteed by setting sata_spd_limit to target_limit above. 2213 2213 */ 2214 2214 if (plink->sata_spd > target) { 2215 - ata_dev_info(dev, "applying link speed limit horkage to %s\n", 2215 + ata_dev_info(dev, "applying link speed limit quirk to %s\n", 2216 2216 sata_spd_string(target)); 2217 2217 return -EAGAIN; 2218 2218 } ··· 2223 2223 { 2224 2224 struct ata_port *ap = dev->link->ap; 2225 2225 2226 - if (ata_dev_blacklisted(dev) & ATA_HORKAGE_BRIDGE_OK) 2226 + if (ata_dev_quirks(dev) & ATA_QUIRK_BRIDGE_OK) 2227 2227 return false; 2228 2228 2229 2229 return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id))); ··· 2246 2246 dev->flags |= ATA_DFLAG_NCQ_SEND_RECV; 2247 2247 memcpy(cmds, ap->sector_buf, ATA_LOG_NCQ_SEND_RECV_SIZE); 2248 2248 2249 - if (dev->horkage & ATA_HORKAGE_NO_NCQ_TRIM) { 2249 + if (dev->quirks & ATA_QUIRK_NO_NCQ_TRIM) { 2250 2250 ata_dev_dbg(dev, "disabling queued TRIM support\n"); 2251 2251 cmds[ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET] &= 2252 2252 ~ATA_LOG_NCQ_SEND_RECV_DSM_TRIM; ··· 2334 2334 } 2335 2335 if (!IS_ENABLED(CONFIG_SATA_HOST)) 2336 2336 return 0; 2337 - if (dev->horkage & ATA_HORKAGE_NONCQ) { 2337 + if (dev->quirks & ATA_QUIRK_NONCQ) { 2338 2338 snprintf(desc, desc_sz, "NCQ (not used)"); 2339 2339 return 0; 2340 2340 } 2341 2341 2342 - if (dev->horkage & ATA_HORKAGE_NO_NCQ_ON_ATI && 2342 + if (dev->quirks & ATA_QUIRK_NO_NCQ_ON_ATI && 2343 2343 ata_dev_check_adapter(dev, PCI_VENDOR_ID_ATI)) { 2344 2344 snprintf(desc, desc_sz, "NCQ (not used)"); 2345 2345 return 0; ··· 2350 2350 dev->flags |= ATA_DFLAG_NCQ; 2351 2351 } 2352 2352 2353 - if (!(dev->horkage & ATA_HORKAGE_BROKEN_FPDMA_AA) && 2353 + if (!(dev->quirks & ATA_QUIRK_BROKEN_FPDMA_AA) && 2354 2354 (ap->flags & ATA_FLAG_FPDMA_AA) && 2355 2355 ata_id_has_fpdma_aa(dev->id)) { 2356 2356 err_mask = ata_dev_set_feature(dev, SETFEATURES_SATA_ENABLE, ··· 2360 2360 "failed to enable AA (error_mask=0x%x)\n", 2361 2361 err_mask); 2362 2362 if (err_mask != AC_ERR_DEV) { 2363 - dev->horkage |= ATA_HORKAGE_BROKEN_FPDMA_AA; 2363 + dev->quirks |= ATA_QUIRK_BROKEN_FPDMA_AA; 2364 2364 return -EIO; 2365 2365 } 2366 2366 } else ··· 2689 2689 goto nofua; 2690 2690 2691 2691 /* Ignore known bad devices and devices that lack NCQ support */ 2692 - if (!ata_ncq_supported(dev) || (dev->horkage & ATA_HORKAGE_NO_FUA)) 2692 + if (!ata_ncq_supported(dev) || (dev->quirks & ATA_QUIRK_NO_FUA)) 2693 2693 goto nofua; 2694 2694 2695 2695 dev->flags |= ATA_DFLAG_FUA; ··· 2829 2829 return 0; 2830 2830 } 2831 2831 2832 - /* set horkage */ 2833 - dev->horkage |= ata_dev_blacklisted(dev); 2834 - ata_force_horkage(dev); 2832 + /* Set quirks */ 2833 + dev->quirks |= ata_dev_quirks(dev); 2834 + ata_force_quirks(dev); 2835 2835 2836 - if (dev->horkage & ATA_HORKAGE_DISABLE) { 2836 + if (dev->quirks & ATA_QUIRK_DISABLE) { 2837 2837 ata_dev_info(dev, "unsupported device, disabling\n"); 2838 2838 ata_dev_disable(dev); 2839 2839 return 0; ··· 2848 2848 return 0; 2849 2849 } 2850 2850 2851 - rc = ata_do_link_spd_horkage(dev); 2851 + rc = ata_do_link_spd_quirk(dev); 2852 2852 if (rc) 2853 2853 return rc; 2854 2854 2855 2855 /* some WD SATA-1 drives have issues with LPM, turn on NOLPM for them */ 2856 - if ((dev->horkage & ATA_HORKAGE_WD_BROKEN_LPM) && 2856 + if ((dev->quirks & ATA_QUIRK_WD_BROKEN_LPM) && 2857 2857 (id[ATA_ID_SATA_CAPABILITY] & 0xe) == 0x2) 2858 - dev->horkage |= ATA_HORKAGE_NOLPM; 2858 + dev->quirks |= ATA_QUIRK_NOLPM; 2859 2859 2860 2860 if (ap->flags & ATA_FLAG_NO_LPM) 2861 - dev->horkage |= ATA_HORKAGE_NOLPM; 2861 + dev->quirks |= ATA_QUIRK_NOLPM; 2862 2862 2863 - if (dev->horkage & ATA_HORKAGE_NOLPM) { 2863 + if (dev->quirks & ATA_QUIRK_NOLPM) { 2864 2864 ata_dev_warn(dev, "LPM support broken, forcing max_power\n"); 2865 2865 dev->link->ap->target_lpm_policy = ATA_LPM_MAX_POWER; 2866 2866 } ··· 3006 3006 cdb_intr_string = ", CDB intr"; 3007 3007 } 3008 3008 3009 - if (atapi_dmadir || (dev->horkage & ATA_HORKAGE_ATAPI_DMADIR) || atapi_id_dmadir(dev->id)) { 3009 + if (atapi_dmadir || (dev->quirks & ATA_QUIRK_ATAPI_DMADIR) || 3010 + atapi_id_dmadir(dev->id)) { 3010 3011 dev->flags |= ATA_DFLAG_DMADIR; 3011 3012 dma_dir_string = ", DMADIR"; 3012 3013 } ··· 3044 3043 if ((dev->class == ATA_DEV_ATAPI) && 3045 3044 (atapi_command_packet_set(id) == TYPE_TAPE)) { 3046 3045 dev->max_sectors = ATA_MAX_SECTORS_TAPE; 3047 - dev->horkage |= ATA_HORKAGE_STUCK_ERR; 3046 + dev->quirks |= ATA_QUIRK_STUCK_ERR; 3048 3047 } 3049 3048 3050 - if (dev->horkage & ATA_HORKAGE_MAX_SEC_128) 3049 + if (dev->quirks & ATA_QUIRK_MAX_SEC_128) 3051 3050 dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128, 3052 3051 dev->max_sectors); 3053 3052 3054 - if (dev->horkage & ATA_HORKAGE_MAX_SEC_1024) 3053 + if (dev->quirks & ATA_QUIRK_MAX_SEC_1024) 3055 3054 dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_1024, 3056 3055 dev->max_sectors); 3057 3056 3058 - if (dev->horkage & ATA_HORKAGE_MAX_SEC_LBA48) 3057 + if (dev->quirks & ATA_QUIRK_MAX_SEC_LBA48) 3059 3058 dev->max_sectors = ATA_MAX_SECTORS_LBA48; 3060 3059 3061 3060 if (ap->ops->dev_config) 3062 3061 ap->ops->dev_config(dev); 3063 3062 3064 - if (dev->horkage & ATA_HORKAGE_DIAGNOSTIC) { 3063 + if (dev->quirks & ATA_QUIRK_DIAGNOSTIC) { 3065 3064 /* Let the user know. We don't want to disallow opens for 3066 3065 rescue purposes, or in case the vendor is just a blithering 3067 3066 idiot. Do this after the dev_config call as some controllers ··· 3076 3075 } 3077 3076 } 3078 3077 3079 - if ((dev->horkage & ATA_HORKAGE_FIRMWARE_WARN) && print_info) { 3078 + if ((dev->quirks & ATA_QUIRK_FIRMWARE_WARN) && print_info) { 3080 3079 ata_dev_warn(dev, "WARNING: device requires firmware update to be fully functional\n"); 3081 3080 ata_dev_warn(dev, " contact the vendor or visit http://ata.wiki.kernel.org\n"); 3082 3081 } ··· 3426 3425 { 3427 3426 struct ata_port *ap = dev->link->ap; 3428 3427 struct ata_eh_context *ehc = &dev->link->eh_context; 3429 - const bool nosetxfer = dev->horkage & ATA_HORKAGE_NOSETXFER; 3428 + const bool nosetxfer = dev->quirks & ATA_QUIRK_NOSETXFER; 3430 3429 const char *dev_err_whine = ""; 3431 3430 int ign_dev_err = 0; 3432 3431 unsigned int err_mask = 0; ··· 3970 3969 */ 3971 3970 if (dev->n_native_sectors == n_native_sectors && 3972 3971 dev->n_sectors < n_sectors && n_sectors == n_native_sectors && 3973 - !(dev->horkage & ATA_HORKAGE_BROKEN_HPA)) { 3972 + !(dev->quirks & ATA_QUIRK_BROKEN_HPA)) { 3974 3973 ata_dev_warn(dev, 3975 3974 "old n_sectors matches native, probably " 3976 3975 "late HPA lock, will try to unlock HPA\n"); ··· 3988 3987 return rc; 3989 3988 } 3990 3989 3991 - struct ata_blacklist_entry { 3990 + struct ata_dev_quirks_entry { 3992 3991 const char *model_num; 3993 3992 const char *model_rev; 3994 - unsigned long horkage; 3993 + unsigned int quirks; 3995 3994 }; 3996 3995 3997 - static const struct ata_blacklist_entry ata_device_blacklist [] = { 3996 + static const struct ata_dev_quirks_entry __ata_dev_quirks[] = { 3998 3997 /* Devices with DMA related problems under Linux */ 3999 - { "WDC AC11000H", NULL, ATA_HORKAGE_NODMA }, 4000 - { "WDC AC22100H", NULL, ATA_HORKAGE_NODMA }, 4001 - { "WDC AC32500H", NULL, ATA_HORKAGE_NODMA }, 4002 - { "WDC AC33100H", NULL, ATA_HORKAGE_NODMA }, 4003 - { "WDC AC31600H", NULL, ATA_HORKAGE_NODMA }, 4004 - { "WDC AC32100H", "24.09P07", ATA_HORKAGE_NODMA }, 4005 - { "WDC AC23200L", "21.10N21", ATA_HORKAGE_NODMA }, 4006 - { "Compaq CRD-8241B", NULL, ATA_HORKAGE_NODMA }, 4007 - { "CRD-8400B", NULL, ATA_HORKAGE_NODMA }, 4008 - { "CRD-848[02]B", NULL, ATA_HORKAGE_NODMA }, 4009 - { "CRD-84", NULL, ATA_HORKAGE_NODMA }, 4010 - { "SanDisk SDP3B", NULL, ATA_HORKAGE_NODMA }, 4011 - { "SanDisk SDP3B-64", NULL, ATA_HORKAGE_NODMA }, 4012 - { "SANYO CD-ROM CRD", NULL, ATA_HORKAGE_NODMA }, 4013 - { "HITACHI CDR-8", NULL, ATA_HORKAGE_NODMA }, 4014 - { "HITACHI CDR-8[34]35",NULL, ATA_HORKAGE_NODMA }, 4015 - { "Toshiba CD-ROM XM-6202B", NULL, ATA_HORKAGE_NODMA }, 4016 - { "TOSHIBA CD-ROM XM-1702BC", NULL, ATA_HORKAGE_NODMA }, 4017 - { "CD-532E-A", NULL, ATA_HORKAGE_NODMA }, 4018 - { "E-IDE CD-ROM CR-840",NULL, ATA_HORKAGE_NODMA }, 4019 - { "CD-ROM Drive/F5A", NULL, ATA_HORKAGE_NODMA }, 4020 - { "WPI CDD-820", NULL, ATA_HORKAGE_NODMA }, 4021 - { "SAMSUNG CD-ROM SC-148C", NULL, ATA_HORKAGE_NODMA }, 4022 - { "SAMSUNG CD-ROM SC", NULL, ATA_HORKAGE_NODMA }, 4023 - { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA }, 4024 - { "_NEC DV5800A", NULL, ATA_HORKAGE_NODMA }, 4025 - { "SAMSUNG CD-ROM SN-124", "N001", ATA_HORKAGE_NODMA }, 4026 - { "Seagate STT20000A", NULL, ATA_HORKAGE_NODMA }, 4027 - { " 2GB ATA Flash Disk", "ADMA428M", ATA_HORKAGE_NODMA }, 4028 - { "VRFDFC22048UCHC-TE*", NULL, ATA_HORKAGE_NODMA }, 3998 + { "WDC AC11000H", NULL, ATA_QUIRK_NODMA }, 3999 + { "WDC AC22100H", NULL, ATA_QUIRK_NODMA }, 4000 + { "WDC AC32500H", NULL, ATA_QUIRK_NODMA }, 4001 + { "WDC AC33100H", NULL, ATA_QUIRK_NODMA }, 4002 + { "WDC AC31600H", NULL, ATA_QUIRK_NODMA }, 4003 + { "WDC AC32100H", "24.09P07", ATA_QUIRK_NODMA }, 4004 + { "WDC AC23200L", "21.10N21", ATA_QUIRK_NODMA }, 4005 + { "Compaq CRD-8241B", NULL, ATA_QUIRK_NODMA }, 4006 + { "CRD-8400B", NULL, ATA_QUIRK_NODMA }, 4007 + { "CRD-848[02]B", NULL, ATA_QUIRK_NODMA }, 4008 + { "CRD-84", NULL, ATA_QUIRK_NODMA }, 4009 + { "SanDisk SDP3B", NULL, ATA_QUIRK_NODMA }, 4010 + { "SanDisk SDP3B-64", NULL, ATA_QUIRK_NODMA }, 4011 + { "SANYO CD-ROM CRD", NULL, ATA_QUIRK_NODMA }, 4012 + { "HITACHI CDR-8", NULL, ATA_QUIRK_NODMA }, 4013 + { "HITACHI CDR-8[34]35", NULL, ATA_QUIRK_NODMA }, 4014 + { "Toshiba CD-ROM XM-6202B", NULL, ATA_QUIRK_NODMA }, 4015 + { "TOSHIBA CD-ROM XM-1702BC", NULL, ATA_QUIRK_NODMA }, 4016 + { "CD-532E-A", NULL, ATA_QUIRK_NODMA }, 4017 + { "E-IDE CD-ROM CR-840", NULL, ATA_QUIRK_NODMA }, 4018 + { "CD-ROM Drive/F5A", NULL, ATA_QUIRK_NODMA }, 4019 + { "WPI CDD-820", NULL, ATA_QUIRK_NODMA }, 4020 + { "SAMSUNG CD-ROM SC-148C", NULL, ATA_QUIRK_NODMA }, 4021 + { "SAMSUNG CD-ROM SC", NULL, ATA_QUIRK_NODMA }, 4022 + { "ATAPI CD-ROM DRIVE 40X MAXIMUM", NULL, ATA_QUIRK_NODMA }, 4023 + { "_NEC DV5800A", NULL, ATA_QUIRK_NODMA }, 4024 + { "SAMSUNG CD-ROM SN-124", "N001", ATA_QUIRK_NODMA }, 4025 + { "Seagate STT20000A", NULL, ATA_QUIRK_NODMA }, 4026 + { " 2GB ATA Flash Disk", "ADMA428M", ATA_QUIRK_NODMA }, 4027 + { "VRFDFC22048UCHC-TE*", NULL, ATA_QUIRK_NODMA }, 4029 4028 /* Odd clown on sil3726/4726 PMPs */ 4030 - { "Config Disk", NULL, ATA_HORKAGE_DISABLE }, 4029 + { "Config Disk", NULL, ATA_QUIRK_DISABLE }, 4031 4030 /* Similar story with ASMedia 1092 */ 4032 - { "ASMT109x- Config", NULL, ATA_HORKAGE_DISABLE }, 4031 + { "ASMT109x- Config", NULL, ATA_QUIRK_DISABLE }, 4033 4032 4034 4033 /* Weird ATAPI devices */ 4035 - { "TORiSAN DVD-ROM DRD-N216", NULL, ATA_HORKAGE_MAX_SEC_128 }, 4036 - { "QUANTUM DAT DAT72-000", NULL, ATA_HORKAGE_ATAPI_MOD16_DMA }, 4037 - { "Slimtype DVD A DS8A8SH", NULL, ATA_HORKAGE_MAX_SEC_LBA48 }, 4038 - { "Slimtype DVD A DS8A9SH", NULL, ATA_HORKAGE_MAX_SEC_LBA48 }, 4034 + { "TORiSAN DVD-ROM DRD-N216", NULL, ATA_QUIRK_MAX_SEC_128 }, 4035 + { "QUANTUM DAT DAT72-000", NULL, ATA_QUIRK_ATAPI_MOD16_DMA }, 4036 + { "Slimtype DVD A DS8A8SH", NULL, ATA_QUIRK_MAX_SEC_LBA48 }, 4037 + { "Slimtype DVD A DS8A9SH", NULL, ATA_QUIRK_MAX_SEC_LBA48 }, 4039 4038 4040 4039 /* 4041 4040 * Causes silent data corruption with higher max sects. 4042 4041 * http://lkml.kernel.org/g/x49wpy40ysk.fsf@segfault.boston.devel.redhat.com 4043 4042 */ 4044 - { "ST380013AS", "3.20", ATA_HORKAGE_MAX_SEC_1024 }, 4043 + { "ST380013AS", "3.20", ATA_QUIRK_MAX_SEC_1024 }, 4045 4044 4046 4045 /* 4047 4046 * These devices time out with higher max sects. 4048 4047 * https://bugzilla.kernel.org/show_bug.cgi?id=121671 4049 4048 */ 4050 - { "LITEON CX1-JB*-HP", NULL, ATA_HORKAGE_MAX_SEC_1024 }, 4051 - { "LITEON EP1-*", NULL, ATA_HORKAGE_MAX_SEC_1024 }, 4049 + { "LITEON CX1-JB*-HP", NULL, ATA_QUIRK_MAX_SEC_1024 }, 4050 + { "LITEON EP1-*", NULL, ATA_QUIRK_MAX_SEC_1024 }, 4052 4051 4053 4052 /* Devices we expect to fail diagnostics */ 4054 4053 4055 4054 /* Devices where NCQ should be avoided */ 4056 4055 /* NCQ is slow */ 4057 - { "WDC WD740ADFD-00", NULL, ATA_HORKAGE_NONCQ }, 4058 - { "WDC WD740ADFD-00NLR1", NULL, ATA_HORKAGE_NONCQ }, 4056 + { "WDC WD740ADFD-00", NULL, ATA_QUIRK_NONCQ }, 4057 + { "WDC WD740ADFD-00NLR1", NULL, ATA_QUIRK_NONCQ }, 4059 4058 /* http://thread.gmane.org/gmane.linux.ide/14907 */ 4060 - { "FUJITSU MHT2060BH", NULL, ATA_HORKAGE_NONCQ }, 4059 + { "FUJITSU MHT2060BH", NULL, ATA_QUIRK_NONCQ }, 4061 4060 /* NCQ is broken */ 4062 - { "Maxtor *", "BANC*", ATA_HORKAGE_NONCQ }, 4063 - { "Maxtor 7V300F0", "VA111630", ATA_HORKAGE_NONCQ }, 4064 - { "ST380817AS", "3.42", ATA_HORKAGE_NONCQ }, 4065 - { "ST3160023AS", "3.42", ATA_HORKAGE_NONCQ }, 4066 - { "OCZ CORE_SSD", "02.10104", ATA_HORKAGE_NONCQ }, 4061 + { "Maxtor *", "BANC*", ATA_QUIRK_NONCQ }, 4062 + { "Maxtor 7V300F0", "VA111630", ATA_QUIRK_NONCQ }, 4063 + { "ST380817AS", "3.42", ATA_QUIRK_NONCQ }, 4064 + { "ST3160023AS", "3.42", ATA_QUIRK_NONCQ }, 4065 + { "OCZ CORE_SSD", "02.10104", ATA_QUIRK_NONCQ }, 4067 4066 4068 4067 /* Seagate NCQ + FLUSH CACHE firmware bug */ 4069 - { "ST31500341AS", "SD1[5-9]", ATA_HORKAGE_NONCQ | 4070 - ATA_HORKAGE_FIRMWARE_WARN }, 4068 + { "ST31500341AS", "SD1[5-9]", ATA_QUIRK_NONCQ | 4069 + ATA_QUIRK_FIRMWARE_WARN }, 4071 4070 4072 - { "ST31000333AS", "SD1[5-9]", ATA_HORKAGE_NONCQ | 4073 - ATA_HORKAGE_FIRMWARE_WARN }, 4071 + { "ST31000333AS", "SD1[5-9]", ATA_QUIRK_NONCQ | 4072 + ATA_QUIRK_FIRMWARE_WARN }, 4074 4073 4075 - { "ST3640[36]23AS", "SD1[5-9]", ATA_HORKAGE_NONCQ | 4076 - ATA_HORKAGE_FIRMWARE_WARN }, 4074 + { "ST3640[36]23AS", "SD1[5-9]", ATA_QUIRK_NONCQ | 4075 + ATA_QUIRK_FIRMWARE_WARN }, 4077 4076 4078 - { "ST3320[68]13AS", "SD1[5-9]", ATA_HORKAGE_NONCQ | 4079 - ATA_HORKAGE_FIRMWARE_WARN }, 4077 + { "ST3320[68]13AS", "SD1[5-9]", ATA_QUIRK_NONCQ | 4078 + ATA_QUIRK_FIRMWARE_WARN }, 4080 4079 4081 4080 /* drives which fail FPDMA_AA activation (some may freeze afterwards) 4082 4081 the ST disks also have LPM issues */ 4083 - { "ST1000LM024 HN-M101MBB", NULL, ATA_HORKAGE_BROKEN_FPDMA_AA | 4084 - ATA_HORKAGE_NOLPM }, 4085 - { "VB0250EAVER", "HPG7", ATA_HORKAGE_BROKEN_FPDMA_AA }, 4082 + { "ST1000LM024 HN-M101MBB", NULL, ATA_QUIRK_BROKEN_FPDMA_AA | 4083 + ATA_QUIRK_NOLPM }, 4084 + { "VB0250EAVER", "HPG7", ATA_QUIRK_BROKEN_FPDMA_AA }, 4086 4085 4087 4086 /* Blacklist entries taken from Silicon Image 3124/3132 4088 4087 Windows driver .inf file - also several Linux problem reports */ 4089 - { "HTS541060G9SA00", "MB3OC60D", ATA_HORKAGE_NONCQ }, 4090 - { "HTS541080G9SA00", "MB4OC60D", ATA_HORKAGE_NONCQ }, 4091 - { "HTS541010G9SA00", "MBZOC60D", ATA_HORKAGE_NONCQ }, 4088 + { "HTS541060G9SA00", "MB3OC60D", ATA_QUIRK_NONCQ }, 4089 + { "HTS541080G9SA00", "MB4OC60D", ATA_QUIRK_NONCQ }, 4090 + { "HTS541010G9SA00", "MBZOC60D", ATA_QUIRK_NONCQ }, 4092 4091 4093 4092 /* https://bugzilla.kernel.org/show_bug.cgi?id=15573 */ 4094 - { "C300-CTFDDAC128MAG", "0001", ATA_HORKAGE_NONCQ }, 4093 + { "C300-CTFDDAC128MAG", "0001", ATA_QUIRK_NONCQ }, 4095 4094 4096 4095 /* Sandisk SD7/8/9s lock up hard on large trims */ 4097 - { "SanDisk SD[789]*", NULL, ATA_HORKAGE_MAX_TRIM_128M }, 4096 + { "SanDisk SD[789]*", NULL, ATA_QUIRK_MAX_TRIM_128M }, 4098 4097 4099 4098 /* devices which puke on READ_NATIVE_MAX */ 4100 - { "HDS724040KLSA80", "KFAOA20N", ATA_HORKAGE_BROKEN_HPA }, 4101 - { "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_HORKAGE_BROKEN_HPA }, 4102 - { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA }, 4103 - { "MAXTOR 6L080L4", "A93.0500", ATA_HORKAGE_BROKEN_HPA }, 4099 + { "HDS724040KLSA80", "KFAOA20N", ATA_QUIRK_BROKEN_HPA }, 4100 + { "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_QUIRK_BROKEN_HPA }, 4101 + { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_QUIRK_BROKEN_HPA }, 4102 + { "MAXTOR 6L080L4", "A93.0500", ATA_QUIRK_BROKEN_HPA }, 4104 4103 4105 4104 /* this one allows HPA unlocking but fails IOs on the area */ 4106 - { "OCZ-VERTEX", "1.30", ATA_HORKAGE_BROKEN_HPA }, 4105 + { "OCZ-VERTEX", "1.30", ATA_QUIRK_BROKEN_HPA }, 4107 4106 4108 4107 /* Devices which report 1 sector over size HPA */ 4109 - { "ST340823A", NULL, ATA_HORKAGE_HPA_SIZE }, 4110 - { "ST320413A", NULL, ATA_HORKAGE_HPA_SIZE }, 4111 - { "ST310211A", NULL, ATA_HORKAGE_HPA_SIZE }, 4108 + { "ST340823A", NULL, ATA_QUIRK_HPA_SIZE }, 4109 + { "ST320413A", NULL, ATA_QUIRK_HPA_SIZE }, 4110 + { "ST310211A", NULL, ATA_QUIRK_HPA_SIZE }, 4112 4111 4113 4112 /* Devices which get the IVB wrong */ 4114 - { "QUANTUM FIREBALLlct10 05", "A03.0900", ATA_HORKAGE_IVB }, 4115 - /* Maybe we should just blacklist TSSTcorp... */ 4116 - { "TSSTcorp CDDVDW SH-S202[HJN]", "SB0[01]", ATA_HORKAGE_IVB }, 4113 + { "QUANTUM FIREBALLlct10 05", "A03.0900", ATA_QUIRK_IVB }, 4114 + /* Maybe we should just add all TSSTcorp devices... */ 4115 + { "TSSTcorp CDDVDW SH-S202[HJN]", "SB0[01]", ATA_QUIRK_IVB }, 4117 4116 4118 4117 /* Devices that do not need bridging limits applied */ 4119 - { "MTRON MSP-SATA*", NULL, ATA_HORKAGE_BRIDGE_OK }, 4120 - { "BUFFALO HD-QSU2/R5", NULL, ATA_HORKAGE_BRIDGE_OK }, 4118 + { "MTRON MSP-SATA*", NULL, ATA_QUIRK_BRIDGE_OK }, 4119 + { "BUFFALO HD-QSU2/R5", NULL, ATA_QUIRK_BRIDGE_OK }, 4121 4120 4122 4121 /* Devices which aren't very happy with higher link speeds */ 4123 - { "WD My Book", NULL, ATA_HORKAGE_1_5_GBPS }, 4124 - { "Seagate FreeAgent GoFlex", NULL, ATA_HORKAGE_1_5_GBPS }, 4122 + { "WD My Book", NULL, ATA_QUIRK_1_5_GBPS }, 4123 + { "Seagate FreeAgent GoFlex", NULL, ATA_QUIRK_1_5_GBPS }, 4125 4124 4126 4125 /* 4127 4126 * Devices which choke on SETXFER. Applies only if both the 4128 4127 * device and controller are SATA. 4129 4128 */ 4130 - { "PIONEER DVD-RW DVRTD08", NULL, ATA_HORKAGE_NOSETXFER }, 4131 - { "PIONEER DVD-RW DVRTD08A", NULL, ATA_HORKAGE_NOSETXFER }, 4132 - { "PIONEER DVD-RW DVR-215", NULL, ATA_HORKAGE_NOSETXFER }, 4133 - { "PIONEER DVD-RW DVR-212D", NULL, ATA_HORKAGE_NOSETXFER }, 4134 - { "PIONEER DVD-RW DVR-216D", NULL, ATA_HORKAGE_NOSETXFER }, 4129 + { "PIONEER DVD-RW DVRTD08", NULL, ATA_QUIRK_NOSETXFER }, 4130 + { "PIONEER DVD-RW DVRTD08A", NULL, ATA_QUIRK_NOSETXFER }, 4131 + { "PIONEER DVD-RW DVR-215", NULL, ATA_QUIRK_NOSETXFER }, 4132 + { "PIONEER DVD-RW DVR-212D", NULL, ATA_QUIRK_NOSETXFER }, 4133 + { "PIONEER DVD-RW DVR-216D", NULL, ATA_QUIRK_NOSETXFER }, 4135 4134 4136 4135 /* These specific Pioneer models have LPM issues */ 4137 - { "PIONEER BD-RW BDR-207M", NULL, ATA_HORKAGE_NOLPM }, 4138 - { "PIONEER BD-RW BDR-205", NULL, ATA_HORKAGE_NOLPM }, 4136 + { "PIONEER BD-RW BDR-207M", NULL, ATA_QUIRK_NOLPM }, 4137 + { "PIONEER BD-RW BDR-205", NULL, ATA_QUIRK_NOLPM }, 4139 4138 4140 4139 /* Crucial devices with broken LPM support */ 4141 - { "CT*0BX*00SSD1", NULL, ATA_HORKAGE_NOLPM }, 4140 + { "CT*0BX*00SSD1", NULL, ATA_QUIRK_NOLPM }, 4142 4141 4143 4142 /* 512GB MX100 with MU01 firmware has both queued TRIM and LPM issues */ 4144 - { "Crucial_CT512MX100*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM | 4145 - ATA_HORKAGE_ZERO_AFTER_TRIM | 4146 - ATA_HORKAGE_NOLPM }, 4143 + { "Crucial_CT512MX100*", "MU01", ATA_QUIRK_NO_NCQ_TRIM | 4144 + ATA_QUIRK_ZERO_AFTER_TRIM | 4145 + ATA_QUIRK_NOLPM }, 4147 4146 /* 512GB MX100 with newer firmware has only LPM issues */ 4148 - { "Crucial_CT512MX100*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM | 4149 - ATA_HORKAGE_NOLPM }, 4147 + { "Crucial_CT512MX100*", NULL, ATA_QUIRK_ZERO_AFTER_TRIM | 4148 + ATA_QUIRK_NOLPM }, 4150 4149 4151 4150 /* 480GB+ M500 SSDs have both queued TRIM and LPM issues */ 4152 - { "Crucial_CT480M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM | 4153 - ATA_HORKAGE_ZERO_AFTER_TRIM | 4154 - ATA_HORKAGE_NOLPM }, 4155 - { "Crucial_CT960M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM | 4156 - ATA_HORKAGE_ZERO_AFTER_TRIM | 4157 - ATA_HORKAGE_NOLPM }, 4151 + { "Crucial_CT480M500*", NULL, ATA_QUIRK_NO_NCQ_TRIM | 4152 + ATA_QUIRK_ZERO_AFTER_TRIM | 4153 + ATA_QUIRK_NOLPM }, 4154 + { "Crucial_CT960M500*", NULL, ATA_QUIRK_NO_NCQ_TRIM | 4155 + ATA_QUIRK_ZERO_AFTER_TRIM | 4156 + ATA_QUIRK_NOLPM }, 4158 4157 4159 4158 /* AMD Radeon devices with broken LPM support */ 4160 - { "R3SL240G", NULL, ATA_HORKAGE_NOLPM }, 4159 + { "R3SL240G", NULL, ATA_QUIRK_NOLPM }, 4161 4160 4162 4161 /* Apacer models with LPM issues */ 4163 - { "Apacer AS340*", NULL, ATA_HORKAGE_NOLPM }, 4162 + { "Apacer AS340*", NULL, ATA_QUIRK_NOLPM }, 4164 4163 4165 4164 /* These specific Samsung models/firmware-revs do not handle LPM well */ 4166 - { "SAMSUNG MZMPC128HBFU-000MV", "CXM14M1Q", ATA_HORKAGE_NOLPM }, 4167 - { "SAMSUNG SSD PM830 mSATA *", "CXM13D1Q", ATA_HORKAGE_NOLPM }, 4168 - { "SAMSUNG MZ7TD256HAFV-000L9", NULL, ATA_HORKAGE_NOLPM }, 4169 - { "SAMSUNG MZ7TE512HMHP-000L1", "EXT06L0Q", ATA_HORKAGE_NOLPM }, 4165 + { "SAMSUNG MZMPC128HBFU-000MV", "CXM14M1Q", ATA_QUIRK_NOLPM }, 4166 + { "SAMSUNG SSD PM830 mSATA *", "CXM13D1Q", ATA_QUIRK_NOLPM }, 4167 + { "SAMSUNG MZ7TD256HAFV-000L9", NULL, ATA_QUIRK_NOLPM }, 4168 + { "SAMSUNG MZ7TE512HMHP-000L1", "EXT06L0Q", ATA_QUIRK_NOLPM }, 4170 4169 4171 4170 /* devices that don't properly handle queued TRIM commands */ 4172 - { "Micron_M500IT_*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM | 4173 - ATA_HORKAGE_ZERO_AFTER_TRIM }, 4174 - { "Micron_M500_*", NULL, ATA_HORKAGE_NO_NCQ_TRIM | 4175 - ATA_HORKAGE_ZERO_AFTER_TRIM }, 4176 - { "Micron_M5[15]0_*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM | 4177 - ATA_HORKAGE_ZERO_AFTER_TRIM }, 4178 - { "Micron_1100_*", NULL, ATA_HORKAGE_NO_NCQ_TRIM | 4179 - ATA_HORKAGE_ZERO_AFTER_TRIM, }, 4180 - { "Crucial_CT*M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM | 4181 - ATA_HORKAGE_ZERO_AFTER_TRIM }, 4182 - { "Crucial_CT*M550*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM | 4183 - ATA_HORKAGE_ZERO_AFTER_TRIM }, 4184 - { "Crucial_CT*MX100*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM | 4185 - ATA_HORKAGE_ZERO_AFTER_TRIM }, 4186 - { "Samsung SSD 840 EVO*", NULL, ATA_HORKAGE_NO_NCQ_TRIM | 4187 - ATA_HORKAGE_NO_DMA_LOG | 4188 - ATA_HORKAGE_ZERO_AFTER_TRIM }, 4189 - { "Samsung SSD 840*", NULL, ATA_HORKAGE_NO_NCQ_TRIM | 4190 - ATA_HORKAGE_ZERO_AFTER_TRIM }, 4191 - { "Samsung SSD 850*", NULL, ATA_HORKAGE_NO_NCQ_TRIM | 4192 - ATA_HORKAGE_ZERO_AFTER_TRIM }, 4193 - { "Samsung SSD 860*", NULL, ATA_HORKAGE_NO_NCQ_TRIM | 4194 - ATA_HORKAGE_ZERO_AFTER_TRIM | 4195 - ATA_HORKAGE_NO_NCQ_ON_ATI }, 4196 - { "Samsung SSD 870*", NULL, ATA_HORKAGE_NO_NCQ_TRIM | 4197 - ATA_HORKAGE_ZERO_AFTER_TRIM | 4198 - ATA_HORKAGE_NO_NCQ_ON_ATI }, 4199 - { "SAMSUNG*MZ7LH*", NULL, ATA_HORKAGE_NO_NCQ_TRIM | 4200 - ATA_HORKAGE_ZERO_AFTER_TRIM | 4201 - ATA_HORKAGE_NO_NCQ_ON_ATI, }, 4202 - { "FCCT*M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM | 4203 - ATA_HORKAGE_ZERO_AFTER_TRIM }, 4171 + { "Micron_M500IT_*", "MU01", ATA_QUIRK_NO_NCQ_TRIM | 4172 + ATA_QUIRK_ZERO_AFTER_TRIM }, 4173 + { "Micron_M500_*", NULL, ATA_QUIRK_NO_NCQ_TRIM | 4174 + ATA_QUIRK_ZERO_AFTER_TRIM }, 4175 + { "Micron_M5[15]0_*", "MU01", ATA_QUIRK_NO_NCQ_TRIM | 4176 + ATA_QUIRK_ZERO_AFTER_TRIM }, 4177 + { "Micron_1100_*", NULL, ATA_QUIRK_NO_NCQ_TRIM | 4178 + ATA_QUIRK_ZERO_AFTER_TRIM, }, 4179 + { "Crucial_CT*M500*", NULL, ATA_QUIRK_NO_NCQ_TRIM | 4180 + ATA_QUIRK_ZERO_AFTER_TRIM }, 4181 + { "Crucial_CT*M550*", "MU01", ATA_QUIRK_NO_NCQ_TRIM | 4182 + ATA_QUIRK_ZERO_AFTER_TRIM }, 4183 + { "Crucial_CT*MX100*", "MU01", ATA_QUIRK_NO_NCQ_TRIM | 4184 + ATA_QUIRK_ZERO_AFTER_TRIM }, 4185 + { "Samsung SSD 840 EVO*", NULL, ATA_QUIRK_NO_NCQ_TRIM | 4186 + ATA_QUIRK_NO_DMA_LOG | 4187 + ATA_QUIRK_ZERO_AFTER_TRIM }, 4188 + { "Samsung SSD 840*", NULL, ATA_QUIRK_NO_NCQ_TRIM | 4189 + ATA_QUIRK_ZERO_AFTER_TRIM }, 4190 + { "Samsung SSD 850*", NULL, ATA_QUIRK_NO_NCQ_TRIM | 4191 + ATA_QUIRK_ZERO_AFTER_TRIM }, 4192 + { "Samsung SSD 860*", NULL, ATA_QUIRK_NO_NCQ_TRIM | 4193 + ATA_QUIRK_ZERO_AFTER_TRIM | 4194 + ATA_QUIRK_NO_NCQ_ON_ATI }, 4195 + { "Samsung SSD 870*", NULL, ATA_QUIRK_NO_NCQ_TRIM | 4196 + ATA_QUIRK_ZERO_AFTER_TRIM | 4197 + ATA_QUIRK_NO_NCQ_ON_ATI }, 4198 + { "SAMSUNG*MZ7LH*", NULL, ATA_QUIRK_NO_NCQ_TRIM | 4199 + ATA_QUIRK_ZERO_AFTER_TRIM | 4200 + ATA_QUIRK_NO_NCQ_ON_ATI, }, 4201 + { "FCCT*M500*", NULL, ATA_QUIRK_NO_NCQ_TRIM | 4202 + ATA_QUIRK_ZERO_AFTER_TRIM }, 4204 4203 4205 4204 /* devices that don't properly handle TRIM commands */ 4206 - { "SuperSSpeed S238*", NULL, ATA_HORKAGE_NOTRIM }, 4207 - { "M88V29*", NULL, ATA_HORKAGE_NOTRIM }, 4205 + { "SuperSSpeed S238*", NULL, ATA_QUIRK_NOTRIM }, 4206 + { "M88V29*", NULL, ATA_QUIRK_NOTRIM }, 4208 4207 4209 4208 /* 4210 4209 * As defined, the DRAT (Deterministic Read After Trim) and RZAT ··· 4224 4223 */ 4225 4224 { "INTEL*SSDSC2MH*", NULL, 0 }, 4226 4225 4227 - { "Micron*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM }, 4228 - { "Crucial*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM }, 4229 - { "INTEL*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM }, 4230 - { "SSD*INTEL*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM }, 4231 - { "Samsung*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM }, 4232 - { "SAMSUNG*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM }, 4233 - { "SAMSUNG*MZ7KM*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM }, 4234 - { "ST[1248][0248]0[FH]*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM }, 4226 + { "Micron*", NULL, ATA_QUIRK_ZERO_AFTER_TRIM }, 4227 + { "Crucial*", NULL, ATA_QUIRK_ZERO_AFTER_TRIM }, 4228 + { "INTEL*SSD*", NULL, ATA_QUIRK_ZERO_AFTER_TRIM }, 4229 + { "SSD*INTEL*", NULL, ATA_QUIRK_ZERO_AFTER_TRIM }, 4230 + { "Samsung*SSD*", NULL, ATA_QUIRK_ZERO_AFTER_TRIM }, 4231 + { "SAMSUNG*SSD*", NULL, ATA_QUIRK_ZERO_AFTER_TRIM }, 4232 + { "SAMSUNG*MZ7KM*", NULL, ATA_QUIRK_ZERO_AFTER_TRIM }, 4233 + { "ST[1248][0248]0[FH]*", NULL, ATA_QUIRK_ZERO_AFTER_TRIM }, 4235 4234 4236 4235 /* 4237 4236 * Some WD SATA-I drives spin up and down erratically when the link ··· 4242 4241 * 4243 4242 * https://bugzilla.kernel.org/show_bug.cgi?id=57211 4244 4243 */ 4245 - { "WDC WD800JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM }, 4246 - { "WDC WD1200JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM }, 4247 - { "WDC WD1600JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM }, 4248 - { "WDC WD2000JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM }, 4249 - { "WDC WD2500JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM }, 4250 - { "WDC WD3000JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM }, 4251 - { "WDC WD3200JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM }, 4244 + { "WDC WD800JD-*", NULL, ATA_QUIRK_WD_BROKEN_LPM }, 4245 + { "WDC WD1200JD-*", NULL, ATA_QUIRK_WD_BROKEN_LPM }, 4246 + { "WDC WD1600JD-*", NULL, ATA_QUIRK_WD_BROKEN_LPM }, 4247 + { "WDC WD2000JD-*", NULL, ATA_QUIRK_WD_BROKEN_LPM }, 4248 + { "WDC WD2500JD-*", NULL, ATA_QUIRK_WD_BROKEN_LPM }, 4249 + { "WDC WD3000JD-*", NULL, ATA_QUIRK_WD_BROKEN_LPM }, 4250 + { "WDC WD3200JD-*", NULL, ATA_QUIRK_WD_BROKEN_LPM }, 4252 4251 4253 4252 /* 4254 4253 * This sata dom device goes on a walkabout when the ATA_LOG_DIRECTORY 4255 4254 * log page is accessed. Ensure we never ask for this log page with 4256 4255 * these devices. 4257 4256 */ 4258 - { "SATADOM-ML 3ME", NULL, ATA_HORKAGE_NO_LOG_DIR }, 4257 + { "SATADOM-ML 3ME", NULL, ATA_QUIRK_NO_LOG_DIR }, 4259 4258 4260 4259 /* Buggy FUA */ 4261 - { "Maxtor", "BANC1G10", ATA_HORKAGE_NO_FUA }, 4262 - { "WDC*WD2500J*", NULL, ATA_HORKAGE_NO_FUA }, 4263 - { "OCZ-VERTEX*", NULL, ATA_HORKAGE_NO_FUA }, 4264 - { "INTEL*SSDSC2CT*", NULL, ATA_HORKAGE_NO_FUA }, 4260 + { "Maxtor", "BANC1G10", ATA_QUIRK_NO_FUA }, 4261 + { "WDC*WD2500J*", NULL, ATA_QUIRK_NO_FUA }, 4262 + { "OCZ-VERTEX*", NULL, ATA_QUIRK_NO_FUA }, 4263 + { "INTEL*SSDSC2CT*", NULL, ATA_QUIRK_NO_FUA }, 4265 4264 4266 4265 /* End Marker */ 4267 4266 { } 4268 4267 }; 4269 4268 4270 - static unsigned long ata_dev_blacklisted(const struct ata_device *dev) 4269 + static unsigned int ata_dev_quirks(const struct ata_device *dev) 4271 4270 { 4272 4271 unsigned char model_num[ATA_ID_PROD_LEN + 1]; 4273 4272 unsigned char model_rev[ATA_ID_FW_REV_LEN + 1]; 4274 - const struct ata_blacklist_entry *ad = ata_device_blacklist; 4273 + const struct ata_dev_quirks_entry *ad = __ata_dev_quirks; 4275 4274 4276 4275 ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num)); 4277 4276 ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev)); ··· 4279 4278 while (ad->model_num) { 4280 4279 if (glob_match(ad->model_num, model_num)) { 4281 4280 if (ad->model_rev == NULL) 4282 - return ad->horkage; 4281 + return ad->quirks; 4283 4282 if (glob_match(ad->model_rev, model_rev)) 4284 - return ad->horkage; 4283 + return ad->quirks; 4285 4284 } 4286 4285 ad++; 4287 4286 } ··· 4298 4297 if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) && 4299 4298 (dev->flags & ATA_DFLAG_CDB_INTR)) 4300 4299 return true; 4301 - return dev->horkage & ATA_HORKAGE_NODMA; 4300 + return dev->quirks & ATA_QUIRK_NODMA; 4302 4301 } 4303 4302 4304 4303 /** ··· 4311 4310 4312 4311 static int ata_is_40wire(struct ata_device *dev) 4313 4312 { 4314 - if (dev->horkage & ATA_HORKAGE_IVB) 4313 + if (dev->quirks & ATA_QUIRK_IVB) 4315 4314 return ata_drive_40wire_relaxed(dev->id); 4316 4315 return ata_drive_40wire(dev->id); 4317 4316 } ··· 4373 4372 * 4374 4373 * Compute supported xfermask of @dev and store it in 4375 4374 * dev->*_mask. This function is responsible for applying all 4376 - * known limits including host controller limits, device 4377 - * blacklist, etc... 4375 + * known limits including host controller limits, device quirks, etc... 4378 4376 * 4379 4377 * LOCKING: 4380 4378 * None. ··· 4589 4589 /* Don't allow DMA if it isn't multiple of 16 bytes. Quite a 4590 4590 * few ATAPI devices choke on such DMA requests. 4591 4591 */ 4592 - if (!(qc->dev->horkage & ATA_HORKAGE_ATAPI_MOD16_DMA) && 4592 + if (!(qc->dev->quirks & ATA_QUIRK_ATAPI_MOD16_DMA) && 4593 4593 unlikely(qc->nbytes & 15)) 4594 4594 return 1; 4595 4595 ··· 5369 5369 */ 5370 5370 spin_lock_irqsave(ap->lock, flags); 5371 5371 dev->flags &= ~ATA_DFLAG_INIT_MASK; 5372 - dev->horkage = 0; 5372 + dev->quirks = 0; 5373 5373 spin_unlock_irqrestore(ap->lock, flags); 5374 5374 5375 5375 memset((void *)dev + ATA_DEVICE_CLEAR_BEGIN, 0, ··· 6298 6298 { "no" #name, .lflags_on = (flags) }, \ 6299 6299 { #name, .lflags_off = (flags) } 6300 6300 6301 - #define force_horkage_on(name, flag) \ 6302 - { #name, .horkage_on = (flag) } 6301 + #define force_quirk_on(name, flag) \ 6302 + { #name, .quirk_on = (flag) } 6303 6303 6304 - #define force_horkage_onoff(name, flag) \ 6305 - { "no" #name, .horkage_on = (flag) }, \ 6306 - { #name, .horkage_off = (flag) } 6304 + #define force_quirk_onoff(name, flag) \ 6305 + { "no" #name, .quirk_on = (flag) }, \ 6306 + { #name, .quirk_off = (flag) } 6307 6307 6308 6308 static const struct ata_force_param force_tbl[] __initconst = { 6309 6309 force_cbl(40c, ATA_CBL_PATA40), ··· 6357 6357 force_lflag_on(rstonce, ATA_LFLAG_RST_ONCE), 6358 6358 force_lflag_onoff(dbdelay, ATA_LFLAG_NO_DEBOUNCE_DELAY), 6359 6359 6360 - force_horkage_onoff(ncq, ATA_HORKAGE_NONCQ), 6361 - force_horkage_onoff(ncqtrim, ATA_HORKAGE_NO_NCQ_TRIM), 6362 - force_horkage_onoff(ncqati, ATA_HORKAGE_NO_NCQ_ON_ATI), 6360 + force_quirk_onoff(ncq, ATA_QUIRK_NONCQ), 6361 + force_quirk_onoff(ncqtrim, ATA_QUIRK_NO_NCQ_TRIM), 6362 + force_quirk_onoff(ncqati, ATA_QUIRK_NO_NCQ_ON_ATI), 6363 6363 6364 - force_horkage_onoff(trim, ATA_HORKAGE_NOTRIM), 6365 - force_horkage_on(trim_zero, ATA_HORKAGE_ZERO_AFTER_TRIM), 6366 - force_horkage_on(max_trim_128m, ATA_HORKAGE_MAX_TRIM_128M), 6364 + force_quirk_onoff(trim, ATA_QUIRK_NOTRIM), 6365 + force_quirk_on(trim_zero, ATA_QUIRK_ZERO_AFTER_TRIM), 6366 + force_quirk_on(max_trim_128m, ATA_QUIRK_MAX_TRIM_128M), 6367 6367 6368 - force_horkage_onoff(dma, ATA_HORKAGE_NODMA), 6369 - force_horkage_on(atapi_dmadir, ATA_HORKAGE_ATAPI_DMADIR), 6370 - force_horkage_on(atapi_mod16_dma, ATA_HORKAGE_ATAPI_MOD16_DMA), 6368 + force_quirk_onoff(dma, ATA_QUIRK_NODMA), 6369 + force_quirk_on(atapi_dmadir, ATA_QUIRK_ATAPI_DMADIR), 6370 + force_quirk_on(atapi_mod16_dma, ATA_QUIRK_ATAPI_MOD16_DMA), 6371 6371 6372 - force_horkage_onoff(dmalog, ATA_HORKAGE_NO_DMA_LOG), 6373 - force_horkage_onoff(iddevlog, ATA_HORKAGE_NO_ID_DEV_LOG), 6374 - force_horkage_onoff(logdir, ATA_HORKAGE_NO_LOG_DIR), 6372 + force_quirk_onoff(dmalog, ATA_QUIRK_NO_DMA_LOG), 6373 + force_quirk_onoff(iddevlog, ATA_QUIRK_NO_ID_DEV_LOG), 6374 + force_quirk_onoff(logdir, ATA_QUIRK_NO_LOG_DIR), 6375 6375 6376 - force_horkage_on(max_sec_128, ATA_HORKAGE_MAX_SEC_128), 6377 - force_horkage_on(max_sec_1024, ATA_HORKAGE_MAX_SEC_1024), 6378 - force_horkage_on(max_sec_lba48, ATA_HORKAGE_MAX_SEC_LBA48), 6376 + force_quirk_on(max_sec_128, ATA_QUIRK_MAX_SEC_128), 6377 + force_quirk_on(max_sec_1024, ATA_QUIRK_MAX_SEC_1024), 6378 + force_quirk_on(max_sec_lba48, ATA_QUIRK_MAX_SEC_LBA48), 6379 6379 6380 - force_horkage_onoff(lpm, ATA_HORKAGE_NOLPM), 6381 - force_horkage_onoff(setxfer, ATA_HORKAGE_NOSETXFER), 6382 - force_horkage_on(dump_id, ATA_HORKAGE_DUMP_ID), 6383 - force_horkage_onoff(fua, ATA_HORKAGE_NO_FUA), 6380 + force_quirk_onoff(lpm, ATA_QUIRK_NOLPM), 6381 + force_quirk_onoff(setxfer, ATA_QUIRK_NOSETXFER), 6382 + force_quirk_on(dump_id, ATA_QUIRK_DUMP_ID), 6383 + force_quirk_onoff(fua, ATA_QUIRK_NO_FUA), 6384 6384 6385 - force_horkage_on(disable, ATA_HORKAGE_DISABLE), 6385 + force_quirk_on(disable, ATA_QUIRK_DISABLE), 6386 6386 }; 6387 6387 6388 6388 static int __init ata_parse_force_one(char **cur,

+1 -1

drivers/ata/libata-sata.c

··· 818 818 819 819 ata_for_each_link(link, ap, EDGE) { 820 820 ata_for_each_dev(dev, &ap->link, ENABLED) { 821 - if (dev->horkage & ATA_HORKAGE_NOLPM) { 821 + if (dev->quirks & ATA_QUIRK_NOLPM) { 822 822 count = -EOPNOTSUPP; 823 823 goto out_unlock; 824 824 }

+4 -5

drivers/ata/libata-scsi.c

··· 2083 2083 if (ata_id_has_trim(args->id)) { 2084 2084 u64 max_blocks = 65535 * ATA_MAX_TRIM_RNUM; 2085 2085 2086 - if (dev->horkage & ATA_HORKAGE_MAX_TRIM_128M) 2086 + if (dev->quirks & ATA_QUIRK_MAX_TRIM_128M) 2087 2087 max_blocks = 128 << (20 - SECTOR_SHIFT); 2088 2088 2089 2089 put_unaligned_be64(max_blocks, &rbuf[36]); ··· 2561 2561 rbuf[15] = lowest_aligned; 2562 2562 2563 2563 if (ata_id_has_trim(args->id) && 2564 - !(dev->horkage & ATA_HORKAGE_NOTRIM)) { 2564 + !(dev->quirks & ATA_QUIRK_NOTRIM)) { 2565 2565 rbuf[14] |= 0x80; /* LBPME */ 2566 2566 2567 2567 if (ata_id_has_zero_after_trim(args->id) && 2568 - dev->horkage & ATA_HORKAGE_ZERO_AFTER_TRIM) { 2568 + dev->quirks & ATA_QUIRK_ZERO_AFTER_TRIM) { 2569 2569 ata_dev_info(dev, "Enabling discard_zeroes_data\n"); 2570 2570 rbuf[14] |= 0x40; /* LBPRZ */ 2571 2571 } ··· 3229 3229 } 3230 3230 scsi_16_lba_len(cdb, &block, &n_block); 3231 3231 3232 - if (!unmap || 3233 - (dev->horkage & ATA_HORKAGE_NOTRIM) || 3232 + if (!unmap || (dev->quirks & ATA_QUIRK_NOTRIM) || 3234 3233 !ata_id_has_trim(dev->id)) { 3235 3234 fp = 1; 3236 3235 bp = 3;

+5 -5

drivers/ata/libata-sff.c

··· 970 970 * We ignore ERR here to workaround and proceed sending 971 971 * the CDB. 972 972 */ 973 - if (!(qc->dev->horkage & ATA_HORKAGE_STUCK_ERR)) { 973 + if (!(qc->dev->quirks & ATA_QUIRK_STUCK_ERR)) { 974 974 ata_ehi_push_desc(ehi, "ST_FIRST: " 975 975 "DRQ=1 with device error, " 976 976 "dev_stat 0x%X", status); ··· 1045 1045 * IDENTIFY, it's likely a phantom 1046 1046 * device. Mark hint. 1047 1047 */ 1048 - if (qc->dev->horkage & 1049 - ATA_HORKAGE_DIAGNOSTIC) 1048 + if (qc->dev->quirks & 1049 + ATA_QUIRK_DIAGNOSTIC) 1050 1050 qc->err_mask |= 1051 1051 AC_ERR_NODEV_HINT; 1052 1052 } else { ··· 1762 1762 /* see if device passed diags: continue and warn later */ 1763 1763 if (err == 0) 1764 1764 /* diagnostic fail : do nothing _YET_ */ 1765 - dev->horkage |= ATA_HORKAGE_DIAGNOSTIC; 1765 + dev->quirks |= ATA_QUIRK_DIAGNOSTIC; 1766 1766 else if (err == 1) 1767 1767 /* do nothing */ ; 1768 1768 else if ((dev->devno == 0) && (err == 0x81)) ··· 1781 1781 * device signature is invalid with diagnostic 1782 1782 * failure. 1783 1783 */ 1784 - if (present && (dev->horkage & ATA_HORKAGE_DIAGNOSTIC)) 1784 + if (present && (dev->quirks & ATA_QUIRK_DIAGNOSTIC)) 1785 1785 class = ATA_DEV_ATA; 1786 1786 else 1787 1787 class = ATA_DEV_NONE;

+3 -3

drivers/ata/libata-transport.c

··· 617 617 618 618 if (!ata_id_has_trim(ata_dev->id)) 619 619 mode = "unsupported"; 620 - else if (ata_dev->horkage & ATA_HORKAGE_NOTRIM) 620 + else if (ata_dev->quirks & ATA_QUIRK_NOTRIM) 621 621 mode = "forced_unsupported"; 622 - else if (ata_dev->horkage & ATA_HORKAGE_NO_NCQ_TRIM) 623 - mode = "forced_unqueued"; 622 + else if (ata_dev->quirks & ATA_QUIRK_NO_NCQ_TRIM) 623 + mode = "forced_unqueued"; 624 624 else if (ata_fpdma_dsm_supported(ata_dev)) 625 625 mode = "queued"; 626 626 else

+2 -2

drivers/ata/pata_it821x.c

··· 519 519 } 520 520 /* This is a controller firmware triggered funny, don't 521 521 report the drive faulty! */ 522 - adev->horkage &= ~ATA_HORKAGE_DIAGNOSTIC; 522 + adev->quirks &= ~ATA_QUIRK_DIAGNOSTIC; 523 523 /* No HPA in 'smart' mode */ 524 - adev->horkage |= ATA_HORKAGE_BROKEN_HPA; 524 + adev->quirks |= ATA_QUIRK_BROKEN_HPA; 525 525 } 526 526 527 527 /**

+1 -1

drivers/ata/sata_sil.c

··· 616 616 unsigned char model_num[ATA_ID_PROD_LEN + 1]; 617 617 618 618 /* This controller doesn't support trim */ 619 - dev->horkage |= ATA_HORKAGE_NOTRIM; 619 + dev->quirks |= ATA_QUIRK_NOTRIM; 620 620 621 621 ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num)); 622 622

+36 -35

include/linux/libata.h

··· 362 362 */ 363 363 ATA_EH_CMD_TIMEOUT_TABLE_SIZE = 8, 364 364 365 - /* Horkage types. May be set by libata or controller on drives 366 - (some horkage may be drive/controller pair dependent */ 367 - 368 - ATA_HORKAGE_DIAGNOSTIC = (1 << 0), /* Failed boot diag */ 369 - ATA_HORKAGE_NODMA = (1 << 1), /* DMA problems */ 370 - ATA_HORKAGE_NONCQ = (1 << 2), /* Don't use NCQ */ 371 - ATA_HORKAGE_MAX_SEC_128 = (1 << 3), /* Limit max sects to 128 */ 372 - ATA_HORKAGE_BROKEN_HPA = (1 << 4), /* Broken HPA */ 373 - ATA_HORKAGE_DISABLE = (1 << 5), /* Disable it */ 374 - ATA_HORKAGE_HPA_SIZE = (1 << 6), /* native size off by one */ 375 - ATA_HORKAGE_IVB = (1 << 8), /* cbl det validity bit bugs */ 376 - ATA_HORKAGE_STUCK_ERR = (1 << 9), /* stuck ERR on next PACKET */ 377 - ATA_HORKAGE_BRIDGE_OK = (1 << 10), /* no bridge limits */ 378 - ATA_HORKAGE_ATAPI_MOD16_DMA = (1 << 11), /* use ATAPI DMA for commands 379 - not multiple of 16 bytes */ 380 - ATA_HORKAGE_FIRMWARE_WARN = (1 << 12), /* firmware update warning */ 381 - ATA_HORKAGE_1_5_GBPS = (1 << 13), /* force 1.5 Gbps */ 382 - ATA_HORKAGE_NOSETXFER = (1 << 14), /* skip SETXFER, SATA only */ 383 - ATA_HORKAGE_BROKEN_FPDMA_AA = (1 << 15), /* skip AA */ 384 - ATA_HORKAGE_DUMP_ID = (1 << 16), /* dump IDENTIFY data */ 385 - ATA_HORKAGE_MAX_SEC_LBA48 = (1 << 17), /* Set max sects to 65535 */ 386 - ATA_HORKAGE_ATAPI_DMADIR = (1 << 18), /* device requires dmadir */ 387 - ATA_HORKAGE_NO_NCQ_TRIM = (1 << 19), /* don't use queued TRIM */ 388 - ATA_HORKAGE_NOLPM = (1 << 20), /* don't use LPM */ 389 - ATA_HORKAGE_WD_BROKEN_LPM = (1 << 21), /* some WDs have broken LPM */ 390 - ATA_HORKAGE_ZERO_AFTER_TRIM = (1 << 22),/* guarantees zero after trim */ 391 - ATA_HORKAGE_NO_DMA_LOG = (1 << 23), /* don't use DMA for log read */ 392 - ATA_HORKAGE_NOTRIM = (1 << 24), /* don't use TRIM */ 393 - ATA_HORKAGE_MAX_SEC_1024 = (1 << 25), /* Limit max sects to 1024 */ 394 - ATA_HORKAGE_MAX_TRIM_128M = (1 << 26), /* Limit max trim size to 128M */ 395 - ATA_HORKAGE_NO_NCQ_ON_ATI = (1 << 27), /* Disable NCQ on ATI chipset */ 396 - ATA_HORKAGE_NO_ID_DEV_LOG = (1 << 28), /* Identify device log missing */ 397 - ATA_HORKAGE_NO_LOG_DIR = (1 << 29), /* Do not read log directory */ 398 - ATA_HORKAGE_NO_FUA = (1 << 30), /* Do not use FUA */ 365 + /* 366 + * Quirk flags: may be set by libata or controller drivers on drives. 367 + * Some quirks may be drive/controller pair dependent. 368 + */ 369 + ATA_QUIRK_DIAGNOSTIC = (1 << 0), /* Failed boot diag */ 370 + ATA_QUIRK_NODMA = (1 << 1), /* DMA problems */ 371 + ATA_QUIRK_NONCQ = (1 << 2), /* Do not use NCQ */ 372 + ATA_QUIRK_MAX_SEC_128 = (1 << 3), /* Limit max sects to 128 */ 373 + ATA_QUIRK_BROKEN_HPA = (1 << 4), /* Broken HPA */ 374 + ATA_QUIRK_DISABLE = (1 << 5), /* Disable it */ 375 + ATA_QUIRK_HPA_SIZE = (1 << 6), /* Native size off by one */ 376 + ATA_QUIRK_IVB = (1 << 8), /* CBL det validity bit bugs */ 377 + ATA_QUIRK_STUCK_ERR = (1 << 9), /* Stuck ERR on next PACKET */ 378 + ATA_QUIRK_BRIDGE_OK = (1 << 10), /* No bridge limits */ 379 + ATA_QUIRK_ATAPI_MOD16_DMA = (1 << 11), /* Use ATAPI DMA for commands */ 380 + /* not multiple of 16 bytes */ 381 + ATA_QUIRK_FIRMWARE_WARN = (1 << 12), /* Firmware update warning */ 382 + ATA_QUIRK_1_5_GBPS = (1 << 13), /* Force 1.5 Gbps */ 383 + ATA_QUIRK_NOSETXFER = (1 << 14), /* Skip SETXFER, SATA only */ 384 + ATA_QUIRK_BROKEN_FPDMA_AA = (1 << 15), /* Skip AA */ 385 + ATA_QUIRK_DUMP_ID = (1 << 16), /* Dump IDENTIFY data */ 386 + ATA_QUIRK_MAX_SEC_LBA48 = (1 << 17), /* Set max sects to 65535 */ 387 + ATA_QUIRK_ATAPI_DMADIR = (1 << 18), /* Device requires dmadir */ 388 + ATA_QUIRK_NO_NCQ_TRIM = (1 << 19), /* Do not use queued TRIM */ 389 + ATA_QUIRK_NOLPM = (1 << 20), /* Do not use LPM */ 390 + ATA_QUIRK_WD_BROKEN_LPM = (1 << 21), /* Some WDs have broken LPM */ 391 + ATA_QUIRK_ZERO_AFTER_TRIM = (1 << 22), /* Guarantees zero after trim */ 392 + ATA_QUIRK_NO_DMA_LOG = (1 << 23), /* Do not use DMA for log read */ 393 + ATA_QUIRK_NOTRIM = (1 << 24), /* Do not use TRIM */ 394 + ATA_QUIRK_MAX_SEC_1024 = (1 << 25), /* Limit max sects to 1024 */ 395 + ATA_QUIRK_MAX_TRIM_128M = (1 << 26), /* Limit max trim size to 128M */ 396 + ATA_QUIRK_NO_NCQ_ON_ATI = (1 << 27), /* Disable NCQ on ATI chipset */ 397 + ATA_QUIRK_NO_ID_DEV_LOG = (1 << 28), /* Identify device log missing */ 398 + ATA_QUIRK_NO_LOG_DIR = (1 << 29), /* Do not read log directory */ 399 + ATA_QUIRK_NO_FUA = (1 << 30), /* Do not use FUA */ 399 400 400 401 /* DMA mask for user DMA control: User visible values; DO NOT 401 402 renumber */ ··· 664 663 struct ata_device { 665 664 struct ata_link *link; 666 665 unsigned int devno; /* 0 or 1 */ 667 - unsigned int horkage; /* List of broken features */ 666 + unsigned int quirks; /* List of broken features */ 668 667 unsigned long flags; /* ATA_DFLAG_xxx */ 669 668 struct scsi_device *sdev; /* attached SCSI device */ 670 669 void *private_data;