760 lines · c
1/* SPDX-License-Identifier: GPL-2.0-only */2/*3 * SAS host prototypes and structures header file4 *5 * Copyright (C) 2005 Adaptec, Inc. All rights reserved.6 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>7 */8 9#ifndef _LIBSAS_H_10#define _LIBSAS_H_11 12 13#include <linux/timer.h>14#include <linux/pci.h>15#include <scsi/sas.h>16#include <linux/libata.h>17#include <linux/list.h>18#include <scsi/scsi_device.h>19#include <scsi/scsi_cmnd.h>20#include <scsi/scsi_transport_sas.h>21#include <linux/scatterlist.h>22#include <linux/slab.h>23 24struct block_device;25 26enum sas_phy_role {27 PHY_ROLE_NONE = 0,28 PHY_ROLE_TARGET = 0x40,29 PHY_ROLE_INITIATOR = 0x80,30};31 32/* The events are mnemonically described in sas_dump.c33 * so when updating/adding events here, please also34 * update the other file too.35 */36enum port_event {37 PORTE_BYTES_DMAED = 0U,38 PORTE_BROADCAST_RCVD,39 PORTE_LINK_RESET_ERR,40 PORTE_TIMER_EVENT,41 PORTE_HARD_RESET,42 PORT_NUM_EVENTS,43};44 45enum phy_event {46 PHYE_LOSS_OF_SIGNAL = 0U,47 PHYE_OOB_DONE,48 PHYE_OOB_ERROR,49 PHYE_SPINUP_HOLD, /* hot plug SATA, no COMWAKE sent */50 PHYE_RESUME_TIMEOUT,51 PHYE_SHUTDOWN,52 PHY_NUM_EVENTS,53};54 55enum discover_event {56 DISCE_DISCOVER_DOMAIN = 0U,57 DISCE_REVALIDATE_DOMAIN,58 DISCE_SUSPEND,59 DISCE_RESUME,60 DISC_NUM_EVENTS,61};62 63/* ---------- Expander Devices ---------- */64 65#define to_dom_device(_obj) container_of(_obj, struct domain_device, dev_obj)66#define to_dev_attr(_attr) container_of(_attr, struct domain_dev_attribute,\67 attr)68 69enum routing_attribute {70 DIRECT_ROUTING,71 SUBTRACTIVE_ROUTING,72 TABLE_ROUTING,73};74 75enum ex_phy_state {76 PHY_EMPTY,77 PHY_VACANT,78 PHY_NOT_PRESENT,79 PHY_DEVICE_DISCOVERED80};81 82struct ex_phy {83 int phy_id;84 85 enum ex_phy_state phy_state;86 87 enum sas_device_type attached_dev_type;88 enum sas_linkrate linkrate;89 90 u8 attached_sata_host:1;91 u8 attached_sata_dev:1;92 u8 attached_sata_ps:1;93 94 enum sas_protocol attached_tproto;95 enum sas_protocol attached_iproto;96 97 u8 attached_sas_addr[SAS_ADDR_SIZE];98 u8 attached_phy_id;99 100 int phy_change_count;101 enum routing_attribute routing_attr;102 u8 virtual:1;103 104 int last_da_index;105 106 struct sas_phy *phy;107 struct sas_port *port;108};109 110struct expander_device {111 struct list_head children;112 113 int ex_change_count;114 u16 max_route_indexes;115 u8 num_phys;116 117 u8 t2t_supp:1;118 u8 configuring:1;119 u8 conf_route_table:1;120 121 u8 enclosure_logical_id[8];122 123 struct ex_phy *ex_phy;124 struct sas_port *parent_port;125 126 struct mutex cmd_mutex;127};128 129/* ---------- SATA device ---------- */130#define ATA_RESP_FIS_SIZE 24131 132struct sata_device {133 unsigned int class;134 u8 port_no; /* port number, if this is a PM (Port) */135 136 struct ata_port *ap;137 struct ata_host *ata_host;138 struct smp_rps_resp rps_resp ____cacheline_aligned; /* report_phy_sata_resp */139 u8 fis[ATA_RESP_FIS_SIZE];140};141 142struct ssp_device {143 struct list_head eh_list_node; /* pending a user requested eh action */144 struct scsi_lun reset_lun;145};146 147enum {148 SAS_DEV_GONE,149 SAS_DEV_FOUND, /* device notified to lldd */150 SAS_DEV_DESTROY,151 SAS_DEV_EH_PENDING,152 SAS_DEV_LU_RESET,153 SAS_DEV_RESET,154};155 156struct domain_device {157 spinlock_t done_lock;158 enum sas_device_type dev_type;159 160 enum sas_linkrate linkrate;161 enum sas_linkrate min_linkrate;162 enum sas_linkrate max_linkrate;163 164 int pathways;165 166 struct domain_device *parent;167 struct list_head siblings; /* devices on the same level */168 struct asd_sas_port *port; /* shortcut to root of the tree */169 struct sas_phy *phy;170 171 struct list_head dev_list_node;172 struct list_head disco_list_node; /* awaiting probe or destruct */173 174 enum sas_protocol iproto;175 enum sas_protocol tproto;176 177 struct sas_rphy *rphy;178 179 u8 sas_addr[SAS_ADDR_SIZE];180 u8 hashed_sas_addr[HASHED_SAS_ADDR_SIZE];181 182 u8 frame_rcvd[32];183 184 union {185 struct expander_device ex_dev;186 struct sata_device sata_dev; /* STP & directly attached */187 struct ssp_device ssp_dev;188 };189 190 void *lldd_dev;191 unsigned long state;192 struct kref kref;193};194 195struct sas_work {196 struct list_head drain_node;197 struct work_struct work;198};199 200static inline bool dev_is_expander(enum sas_device_type type)201{202 return type == SAS_EDGE_EXPANDER_DEVICE ||203 type == SAS_FANOUT_EXPANDER_DEVICE;204}205 206static inline void INIT_SAS_WORK(struct sas_work *sw, void (*fn)(struct work_struct *))207{208 INIT_WORK(&sw->work, fn);209 INIT_LIST_HEAD(&sw->drain_node);210}211 212struct sas_discovery_event {213 struct sas_work work;214 struct asd_sas_port *port;215};216 217static inline struct sas_discovery_event *to_sas_discovery_event(struct work_struct *work)218{219 struct sas_discovery_event *ev = container_of(work, typeof(*ev), work.work);220 221 return ev;222}223 224struct sas_discovery {225 struct sas_discovery_event disc_work[DISC_NUM_EVENTS];226 unsigned long pending;227 u8 fanout_sas_addr[SAS_ADDR_SIZE];228 u8 eeds_a[SAS_ADDR_SIZE];229 u8 eeds_b[SAS_ADDR_SIZE];230 int max_level;231};232 233/* The port struct is Class:RW, driver:RO */234struct asd_sas_port {235/* private: */236 struct sas_discovery disc;237 struct domain_device *port_dev;238 spinlock_t dev_list_lock;239 struct list_head dev_list;240 struct list_head disco_list;241 struct list_head destroy_list;242 struct list_head sas_port_del_list;243 enum sas_linkrate linkrate;244 245 struct sas_work work;246 int suspended;247 248/* public: */249 int id;250 251 u8 sas_addr[SAS_ADDR_SIZE];252 u8 attached_sas_addr[SAS_ADDR_SIZE];253 enum sas_protocol iproto;254 enum sas_protocol tproto;255 256 enum sas_oob_mode oob_mode;257 258 spinlock_t phy_list_lock;259 struct list_head phy_list;260 int num_phys;261 u32 phy_mask;262 263 struct sas_ha_struct *ha;264 265 struct sas_port *port;266 267 void *lldd_port; /* not touched by the sas class code */268};269 270struct asd_sas_event {271 struct sas_work work;272 struct asd_sas_phy *phy;273 int event;274};275 276static inline struct asd_sas_event *to_asd_sas_event(struct work_struct *work)277{278 struct asd_sas_event *ev = container_of(work, typeof(*ev), work.work);279 280 return ev;281}282 283static inline void INIT_SAS_EVENT(struct asd_sas_event *ev,284 void (*fn)(struct work_struct *),285 struct asd_sas_phy *phy, int event)286{287 INIT_SAS_WORK(&ev->work, fn);288 ev->phy = phy;289 ev->event = event;290}291 292#define SAS_PHY_SHUTDOWN_THRES 1024293 294/* The phy pretty much is controlled by the LLDD.295 * The class only reads those fields.296 */297struct asd_sas_phy {298/* private: */299 atomic_t event_nr;300 int in_shutdown;301 int error;302 int suspended;303 304 struct sas_phy *phy;305 306/* public: */307 /* The following are class:RO, driver:R/W */308 int enabled; /* must be set */309 310 int id; /* must be set */311 enum sas_protocol iproto;312 enum sas_protocol tproto;313 314 enum sas_phy_role role;315 enum sas_oob_mode oob_mode;316 enum sas_linkrate linkrate;317 318 u8 *sas_addr; /* must be set */319 u8 attached_sas_addr[SAS_ADDR_SIZE]; /* class:RO, driver: R/W */320 321 spinlock_t frame_rcvd_lock;322 u8 *frame_rcvd; /* must be set */323 int frame_rcvd_size;324 325 spinlock_t sas_prim_lock;326 u32 sas_prim;327 328 struct list_head port_phy_el; /* driver:RO */329 struct asd_sas_port *port; /* Class:RW, driver: RO */330 331 struct sas_ha_struct *ha; /* may be set; the class sets it anyway */332 333 void *lldd_phy; /* not touched by the sas_class_code */334};335 336enum sas_ha_state {337 SAS_HA_REGISTERED,338 SAS_HA_DRAINING,339 SAS_HA_ATA_EH_ACTIVE,340 SAS_HA_FROZEN,341 SAS_HA_RESUMING,342};343 344struct sas_ha_struct {345/* private: */346 struct list_head defer_q; /* work queued while draining */347 struct mutex drain_mutex;348 unsigned long state;349 spinlock_t lock;350 int eh_active;351 wait_queue_head_t eh_wait_q;352 struct list_head eh_dev_q;353 354 struct mutex disco_mutex;355 356 struct Scsi_Host *shost;357 358/* public: */359 char *sas_ha_name;360 struct device *dev; /* should be set */361 362 struct workqueue_struct *event_q;363 struct workqueue_struct *disco_q;364 365 u8 *sas_addr; /* must be set */366 u8 hashed_sas_addr[HASHED_SAS_ADDR_SIZE];367 368 spinlock_t phy_port_lock;369 struct asd_sas_phy **sas_phy; /* array of valid pointers, must be set */370 struct asd_sas_port **sas_port; /* array of valid pointers, must be set */371 int num_phys; /* must be set, gt 0, static */372 373 int strict_wide_ports; /* both sas_addr and attached_sas_addr must match374 * their siblings when forming wide ports */375 376 void *lldd_ha; /* not touched by sas class code */377 378 struct list_head eh_done_q; /* complete via scsi_eh_flush_done_q */379 struct list_head eh_ata_q; /* scmds to promote from sas to ata eh */380 381 int event_thres;382};383 384#define SHOST_TO_SAS_HA(_shost) (*(struct sas_ha_struct **)(_shost)->hostdata)385 386static inline struct domain_device *387starget_to_domain_dev(struct scsi_target *starget) {388 return starget->hostdata;389}390 391static inline struct domain_device *392sdev_to_domain_dev(struct scsi_device *sdev) {393 return starget_to_domain_dev(sdev->sdev_target);394}395 396static inline struct ata_device *sas_to_ata_dev(struct domain_device *dev)397{398 return &dev->sata_dev.ap->link.device[0];399}400 401static inline struct domain_device *402cmd_to_domain_dev(struct scsi_cmnd *cmd)403{404 return sdev_to_domain_dev(cmd->device);405}406 407/* Before calling a notify event, LLDD should use this function408 * when the link is severed (possibly from its tasklet).409 * The idea is that the Class only reads those, while the LLDD,410 * can R/W these (thus avoiding a race).411 */412static inline void sas_phy_disconnected(struct asd_sas_phy *phy)413{414 phy->oob_mode = OOB_NOT_CONNECTED;415 phy->linkrate = SAS_LINK_RATE_UNKNOWN;416}417 418static inline unsigned int to_sas_gpio_od(int device, int bit)419{420 return 3 * device + bit;421}422 423static inline void sas_put_local_phy(struct sas_phy *phy)424{425 put_device(&phy->dev);426}427 428#ifdef CONFIG_SCSI_SAS_HOST_SMP429int try_test_sas_gpio_gp_bit(unsigned int od, u8 *data, u8 index, u8 count);430#else431static inline int try_test_sas_gpio_gp_bit(unsigned int od, u8 *data, u8 index, u8 count)432{433 return -1;434}435#endif436 437/* ---------- Tasks ---------- */438/*439 service_response | SAS_TASK_COMPLETE | SAS_TASK_UNDELIVERED |440 exec_status | | |441 ---------------------+---------------------+-----------------------+442 SAM_... | X | |443 DEV_NO_RESPONSE | X | X |444 INTERRUPTED | X | |445 QUEUE_FULL | | X |446 DEVICE_UNKNOWN | | X |447 SG_ERR | | X |448 ---------------------+---------------------+-----------------------+449 */450 451enum service_response {452 SAS_TASK_COMPLETE,453 SAS_TASK_UNDELIVERED = -1,454};455 456enum exec_status {457 /*458 * Values 0..0x7f are used to return the SAM_STAT_* codes. To avoid459 * 'case value not in enumerated type' compiler warnings every value460 * returned through the exec_status enum needs an alias with the SAS_461 * prefix here.462 */463 SAS_SAM_STAT_GOOD = SAM_STAT_GOOD,464 SAS_SAM_STAT_BUSY = SAM_STAT_BUSY,465 SAS_SAM_STAT_TASK_ABORTED = SAM_STAT_TASK_ABORTED,466 SAS_SAM_STAT_CHECK_CONDITION = SAM_STAT_CHECK_CONDITION,467 468 SAS_DEV_NO_RESPONSE = 0x80,469 SAS_DATA_UNDERRUN,470 SAS_DATA_OVERRUN,471 SAS_INTERRUPTED,472 SAS_QUEUE_FULL,473 SAS_DEVICE_UNKNOWN,474 SAS_OPEN_REJECT,475 SAS_OPEN_TO,476 SAS_PROTO_RESPONSE,477 SAS_PHY_DOWN,478 SAS_NAK_R_ERR,479 SAS_PENDING,480 SAS_ABORTED_TASK,481};482 483/* When a task finishes with a response, the LLDD examines the484 * response:485 * - For an ATA task task_status_struct::stat is set to486 * SAS_PROTO_RESPONSE, and the task_status_struct::buf is set to the487 * contents of struct ata_task_resp.488 * - For SSP tasks, if no data is present or status/TMF response489 * is valid, task_status_struct::stat is set. If data is present490 * (SENSE data), the LLDD copies up to SAS_STATUS_BUF_SIZE, sets491 * task_status_struct::buf_valid_size, and task_status_struct::stat is492 * set to SAM_CHECK_COND.493 *494 * "buf" has format SCSI Sense for SSP task, or struct ata_task_resp495 * for ATA task.496 *497 * "frame_len" is the total frame length, which could be more or less498 * than actually copied.499 *500 * Tasks ending with response, always set the residual field.501 */502struct ata_task_resp {503 u16 frame_len;504 u8 ending_fis[ATA_RESP_FIS_SIZE]; /* dev to host or data-in */505};506 507#define SAS_STATUS_BUF_SIZE 96508 509struct task_status_struct {510 enum service_response resp;511 enum exec_status stat;512 int buf_valid_size;513 514 u8 buf[SAS_STATUS_BUF_SIZE];515 516 u32 residual;517 enum sas_open_rej_reason open_rej_reason;518};519 520/* ATA and ATAPI task queuable to a SAS LLDD.521 */522struct sas_ata_task {523 struct host_to_dev_fis fis;524 u8 atapi_packet[16]; /* 0 if not ATAPI task */525 526 u8 dma_xfer:1; /* PIO:0 or DMA:1 */527 u8 use_ncq:1;528 u8 return_fis_on_success:1;529 530 u8 device_control_reg_update:1;531 532 bool force_phy;533 int force_phy_id;534};535 536/* LLDDs rely on these values */537enum sas_internal_abort {538 SAS_INTERNAL_ABORT_SINGLE = 0,539 SAS_INTERNAL_ABORT_DEV = 1,540};541 542struct sas_internal_abort_task {543 enum sas_internal_abort type;544 unsigned int qid;545 u16 tag;546};547 548struct sas_smp_task {549 struct scatterlist smp_req;550 struct scatterlist smp_resp;551};552 553enum task_attribute {554 TASK_ATTR_SIMPLE = 0,555 TASK_ATTR_HOQ = 1,556 TASK_ATTR_ORDERED= 2,557 TASK_ATTR_ACA = 4,558};559 560struct sas_ssp_task {561 u8 LUN[8];562 enum task_attribute task_attr;563 struct scsi_cmnd *cmd;564};565 566struct sas_tmf_task {567 u8 tmf;568 u16 tag_of_task_to_be_managed;569};570 571struct sas_task {572 struct domain_device *dev;573 574 spinlock_t task_state_lock;575 unsigned task_state_flags;576 577 enum sas_protocol task_proto;578 579 union {580 struct sas_ata_task ata_task;581 struct sas_smp_task smp_task;582 struct sas_ssp_task ssp_task;583 struct sas_internal_abort_task abort_task;584 };585 586 struct scatterlist *scatter;587 int num_scatter;588 u32 total_xfer_len;589 u8 data_dir:2; /* Use PCI_DMA_... */590 591 struct task_status_struct task_status;592 void (*task_done)(struct sas_task *);593 594 void *lldd_task; /* for use by LLDDs */595 void *uldd_task;596 struct sas_task_slow *slow_task;597 struct sas_tmf_task *tmf;598};599 600struct sas_task_slow {601 /* standard/extra infrastructure for slow path commands (SMP and602 * internal lldd commands603 */604 struct timer_list timer;605 struct completion completion;606 struct sas_task *task;607};608 609#define SAS_TASK_STATE_PENDING 1610#define SAS_TASK_STATE_DONE 2611#define SAS_TASK_STATE_ABORTED 4612#define SAS_TASK_NEED_DEV_RESET 8613 614static inline bool sas_is_internal_abort(struct sas_task *task)615{616 return task->task_proto == SAS_PROTOCOL_INTERNAL_ABORT;617}618 619static inline struct request *sas_task_find_rq(struct sas_task *task)620{621 struct scsi_cmnd *scmd;622 623 if (task->task_proto & SAS_PROTOCOL_STP_ALL) {624 struct ata_queued_cmd *qc = task->uldd_task;625 626 scmd = qc ? qc->scsicmd : NULL;627 } else {628 scmd = task->uldd_task;629 }630 631 if (!scmd)632 return NULL;633 634 return scsi_cmd_to_rq(scmd);635}636 637struct sas_domain_function_template {638 /* The class calls these to notify the LLDD of an event. */639 void (*lldd_port_formed)(struct asd_sas_phy *);640 void (*lldd_port_deformed)(struct asd_sas_phy *);641 642 /* The class calls these when a device is found or gone. */643 int (*lldd_dev_found)(struct domain_device *);644 void (*lldd_dev_gone)(struct domain_device *);645 646 int (*lldd_execute_task)(struct sas_task *, gfp_t gfp_flags);647 648 /* Task Management Functions. Must be called from process context. */649 int (*lldd_abort_task)(struct sas_task *);650 int (*lldd_abort_task_set)(struct domain_device *, u8 *lun);651 int (*lldd_clear_task_set)(struct domain_device *, u8 *lun);652 int (*lldd_I_T_nexus_reset)(struct domain_device *);653 int (*lldd_ata_check_ready)(struct domain_device *);654 void (*lldd_ata_set_dmamode)(struct domain_device *);655 int (*lldd_lu_reset)(struct domain_device *, u8 *lun);656 int (*lldd_query_task)(struct sas_task *);657 658 /* Special TMF callbacks */659 void (*lldd_tmf_exec_complete)(struct domain_device *dev);660 void (*lldd_tmf_aborted)(struct sas_task *task);661 bool (*lldd_abort_timeout)(struct sas_task *task, void *data);662 663 /* Port and Adapter management */664 int (*lldd_clear_nexus_port)(struct asd_sas_port *);665 int (*lldd_clear_nexus_ha)(struct sas_ha_struct *);666 667 /* Phy management */668 int (*lldd_control_phy)(struct asd_sas_phy *, enum phy_func, void *);669 670 /* GPIO support */671 int (*lldd_write_gpio)(struct sas_ha_struct *, u8 reg_type,672 u8 reg_index, u8 reg_count, u8 *write_data);673};674 675extern int sas_register_ha(struct sas_ha_struct *);676extern int sas_unregister_ha(struct sas_ha_struct *);677extern void sas_prep_resume_ha(struct sas_ha_struct *sas_ha);678extern void sas_resume_ha(struct sas_ha_struct *sas_ha);679extern void sas_resume_ha_no_sync(struct sas_ha_struct *sas_ha);680extern void sas_suspend_ha(struct sas_ha_struct *sas_ha);681 682int sas_phy_reset(struct sas_phy *phy, int hard_reset);683int sas_phy_enable(struct sas_phy *phy, int enable);684extern int sas_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);685extern int sas_target_alloc(struct scsi_target *);686int sas_device_configure(struct scsi_device *dev,687 struct queue_limits *lim);688extern int sas_change_queue_depth(struct scsi_device *, int new_depth);689extern int sas_bios_param(struct scsi_device *, struct block_device *,690 sector_t capacity, int *hsc);691int sas_execute_internal_abort_single(struct domain_device *device,692 u16 tag, unsigned int qid,693 void *data);694int sas_execute_internal_abort_dev(struct domain_device *device,695 unsigned int qid, void *data);696extern struct scsi_transport_template *697sas_domain_attach_transport(struct sas_domain_function_template *);698extern struct device_attribute dev_attr_phy_event_threshold;699 700void sas_task_abort(struct sas_task *);701int sas_eh_abort_handler(struct scsi_cmnd *cmd);702int sas_eh_device_reset_handler(struct scsi_cmnd *cmd);703int sas_eh_target_reset_handler(struct scsi_cmnd *cmd);704 705extern void sas_target_destroy(struct scsi_target *);706extern int sas_slave_alloc(struct scsi_device *);707extern int sas_ioctl(struct scsi_device *sdev, unsigned int cmd,708 void __user *arg);709extern int sas_drain_work(struct sas_ha_struct *ha);710 711extern void sas_ssp_task_response(struct device *dev, struct sas_task *task,712 struct ssp_response_iu *iu);713struct sas_phy *sas_get_local_phy(struct domain_device *dev);714 715int sas_request_addr(struct Scsi_Host *shost, u8 *addr);716 717int sas_abort_task_set(struct domain_device *dev, u8 *lun);718int sas_clear_task_set(struct domain_device *dev, u8 *lun);719int sas_lu_reset(struct domain_device *dev, u8 *lun);720int sas_query_task(struct sas_task *task, u16 tag);721int sas_abort_task(struct sas_task *task, u16 tag);722int sas_find_attached_phy_id(struct expander_device *ex_dev,723 struct domain_device *dev);724 725void sas_notify_port_event(struct asd_sas_phy *phy, enum port_event event,726 gfp_t gfp_flags);727void sas_notify_phy_event(struct asd_sas_phy *phy, enum phy_event event,728 gfp_t gfp_flags);729 730#define __LIBSAS_SHT_BASE \731 .module = THIS_MODULE, \732 .name = DRV_NAME, \733 .proc_name = DRV_NAME, \734 .queuecommand = sas_queuecommand, \735 .dma_need_drain = ata_scsi_dma_need_drain, \736 .target_alloc = sas_target_alloc, \737 .change_queue_depth = sas_change_queue_depth, \738 .bios_param = sas_bios_param, \739 .this_id = -1, \740 .eh_device_reset_handler = sas_eh_device_reset_handler, \741 .eh_target_reset_handler = sas_eh_target_reset_handler, \742 .target_destroy = sas_target_destroy, \743 .ioctl = sas_ioctl, \744 745#ifdef CONFIG_COMPAT746#define _LIBSAS_SHT_BASE __LIBSAS_SHT_BASE \747 .compat_ioctl = sas_ioctl,748#else749#define _LIBSAS_SHT_BASE __LIBSAS_SHT_BASE750#endif751 752#define LIBSAS_SHT_BASE _LIBSAS_SHT_BASE \753 .device_configure = sas_device_configure, \754 .slave_alloc = sas_slave_alloc, \755 756#define LIBSAS_SHT_BASE_NO_SLAVE_INIT _LIBSAS_SHT_BASE757 758 759#endif /* _SASLIB_H_ */760