Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
C
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191/* SPDX-License-Identifier: GPL-2.0-or-later *//* * Copyright 2003-2005 Red Hat, Inc. All rights reserved. * Copyright 2003-2005 Jeff Garzik * * libata documentation is available via 'make {ps|pdf}docs', * as Documentation/driver-api/libata.rst */
#ifndef __LINUX_LIBATA_H__#define __LINUX_LIBATA_H__
#include <linux/delay.h>#include <linux/jiffies.h>#include <linux/interrupt.h>#include <linux/dma-mapping.h>#include <linux/scatterlist.h>#include <linux/io.h>#include <linux/ata.h>#include <linux/workqueue.h>#include <scsi/scsi_host.h>#include <linux/acpi.h>#include <linux/cdrom.h>#include <linux/sched.h>#include <linux/async.h>
/* * Define if arch has non-standard setup. This is a _PCI_ standard * not a legacy or ISA standard. */#ifdef CONFIG_ATA_NONSTANDARD#include <asm/libata-portmap.h>#else#define ATA_PRIMARY_IRQ(dev) 14#define ATA_SECONDARY_IRQ(dev) 15#endif
/* * compile-time options: to be removed as soon as all the drivers are * converted to the new debugging mechanism */#undef ATA_IRQ_TRAP /* define to ack screaming irqs */
/* defines only for the constants which don't work well as enums */#define ATA_TAG_POISON 0xfafbfcfdU
/* * Quirk flags bits. * 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_BROKEN_HPA, /* Broken HPA */ __ATA_QUIRK_DISABLE, /* Disable it */ __ATA_QUIRK_HPA_SIZE, /* Native size off by one */ __ATA_QUIRK_IVB, /* cbl det validity bit bugs */ __ATA_QUIRK_STUCK_ERR, /* Stuck ERR on next PACKET */ __ATA_QUIRK_BRIDGE_OK, /* No bridge limits */ __ATA_QUIRK_ATAPI_MOD16_DMA, /* Use ATAPI DMA for commands that */ /* are not a multiple of 16 bytes */ __ATA_QUIRK_FIRMWARE_WARN, /* Firmware update warning */ __ATA_QUIRK_1_5_GBPS, /* Force 1.5 Gbps */ __ATA_QUIRK_NOSETXFER, /* Skip SETXFER, SATA only */ __ATA_QUIRK_BROKEN_FPDMA_AA, /* Skip AA */ __ATA_QUIRK_DUMP_ID, /* Dump IDENTIFY data */ __ATA_QUIRK_MAX_SEC_LBA48, /* Set max sects to 65535 */ __ATA_QUIRK_ATAPI_DMADIR, /* Device requires dmadir */ __ATA_QUIRK_NO_NCQ_TRIM, /* Do not use queued TRIM */ __ATA_QUIRK_NOLPM, /* Do not use LPM */ __ATA_QUIRK_WD_BROKEN_LPM, /* Some WDs have broken LPM */ __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, /* 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_AND_AMD, /* Disable LPM on ATI and AMD chipsets */ __ATA_QUIRK_NO_ID_DEV_LOG, /* Identify device log missing */ __ATA_QUIRK_NO_LOG_DIR, /* Do not read log directory */ __ATA_QUIRK_NO_FUA, /* Do not use FUA */
__ATA_QUIRK_MAX,};
/* * Quirk flags: may be set by libata or controller drivers on drives. * Some quirks may be drive/controller pair dependent. */enum { 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_AND_AMD = BIT_ULL(__ATA_QUIRK_NO_LPM_ON_ATI_AND_AMD), 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),};
/* * struct ata_device flags */enum { ATA_DFLAG_LBA = (1UL << 0), /* device supports LBA */ ATA_DFLAG_LBA48 = (1UL << 1), /* device supports LBA48 */ ATA_DFLAG_CDB_INTR = (1UL << 2), /* device asserts INTRQ when ready for CDB */ ATA_DFLAG_NCQ = (1UL << 3), /* device supports NCQ */ ATA_DFLAG_FLUSH_EXT = (1UL << 4), /* do FLUSH_EXT instead of FLUSH */ ATA_DFLAG_ACPI_PENDING = (1UL << 5), /* ACPI resume action pending */ ATA_DFLAG_ACPI_FAILED = (1UL << 6), /* ACPI on devcfg has failed */ ATA_DFLAG_AN = (1UL << 7), /* AN configured */ ATA_DFLAG_TRUSTED = (1UL << 8), /* device supports trusted send/recv */ ATA_DFLAG_FUA = (1UL << 9), /* device supports FUA */ ATA_DFLAG_DMADIR = (1UL << 10), /* device requires DMADIR */ ATA_DFLAG_NCQ_SEND_RECV = (1UL << 11), /* device supports NCQ SEND and RECV */ ATA_DFLAG_NCQ_PRIO = (1UL << 12), /* device supports NCQ priority */ ATA_DFLAG_CDL = (1UL << 13), /* supports cmd duration limits */ ATA_DFLAG_DEPOP = (1UL << 14), /* supports depopulation capability */ ATA_DFLAG_DEPOP_RESTORE = (1UL << 15), /* supports depopulation restoration */ ATA_DFLAG_DEPOP_MODIFY = (1UL << 16), /* supports zoned depopulation */ ATA_DFLAG_CFG_MASK = (1UL << 17) - 1,
ATA_DFLAG_PIO = (1UL << 17), /* device limited to PIO mode */ ATA_DFLAG_NCQ_OFF = (1UL << 18), /* device limited to non-NCQ mode */ ATA_DFLAG_SLEEPING = (1UL << 19), /* device is sleeping */ ATA_DFLAG_DUBIOUS_XFER = (1UL << 20), /* data transfer not verified */ ATA_DFLAG_NO_UNLOAD = (1UL << 21), /* device doesn't support unload */ ATA_DFLAG_UNLOCK_HPA = (1UL << 22), /* unlock HPA */ ATA_DFLAG_INIT_MASK = (1UL << 23) - 1,
ATA_DFLAG_NCQ_PRIO_ENABLED = (1UL << 23), /* Priority cmds sent to dev */ ATA_DFLAG_CDL_ENABLED = (1UL << 24), /* cmd duration limits is enabled */ ATA_DFLAG_RESUMING = (1UL << 25), /* Device is resuming */ ATA_DFLAG_DETACH = (1UL << 26), ATA_DFLAG_DETACHED = (1UL << 27), ATA_DFLAG_DA = (1UL << 28), /* device supports Device Attention */ ATA_DFLAG_DEVSLP = (1UL << 29), /* device supports Device Sleep */ ATA_DFLAG_ACPI_DISABLED = (1UL << 30), /* ACPI for the device is disabled */ ATA_DFLAG_D_SENSE = (1UL << 31), /* Descriptor sense requested */
ATA_DFLAG_FEATURES_MASK = (ATA_DFLAG_TRUSTED | ATA_DFLAG_DA | \ ATA_DFLAG_DEVSLP | ATA_DFLAG_NCQ_SEND_RECV | \ ATA_DFLAG_NCQ_PRIO | ATA_DFLAG_FUA | \ ATA_DFLAG_CDL | ATA_DFLAG_DEPOP | \ ATA_DFLAG_DEPOP_RESTORE | ATA_DFLAG_DEPOP_MODIFY)};
enum { /* various global constants */ LIBATA_MAX_PRD = ATA_MAX_PRD / 2, LIBATA_DUMB_MAX_PRD = ATA_MAX_PRD / 4, /* Worst case */ ATA_DEF_QUEUE = 1, ATA_MAX_QUEUE = 32, ATA_TAG_INTERNAL = ATA_MAX_QUEUE, ATA_SHORT_PAUSE = 16,
ATAPI_MAX_DRAIN = 16 << 10,
ATA_ALL_DEVICES = (1 << ATA_MAX_DEVICES) - 1,
ATA_SHT_EMULATED = 1, ATA_SHT_THIS_ID = -1,
/* struct ata_taskfile flags */ ATA_TFLAG_LBA48 = (1 << 0), /* enable 48-bit LBA and "HOB" */ ATA_TFLAG_ISADDR = (1 << 1), /* enable r/w to nsect/lba regs */ ATA_TFLAG_DEVICE = (1 << 2), /* enable r/w to device reg */ ATA_TFLAG_WRITE = (1 << 3), /* data dir: host->dev==1 (write) */ ATA_TFLAG_LBA = (1 << 4), /* enable LBA */ ATA_TFLAG_FUA = (1 << 5), /* enable FUA */ ATA_TFLAG_POLLING = (1 << 6), /* set nIEN to 1 and use polling */
/* sturct ata_device class. */ ATA_DEV_UNKNOWN = 0, /* unknown device */ ATA_DEV_ATA = 1, /* ATA device */ ATA_DEV_ATA_UNSUP = 2, /* ATA device (unsupported) */ ATA_DEV_ATAPI = 3, /* ATAPI device */ ATA_DEV_ATAPI_UNSUP = 4, /* ATAPI device (unsupported) */ ATA_DEV_PMP = 5, /* SATA port multiplier */ ATA_DEV_PMP_UNSUP = 6, /* SATA port multiplier (unsupported) */ ATA_DEV_SEMB = 7, /* SEMB */ ATA_DEV_SEMB_UNSUP = 8, /* SEMB (unsupported) */ ATA_DEV_ZAC = 9, /* ZAC device */ ATA_DEV_ZAC_UNSUP = 10, /* ZAC device (unsupported) */ ATA_DEV_NONE = 11, /* no device */
/* struct ata_link flags */ /* NOTE: struct ata_force_param currently stores lflags in u16 */ ATA_LFLAG_NO_HRST = (1 << 1), /* avoid hardreset */ ATA_LFLAG_NO_SRST = (1 << 2), /* avoid softreset */ ATA_LFLAG_ASSUME_ATA = (1 << 3), /* assume ATA class */ ATA_LFLAG_ASSUME_SEMB = (1 << 4), /* assume SEMB class */ ATA_LFLAG_ASSUME_CLASS = ATA_LFLAG_ASSUME_ATA | ATA_LFLAG_ASSUME_SEMB, ATA_LFLAG_NO_RETRY = (1 << 5), /* don't retry this link */ ATA_LFLAG_DISABLED = (1 << 6), /* link is disabled */ ATA_LFLAG_SW_ACTIVITY = (1 << 7), /* keep activity stats */ ATA_LFLAG_NO_LPM = (1 << 8), /* disable LPM on this link */ ATA_LFLAG_RST_ONCE = (1 << 9), /* limit recovery to one reset */ ATA_LFLAG_CHANGED = (1 << 10), /* LPM state changed on this link */ ATA_LFLAG_NO_DEBOUNCE_DELAY = (1 << 11), /* no debounce delay on link resume */
/* struct ata_port flags */ ATA_FLAG_SLAVE_POSS = (1 << 0), /* host supports slave dev */ /* (doesn't imply presence) */ ATA_FLAG_SATA = (1 << 1), ATA_FLAG_NO_LPM = (1 << 2), /* host not happy with LPM */ ATA_FLAG_NO_LOG_PAGE = (1 << 5), /* do not issue log page read */ ATA_FLAG_NO_ATAPI = (1 << 6), /* No ATAPI support */ ATA_FLAG_PIO_DMA = (1 << 7), /* PIO cmds via DMA */ ATA_FLAG_PIO_LBA48 = (1 << 8), /* Host DMA engine is LBA28 only */ ATA_FLAG_PIO_POLLING = (1 << 9), /* use polling PIO if LLD * doesn't handle PIO interrupts */ ATA_FLAG_NCQ = (1 << 10), /* host supports NCQ */ ATA_FLAG_NO_POWEROFF_SPINDOWN = (1 << 11), /* don't spindown before poweroff */ ATA_FLAG_NO_HIBERNATE_SPINDOWN = (1 << 12), /* don't spindown before hibernation */ ATA_FLAG_DEBUGMSG = (1 << 13), ATA_FLAG_FPDMA_AA = (1 << 14), /* driver supports Auto-Activate */ ATA_FLAG_IGN_SIMPLEX = (1 << 15), /* ignore SIMPLEX */ ATA_FLAG_NO_IORDY = (1 << 16), /* controller lacks iordy */ ATA_FLAG_ACPI_SATA = (1 << 17), /* need native SATA ACPI layout */ ATA_FLAG_AN = (1 << 18), /* controller supports AN */ ATA_FLAG_PMP = (1 << 19), /* controller supports PMP */ ATA_FLAG_FPDMA_AUX = (1 << 20), /* controller supports H2DFIS aux field */ ATA_FLAG_EM = (1 << 21), /* driver supports enclosure * management */ ATA_FLAG_SW_ACTIVITY = (1 << 22), /* driver supports sw activity * led */ ATA_FLAG_NO_DIPM = (1 << 23), /* host not happy with DIPM */ ATA_FLAG_SAS_HOST = (1 << 24), /* SAS host */
/* bits 24:31 of ap->flags are reserved for LLD specific flags */
/* struct ata_port pflags */ ATA_PFLAG_EH_PENDING = (1 << 0), /* EH pending */ ATA_PFLAG_EH_IN_PROGRESS = (1 << 1), /* EH in progress */ ATA_PFLAG_FROZEN = (1 << 2), /* port is frozen */ ATA_PFLAG_RECOVERED = (1 << 3), /* recovery action performed */ ATA_PFLAG_LOADING = (1 << 4), /* boot/loading probe */ ATA_PFLAG_SCSI_HOTPLUG = (1 << 6), /* SCSI hotplug scheduled */ ATA_PFLAG_INITIALIZING = (1 << 7), /* being initialized, don't touch */ ATA_PFLAG_RESETTING = (1 << 8), /* reset in progress */ ATA_PFLAG_UNLOADING = (1 << 9), /* driver is being unloaded */ ATA_PFLAG_UNLOADED = (1 << 10), /* driver is unloaded */
ATA_PFLAG_RESUMING = (1 << 16), /* port is being resumed */ ATA_PFLAG_SUSPENDED = (1 << 17), /* port is suspended (power) */ ATA_PFLAG_PM_PENDING = (1 << 18), /* PM operation pending */ ATA_PFLAG_INIT_GTM_VALID = (1 << 19), /* initial gtm data valid */
ATA_PFLAG_PIO32 = (1 << 20), /* 32bit PIO */ ATA_PFLAG_PIO32CHANGE = (1 << 21), /* 32bit PIO can be turned on/off */ ATA_PFLAG_EXTERNAL = (1 << 22), /* eSATA/external port */
/* struct ata_queued_cmd flags */ ATA_QCFLAG_ACTIVE = (1 << 0), /* cmd not yet ack'd to scsi lyer */ ATA_QCFLAG_DMAMAP = (1 << 1), /* SG table is DMA mapped */ ATA_QCFLAG_RTF_FILLED = (1 << 2), /* result TF has been filled */ ATA_QCFLAG_IO = (1 << 3), /* standard IO command */ ATA_QCFLAG_RESULT_TF = (1 << 4), /* result TF requested */ ATA_QCFLAG_CLEAR_EXCL = (1 << 5), /* clear excl_link on completion */ ATA_QCFLAG_QUIET = (1 << 6), /* don't report device error */ ATA_QCFLAG_RETRY = (1 << 7), /* retry after failure */ ATA_QCFLAG_HAS_CDL = (1 << 8), /* qc has CDL a descriptor set */
ATA_QCFLAG_EH = (1 << 16), /* cmd aborted and owned by EH */ ATA_QCFLAG_SENSE_VALID = (1 << 17), /* sense data valid */ ATA_QCFLAG_EH_SCHEDULED = (1 << 18), /* EH scheduled (obsolete) */ ATA_QCFLAG_EH_SUCCESS_CMD = (1 << 19), /* EH should fetch sense for this successful cmd */
/* host set flags */ ATA_HOST_SIMPLEX = (1 << 0), /* Host is simplex, one DMA channel per host only */ ATA_HOST_STARTED = (1 << 1), /* Host started */ ATA_HOST_PARALLEL_SCAN = (1 << 2), /* Ports on this host can be scanned in parallel */ ATA_HOST_IGNORE_ATA = (1 << 3), /* Ignore ATA devices on this host. */
ATA_HOST_NO_PART = (1 << 4), /* Host does not support partial */ ATA_HOST_NO_SSC = (1 << 5), /* Host does not support slumber */ ATA_HOST_NO_DEVSLP = (1 << 6), /* Host does not support devslp */
/* bits 24:31 of host->flags are reserved for LLD specific flags */
/* Various lengths of time */ ATA_TMOUT_INTERNAL_QUICK = 5000, ATA_TMOUT_MAX_PARK = 30000,
/* * GoVault needs 2s and iVDR disk HHD424020F7SV00 800ms. 2s * is too much without parallel probing. Use 2s if parallel * probing is available, 800ms otherwise. */ ATA_TMOUT_FF_WAIT_LONG = 2000, ATA_TMOUT_FF_WAIT = 800,
/* Spec mandates to wait for ">= 2ms" before checking status * after reset. We wait 150ms, because that was the magic * delay used for ATAPI devices in Hale Landis's ATADRVR, for * the period of time between when the ATA command register is * written, and then status is checked. Because waiting for * "a while" before checking status is fine, post SRST, we * perform this magic delay here as well. * * Old drivers/ide uses the 2mS rule and then waits for ready. */ ATA_WAIT_AFTER_RESET = 150,
/* If PMP is supported, we have to do follow-up SRST. As some * PMPs don't send D2H Reg FIS after hardreset, LLDs are * advised to wait only for the following duration before * doing SRST. */ ATA_TMOUT_PMP_SRST_WAIT = 10000,
/* When the LPM policy is set to ATA_LPM_MAX_POWER, there might * be a spurious PHY event, so ignore the first PHY event that * occurs within 10s after the policy change. */ ATA_TMOUT_SPURIOUS_PHY = 10000,
/* ATA bus states */ BUS_UNKNOWN = 0, BUS_DMA = 1, BUS_IDLE = 2, BUS_NOINTR = 3, BUS_NODATA = 4, BUS_TIMER = 5, BUS_PIO = 6, BUS_EDD = 7, BUS_IDENTIFY = 8, BUS_PACKET = 9,
/* SATA port states */ PORT_UNKNOWN = 0, PORT_ENABLED = 1, PORT_DISABLED = 2,
/* encoding various smaller bitmaps into a single * unsigned int bitmap */ ATA_NR_PIO_MODES = 7, ATA_NR_MWDMA_MODES = 5, ATA_NR_UDMA_MODES = 8,
ATA_SHIFT_PIO = 0, ATA_SHIFT_MWDMA = ATA_SHIFT_PIO + ATA_NR_PIO_MODES, ATA_SHIFT_UDMA = ATA_SHIFT_MWDMA + ATA_NR_MWDMA_MODES, ATA_SHIFT_PRIO = 6,
ATA_PRIO_HIGH = 2, /* size of buffer to pad xfers ending on unaligned boundaries */ ATA_DMA_PAD_SZ = 4,
/* ering size */ ATA_ERING_SIZE = 32,
/* return values for ->qc_defer */ ATA_DEFER_LINK = 1, ATA_DEFER_PORT = 2, ATA_DEFER_LINK_EXCL = 3,
/* desc_len for ata_eh_info and context */ ATA_EH_DESC_LEN = 80,
/* reset / recovery action types */ ATA_EH_REVALIDATE = (1 << 0), ATA_EH_SOFTRESET = (1 << 1), /* meaningful only in ->prereset */ ATA_EH_HARDRESET = (1 << 2), /* meaningful only in ->prereset */ ATA_EH_RESET = ATA_EH_SOFTRESET | ATA_EH_HARDRESET, ATA_EH_ENABLE_LINK = (1 << 3), ATA_EH_PARK = (1 << 5), /* unload heads and stop I/O */ ATA_EH_GET_SUCCESS_SENSE = (1 << 6), /* Get sense data for successful cmd */ ATA_EH_SET_ACTIVE = (1 << 7), /* Set a device to active power mode */
ATA_EH_PERDEV_MASK = ATA_EH_REVALIDATE | ATA_EH_PARK | ATA_EH_GET_SUCCESS_SENSE | ATA_EH_SET_ACTIVE, ATA_EH_ALL_ACTIONS = ATA_EH_REVALIDATE | ATA_EH_RESET | ATA_EH_ENABLE_LINK,
/* ata_eh_info->flags */ ATA_EHI_HOTPLUGGED = (1 << 0), /* could have been hotplugged */ ATA_EHI_NO_AUTOPSY = (1 << 2), /* no autopsy */ ATA_EHI_QUIET = (1 << 3), /* be quiet */ ATA_EHI_NO_RECOVERY = (1 << 4), /* no recovery */
ATA_EHI_DID_SOFTRESET = (1 << 16), /* already soft-reset this port */ ATA_EHI_DID_HARDRESET = (1 << 17), /* already soft-reset this port */ ATA_EHI_PRINTINFO = (1 << 18), /* print configuration info */ ATA_EHI_SETMODE = (1 << 19), /* configure transfer mode */ ATA_EHI_POST_SETMODE = (1 << 20), /* revalidating after setmode */ ATA_EHI_DID_PRINT_QUIRKS = (1 << 21), /* already printed quirks info */
ATA_EHI_DID_RESET = ATA_EHI_DID_SOFTRESET | ATA_EHI_DID_HARDRESET,
/* mask of flags to transfer *to* the slave link */ ATA_EHI_TO_SLAVE_MASK = ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET,
/* max tries if error condition is still set after ->error_handler */ ATA_EH_MAX_TRIES = 5,
/* sometimes resuming a link requires several retries */ ATA_LINK_RESUME_TRIES = 5,
/* how hard are we gonna try to probe/recover devices */ ATA_EH_DEV_TRIES = 3, ATA_EH_PMP_TRIES = 5, ATA_EH_PMP_LINK_TRIES = 3,
SATA_PMP_RW_TIMEOUT = 3000, /* PMP read/write timeout */
/* This should match the actual table size of * ata_eh_cmd_timeout_table in libata-eh.c. */ ATA_EH_CMD_TIMEOUT_TABLE_SIZE = 9,
/* User visible DMA mask for DMA control. DO NOT renumber. */ ATA_DMA_MASK_ATA = (1 << 0), /* DMA on ATA Disk */ ATA_DMA_MASK_ATAPI = (1 << 1), /* DMA on ATAPI */ ATA_DMA_MASK_CFA = (1 << 2), /* DMA on CF Card */
/* ATAPI command types */ ATAPI_READ = 0, /* READs */ ATAPI_WRITE = 1, /* WRITEs */ ATAPI_READ_CD = 2, /* READ CD [MSF] */ ATAPI_PASS_THRU = 3, /* SAT pass-thru */ ATAPI_MISC = 4, /* the rest */
/* Timing constants */ ATA_TIMING_SETUP = (1 << 0), ATA_TIMING_ACT8B = (1 << 1), ATA_TIMING_REC8B = (1 << 2), ATA_TIMING_CYC8B = (1 << 3), ATA_TIMING_8BIT = ATA_TIMING_ACT8B | ATA_TIMING_REC8B | ATA_TIMING_CYC8B, ATA_TIMING_ACTIVE = (1 << 4), ATA_TIMING_RECOVER = (1 << 5), ATA_TIMING_DMACK_HOLD = (1 << 6), ATA_TIMING_CYCLE = (1 << 7), ATA_TIMING_UDMA = (1 << 8), ATA_TIMING_ALL = ATA_TIMING_SETUP | ATA_TIMING_ACT8B | ATA_TIMING_REC8B | ATA_TIMING_CYC8B | ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER | ATA_TIMING_DMACK_HOLD | ATA_TIMING_CYCLE | ATA_TIMING_UDMA,
/* ACPI constants */ ATA_ACPI_FILTER_SETXFER = 1 << 0, ATA_ACPI_FILTER_LOCK = 1 << 1, ATA_ACPI_FILTER_DIPM = 1 << 2, ATA_ACPI_FILTER_FPDMA_OFFSET = 1 << 3, /* FPDMA non-zero offset */ ATA_ACPI_FILTER_FPDMA_AA = 1 << 4, /* FPDMA auto activate */
ATA_ACPI_FILTER_DEFAULT = ATA_ACPI_FILTER_SETXFER | ATA_ACPI_FILTER_LOCK | ATA_ACPI_FILTER_DIPM,};
enum ata_xfer_mask { ATA_MASK_PIO = ((1U << ATA_NR_PIO_MODES) - 1) << ATA_SHIFT_PIO, ATA_MASK_MWDMA = ((1U << ATA_NR_MWDMA_MODES) - 1) << ATA_SHIFT_MWDMA, ATA_MASK_UDMA = ((1U << ATA_NR_UDMA_MODES) - 1) << ATA_SHIFT_UDMA,};
enum hsm_task_states { HSM_ST_IDLE, /* no command on going */ HSM_ST_FIRST, /* (waiting the device to) write CDB or first data block */ HSM_ST, /* (waiting the device to) transfer data */ HSM_ST_LAST, /* (waiting the device to) complete command */ HSM_ST_ERR, /* error */};
enum ata_completion_errors { AC_ERR_OK = 0, /* no error */ AC_ERR_DEV = (1 << 0), /* device reported error */ AC_ERR_HSM = (1 << 1), /* host state machine violation */ AC_ERR_TIMEOUT = (1 << 2), /* timeout */ AC_ERR_MEDIA = (1 << 3), /* media error */ AC_ERR_ATA_BUS = (1 << 4), /* ATA bus error */ AC_ERR_HOST_BUS = (1 << 5), /* host bus error */ AC_ERR_SYSTEM = (1 << 6), /* system error */ AC_ERR_INVALID = (1 << 7), /* invalid argument */ AC_ERR_OTHER = (1 << 8), /* unknown */ AC_ERR_NODEV_HINT = (1 << 9), /* polling device detection hint */ AC_ERR_NCQ = (1 << 10), /* marker for offending NCQ qc */};
/* * Link Power Management (LPM) policies. * * The default LPM policy to use for a device link is defined using these values * with the CONFIG_SATA_MOBILE_LPM_POLICY config option and applied through the * target_lpm_policy field of struct ata_port. * * If you alter this, you also need to alter the policy names used with the * sysfs attribute link_power_management_policy defined in libata-sata.c. */enum ata_lpm_policy { /* Keep firmware settings */ ATA_LPM_UNKNOWN, /* No power savings (maximum performance) */ ATA_LPM_MAX_POWER, /* HIPM (Partial) */ ATA_LPM_MED_POWER, /* HIPM (Partial) and DIPM (Partial and Slumber) */ ATA_LPM_MED_POWER_WITH_DIPM, /* HIPM (Partial and DevSleep) and DIPM (Partial and Slumber) */ ATA_LPM_MIN_POWER_WITH_PARTIAL, /* HIPM (Slumber and DevSleep) and DIPM (Partial and Slumber) */ ATA_LPM_MIN_POWER,};
enum ata_lpm_hints { ATA_LPM_EMPTY = (1 << 0), /* port empty/probing */ ATA_LPM_HIPM = (1 << 1), /* may use HIPM */ ATA_LPM_WAKE_ONLY = (1 << 2), /* only wake up link */};
/* forward declarations */struct scsi_device;struct ata_port_operations;struct ata_port;struct ata_link;struct ata_queued_cmd;
/* typedefs */typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);typedef int (*ata_prereset_fn_t)(struct ata_link *link, unsigned long deadline);typedef int (*ata_reset_fn_t)(struct ata_link *link, unsigned int *classes, unsigned long deadline);typedef void (*ata_postreset_fn_t)(struct ata_link *link, unsigned int *classes);
extern struct device_attribute dev_attr_unload_heads;#ifdef CONFIG_SATA_HOSTextern struct device_attribute dev_attr_link_power_management_supported;extern struct device_attribute dev_attr_link_power_management_policy;extern struct device_attribute dev_attr_ncq_prio_supported;extern struct device_attribute dev_attr_ncq_prio_enable;extern struct device_attribute dev_attr_em_message_type;extern struct device_attribute dev_attr_em_message;extern struct device_attribute dev_attr_sw_activity;#endif
enum sw_activity { OFF, BLINK_ON, BLINK_OFF,};
struct ata_taskfile { unsigned long flags; /* ATA_TFLAG_xxx */ u8 protocol; /* ATA_PROT_xxx */
u8 ctl; /* control reg */
u8 hob_feature; /* additional data */ u8 hob_nsect; /* to support LBA48 */ u8 hob_lbal; u8 hob_lbam; u8 hob_lbah;
union { u8 error; u8 feature; }; u8 nsect; u8 lbal; u8 lbam; u8 lbah;
u8 device;
union { u8 status; u8 command; };
u32 auxiliary; /* auxiliary field */ /* from SATA 3.1 and */ /* ATA-8 ACS-3 */};
#ifdef CONFIG_ATA_SFFstruct ata_ioports { void __iomem *cmd_addr; void __iomem *data_addr; void __iomem *error_addr; void __iomem *feature_addr; void __iomem *nsect_addr; void __iomem *lbal_addr; void __iomem *lbam_addr; void __iomem *lbah_addr; void __iomem *device_addr; void __iomem *status_addr; void __iomem *command_addr; void __iomem *altstatus_addr; void __iomem *ctl_addr;#ifdef CONFIG_ATA_BMDMA void __iomem *bmdma_addr;#endif /* CONFIG_ATA_BMDMA */ void __iomem *scr_addr;};#endif /* CONFIG_ATA_SFF */
struct ata_host { spinlock_t lock; struct device *dev; void __iomem * const *iomap; unsigned int n_ports; unsigned int n_tags; /* nr of NCQ tags */ void *private_data; struct ata_port_operations *ops; unsigned long flags; struct kref kref;
struct mutex eh_mutex; struct task_struct *eh_owner;
struct ata_port *simplex_claimed; /* channel owning the DMA */ struct ata_port *ports[];};
struct ata_queued_cmd { struct ata_port *ap; struct ata_device *dev;
struct scsi_cmnd *scsicmd; void (*scsidone)(struct scsi_cmnd *);
struct ata_taskfile tf; u8 cdb[ATAPI_CDB_LEN];
unsigned long flags; /* ATA_QCFLAG_xxx */ unsigned int tag; /* libata core tag */ unsigned int hw_tag; /* driver tag */ unsigned int n_elem; unsigned int orig_n_elem;
int dma_dir;
unsigned int sect_size;
unsigned int nbytes; unsigned int extrabytes; unsigned int curbytes;
struct scatterlist sgent;
struct scatterlist *sg;
struct scatterlist *cursg; unsigned int cursg_ofs;
unsigned int err_mask; struct ata_taskfile result_tf; ata_qc_cb_t complete_fn;
void *private_data; void *lldd_task;};
struct ata_port_stats { unsigned long unhandled_irq; unsigned long idle_irq; unsigned long rw_reqbuf;};
struct ata_ering_entry { unsigned int eflags; unsigned int err_mask; u64 timestamp;};
struct ata_ering { int cursor; struct ata_ering_entry ring[ATA_ERING_SIZE];};
struct ata_cpr { u8 num; u8 num_storage_elements; u64 start_lba; u64 num_lbas;};
struct ata_cpr_log { u8 nr_cpr; struct ata_cpr cpr[] __counted_by(nr_cpr);};
struct ata_cdl { /* * Buffer to cache the CDL log page 18h (command duration descriptors) * for SCSI-ATA translation. */ u8 desc_log_buf[ATA_LOG_CDL_SIZE];
/* * Buffer to handle reading the sense data for successful NCQ Commands * log page for commands using a CDL with one of the limits policy set * to 0xD (successful completion with sense data available bit set). */ u8 ncq_sense_log_buf[ATA_LOG_SENSE_NCQ_SIZE];};
struct ata_device { struct ata_link *link; unsigned int devno; /* 0 or 1 */ u64 quirks; /* List of broken features */ unsigned long flags; /* ATA_DFLAG_xxx */ struct scsi_device *sdev; /* attached SCSI device */ void *private_data;#ifdef CONFIG_ATA_ACPI union acpi_object *gtf_cache; unsigned int gtf_filter;#endif#ifdef CONFIG_SATA_ZPODD void *zpodd;#endif struct device tdev; /* n_sector is CLEAR_BEGIN, read comment above CLEAR_BEGIN */ u64 n_sectors; /* size of device, if ATA */ u64 n_native_sectors; /* native size, if ATA */ unsigned int class; /* ATA_DEV_xxx */ unsigned long unpark_deadline;
u8 pio_mode; u8 dma_mode; u8 xfer_mode; unsigned int xfer_shift; /* ATA_SHIFT_xxx */
unsigned int multi_count; /* sectors count for READ/WRITE MULTIPLE */ unsigned int max_sectors; /* per-device max sectors */ unsigned int cdb_len;
/* per-dev xfer mask */ unsigned int pio_mask; unsigned int mwdma_mask; unsigned int udma_mask;
/* for CHS addressing */ u16 cylinders; /* Number of cylinders */ u16 heads; /* Number of heads */ u16 sectors; /* Number of sectors per track */
union { u16 id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */ u32 gscr[SATA_PMP_GSCR_DWORDS]; /* PMP GSCR block */ } ____cacheline_aligned;
/* General Purpose Log Directory log page */ u8 gp_log_dir[ATA_SECT_SIZE] ____cacheline_aligned;
/* DEVSLP Timing Variables from Identify Device Data Log */ u8 devslp_timing[ATA_LOG_DEVSLP_SIZE];
/* NCQ send and receive log subcommand support */ u8 ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_SIZE]; u8 ncq_non_data_cmds[ATA_LOG_NCQ_NON_DATA_SIZE];
/* ZAC zone configuration */ u32 zac_zoned_cap; u32 zac_zones_optimal_open; u32 zac_zones_optimal_nonseq; u32 zac_zones_max_open;
/* Concurrent positioning ranges */ struct ata_cpr_log *cpr_log;
/* Command Duration Limits support */ struct ata_cdl *cdl;
/* error history */ int spdn_cnt; /* ering is CLEAR_END, read comment above CLEAR_END */ struct ata_ering ering;
/* For EH */ u8 sector_buf[ATA_SECT_SIZE] ____cacheline_aligned;};
/* Fields between ATA_DEVICE_CLEAR_BEGIN and ATA_DEVICE_CLEAR_END are * cleared to zero on ata_dev_init(). */#define ATA_DEVICE_CLEAR_BEGIN offsetof(struct ata_device, n_sectors)#define ATA_DEVICE_CLEAR_END offsetof(struct ata_device, ering)
struct ata_eh_info { struct ata_device *dev; /* offending device */ u32 serror; /* SError from LLDD */ unsigned int err_mask; /* port-wide err_mask */ unsigned int action; /* ATA_EH_* action mask */ unsigned int dev_action[ATA_MAX_DEVICES]; /* dev EH action */ unsigned int flags; /* ATA_EHI_* flags */
unsigned int probe_mask;
char desc[ATA_EH_DESC_LEN]; int desc_len;};
struct ata_eh_context { struct ata_eh_info i; int tries[ATA_MAX_DEVICES]; int cmd_timeout_idx[ATA_MAX_DEVICES] [ATA_EH_CMD_TIMEOUT_TABLE_SIZE]; unsigned int classes[ATA_MAX_DEVICES]; unsigned int did_probe_mask; unsigned int unloaded_mask; unsigned int saved_ncq_enabled; u8 saved_xfer_mode[ATA_MAX_DEVICES]; /* timestamp for the last reset attempt or success */ unsigned long last_reset;};
struct ata_acpi_drive{ u32 pio; u32 dma;} __packed;
struct ata_acpi_gtm { struct ata_acpi_drive drive[2]; u32 flags;} __packed;
struct ata_link { struct ata_port *ap; int pmp; /* port multiplier port # */
struct device tdev; unsigned int active_tag; /* active tag on this link */ u32 sactive; /* active NCQ commands */
unsigned int flags; /* ATA_LFLAG_xxx */
u32 saved_scontrol; /* SControl on probe */ unsigned int hw_sata_spd_limit; unsigned int sata_spd_limit; unsigned int sata_spd; /* current SATA PHY speed */ enum ata_lpm_policy lpm_policy;
struct work_struct deferred_qc_work; struct ata_queued_cmd *deferred_qc;
/* record runtime error info, protected by host_set lock */ struct ata_eh_info eh_info; /* EH context */ struct ata_eh_context eh_context;
struct ata_device device[ATA_MAX_DEVICES];
unsigned long last_lpm_change; /* when last LPM change happened */};#define ATA_LINK_CLEAR_BEGIN offsetof(struct ata_link, active_tag)#define ATA_LINK_CLEAR_END offsetof(struct ata_link, device[0])
struct ata_port { struct Scsi_Host *scsi_host; /* our co-allocated scsi host */ struct ata_port_operations *ops; spinlock_t *lock; /* Flags owned by the EH context. Only EH should touch these once the port is active */ unsigned long flags; /* ATA_FLAG_xxx */ /* Flags that change dynamically, protected by ap->lock */ unsigned int pflags; /* ATA_PFLAG_xxx */ unsigned int print_id; /* user visible unique port ID */ unsigned int port_no; /* 0 based port no. inside the host */
#ifdef CONFIG_ATA_SFF struct ata_ioports ioaddr; /* ATA cmd/ctl/dma register blocks */ u8 ctl; /* cache of ATA control register */ u8 last_ctl; /* Cache last written value */ struct ata_link* sff_pio_task_link; /* link currently used */ struct delayed_work sff_pio_task;#ifdef CONFIG_ATA_BMDMA struct ata_bmdma_prd *bmdma_prd; /* BMDMA SG list */ dma_addr_t bmdma_prd_dma; /* and its DMA mapping */#endif /* CONFIG_ATA_BMDMA */#endif /* CONFIG_ATA_SFF */
unsigned int pio_mask; unsigned int mwdma_mask; unsigned int udma_mask; unsigned int cbl; /* cable type; ATA_CBL_xxx */
struct ata_queued_cmd qcmd[ATA_MAX_QUEUE + 1]; u64 qc_active; int nr_active_links; /* #links with active qcs */
struct ata_link link; /* host default link */ struct ata_link *slave_link; /* see ata_slave_link_init() */
int nr_pmp_links; /* nr of available PMP links */ struct ata_link *pmp_link; /* array of PMP links */ struct ata_link *excl_link; /* for PMP qc exclusion */
struct ata_port_stats stats; struct ata_host *host; struct device *dev; struct device tdev;
struct mutex scsi_scan_mutex; struct delayed_work hotplug_task; struct delayed_work scsi_rescan_task;
unsigned int hsm_task_state;
struct list_head eh_done_q; wait_queue_head_t eh_wait_q; int eh_tries; struct completion park_req_pending;
pm_message_t pm_mesg; enum ata_lpm_policy target_lpm_policy;
struct timer_list fastdrain_timer; unsigned int fastdrain_cnt;
async_cookie_t cookie;
int em_message_type; void *private_data;
#ifdef CONFIG_ATA_ACPI struct ata_acpi_gtm __acpi_init_gtm; /* use ata_acpi_init_gtm() */#endif};
/* The following initializer overrides a method to NULL whether one of * its parent has the method defined or not. This is equivalent to * ERR_PTR(-ENOENT). Unfortunately, ERR_PTR doesn't render a constant * expression and thus can't be used as an initializer. */#define ATA_OP_NULL (void *)(unsigned long)(-ENOENT)
struct ata_reset_operations { ata_prereset_fn_t prereset; ata_reset_fn_t softreset; ata_reset_fn_t hardreset; ata_postreset_fn_t postreset;};
struct ata_port_operations { /* * Command execution */ int (*qc_defer)(struct ata_queued_cmd *qc); int (*check_atapi_dma)(struct ata_queued_cmd *qc); enum ata_completion_errors (*qc_prep)(struct ata_queued_cmd *qc); unsigned int (*qc_issue)(struct ata_queued_cmd *qc); void (*qc_fill_rtf)(struct ata_queued_cmd *qc); void (*qc_ncq_fill_rtf)(struct ata_port *ap, u64 done_mask);
/* * Configuration and exception handling */ int (*cable_detect)(struct ata_port *ap); unsigned int (*mode_filter)(struct ata_device *dev, unsigned int xfer_mask); void (*set_piomode)(struct ata_port *ap, struct ata_device *dev); void (*set_dmamode)(struct ata_port *ap, struct ata_device *dev); int (*set_mode)(struct ata_link *link, struct ata_device **r_failed_dev); unsigned int (*read_id)(struct ata_device *dev, struct ata_taskfile *tf, __le16 *id);
void (*dev_config)(struct ata_device *dev);
void (*freeze)(struct ata_port *ap); void (*thaw)(struct ata_port *ap); struct ata_reset_operations reset; struct ata_reset_operations pmp_reset; void (*error_handler)(struct ata_port *ap) __must_hold(&ap->host->eh_mutex); void (*lost_interrupt)(struct ata_port *ap); void (*post_internal_cmd)(struct ata_queued_cmd *qc); void (*sched_eh)(struct ata_port *ap); void (*end_eh)(struct ata_port *ap);
/* * Optional features */ int (*scr_read)(struct ata_link *link, unsigned int sc_reg, u32 *val); int (*scr_write)(struct ata_link *link, unsigned int sc_reg, u32 val); void (*pmp_attach)(struct ata_port *ap); void (*pmp_detach)(struct ata_port *ap); int (*set_lpm)(struct ata_link *link, enum ata_lpm_policy policy, unsigned hints);
/* * Start, stop, suspend and resume */ int (*port_suspend)(struct ata_port *ap, pm_message_t mesg); int (*port_resume)(struct ata_port *ap); int (*port_start)(struct ata_port *ap); void (*port_stop)(struct ata_port *ap); void (*host_stop)(struct ata_host *host);
#ifdef CONFIG_ATA_SFF /* * SFF / taskfile oriented ops */ void (*sff_dev_select)(struct ata_port *ap, unsigned int device); void (*sff_set_devctl)(struct ata_port *ap, u8 ctl); u8 (*sff_check_status)(struct ata_port *ap); u8 (*sff_check_altstatus)(struct ata_port *ap); void (*sff_tf_load)(struct ata_port *ap, const struct ata_taskfile *tf); void (*sff_tf_read)(struct ata_port *ap, struct ata_taskfile *tf); void (*sff_exec_command)(struct ata_port *ap, const struct ata_taskfile *tf); unsigned int (*sff_data_xfer)(struct ata_queued_cmd *qc, unsigned char *buf, unsigned int buflen, int rw); void (*sff_irq_on)(struct ata_port *); bool (*sff_irq_check)(struct ata_port *); void (*sff_irq_clear)(struct ata_port *); void (*sff_drain_fifo)(struct ata_queued_cmd *qc);
#ifdef CONFIG_ATA_BMDMA void (*bmdma_setup)(struct ata_queued_cmd *qc); void (*bmdma_start)(struct ata_queued_cmd *qc); void (*bmdma_stop)(struct ata_queued_cmd *qc); u8 (*bmdma_status)(struct ata_port *ap);#endif /* CONFIG_ATA_BMDMA */#endif /* CONFIG_ATA_SFF */
ssize_t (*em_show)(struct ata_port *ap, char *buf); ssize_t (*em_store)(struct ata_port *ap, const char *message, size_t size); ssize_t (*sw_activity_show)(struct ata_device *dev, char *buf); ssize_t (*sw_activity_store)(struct ata_device *dev, enum sw_activity val); ssize_t (*transmit_led_message)(struct ata_port *ap, u32 state, ssize_t size);
/* * ->inherits must be the last field and all the preceding * fields must be pointers. */ const struct ata_port_operations *inherits;};
struct ata_port_info { unsigned long flags; unsigned long link_flags; unsigned int pio_mask; unsigned int mwdma_mask; unsigned int udma_mask; struct ata_port_operations *port_ops; void *private_data;};
struct ata_timing { unsigned short mode; /* ATA mode */ unsigned short setup; /* t1 */ unsigned short act8b; /* t2 for 8-bit I/O */ unsigned short rec8b; /* t2i for 8-bit I/O */ unsigned short cyc8b; /* t0 for 8-bit I/O */ unsigned short active; /* t2 or tD */ unsigned short recover; /* t2i or tK */ unsigned short dmack_hold; /* tj */ unsigned short cycle; /* t0 */ unsigned short udma; /* t2CYCTYP/2 */};
/* * Core layer - drivers/ata/libata-core.c */extern struct ata_port_operations ata_dummy_port_ops;extern const struct ata_port_info ata_dummy_port_info;
static inline bool ata_is_atapi(u8 prot){ return prot & ATA_PROT_FLAG_ATAPI;}
static inline bool ata_is_pio(u8 prot){ return prot & ATA_PROT_FLAG_PIO;}
static inline bool ata_is_dma(u8 prot){ return prot & ATA_PROT_FLAG_DMA;}
static inline bool ata_is_ncq(u8 prot){ return prot & ATA_PROT_FLAG_NCQ;}
static inline bool ata_is_data(u8 prot){ return prot & (ATA_PROT_FLAG_PIO | ATA_PROT_FLAG_DMA);}
static inline int is_multi_taskfile(struct ata_taskfile *tf){ return (tf->command == ATA_CMD_READ_MULTI) || (tf->command == ATA_CMD_WRITE_MULTI) || (tf->command == ATA_CMD_READ_MULTI_EXT) || (tf->command == ATA_CMD_WRITE_MULTI_EXT) || (tf->command == ATA_CMD_WRITE_MULTI_FUA_EXT);}
static inline int ata_port_is_dummy(struct ata_port *ap){ return ap->ops == &ata_dummy_port_ops;}
static inline bool ata_port_is_frozen(const struct ata_port *ap){ return ap->pflags & ATA_PFLAG_FROZEN;}
extern int ata_std_prereset(struct ata_link *link, unsigned long deadline);extern int ata_wait_after_reset(struct ata_link *link, unsigned long deadline, int (*check_ready)(struct ata_link *link));extern void ata_std_postreset(struct ata_link *link, unsigned int *classes);
extern struct ata_host *ata_host_alloc(struct device *dev, int n_ports);extern struct ata_host *ata_host_alloc_pinfo(struct device *dev, const struct ata_port_info * const * ppi, int n_ports);extern void ata_host_get(struct ata_host *host);extern void ata_host_put(struct ata_host *host);extern int ata_host_start(struct ata_host *host);extern int ata_host_register(struct ata_host *host, const struct scsi_host_template *sht);extern int ata_host_activate(struct ata_host *host, int irq, irq_handler_t irq_handler, unsigned long irq_flags, const struct scsi_host_template *sht);extern void ata_host_detach(struct ata_host *host);extern void ata_host_init(struct ata_host *, struct device *, struct ata_port_operations *);extern int ata_scsi_ioctl(struct scsi_device *dev, unsigned int cmd, void __user *arg);#ifdef CONFIG_COMPAT#define ATA_SCSI_COMPAT_IOCTL .compat_ioctl = ata_scsi_ioctl,#else#define ATA_SCSI_COMPAT_IOCTL /* empty */#endifextern enum scsi_qc_status ata_scsi_queuecmd(struct Scsi_Host *h, struct scsi_cmnd *cmd);enum scsi_timeout_action ata_scsi_retry_deferred_qc(struct ata_port *ap, struct scsi_cmnd *scmd);enum scsi_timeout_action ata_scsi_eh_timed_out(struct scsi_cmnd *cmd);#if IS_REACHABLE(CONFIG_ATA)bool ata_scsi_dma_need_drain(struct request *rq);#else#define ata_scsi_dma_need_drain NULL#endifextern int ata_sas_scsi_ioctl(struct ata_port *ap, struct scsi_device *dev, unsigned int cmd, void __user *arg);extern bool ata_link_online(struct ata_link *link);extern bool ata_link_offline(struct ata_link *link);#ifdef CONFIG_PMextern void ata_host_suspend(struct ata_host *host, pm_message_t mesg);extern void ata_host_resume(struct ata_host *host);extern void ata_sas_port_suspend(struct ata_port *ap);extern void ata_sas_port_resume(struct ata_port *ap);#elsestatic inline void ata_sas_port_suspend(struct ata_port *ap){}static inline void ata_sas_port_resume(struct ata_port *ap){}#endifextern int ata_ratelimit(void);extern void ata_msleep(struct ata_port *ap, unsigned int msecs);extern u32 ata_wait_register(struct ata_port *ap, void __iomem *reg, u32 mask, u32 val, unsigned int interval, unsigned int timeout);extern int atapi_cmd_type(u8 opcode);extern unsigned int ata_pack_xfermask(unsigned int pio_mask, unsigned int mwdma_mask, unsigned int udma_mask);extern void ata_unpack_xfermask(unsigned int xfer_mask, unsigned int *pio_mask, unsigned int *mwdma_mask, unsigned int *udma_mask);extern u8 ata_xfer_mask2mode(unsigned int xfer_mask);extern unsigned int ata_xfer_mode2mask(u8 xfer_mode);extern int ata_xfer_mode2shift(u8 xfer_mode);extern const char *ata_mode_string(unsigned int xfer_mask);extern unsigned int ata_id_xfermask(const u16 *id);extern int ata_std_qc_defer(struct ata_queued_cmd *qc);extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg, unsigned int n_elem);extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);extern unsigned int ata_port_classify(struct ata_port *ap, const struct ata_taskfile *tf);extern void ata_dev_disable(struct ata_device *adev);extern void ata_id_string(const u16 *id, unsigned char *s, unsigned int ofs, unsigned int len);extern void ata_id_c_string(const u16 *id, unsigned char *s, unsigned int ofs, unsigned int len);extern unsigned int ata_do_dev_read_id(struct ata_device *dev, struct ata_taskfile *tf, __le16 *id);extern void ata_qc_complete(struct ata_queued_cmd *qc);extern u64 ata_qc_get_active(struct ata_port *ap);extern int ata_std_bios_param(struct scsi_device *sdev, struct gendisk *unused, sector_t capacity, int geom[]);extern void ata_scsi_unlock_native_capacity(struct scsi_device *sdev);extern int ata_scsi_sdev_init(struct scsi_device *sdev);int ata_scsi_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim);extern void ata_scsi_sdev_destroy(struct scsi_device *sdev);extern int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth);extern int ata_change_queue_depth(struct ata_port *ap, struct scsi_device *sdev, int queue_depth);extern int ata_ncq_prio_supported(struct ata_port *ap, struct scsi_device *sdev, bool *supported);extern int ata_ncq_prio_enabled(struct ata_port *ap, struct scsi_device *sdev, bool *enabled);extern int ata_ncq_prio_enable(struct ata_port *ap, struct scsi_device *sdev, bool enable);extern struct ata_device *ata_dev_pair(struct ata_device *adev);int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);extern void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap);int ata_scsi_cmd_error_handler(struct Scsi_Host *host, struct ata_port *ap, struct list_head *eh_q);
/* * SATA specific code - drivers/ata/libata-sata.c */#ifdef CONFIG_SATA_HOSTextern const unsigned int sata_deb_timing_normal[];extern const unsigned int sata_deb_timing_hotplug[];extern const unsigned int sata_deb_timing_long[];
static inline const unsigned int *sata_ehc_deb_timing(struct ata_eh_context *ehc){ if (ehc->i.flags & ATA_EHI_HOTPLUGGED) return sata_deb_timing_hotplug; else return sata_deb_timing_normal;}
extern int sata_scr_valid(struct ata_link *link);extern int sata_scr_read(struct ata_link *link, int reg, u32 *val);extern int sata_scr_write(struct ata_link *link, int reg, u32 val);extern int sata_scr_write_flush(struct ata_link *link, int reg, u32 val);extern int sata_set_spd(struct ata_link *link);int sata_std_hardreset(struct ata_link *link, unsigned int *class, unsigned long deadline);extern int sata_link_hardreset(struct ata_link *link, const unsigned int *timing, unsigned long deadline, bool *online, int (*check_ready)(struct ata_link *));extern int sata_link_resume(struct ata_link *link, const unsigned int *params, unsigned long deadline);extern void ata_eh_analyze_ncq_error(struct ata_link *link);#elsestatic inline const unsigned int *sata_ehc_deb_timing(struct ata_eh_context *ehc){ return NULL;}static inline int sata_scr_valid(struct ata_link *link) { return 0; }static inline int sata_scr_read(struct ata_link *link, int reg, u32 *val){ return -EOPNOTSUPP;}static inline int sata_scr_write(struct ata_link *link, int reg, u32 val){ return -EOPNOTSUPP;}static inline int sata_scr_write_flush(struct ata_link *link, int reg, u32 val){ return -EOPNOTSUPP;}static inline int sata_set_spd(struct ata_link *link) { return -EOPNOTSUPP; }static inline int sata_std_hardreset(struct ata_link *link, unsigned int *class, unsigned long deadline){ return -EOPNOTSUPP;}static inline int sata_link_hardreset(struct ata_link *link, const unsigned int *timing, unsigned long deadline, bool *online, int (*check_ready)(struct ata_link *)){ if (online) *online = false; return -EOPNOTSUPP;}static inline int sata_link_resume(struct ata_link *link, const unsigned int *params, unsigned long deadline){ return -EOPNOTSUPP;}static inline void ata_eh_analyze_ncq_error(struct ata_link *link) { }#endifextern int sata_link_debounce(struct ata_link *link, const unsigned int *params, unsigned long deadline);extern int sata_link_scr_lpm(struct ata_link *link, enum ata_lpm_policy policy, bool spm_wakeup);extern int ata_slave_link_init(struct ata_port *ap);extern void ata_port_probe(struct ata_port *ap);extern struct ata_port *ata_port_alloc(struct ata_host *host);extern void ata_port_free(struct ata_port *ap);extern int ata_tport_add(struct device *parent, struct ata_port *ap);extern void ata_tport_delete(struct ata_port *ap);int ata_sas_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim, struct ata_port *ap);extern int ata_sas_queuecmd(struct scsi_cmnd *cmd, struct ata_port *ap) __must_hold(ap->lock);extern void ata_tf_to_fis(const struct ata_taskfile *tf, u8 pmp, int is_cmd, u8 *fis);extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);extern int ata_qc_complete_multiple(struct ata_port *ap, u64 qc_active);extern bool sata_lpm_ignore_phy_events(struct ata_link *link);extern int sata_async_notification(struct ata_port *ap);
extern int ata_cable_40wire(struct ata_port *ap);extern int ata_cable_80wire(struct ata_port *ap);extern int ata_cable_sata(struct ata_port *ap);extern int ata_cable_ignore(struct ata_port *ap);extern int ata_cable_unknown(struct ata_port *ap);
/* Timing helpers */extern unsigned int ata_pio_need_iordy(const struct ata_device *);extern u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle);
/* PCI */#ifdef CONFIG_PCIstruct pci_dev;
struct pci_bits { unsigned int reg; /* PCI config register to read */ unsigned int width; /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */ unsigned long mask; unsigned long val;};
extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);extern void ata_pci_shutdown_one(struct pci_dev *pdev);extern void ata_pci_remove_one(struct pci_dev *pdev);
#ifdef CONFIG_PMextern void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg);extern int __must_check ata_pci_device_do_resume(struct pci_dev *pdev);extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);extern int ata_pci_device_resume(struct pci_dev *pdev);#endif /* CONFIG_PM */#endif /* CONFIG_PCI */
struct platform_device;
extern void ata_platform_remove_one(struct platform_device *pdev);
/* * ACPI - drivers/ata/libata-acpi.c */#ifdef CONFIG_ATA_ACPIstatic inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap){ if (ap->pflags & ATA_PFLAG_INIT_GTM_VALID) return &ap->__acpi_init_gtm; return NULL;}int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm);int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *stm);unsigned int ata_acpi_gtm_xfermask(struct ata_device *dev, const struct ata_acpi_gtm *gtm);int ata_acpi_cbl_pata_type(struct ata_port *ap);#elsestatic inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap){ return NULL;}
static inline int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm){ return -ENOSYS;}
static inline int ata_acpi_gtm(const struct ata_port *ap, struct ata_acpi_gtm *stm){ return -ENOSYS;}
static inline unsigned int ata_acpi_gtm_xfermask(struct ata_device *dev, const struct ata_acpi_gtm *gtm){ return 0;}
static inline int ata_acpi_cbl_pata_type(struct ata_port *ap){ return ATA_CBL_PATA40;}#endif
/* * EH - drivers/ata/libata-eh.c */extern void ata_port_schedule_eh(struct ata_port *ap);extern void ata_port_wait_eh(struct ata_port *ap);extern int ata_link_abort(struct ata_link *link);extern int ata_port_abort(struct ata_port *ap);extern int ata_port_freeze(struct ata_port *ap);
extern void ata_eh_freeze_port(struct ata_port *ap);extern void ata_eh_thaw_port(struct ata_port *ap);
extern void ata_std_error_handler(struct ata_port *ap) __must_hold(&ap->host->eh_mutex);extern void ata_std_sched_eh(struct ata_port *ap);extern void ata_std_end_eh(struct ata_port *ap);extern int ata_link_nr_enabled(struct ata_link *link);
/* * Base operations to inherit from and initializers for sht * * Operations * * base : Common to all libata drivers. * sata : SATA controllers w/ native interface. * pmp : SATA controllers w/ PMP support. * sff : SFF ATA controllers w/o BMDMA support. * bmdma : SFF ATA controllers w/ BMDMA support. * * sht initializers * * BASE : Common to all libata drivers. The user must set * sg_tablesize and dma_boundary. * PIO : SFF ATA controllers w/ only PIO support. * BMDMA : SFF ATA controllers w/ BMDMA support. sg_tablesize and * dma_boundary are set to BMDMA limits. * NCQ : SATA controllers supporting NCQ. The user must set * sg_tablesize, dma_boundary and can_queue. */extern const struct ata_port_operations ata_base_port_ops;extern const struct ata_port_operations sata_port_ops;extern const struct attribute_group *ata_common_sdev_groups[];
/* * All sht initializers (BASE, PIO, BMDMA, NCQ) must be instantiated * by the edge drivers. Because the 'module' field of sht must be the * edge driver's module reference, otherwise the driver can be unloaded * even if the scsi_device is being accessed. */#define __ATA_BASE_SHT(drv_name) \ .module = THIS_MODULE, \ .name = drv_name, \ .ioctl = ata_scsi_ioctl, \ ATA_SCSI_COMPAT_IOCTL \ .queuecommand = ata_scsi_queuecmd, \ .eh_timed_out = ata_scsi_eh_timed_out, \ .dma_need_drain = ata_scsi_dma_need_drain, \ .this_id = ATA_SHT_THIS_ID, \ .emulated = ATA_SHT_EMULATED, \ .proc_name = drv_name, \ .sdev_init = ata_scsi_sdev_init, \ .sdev_destroy = ata_scsi_sdev_destroy, \ .bios_param = ata_std_bios_param, \ .unlock_native_capacity = ata_scsi_unlock_native_capacity,\ .max_sectors = ATA_MAX_SECTORS_LBA48
#define ATA_SUBBASE_SHT(drv_name) \ __ATA_BASE_SHT(drv_name), \ .can_queue = ATA_DEF_QUEUE, \ .tag_alloc_policy_rr = true, \ .sdev_configure = ata_scsi_sdev_configure
#define ATA_SUBBASE_SHT_QD(drv_name, drv_qd) \ __ATA_BASE_SHT(drv_name), \ .can_queue = drv_qd, \ .tag_alloc_policy_rr = true, \ .sdev_configure = ata_scsi_sdev_configure
#define ATA_BASE_SHT(drv_name) \ ATA_SUBBASE_SHT(drv_name), \ .sdev_groups = ata_common_sdev_groups
#ifdef CONFIG_SATA_HOSTextern const struct attribute_group *ata_ncq_sdev_groups[];
#define ATA_NCQ_SHT(drv_name) \ ATA_SUBBASE_SHT(drv_name), \ .sdev_groups = ata_ncq_sdev_groups, \ .change_queue_depth = ata_scsi_change_queue_depth
#define ATA_NCQ_SHT_QD(drv_name, drv_qd) \ ATA_SUBBASE_SHT_QD(drv_name, drv_qd), \ .sdev_groups = ata_ncq_sdev_groups, \ .change_queue_depth = ata_scsi_change_queue_depth#endif
/* * PMP helpers */#ifdef CONFIG_SATA_PMPstatic inline bool sata_pmp_supported(struct ata_port *ap){ return ap->flags & ATA_FLAG_PMP;}
static inline bool sata_pmp_attached(struct ata_port *ap){ return ap->nr_pmp_links != 0;}
static inline bool ata_is_host_link(const struct ata_link *link){ return link == &link->ap->link || link == link->ap->slave_link;}#else /* CONFIG_SATA_PMP */static inline bool sata_pmp_supported(struct ata_port *ap){ return false;}
static inline bool sata_pmp_attached(struct ata_port *ap){ return false;}
static inline bool ata_is_host_link(const struct ata_link *link){ return true;}#endif /* CONFIG_SATA_PMP */
static inline int sata_srst_pmp(struct ata_link *link){ if (sata_pmp_supported(link->ap) && ata_is_host_link(link)) return SATA_PMP_CTRL_PORT; return link->pmp;}
#define ata_port_printk(level, ap, fmt, ...) \ pr_ ## level ("ata%u: " fmt, (ap)->print_id, ##__VA_ARGS__)
#define ata_port_err(ap, fmt, ...) \ ata_port_printk(err, ap, fmt, ##__VA_ARGS__)#define ata_port_warn(ap, fmt, ...) \ ata_port_printk(warn, ap, fmt, ##__VA_ARGS__)#define ata_port_notice(ap, fmt, ...) \ ata_port_printk(notice, ap, fmt, ##__VA_ARGS__)#define ata_port_info(ap, fmt, ...) \ ata_port_printk(info, ap, fmt, ##__VA_ARGS__)#define ata_port_dbg(ap, fmt, ...) \ ata_port_printk(debug, ap, fmt, ##__VA_ARGS__)
#define ata_link_printk(level, link, fmt, ...) \do { \ if (sata_pmp_attached((link)->ap) || \ (link)->ap->slave_link) \ pr_ ## level ("ata%u.%02u: " fmt, \ (link)->ap->print_id, \ (link)->pmp, \ ##__VA_ARGS__); \ else \ pr_ ## level ("ata%u: " fmt, \ (link)->ap->print_id, \ ##__VA_ARGS__); \} while (0)
#define ata_link_err(link, fmt, ...) \ ata_link_printk(err, link, fmt, ##__VA_ARGS__)#define ata_link_warn(link, fmt, ...) \ ata_link_printk(warn, link, fmt, ##__VA_ARGS__)#define ata_link_notice(link, fmt, ...) \ ata_link_printk(notice, link, fmt, ##__VA_ARGS__)#define ata_link_info(link, fmt, ...) \ ata_link_printk(info, link, fmt, ##__VA_ARGS__)#define ata_link_dbg(link, fmt, ...) \ ata_link_printk(debug, link, fmt, ##__VA_ARGS__)
#define ata_dev_printk(level, dev, fmt, ...) \ pr_ ## level("ata%u.%02u: " fmt, \ (dev)->link->ap->print_id, \ (dev)->link->pmp + (dev)->devno, \ ##__VA_ARGS__)
#define ata_dev_err(dev, fmt, ...) \ ata_dev_printk(err, dev, fmt, ##__VA_ARGS__)#define ata_dev_warn(dev, fmt, ...) \ ata_dev_printk(warn, dev, fmt, ##__VA_ARGS__)#define ata_dev_notice(dev, fmt, ...) \ ata_dev_printk(notice, dev, fmt, ##__VA_ARGS__)#define ata_dev_info(dev, fmt, ...) \ ata_dev_printk(info, dev, fmt, ##__VA_ARGS__)#define ata_dev_dbg(dev, fmt, ...) \ ata_dev_printk(debug, dev, fmt, ##__VA_ARGS__)
#define ata_dev_warn_once(dev, fmt, ...) \ pr_warn_once("ata%u.%02u: " fmt, \ (dev)->link->ap->print_id, \ (dev)->link->pmp + (dev)->devno, \ ##__VA_ARGS__)
static inline void ata_print_version_once(const struct device *dev, const char *version){ dev_dbg_once(dev, "version %s\n", version);}
/* * ata_eh_info helpers */extern __printf(2, 3)void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);extern __printf(2, 3)void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);extern void ata_ehi_clear_desc(struct ata_eh_info *ehi);
static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi){ ehi->probe_mask |= (1 << ATA_MAX_DEVICES) - 1; ehi->flags |= ATA_EHI_HOTPLUGGED; ehi->action |= ATA_EH_RESET | ATA_EH_ENABLE_LINK; ehi->err_mask |= AC_ERR_ATA_BUS;}
/* * port description helpers */extern __printf(2, 3)void ata_port_desc(struct ata_port *ap, const char *fmt, ...);#ifdef CONFIG_PCIextern void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset, const char *name);#endifstatic inline void ata_port_desc_misc(struct ata_port *ap, int irq){ ata_port_desc(ap, "irq %d", irq); ata_port_desc(ap, "lpm-pol %d", ap->target_lpm_policy); if (ap->pflags & ATA_PFLAG_EXTERNAL) ata_port_desc(ap, "ext");}
static inline bool ata_tag_internal(unsigned int tag){ return tag == ATA_TAG_INTERNAL;}
static inline bool ata_tag_valid(unsigned int tag){ return tag < ATA_MAX_QUEUE || ata_tag_internal(tag);}
#define __ata_qc_for_each(ap, qc, tag, max_tag, fn) \ for ((tag) = 0; (tag) < (max_tag) && \ ({ qc = fn((ap), (tag)); 1; }); (tag)++) \
/* * Internal use only, iterate commands ignoring error handling and * status of 'qc'. */#define ata_qc_for_each_raw(ap, qc, tag) \ __ata_qc_for_each(ap, qc, tag, ATA_MAX_QUEUE, __ata_qc_from_tag)
/* * Iterate all potential commands that can be queued */#define ata_qc_for_each(ap, qc, tag) \ __ata_qc_for_each(ap, qc, tag, ATA_MAX_QUEUE, ata_qc_from_tag)
/* * Like ata_qc_for_each, but with the internal tag included */#define ata_qc_for_each_with_internal(ap, qc, tag) \ __ata_qc_for_each(ap, qc, tag, ATA_MAX_QUEUE + 1, ata_qc_from_tag)
/* * device helpers */static inline unsigned int ata_class_enabled(unsigned int class){ return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI || class == ATA_DEV_PMP || class == ATA_DEV_SEMB || class == ATA_DEV_ZAC;}
static inline unsigned int ata_class_disabled(unsigned int class){ return class == ATA_DEV_ATA_UNSUP || class == ATA_DEV_ATAPI_UNSUP || class == ATA_DEV_PMP_UNSUP || class == ATA_DEV_SEMB_UNSUP || class == ATA_DEV_ZAC_UNSUP;}
static inline unsigned int ata_class_absent(unsigned int class){ return !ata_class_enabled(class) && !ata_class_disabled(class);}
static inline unsigned int ata_dev_enabled(const struct ata_device *dev){ return ata_class_enabled(dev->class);}
static inline unsigned int ata_dev_disabled(const struct ata_device *dev){ return ata_class_disabled(dev->class);}
static inline unsigned int ata_dev_absent(const struct ata_device *dev){ return ata_class_absent(dev->class);}
/* * link helpers */static inline int ata_link_max_devices(const struct ata_link *link){ if (ata_is_host_link(link) && link->ap->flags & ATA_FLAG_SLAVE_POSS) return 2; return 1;}
static inline int ata_link_active(struct ata_link *link){ return ata_tag_valid(link->active_tag) || link->sactive;}
/* * Iterators * * ATA_LITER_* constants are used to select link iteration mode and * ATA_DITER_* device iteration mode. * * For a custom iteration directly using ata_{link|dev}_next(), if * @link or @dev, respectively, is NULL, the first element is * returned. @dev and @link can be any valid device or link and the * next element according to the iteration mode will be returned. * After the last element, NULL is returned. */enum ata_link_iter_mode { ATA_LITER_EDGE, /* if present, PMP links only; otherwise, * host link. no slave link */ ATA_LITER_HOST_FIRST, /* host link followed by PMP or slave links */ ATA_LITER_PMP_FIRST, /* PMP links followed by host link, * slave link still comes after host link */};
enum ata_dev_iter_mode { ATA_DITER_ENABLED, ATA_DITER_ENABLED_REVERSE, ATA_DITER_ALL, ATA_DITER_ALL_REVERSE,};
extern struct ata_link *ata_link_next(struct ata_link *link, struct ata_port *ap, enum ata_link_iter_mode mode);
extern struct ata_device *ata_dev_next(struct ata_device *dev, struct ata_link *link, enum ata_dev_iter_mode mode);
/* * Shortcut notation for iterations * * ata_for_each_link() iterates over each link of @ap according to * @mode. @link points to the current link in the loop. @link is * NULL after loop termination. ata_for_each_dev() works the same way * except that it iterates over each device of @link. * * Note that the mode prefixes ATA_{L|D}ITER_ shouldn't need to be * specified when using the following shorthand notations. Only the * mode itself (EDGE, HOST_FIRST, ENABLED, etc...) should be * specified. This not only increases brevity but also makes it * impossible to use ATA_LITER_* for device iteration or vice-versa. */#define ata_for_each_link(link, ap, mode) \ for ((link) = ata_link_next(NULL, (ap), ATA_LITER_##mode); (link); \ (link) = ata_link_next((link), (ap), ATA_LITER_##mode))
#define ata_for_each_dev(dev, link, mode) \ for ((dev) = ata_dev_next(NULL, (link), ATA_DITER_##mode); (dev); \ (dev) = ata_dev_next((dev), (link), ATA_DITER_##mode))
/** * ata_ncq_supported - Test whether NCQ is supported * @dev: ATA device to test * * LOCKING: * spin_lock_irqsave(host lock) * * RETURNS: * true if @dev supports NCQ, false otherwise. */static inline bool ata_ncq_supported(struct ata_device *dev){ if (!IS_ENABLED(CONFIG_SATA_HOST)) return false; return (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ)) == ATA_DFLAG_NCQ;}
/** * ata_ncq_enabled - Test whether NCQ is enabled * @dev: ATA device to test * * LOCKING: * spin_lock_irqsave(host lock) * * RETURNS: * true if NCQ is enabled for @dev, false otherwise. */static inline bool ata_ncq_enabled(struct ata_device *dev){ return ata_ncq_supported(dev) && !(dev->flags & ATA_DFLAG_NCQ_OFF);}
static inline bool ata_fpdma_dsm_supported(struct ata_device *dev){ return (dev->flags & ATA_DFLAG_NCQ_SEND_RECV) && (dev->ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET] & ATA_LOG_NCQ_SEND_RECV_DSM_TRIM);}
static inline bool ata_fpdma_read_log_supported(struct ata_device *dev){ return (dev->flags & ATA_DFLAG_NCQ_SEND_RECV) && (dev->ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_RD_LOG_OFFSET] & ATA_LOG_NCQ_SEND_RECV_RD_LOG_SUPPORTED);}
static inline bool ata_fpdma_zac_mgmt_in_supported(struct ata_device *dev){ return (dev->flags & ATA_DFLAG_NCQ_SEND_RECV) && (dev->ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_ZAC_MGMT_OFFSET] & ATA_LOG_NCQ_SEND_RECV_ZAC_MGMT_IN_SUPPORTED);}
static inline bool ata_fpdma_zac_mgmt_out_supported(struct ata_device *dev){ return (dev->ncq_non_data_cmds[ATA_LOG_NCQ_NON_DATA_ZAC_MGMT_OFFSET] & ATA_LOG_NCQ_NON_DATA_ZAC_MGMT_OUT);}
static inline void ata_qc_set_polling(struct ata_queued_cmd *qc){ qc->tf.ctl |= ATA_NIEN;}
static inline struct ata_queued_cmd *__ata_qc_from_tag(struct ata_port *ap, unsigned int tag){ if (ata_tag_valid(tag)) return &ap->qcmd[tag]; return NULL;}
static inline struct ata_queued_cmd *ata_qc_from_tag(struct ata_port *ap, unsigned int tag){ struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
if (unlikely(!qc)) return qc;
if ((qc->flags & (ATA_QCFLAG_ACTIVE | ATA_QCFLAG_EH)) == ATA_QCFLAG_ACTIVE) return qc;
return NULL;}
static inline unsigned int ata_qc_raw_nbytes(struct ata_queued_cmd *qc){ return qc->nbytes - min(qc->extrabytes, qc->nbytes);}
static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf){ memset(tf, 0, sizeof(*tf));
#ifdef CONFIG_ATA_SFF tf->ctl = dev->link->ap->ctl;#else tf->ctl = ATA_DEVCTL_OBS;#endif if (dev->devno == 0) tf->device = ATA_DEVICE_OBS; else tf->device = ATA_DEVICE_OBS | ATA_DEV1;}
static inline void ata_qc_reinit(struct ata_queued_cmd *qc){ qc->dma_dir = DMA_NONE; qc->sg = NULL; qc->flags = 0; qc->cursg = NULL; qc->cursg_ofs = 0; qc->nbytes = qc->extrabytes = qc->curbytes = 0; qc->n_elem = 0; qc->err_mask = 0; qc->sect_size = ATA_SECT_SIZE;
ata_tf_init(qc->dev, &qc->tf);
/* init result_tf such that it indicates normal completion */ qc->result_tf.command = ATA_DRDY; qc->result_tf.feature = 0;}
static inline int ata_try_flush_cache(const struct ata_device *dev){ return ata_id_wcache_enabled(dev->id) || ata_id_has_flush(dev->id) || ata_id_has_flush_ext(dev->id);}
static inline unsigned int ac_err_mask(u8 status){ if (status & (ATA_BUSY | ATA_DRQ)) return AC_ERR_HSM; if (status & (ATA_ERR | ATA_DF)) return AC_ERR_DEV; return 0;}
static inline unsigned int __ac_err_mask(u8 status){ unsigned int mask = ac_err_mask(status); if (mask == 0) return AC_ERR_OTHER; return mask;}
static inline struct ata_port *ata_shost_to_port(struct Scsi_Host *host){ return *(struct ata_port **)&host->hostdata[0];}
static inline int ata_check_ready(u8 status){ if (!(status & ATA_BUSY)) return 1;
/* 0xff indicates either no device or device not ready */ if (status == 0xff) return -ENODEV;
return 0;}
static inline unsigned long ata_deadline(unsigned long from_jiffies, unsigned int timeout_msecs){ return from_jiffies + msecs_to_jiffies(timeout_msecs);}
/* Don't open code these in drivers as there are traps. Firstly the range may change in future hardware and specs, secondly 0xFF means 'no DMA' but is > UDMA_0. Dyma ddreigiau */
static inline bool ata_using_mwdma(struct ata_device *adev){ return adev->dma_mode >= XFER_MW_DMA_0 && adev->dma_mode <= XFER_MW_DMA_4;}
static inline bool ata_using_udma(struct ata_device *adev){ return adev->dma_mode >= XFER_UDMA_0 && adev->dma_mode <= XFER_UDMA_7;}
static inline bool ata_dma_enabled(struct ata_device *adev){ return adev->dma_mode != 0xFF;}
/************************************************************************** * PATA timings - drivers/ata/libata-pata-timings.c */extern const struct ata_timing *ata_timing_find_mode(u8 xfer_mode);extern int ata_timing_compute(struct ata_device *, unsigned short, struct ata_timing *, int, int);extern void ata_timing_merge(const struct ata_timing *, const struct ata_timing *, struct ata_timing *, unsigned int);
/************************************************************************** * PMP - drivers/ata/libata-pmp.c */#ifdef CONFIG_SATA_PMP
extern const struct ata_port_operations sata_pmp_port_ops;
extern int sata_pmp_qc_defer_cmd_switch(struct ata_queued_cmd *qc);extern void sata_pmp_error_handler(struct ata_port *ap) __must_hold(&ap->host->eh_mutex);
#else /* CONFIG_SATA_PMP */
#define sata_pmp_port_ops sata_port_ops#define sata_pmp_qc_defer_cmd_switch ata_std_qc_defer#define sata_pmp_error_handler ata_std_error_handler
#endif /* CONFIG_SATA_PMP */
/************************************************************************** * SFF - drivers/ata/libata-sff.c */#ifdef CONFIG_ATA_SFF
extern const struct ata_port_operations ata_sff_port_ops;extern const struct ata_port_operations ata_bmdma32_port_ops;
/* PIO only, sg_tablesize and dma_boundary limits can be removed */#define ATA_PIO_SHT(drv_name) \ ATA_BASE_SHT(drv_name), \ .sg_tablesize = LIBATA_MAX_PRD, \ .dma_boundary = ATA_DMA_BOUNDARY
extern void ata_sff_dev_select(struct ata_port *ap, unsigned int device);extern u8 ata_sff_check_status(struct ata_port *ap);extern void ata_sff_pause(struct ata_port *ap);extern void ata_sff_dma_pause(struct ata_port *ap);extern int ata_sff_wait_ready(struct ata_link *link, unsigned long deadline);extern void ata_sff_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);extern void ata_sff_tf_read(struct ata_port *ap, struct ata_taskfile *tf);extern void ata_sff_exec_command(struct ata_port *ap, const struct ata_taskfile *tf);extern unsigned int ata_sff_data_xfer(struct ata_queued_cmd *qc, unsigned char *buf, unsigned int buflen, int rw);extern unsigned int ata_sff_data_xfer32(struct ata_queued_cmd *qc, unsigned char *buf, unsigned int buflen, int rw);extern void ata_sff_irq_on(struct ata_port *ap);extern int ata_sff_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc, u8 status, int in_wq);extern void ata_sff_queue_work(struct work_struct *work);extern void ata_sff_queue_delayed_work(struct delayed_work *dwork, unsigned long delay);extern void ata_sff_queue_pio_task(struct ata_link *link, unsigned long delay);extern unsigned int ata_sff_qc_issue(struct ata_queued_cmd *qc);extern void ata_sff_qc_fill_rtf(struct ata_queued_cmd *qc);extern unsigned int ata_sff_port_intr(struct ata_port *ap, struct ata_queued_cmd *qc);extern irqreturn_t ata_sff_interrupt(int irq, void *dev_instance);extern void ata_sff_lost_interrupt(struct ata_port *ap);extern void ata_sff_freeze(struct ata_port *ap);extern void ata_sff_thaw(struct ata_port *ap);extern int ata_sff_prereset(struct ata_link *link, unsigned long deadline);extern unsigned int ata_sff_dev_classify(struct ata_device *dev, int present, u8 *r_err);extern int ata_sff_wait_after_reset(struct ata_link *link, unsigned int devmask, unsigned long deadline);extern int ata_sff_softreset(struct ata_link *link, unsigned int *classes, unsigned long deadline);extern int sata_sff_hardreset(struct ata_link *link, unsigned int *class, unsigned long deadline);extern void ata_sff_postreset(struct ata_link *link, unsigned int *classes);extern void ata_sff_drain_fifo(struct ata_queued_cmd *qc);extern void ata_sff_error_handler(struct ata_port *ap) __must_hold(&ap->host->eh_mutex);extern void ata_sff_std_ports(struct ata_ioports *ioaddr);#ifdef CONFIG_PCIextern int ata_pci_sff_init_host(struct ata_host *host);extern int ata_pci_sff_prepare_host(struct pci_dev *pdev, const struct ata_port_info * const * ppi, struct ata_host **r_host);extern int ata_pci_sff_activate_host(struct ata_host *host, irq_handler_t irq_handler, const struct scsi_host_template *sht);extern int ata_pci_sff_init_one(struct pci_dev *pdev, const struct ata_port_info * const * ppi, const struct scsi_host_template *sht, void *host_priv, int hflags);#endif /* CONFIG_PCI */
#ifdef CONFIG_ATA_BMDMA
extern const struct ata_port_operations ata_bmdma_port_ops;
#define ATA_BMDMA_SHT(drv_name) \ ATA_BASE_SHT(drv_name), \ .sg_tablesize = LIBATA_MAX_PRD, \ .dma_boundary = ATA_DMA_BOUNDARY
extern enum ata_completion_errors ata_bmdma_qc_prep(struct ata_queued_cmd *qc);extern unsigned int ata_bmdma_qc_issue(struct ata_queued_cmd *qc);extern enum ata_completion_errors ata_bmdma_dumb_qc_prep(struct ata_queued_cmd *qc);extern unsigned int ata_bmdma_port_intr(struct ata_port *ap, struct ata_queued_cmd *qc);extern irqreturn_t ata_bmdma_interrupt(int irq, void *dev_instance);extern void ata_bmdma_error_handler(struct ata_port *ap) __must_hold(&ap->host->eh_mutex);extern void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc);extern void ata_bmdma_irq_clear(struct ata_port *ap);extern void ata_bmdma_setup(struct ata_queued_cmd *qc);extern void ata_bmdma_start(struct ata_queued_cmd *qc);extern void ata_bmdma_stop(struct ata_queued_cmd *qc);extern u8 ata_bmdma_status(struct ata_port *ap);extern int ata_bmdma_port_start(struct ata_port *ap);extern int ata_bmdma_port_start32(struct ata_port *ap);
#ifdef CONFIG_PCIextern int ata_pci_bmdma_clear_simplex(struct pci_dev *pdev);extern void ata_pci_bmdma_init(struct ata_host *host);extern int ata_pci_bmdma_prepare_host(struct pci_dev *pdev, const struct ata_port_info * const * ppi, struct ata_host **r_host);extern int ata_pci_bmdma_init_one(struct pci_dev *pdev, const struct ata_port_info * const * ppi, const struct scsi_host_template *sht, void *host_priv, int hflags);#endif /* CONFIG_PCI */#endif /* CONFIG_ATA_BMDMA */
/** * ata_sff_busy_wait - Wait for a port status register * @ap: Port to wait for. * @bits: bits that must be clear * @max: number of 10uS waits to perform * * Waits up to max*10 microseconds for the selected bits in the port's * status register to be cleared. * Returns final value of status register. * * LOCKING: * Inherited from caller. */static inline u8 ata_sff_busy_wait(struct ata_port *ap, unsigned int bits, unsigned int max){ u8 status;
do { udelay(10); status = ap->ops->sff_check_status(ap); max--; } while (status != 0xff && (status & bits) && (max > 0));
return status;}
/** * ata_wait_idle - Wait for a port to be idle. * @ap: Port to wait for. * * Waits up to 10ms for port's BUSY and DRQ signals to clear. * Returns final value of status register. * * LOCKING: * Inherited from caller. */static inline u8 ata_wait_idle(struct ata_port *ap){ u8 status = ata_sff_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
if (status != 0xff && (status & (ATA_BUSY | ATA_DRQ))) ata_port_dbg(ap, "abnormal Status 0x%X\n", status);
return status;}#else /* CONFIG_ATA_SFF */static inline int sata_sff_hardreset(struct ata_link *link, unsigned int *class, unsigned long deadline){ return -EOPNOTSUPP;}#endif /* CONFIG_ATA_SFF */
#endif /* __LINUX_LIBATA_H__ */