xref: /linux/include/scsi/libsas.h (revision 621cde16e49b3ecf7d59a8106a20aaebfb4a59a9)
1 /* SPDX-License-Identifier: GPL-2.0-only */
2 /*
3  * SAS host prototypes and structures header file
4  *
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 
24 struct block_device;
25 
26 enum 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.c
33  * so when updating/adding events here, please also
34  * update the other file too.
35  */
36 enum 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 
45 enum 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 
55 enum 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 
69 enum routing_attribute {
70 	DIRECT_ROUTING,
71 	SUBTRACTIVE_ROUTING,
72 	TABLE_ROUTING,
73 };
74 
75 enum ex_phy_state {
76 	PHY_EMPTY,
77 	PHY_VACANT,
78 	PHY_NOT_PRESENT,
79 	PHY_DEVICE_DISCOVERED
80 };
81 
82 struct 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 
110 struct 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 24
131 
132 struct 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 
142 struct ssp_device {
143 	struct list_head eh_list_node; /* pending a user requested eh action */
144 	struct scsi_lun reset_lun;
145 };
146 
147 enum {
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 
156 struct 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 
195 struct sas_work {
196 	struct list_head drain_node;
197 	struct work_struct work;
198 };
199 
dev_is_expander(enum sas_device_type type)200 static 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 
INIT_SAS_WORK(struct sas_work * sw,void (* fn)(struct work_struct *))206 static 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 
212 struct sas_discovery_event {
213 	struct sas_work work;
214 	struct asd_sas_port *port;
215 };
216 
to_sas_discovery_event(struct work_struct * work)217 static 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 
224 struct 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 */
234 struct 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 
270 struct asd_sas_event {
271 	struct sas_work work;
272 	struct asd_sas_phy *phy;
273 	int event;
274 };
275 
to_asd_sas_event(struct work_struct * work)276 static 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 
INIT_SAS_EVENT(struct asd_sas_event * ev,void (* fn)(struct work_struct *),struct asd_sas_phy * phy,int event)283 static 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   1024
293 
294 /* The phy pretty much is controlled by the LLDD.
295  * The class only reads those fields.
296  */
297 struct 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 
336 enum 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 
344 struct 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 match
374 				* 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 
386 static inline struct domain_device *
starget_to_domain_dev(struct scsi_target * starget)387 starget_to_domain_dev(struct scsi_target *starget) {
388 	return starget->hostdata;
389 }
390 
391 static inline struct domain_device *
sdev_to_domain_dev(struct scsi_device * sdev)392 sdev_to_domain_dev(struct scsi_device *sdev) {
393 	return starget_to_domain_dev(sdev->sdev_target);
394 }
395 
sas_to_ata_dev(struct domain_device * dev)396 static inline struct ata_device *sas_to_ata_dev(struct domain_device *dev)
397 {
398 	return &dev->sata_dev.ap->link.device[0];
399 }
400 
401 static inline struct domain_device *
cmd_to_domain_dev(struct scsi_cmnd * cmd)402 cmd_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 function
408  * 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  */
sas_phy_disconnected(struct asd_sas_phy * phy)412 static 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 
to_sas_gpio_od(int device,int bit)418 static inline unsigned int to_sas_gpio_od(int device, int bit)
419 {
420 	return 3 * device + bit;
421 }
422 
sas_put_local_phy(struct sas_phy * phy)423 static inline void sas_put_local_phy(struct sas_phy *phy)
424 {
425 	put_device(&phy->dev);
426 }
427 
428 #ifdef CONFIG_SCSI_SAS_HOST_SMP
429 int try_test_sas_gpio_gp_bit(unsigned int od, u8 *data, u8 index, u8 count);
430 #else
try_test_sas_gpio_gp_bit(unsigned int od,u8 * data,u8 index,u8 count)431 static inline int try_test_sas_gpio_gp_bit(unsigned int od, u8 *data, u8 index, u8 count)
432 {
433 	return -1;
434 }
435 #endif
436 
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 
451 enum service_response {
452 	SAS_TASK_COMPLETE,
453 	SAS_TASK_UNDELIVERED = -1,
454 };
455 
456 enum exec_status {
457 	/*
458 	 * Values 0..0x7f are used to return the SAM_STAT_* codes.  To avoid
459 	 * 'case value not in enumerated type' compiler warnings every value
460 	 * 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 the
484  * response:
485  *	- For an ATA task task_status_struct::stat is set to
486  * SAS_PROTO_RESPONSE, and the task_status_struct::buf is set to the
487  * contents of struct ata_task_resp.
488  *	- For SSP tasks, if no data is present or status/TMF response
489  * is valid, task_status_struct::stat is set.  If data is present
490  * (SENSE data), the LLDD copies up to SAS_STATUS_BUF_SIZE, sets
491  * task_status_struct::buf_valid_size, and task_status_struct::stat is
492  * set to SAM_CHECK_COND.
493  *
494  * "buf" has format SCSI Sense for SSP task, or struct ata_task_resp
495  * for ATA task.
496  *
497  * "frame_len" is the total frame length, which could be more or less
498  * than actually copied.
499  *
500  * Tasks ending with response, always set the residual field.
501  */
502 struct 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 96
508 
509 struct 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  */
522 struct 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 */
537 enum sas_internal_abort {
538 	SAS_INTERNAL_ABORT_SINGLE	= 0,
539 	SAS_INTERNAL_ABORT_DEV		= 1,
540 };
541 
542 struct sas_internal_abort_task {
543 	enum sas_internal_abort type;
544 	unsigned int qid;
545 	u16 tag;
546 };
547 
548 struct sas_smp_task {
549 	struct scatterlist smp_req;
550 	struct scatterlist smp_resp;
551 };
552 
553 enum task_attribute {
554 	TASK_ATTR_SIMPLE = 0,
555 	TASK_ATTR_HOQ    = 1,
556 	TASK_ATTR_ORDERED= 2,
557 	TASK_ATTR_ACA    = 4,
558 };
559 
560 struct sas_ssp_task {
561 	u8     LUN[8];
562 	enum   task_attribute task_attr;
563 	struct scsi_cmnd *cmd;
564 };
565 
566 struct sas_tmf_task {
567 	u8 tmf;
568 	u16 tag_of_task_to_be_managed;
569 };
570 
571 struct 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 
600 struct sas_task_slow {
601 	/* standard/extra infrastructure for slow path commands (SMP and
602 	 * internal lldd commands
603 	 */
604 	struct timer_list     timer;
605 	struct completion     completion;
606 	struct sas_task       *task;
607 };
608 
609 #define SAS_TASK_STATE_PENDING      1
610 #define SAS_TASK_STATE_DONE         2
611 #define SAS_TASK_STATE_ABORTED      4
612 #define SAS_TASK_NEED_DEV_RESET     8
613 
sas_is_internal_abort(struct sas_task * task)614 static inline bool sas_is_internal_abort(struct sas_task *task)
615 {
616 	return task->task_proto == SAS_PROTOCOL_INTERNAL_ABORT;
617 }
618 
sas_task_find_rq(struct sas_task * task)619 static 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 
637 struct 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 
675 extern int sas_register_ha(struct sas_ha_struct *);
676 extern int sas_unregister_ha(struct sas_ha_struct *);
677 extern void sas_prep_resume_ha(struct sas_ha_struct *sas_ha);
678 extern void sas_resume_ha(struct sas_ha_struct *sas_ha);
679 extern void sas_resume_ha_no_sync(struct sas_ha_struct *sas_ha);
680 extern void sas_suspend_ha(struct sas_ha_struct *sas_ha);
681 
682 int sas_phy_reset(struct sas_phy *phy, int hard_reset);
683 int sas_phy_enable(struct sas_phy *phy, int enable);
684 extern int sas_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);
685 extern int sas_target_alloc(struct scsi_target *);
686 int sas_device_configure(struct scsi_device *dev,
687 		struct queue_limits *lim);
688 extern int sas_change_queue_depth(struct scsi_device *, int new_depth);
689 extern int sas_bios_param(struct scsi_device *, struct block_device *,
690 			  sector_t capacity, int *hsc);
691 int sas_execute_internal_abort_single(struct domain_device *device,
692 				      u16 tag, unsigned int qid,
693 				      void *data);
694 int sas_execute_internal_abort_dev(struct domain_device *device,
695 				   unsigned int qid, void *data);
696 extern struct scsi_transport_template *
697 sas_domain_attach_transport(struct sas_domain_function_template *);
698 extern struct device_attribute dev_attr_phy_event_threshold;
699 
700 void sas_task_abort(struct sas_task *);
701 int sas_eh_abort_handler(struct scsi_cmnd *cmd);
702 int sas_eh_device_reset_handler(struct scsi_cmnd *cmd);
703 int sas_eh_target_reset_handler(struct scsi_cmnd *cmd);
704 
705 extern void sas_target_destroy(struct scsi_target *);
706 extern int sas_slave_alloc(struct scsi_device *);
707 extern int sas_ioctl(struct scsi_device *sdev, unsigned int cmd,
708 		     void __user *arg);
709 extern int sas_drain_work(struct sas_ha_struct *ha);
710 
711 extern void sas_ssp_task_response(struct device *dev, struct sas_task *task,
712 				  struct ssp_response_iu *iu);
713 struct sas_phy *sas_get_local_phy(struct domain_device *dev);
714 
715 int sas_request_addr(struct Scsi_Host *shost, u8 *addr);
716 
717 int sas_abort_task_set(struct domain_device *dev, u8 *lun);
718 int sas_clear_task_set(struct domain_device *dev, u8 *lun);
719 int sas_lu_reset(struct domain_device *dev, u8 *lun);
720 int sas_query_task(struct sas_task *task, u16 tag);
721 int sas_abort_task(struct sas_task *task, u16 tag);
722 int sas_find_attached_phy_id(struct expander_device *ex_dev,
723 			     struct domain_device *dev);
724 
725 void sas_notify_port_event(struct asd_sas_phy *phy, enum port_event event,
726 			   gfp_t gfp_flags);
727 void 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_COMPAT
746 #define _LIBSAS_SHT_BASE		__LIBSAS_SHT_BASE		\
747 	.compat_ioctl			= sas_ioctl,
748 #else
749 #define _LIBSAS_SHT_BASE		__LIBSAS_SHT_BASE
750 #endif
751 
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_BASE
757 
758 
759 #endif /* _SASLIB_H_ */
760