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
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.c
33 * so when updating/adding events here, please also
34 * 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_DISCOVERED
80};
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 24
131
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 bool dev_parent_is_expander(struct domain_device *dev)
207{
208 if (!dev->parent)
209 return false;
210
211 return dev_is_expander(type: dev->parent->dev_type);
212}
213
214static inline void INIT_SAS_WORK(struct sas_work *sw, void (*fn)(struct work_struct *))
215{
216 INIT_WORK(&sw->work, fn);
217 INIT_LIST_HEAD(list: &sw->drain_node);
218}
219
220struct sas_discovery_event {
221 struct sas_work work;
222 struct asd_sas_port *port;
223};
224
225static inline struct sas_discovery_event *to_sas_discovery_event(struct work_struct *work)
226{
227 struct sas_discovery_event *ev = container_of(work, typeof(*ev), work.work);
228
229 return ev;
230}
231
232struct sas_discovery {
233 struct sas_discovery_event disc_work[DISC_NUM_EVENTS];
234 unsigned long pending;
235 u8 fanout_sas_addr[SAS_ADDR_SIZE];
236 u8 eeds_a[SAS_ADDR_SIZE];
237 u8 eeds_b[SAS_ADDR_SIZE];
238 int max_level;
239};
240
241/* The port struct is Class:RW, driver:RO */
242struct asd_sas_port {
243/* private: */
244 struct sas_discovery disc;
245 struct domain_device *port_dev;
246 spinlock_t dev_list_lock;
247 struct list_head dev_list;
248 struct list_head disco_list;
249 struct list_head destroy_list;
250 struct list_head sas_port_del_list;
251 enum sas_linkrate linkrate;
252
253 struct sas_work work;
254 int suspended;
255
256/* public: */
257 int id;
258
259 u8 sas_addr[SAS_ADDR_SIZE];
260 u8 attached_sas_addr[SAS_ADDR_SIZE];
261 enum sas_protocol iproto;
262 enum sas_protocol tproto;
263
264 enum sas_oob_mode oob_mode;
265
266 spinlock_t phy_list_lock;
267 struct list_head phy_list;
268 int num_phys;
269 u32 phy_mask;
270
271 struct sas_ha_struct *ha;
272
273 struct sas_port *port;
274
275 void *lldd_port; /* not touched by the sas class code */
276};
277
278struct asd_sas_event {
279 struct sas_work work;
280 struct asd_sas_phy *phy;
281 int event;
282};
283
284static inline struct asd_sas_event *to_asd_sas_event(struct work_struct *work)
285{
286 struct asd_sas_event *ev = container_of(work, typeof(*ev), work.work);
287
288 return ev;
289}
290
291static inline void INIT_SAS_EVENT(struct asd_sas_event *ev,
292 void (*fn)(struct work_struct *),
293 struct asd_sas_phy *phy, int event)
294{
295 INIT_SAS_WORK(sw: &ev->work, fn);
296 ev->phy = phy;
297 ev->event = event;
298}
299
300#define SAS_PHY_SHUTDOWN_THRES 1024
301
302/* The phy pretty much is controlled by the LLDD.
303 * The class only reads those fields.
304 */
305struct asd_sas_phy {
306/* private: */
307 atomic_t event_nr;
308 int in_shutdown;
309 int error;
310 int suspended;
311
312 struct sas_phy *phy;
313
314/* public: */
315 /* The following are class:RO, driver:R/W */
316 int enabled; /* must be set */
317
318 int id; /* must be set */
319 enum sas_protocol iproto;
320 enum sas_protocol tproto;
321
322 enum sas_phy_role role;
323 enum sas_oob_mode oob_mode;
324 enum sas_linkrate linkrate;
325
326 u8 *sas_addr; /* must be set */
327 u8 attached_sas_addr[SAS_ADDR_SIZE]; /* class:RO, driver: R/W */
328
329 spinlock_t frame_rcvd_lock;
330 u8 *frame_rcvd; /* must be set */
331 int frame_rcvd_size;
332
333 spinlock_t sas_prim_lock;
334 u32 sas_prim;
335
336 struct list_head port_phy_el; /* driver:RO */
337 struct asd_sas_port *port; /* Class:RW, driver: RO */
338
339 struct sas_ha_struct *ha; /* may be set; the class sets it anyway */
340
341 void *lldd_phy; /* not touched by the sas_class_code */
342};
343
344enum sas_ha_state {
345 SAS_HA_REGISTERED,
346 SAS_HA_DRAINING,
347 SAS_HA_ATA_EH_ACTIVE,
348 SAS_HA_FROZEN,
349 SAS_HA_RESUMING,
350};
351
352struct sas_ha_struct {
353/* private: */
354 struct list_head defer_q; /* work queued while draining */
355 struct mutex drain_mutex;
356 unsigned long state;
357 spinlock_t lock;
358 int eh_active;
359 wait_queue_head_t eh_wait_q;
360 struct list_head eh_dev_q;
361
362 struct mutex disco_mutex;
363
364 struct Scsi_Host *shost;
365
366/* public: */
367 char *sas_ha_name;
368 struct device *dev; /* should be set */
369
370 struct workqueue_struct *event_q;
371 struct workqueue_struct *disco_q;
372
373 u8 *sas_addr; /* must be set */
374 u8 hashed_sas_addr[HASHED_SAS_ADDR_SIZE];
375
376 spinlock_t phy_port_lock;
377 struct asd_sas_phy **sas_phy; /* array of valid pointers, must be set */
378 struct asd_sas_port **sas_port; /* array of valid pointers, must be set */
379 int num_phys; /* must be set, gt 0, static */
380
381 int strict_wide_ports; /* both sas_addr and attached_sas_addr must match
382 * their siblings when forming wide ports */
383
384 void *lldd_ha; /* not touched by sas class code */
385
386 struct list_head eh_done_q; /* complete via scsi_eh_flush_done_q */
387 struct list_head eh_ata_q; /* scmds to promote from sas to ata eh */
388
389 int event_thres;
390};
391
392#define SHOST_TO_SAS_HA(_shost) (*(struct sas_ha_struct **)(_shost)->hostdata)
393
394static inline struct domain_device *
395starget_to_domain_dev(struct scsi_target *starget) {
396 return starget->hostdata;
397}
398
399static inline struct domain_device *
400sdev_to_domain_dev(struct scsi_device *sdev) {
401 return starget_to_domain_dev(starget: sdev->sdev_target);
402}
403
404static inline struct ata_device *sas_to_ata_dev(struct domain_device *dev)
405{
406 return &dev->sata_dev.ap->link.device[0];
407}
408
409static inline struct domain_device *
410cmd_to_domain_dev(struct scsi_cmnd *cmd)
411{
412 return sdev_to_domain_dev(sdev: cmd->device);
413}
414
415/* Before calling a notify event, LLDD should use this function
416 * when the link is severed (possibly from its tasklet).
417 * The idea is that the Class only reads those, while the LLDD,
418 * can R/W these (thus avoiding a race).
419 */
420static inline void sas_phy_disconnected(struct asd_sas_phy *phy)
421{
422 phy->oob_mode = OOB_NOT_CONNECTED;
423 phy->linkrate = SAS_LINK_RATE_UNKNOWN;
424}
425
426static inline unsigned int to_sas_gpio_od(int device, int bit)
427{
428 return 3 * device + bit;
429}
430
431static inline void sas_put_local_phy(struct sas_phy *phy)
432{
433 put_device(dev: &phy->dev);
434}
435
436#ifdef CONFIG_SCSI_SAS_HOST_SMP
437int try_test_sas_gpio_gp_bit(unsigned int od, u8 *data, u8 index, u8 count);
438#else
439static inline int try_test_sas_gpio_gp_bit(unsigned int od, u8 *data, u8 index, u8 count)
440{
441 return -1;
442}
443#endif
444
445/* ---------- Tasks ---------- */
446/*
447 service_response | SAS_TASK_COMPLETE | SAS_TASK_UNDELIVERED |
448 exec_status | | |
449 ---------------------+---------------------+-----------------------+
450 SAM_... | X | |
451 DEV_NO_RESPONSE | X | X |
452 INTERRUPTED | X | |
453 QUEUE_FULL | | X |
454 DEVICE_UNKNOWN | | X |
455 SG_ERR | | X |
456 ---------------------+---------------------+-----------------------+
457 */
458
459enum service_response {
460 SAS_TASK_COMPLETE,
461 SAS_TASK_UNDELIVERED = -1,
462};
463
464enum exec_status {
465 /*
466 * Values 0..0x7f are used to return the SAM_STAT_* codes. To avoid
467 * 'case value not in enumerated type' compiler warnings every value
468 * returned through the exec_status enum needs an alias with the SAS_
469 * prefix here.
470 */
471 SAS_SAM_STAT_GOOD = SAM_STAT_GOOD,
472 SAS_SAM_STAT_BUSY = SAM_STAT_BUSY,
473 SAS_SAM_STAT_TASK_ABORTED = SAM_STAT_TASK_ABORTED,
474 SAS_SAM_STAT_CHECK_CONDITION = SAM_STAT_CHECK_CONDITION,
475
476 SAS_DEV_NO_RESPONSE = 0x80,
477 SAS_DATA_UNDERRUN,
478 SAS_DATA_OVERRUN,
479 SAS_INTERRUPTED,
480 SAS_QUEUE_FULL,
481 SAS_DEVICE_UNKNOWN,
482 SAS_OPEN_REJECT,
483 SAS_OPEN_TO,
484 SAS_PROTO_RESPONSE,
485 SAS_PHY_DOWN,
486 SAS_NAK_R_ERR,
487 SAS_PENDING,
488 SAS_ABORTED_TASK,
489};
490
491/* When a task finishes with a response, the LLDD examines the
492 * response:
493 * - For an ATA task task_status_struct::stat is set to
494 * SAS_PROTO_RESPONSE, and the task_status_struct::buf is set to the
495 * contents of struct ata_task_resp.
496 * - For SSP tasks, if no data is present or status/TMF response
497 * is valid, task_status_struct::stat is set. If data is present
498 * (SENSE data), the LLDD copies up to SAS_STATUS_BUF_SIZE, sets
499 * task_status_struct::buf_valid_size, and task_status_struct::stat is
500 * set to SAM_CHECK_COND.
501 *
502 * "buf" has format SCSI Sense for SSP task, or struct ata_task_resp
503 * for ATA task.
504 *
505 * "frame_len" is the total frame length, which could be more or less
506 * than actually copied.
507 *
508 * Tasks ending with response, always set the residual field.
509 */
510struct ata_task_resp {
511 u16 frame_len;
512 u8 ending_fis[ATA_RESP_FIS_SIZE]; /* dev to host or data-in */
513};
514
515#define SAS_STATUS_BUF_SIZE 96
516
517struct task_status_struct {
518 enum service_response resp;
519 enum exec_status stat;
520 int buf_valid_size;
521
522 u8 buf[SAS_STATUS_BUF_SIZE];
523
524 u32 residual;
525 enum sas_open_rej_reason open_rej_reason;
526};
527
528/* ATA and ATAPI task queuable to a SAS LLDD.
529 */
530struct sas_ata_task {
531 struct host_to_dev_fis fis;
532 u8 atapi_packet[16]; /* 0 if not ATAPI task */
533
534 u8 dma_xfer:1; /* PIO:0 or DMA:1 */
535 u8 use_ncq:1;
536 u8 return_fis_on_success:1;
537
538 u8 device_control_reg_update:1;
539
540 bool force_phy;
541 int force_phy_id;
542};
543
544/* LLDDs rely on these values */
545enum sas_internal_abort {
546 SAS_INTERNAL_ABORT_SINGLE = 0,
547 SAS_INTERNAL_ABORT_DEV = 1,
548};
549
550struct sas_internal_abort_task {
551 enum sas_internal_abort type;
552 unsigned int qid;
553 u16 tag;
554};
555
556struct sas_smp_task {
557 struct scatterlist smp_req;
558 struct scatterlist smp_resp;
559};
560
561enum task_attribute {
562 TASK_ATTR_SIMPLE = 0,
563 TASK_ATTR_HOQ = 1,
564 TASK_ATTR_ORDERED= 2,
565 TASK_ATTR_ACA = 4,
566};
567
568struct sas_ssp_task {
569 u8 LUN[8];
570 enum task_attribute task_attr;
571 struct scsi_cmnd *cmd;
572};
573
574struct sas_tmf_task {
575 u8 tmf;
576 u16 tag_of_task_to_be_managed;
577};
578
579struct sas_task {
580 struct domain_device *dev;
581
582 spinlock_t task_state_lock;
583 unsigned task_state_flags;
584
585 enum sas_protocol task_proto;
586
587 union {
588 struct sas_ata_task ata_task;
589 struct sas_smp_task smp_task;
590 struct sas_ssp_task ssp_task;
591 struct sas_internal_abort_task abort_task;
592 };
593
594 struct scatterlist *scatter;
595 int num_scatter;
596 u32 total_xfer_len;
597 u8 data_dir:2; /* Use PCI_DMA_... */
598
599 struct task_status_struct task_status;
600 void (*task_done)(struct sas_task *);
601
602 void *lldd_task; /* for use by LLDDs */
603 void *uldd_task;
604 struct sas_task_slow *slow_task;
605 struct sas_tmf_task *tmf;
606};
607
608struct sas_task_slow {
609 /* standard/extra infrastructure for slow path commands (SMP and
610 * internal lldd commands
611 */
612 struct timer_list timer;
613 struct completion completion;
614 struct sas_task *task;
615};
616
617#define SAS_TASK_STATE_PENDING 1
618#define SAS_TASK_STATE_DONE 2
619#define SAS_TASK_STATE_ABORTED 4
620#define SAS_TASK_NEED_DEV_RESET 8
621
622static inline bool sas_is_internal_abort(struct sas_task *task)
623{
624 return task->task_proto == SAS_PROTOCOL_INTERNAL_ABORT;
625}
626
627static inline struct request *sas_task_find_rq(struct sas_task *task)
628{
629 struct scsi_cmnd *scmd;
630
631 if (task->task_proto & SAS_PROTOCOL_STP_ALL) {
632 struct ata_queued_cmd *qc = task->uldd_task;
633
634 scmd = qc ? qc->scsicmd : NULL;
635 } else {
636 scmd = task->uldd_task;
637 }
638
639 if (!scmd)
640 return NULL;
641
642 return scsi_cmd_to_rq(scmd);
643}
644
645struct sas_domain_function_template {
646 /* The class calls these to notify the LLDD of an event. */
647 void (*lldd_port_formed)(struct asd_sas_phy *);
648 void (*lldd_port_deformed)(struct asd_sas_phy *);
649
650 /* The class calls these when a device is found or gone. */
651 int (*lldd_dev_found)(struct domain_device *);
652 void (*lldd_dev_gone)(struct domain_device *);
653
654 int (*lldd_execute_task)(struct sas_task *, gfp_t gfp_flags);
655
656 /* Task Management Functions. Must be called from process context. */
657 int (*lldd_abort_task)(struct sas_task *);
658 int (*lldd_abort_task_set)(struct domain_device *, u8 *lun);
659 int (*lldd_clear_task_set)(struct domain_device *, u8 *lun);
660 int (*lldd_I_T_nexus_reset)(struct domain_device *);
661 int (*lldd_ata_check_ready)(struct domain_device *);
662 void (*lldd_ata_set_dmamode)(struct domain_device *);
663 int (*lldd_lu_reset)(struct domain_device *, u8 *lun);
664 int (*lldd_query_task)(struct sas_task *);
665
666 /* Special TMF callbacks */
667 void (*lldd_tmf_exec_complete)(struct domain_device *dev);
668 void (*lldd_tmf_aborted)(struct sas_task *task);
669 bool (*lldd_abort_timeout)(struct sas_task *task, void *data);
670
671 /* Port and Adapter management */
672 int (*lldd_clear_nexus_port)(struct asd_sas_port *);
673 int (*lldd_clear_nexus_ha)(struct sas_ha_struct *);
674
675 /* Phy management */
676 int (*lldd_control_phy)(struct asd_sas_phy *, enum phy_func, void *);
677
678 /* GPIO support */
679 int (*lldd_write_gpio)(struct sas_ha_struct *, u8 reg_type,
680 u8 reg_index, u8 reg_count, u8 *write_data);
681};
682
683extern int sas_register_ha(struct sas_ha_struct *);
684extern int sas_unregister_ha(struct sas_ha_struct *);
685extern void sas_prep_resume_ha(struct sas_ha_struct *sas_ha);
686extern void sas_resume_ha(struct sas_ha_struct *sas_ha);
687extern void sas_resume_ha_no_sync(struct sas_ha_struct *sas_ha);
688extern void sas_suspend_ha(struct sas_ha_struct *sas_ha);
689
690int sas_phy_reset(struct sas_phy *phy, int hard_reset);
691int sas_phy_enable(struct sas_phy *phy, int enable);
692extern int sas_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);
693extern int sas_target_alloc(struct scsi_target *);
694int sas_sdev_configure(struct scsi_device *dev, struct queue_limits *lim);
695extern int sas_change_queue_depth(struct scsi_device *, int new_depth);
696extern int sas_bios_param(struct scsi_device *, struct gendisk *,
697 sector_t capacity, int *hsc);
698int sas_execute_internal_abort_single(struct domain_device *device,
699 u16 tag, unsigned int qid,
700 void *data);
701int sas_execute_internal_abort_dev(struct domain_device *device,
702 unsigned int qid, void *data);
703extern struct scsi_transport_template *
704sas_domain_attach_transport(struct sas_domain_function_template *);
705extern struct device_attribute dev_attr_phy_event_threshold;
706
707void sas_task_abort(struct sas_task *);
708int sas_eh_abort_handler(struct scsi_cmnd *cmd);
709int sas_eh_device_reset_handler(struct scsi_cmnd *cmd);
710int sas_eh_target_reset_handler(struct scsi_cmnd *cmd);
711
712extern void sas_target_destroy(struct scsi_target *);
713extern int sas_sdev_init(struct scsi_device *);
714extern int sas_ioctl(struct scsi_device *sdev, unsigned int cmd,
715 void __user *arg);
716extern int sas_drain_work(struct sas_ha_struct *ha);
717
718extern void sas_ssp_task_response(struct device *dev, struct sas_task *task,
719 struct ssp_response_iu *iu);
720struct sas_phy *sas_get_local_phy(struct domain_device *dev);
721
722int sas_request_addr(struct Scsi_Host *shost, u8 *addr);
723
724int sas_abort_task_set(struct domain_device *dev, u8 *lun);
725int sas_clear_task_set(struct domain_device *dev, u8 *lun);
726int sas_lu_reset(struct domain_device *dev, u8 *lun);
727int sas_query_task(struct sas_task *task, u16 tag);
728int sas_abort_task(struct sas_task *task, u16 tag);
729int sas_find_attached_phy_id(struct expander_device *ex_dev,
730 struct domain_device *dev);
731
732void sas_notify_port_event(struct asd_sas_phy *phy, enum port_event event,
733 gfp_t gfp_flags);
734void sas_notify_phy_event(struct asd_sas_phy *phy, enum phy_event event,
735 gfp_t gfp_flags);
736
737#define __LIBSAS_SHT_BASE \
738 .module = THIS_MODULE, \
739 .name = DRV_NAME, \
740 .proc_name = DRV_NAME, \
741 .queuecommand = sas_queuecommand, \
742 .dma_need_drain = ata_scsi_dma_need_drain, \
743 .target_alloc = sas_target_alloc, \
744 .change_queue_depth = sas_change_queue_depth, \
745 .bios_param = sas_bios_param, \
746 .this_id = -1, \
747 .eh_device_reset_handler = sas_eh_device_reset_handler, \
748 .eh_target_reset_handler = sas_eh_target_reset_handler, \
749 .target_destroy = sas_target_destroy, \
750 .ioctl = sas_ioctl, \
751
752#ifdef CONFIG_COMPAT
753#define _LIBSAS_SHT_BASE __LIBSAS_SHT_BASE \
754 .compat_ioctl = sas_ioctl,
755#else
756#define _LIBSAS_SHT_BASE __LIBSAS_SHT_BASE
757#endif
758
759#define LIBSAS_SHT_BASE _LIBSAS_SHT_BASE \
760 .sdev_configure = sas_sdev_configure, \
761 .sdev_init = sas_sdev_init, \
762
763#define LIBSAS_SHT_BASE_NO_SLAVE_INIT _LIBSAS_SHT_BASE
764
765
766#endif /* _SASLIB_H_ */
767

source code of linux/include/scsi/libsas.h