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 | |
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 | |
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(list: &sw->drain_node); |
210 | } |
211 | |
212 | struct sas_discovery_event { |
213 | struct sas_work work; |
214 | struct asd_sas_port *port; |
215 | }; |
216 | |
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 | |
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 | |
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(sw: &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 * |
387 | starget_to_domain_dev(struct scsi_target *starget) { |
388 | return starget->hostdata; |
389 | } |
390 | |
391 | static inline struct domain_device * |
392 | sdev_to_domain_dev(struct scsi_device *sdev) { |
393 | return starget_to_domain_dev(starget: sdev->sdev_target); |
394 | } |
395 | |
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 * |
402 | cmd_to_domain_dev(struct scsi_cmnd *cmd) |
403 | { |
404 | return sdev_to_domain_dev(sdev: 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 | */ |
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 | |
418 | static inline unsigned int to_sas_gpio_od(int device, int bit) |
419 | { |
420 | return 3 * device + bit; |
421 | } |
422 | |
423 | static inline void sas_put_local_phy(struct sas_phy *phy) |
424 | { |
425 | put_device(dev: &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 |
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 | |
614 | static inline bool sas_is_internal_abort(struct sas_task *task) |
615 | { |
616 | return task->task_proto == SAS_PROTOCOL_INTERNAL_ABORT; |
617 | } |
618 | |
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 | extern int sas_slave_configure(struct scsi_device *); |
687 | extern int sas_change_queue_depth(struct scsi_device *, int new_depth); |
688 | extern int sas_bios_param(struct scsi_device *, struct block_device *, |
689 | sector_t capacity, int *hsc); |
690 | int sas_execute_internal_abort_single(struct domain_device *device, |
691 | u16 tag, unsigned int qid, |
692 | void *data); |
693 | int sas_execute_internal_abort_dev(struct domain_device *device, |
694 | unsigned int qid, void *data); |
695 | extern struct scsi_transport_template * |
696 | sas_domain_attach_transport(struct sas_domain_function_template *); |
697 | extern struct device_attribute dev_attr_phy_event_threshold; |
698 | |
699 | void sas_task_abort(struct sas_task *); |
700 | int sas_eh_abort_handler(struct scsi_cmnd *cmd); |
701 | int sas_eh_device_reset_handler(struct scsi_cmnd *cmd); |
702 | int sas_eh_target_reset_handler(struct scsi_cmnd *cmd); |
703 | |
704 | extern void sas_target_destroy(struct scsi_target *); |
705 | extern int sas_slave_alloc(struct scsi_device *); |
706 | extern int sas_ioctl(struct scsi_device *sdev, unsigned int cmd, |
707 | void __user *arg); |
708 | extern int sas_drain_work(struct sas_ha_struct *ha); |
709 | |
710 | extern void sas_ssp_task_response(struct device *dev, struct sas_task *task, |
711 | struct ssp_response_iu *iu); |
712 | struct sas_phy *sas_get_local_phy(struct domain_device *dev); |
713 | |
714 | int sas_request_addr(struct Scsi_Host *shost, u8 *addr); |
715 | |
716 | int sas_abort_task_set(struct domain_device *dev, u8 *lun); |
717 | int sas_clear_task_set(struct domain_device *dev, u8 *lun); |
718 | int sas_lu_reset(struct domain_device *dev, u8 *lun); |
719 | int sas_query_task(struct sas_task *task, u16 tag); |
720 | int sas_abort_task(struct sas_task *task, u16 tag); |
721 | int sas_find_attached_phy_id(struct expander_device *ex_dev, |
722 | struct domain_device *dev); |
723 | |
724 | void sas_notify_port_event(struct asd_sas_phy *phy, enum port_event event, |
725 | gfp_t gfp_flags); |
726 | void sas_notify_phy_event(struct asd_sas_phy *phy, enum phy_event event, |
727 | gfp_t gfp_flags); |
728 | |
729 | #endif /* _SASLIB_H_ */ |
730 | |