1 /* 2 * SAS host prototypes and structures header file 3 * 4 * Copyright (C) 2005 Adaptec, Inc. All rights reserved. 5 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com> 6 * 7 * This file is licensed under GPLv2. 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License as 11 * published by the Free Software Foundation; either version 2 of the 12 * License, or (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 22 * USA 23 * 24 */ 25 26 #ifndef _LIBSAS_H_ 27 #define _LIBSAS_H_ 28 29 30 #include <linux/timer.h> 31 #include <linux/pci.h> 32 #include <scsi/sas.h> 33 #include <linux/libata.h> 34 #include <linux/list.h> 35 #include <scsi/scsi_device.h> 36 #include <scsi/scsi_cmnd.h> 37 #include <scsi/scsi_transport_sas.h> 38 #include <linux/scatterlist.h> 39 #include <linux/slab.h> 40 41 struct block_device; 42 43 enum sas_class { 44 SAS, 45 EXPANDER 46 }; 47 48 enum sas_phy_role { 49 PHY_ROLE_NONE = 0, 50 PHY_ROLE_TARGET = 0x40, 51 PHY_ROLE_INITIATOR = 0x80, 52 }; 53 54 enum sas_phy_type { 55 PHY_TYPE_PHYSICAL, 56 PHY_TYPE_VIRTUAL 57 }; 58 59 /* The events are mnemonically described in sas_dump.c 60 * so when updating/adding events here, please also 61 * update the other file too. 62 */ 63 enum port_event { 64 PORTE_BYTES_DMAED = 0U, 65 PORTE_BROADCAST_RCVD, 66 PORTE_LINK_RESET_ERR, 67 PORTE_TIMER_EVENT, 68 PORTE_HARD_RESET, 69 PORT_NUM_EVENTS, 70 }; 71 72 enum phy_event { 73 PHYE_LOSS_OF_SIGNAL = 0U, 74 PHYE_OOB_DONE, 75 PHYE_OOB_ERROR, 76 PHYE_SPINUP_HOLD, /* hot plug SATA, no COMWAKE sent */ 77 PHYE_RESUME_TIMEOUT, 78 PHYE_SHUTDOWN, 79 PHY_NUM_EVENTS, 80 }; 81 82 enum discover_event { 83 DISCE_DISCOVER_DOMAIN = 0U, 84 DISCE_REVALIDATE_DOMAIN, 85 DISCE_SUSPEND, 86 DISCE_RESUME, 87 DISC_NUM_EVENTS, 88 }; 89 90 /* ---------- Expander Devices ---------- */ 91 92 #define to_dom_device(_obj) container_of(_obj, struct domain_device, dev_obj) 93 #define to_dev_attr(_attr) container_of(_attr, struct domain_dev_attribute,\ 94 attr) 95 96 enum routing_attribute { 97 DIRECT_ROUTING, 98 SUBTRACTIVE_ROUTING, 99 TABLE_ROUTING, 100 }; 101 102 enum ex_phy_state { 103 PHY_EMPTY, 104 PHY_VACANT, 105 PHY_NOT_PRESENT, 106 PHY_DEVICE_DISCOVERED 107 }; 108 109 struct ex_phy { 110 int phy_id; 111 112 enum ex_phy_state phy_state; 113 114 enum sas_device_type attached_dev_type; 115 enum sas_linkrate linkrate; 116 117 u8 attached_sata_host:1; 118 u8 attached_sata_dev:1; 119 u8 attached_sata_ps:1; 120 121 enum sas_protocol attached_tproto; 122 enum sas_protocol attached_iproto; 123 124 u8 attached_sas_addr[SAS_ADDR_SIZE]; 125 u8 attached_phy_id; 126 127 int phy_change_count; 128 enum routing_attribute routing_attr; 129 u8 virtual:1; 130 131 int last_da_index; 132 133 struct sas_phy *phy; 134 struct sas_port *port; 135 }; 136 137 struct expander_device { 138 struct list_head children; 139 140 int ex_change_count; 141 u16 max_route_indexes; 142 u8 num_phys; 143 144 u8 t2t_supp:1; 145 u8 configuring:1; 146 u8 conf_route_table:1; 147 148 u8 enclosure_logical_id[8]; 149 150 struct ex_phy *ex_phy; 151 struct sas_port *parent_port; 152 153 struct mutex cmd_mutex; 154 }; 155 156 /* ---------- SATA device ---------- */ 157 #define ATA_RESP_FIS_SIZE 24 158 159 struct sata_device { 160 unsigned int class; 161 u8 port_no; /* port number, if this is a PM (Port) */ 162 163 struct ata_port *ap; 164 struct ata_host *ata_host; 165 struct smp_resp rps_resp ____cacheline_aligned; /* report_phy_sata_resp */ 166 u8 fis[ATA_RESP_FIS_SIZE]; 167 }; 168 169 struct ssp_device { 170 struct list_head eh_list_node; /* pending a user requested eh action */ 171 struct scsi_lun reset_lun; 172 }; 173 174 enum { 175 SAS_DEV_GONE, 176 SAS_DEV_FOUND, /* device notified to lldd */ 177 SAS_DEV_DESTROY, 178 SAS_DEV_EH_PENDING, 179 SAS_DEV_LU_RESET, 180 SAS_DEV_RESET, 181 }; 182 183 struct domain_device { 184 spinlock_t done_lock; 185 enum sas_device_type dev_type; 186 187 enum sas_linkrate linkrate; 188 enum sas_linkrate min_linkrate; 189 enum sas_linkrate max_linkrate; 190 191 int pathways; 192 193 struct domain_device *parent; 194 struct list_head siblings; /* devices on the same level */ 195 struct asd_sas_port *port; /* shortcut to root of the tree */ 196 struct sas_phy *phy; 197 198 struct list_head dev_list_node; 199 struct list_head disco_list_node; /* awaiting probe or destruct */ 200 201 enum sas_protocol iproto; 202 enum sas_protocol tproto; 203 204 struct sas_rphy *rphy; 205 206 u8 sas_addr[SAS_ADDR_SIZE]; 207 u8 hashed_sas_addr[HASHED_SAS_ADDR_SIZE]; 208 209 u8 frame_rcvd[32]; 210 211 union { 212 struct expander_device ex_dev; 213 struct sata_device sata_dev; /* STP & directly attached */ 214 struct ssp_device ssp_dev; 215 }; 216 217 void *lldd_dev; 218 unsigned long state; 219 struct kref kref; 220 }; 221 222 struct sas_work { 223 struct list_head drain_node; 224 struct work_struct work; 225 }; 226 227 /* Lots of code duplicates this in the SCSI tree, which can be factored out */ 228 static inline bool sas_dev_type_is_expander(enum sas_device_type type) 229 { 230 return type == SAS_EDGE_EXPANDER_DEVICE || 231 type == SAS_FANOUT_EXPANDER_DEVICE; 232 } 233 234 static inline void INIT_SAS_WORK(struct sas_work *sw, void (*fn)(struct work_struct *)) 235 { 236 INIT_WORK(&sw->work, fn); 237 INIT_LIST_HEAD(&sw->drain_node); 238 } 239 240 struct sas_discovery_event { 241 struct sas_work work; 242 struct asd_sas_port *port; 243 }; 244 245 static inline struct sas_discovery_event *to_sas_discovery_event(struct work_struct *work) 246 { 247 struct sas_discovery_event *ev = container_of(work, typeof(*ev), work.work); 248 249 return ev; 250 } 251 252 struct sas_discovery { 253 struct sas_discovery_event disc_work[DISC_NUM_EVENTS]; 254 unsigned long pending; 255 u8 fanout_sas_addr[SAS_ADDR_SIZE]; 256 u8 eeds_a[SAS_ADDR_SIZE]; 257 u8 eeds_b[SAS_ADDR_SIZE]; 258 int max_level; 259 }; 260 261 /* The port struct is Class:RW, driver:RO */ 262 struct asd_sas_port { 263 /* private: */ 264 struct sas_discovery disc; 265 struct domain_device *port_dev; 266 spinlock_t dev_list_lock; 267 struct list_head dev_list; 268 struct list_head disco_list; 269 struct list_head destroy_list; 270 struct list_head sas_port_del_list; 271 enum sas_linkrate linkrate; 272 273 struct sas_work work; 274 int suspended; 275 276 /* public: */ 277 int id; 278 279 enum sas_class class; 280 u8 sas_addr[SAS_ADDR_SIZE]; 281 u8 attached_sas_addr[SAS_ADDR_SIZE]; 282 enum sas_protocol iproto; 283 enum sas_protocol tproto; 284 285 enum sas_oob_mode oob_mode; 286 287 spinlock_t phy_list_lock; 288 struct list_head phy_list; 289 int num_phys; 290 u32 phy_mask; 291 292 struct sas_ha_struct *ha; 293 294 struct sas_port *port; 295 296 void *lldd_port; /* not touched by the sas class code */ 297 }; 298 299 struct asd_sas_event { 300 struct sas_work work; 301 struct asd_sas_phy *phy; 302 int event; 303 }; 304 305 static inline struct asd_sas_event *to_asd_sas_event(struct work_struct *work) 306 { 307 struct asd_sas_event *ev = container_of(work, typeof(*ev), work.work); 308 309 return ev; 310 } 311 312 static inline void INIT_SAS_EVENT(struct asd_sas_event *ev, 313 void (*fn)(struct work_struct *), 314 struct asd_sas_phy *phy, int event) 315 { 316 INIT_SAS_WORK(&ev->work, fn); 317 ev->phy = phy; 318 ev->event = event; 319 } 320 321 #define SAS_PHY_SHUTDOWN_THRES 1024 322 323 /* The phy pretty much is controlled by the LLDD. 324 * The class only reads those fields. 325 */ 326 struct asd_sas_phy { 327 /* private: */ 328 atomic_t event_nr; 329 int in_shutdown; 330 int error; 331 int suspended; 332 333 struct sas_phy *phy; 334 335 /* public: */ 336 /* The following are class:RO, driver:R/W */ 337 int enabled; /* must be set */ 338 339 int id; /* must be set */ 340 enum sas_class class; 341 enum sas_protocol iproto; 342 enum sas_protocol tproto; 343 344 enum sas_phy_type type; 345 enum sas_phy_role role; 346 enum sas_oob_mode oob_mode; 347 enum sas_linkrate linkrate; 348 349 u8 *sas_addr; /* must be set */ 350 u8 attached_sas_addr[SAS_ADDR_SIZE]; /* class:RO, driver: R/W */ 351 352 spinlock_t frame_rcvd_lock; 353 u8 *frame_rcvd; /* must be set */ 354 int frame_rcvd_size; 355 356 spinlock_t sas_prim_lock; 357 u32 sas_prim; 358 359 struct list_head port_phy_el; /* driver:RO */ 360 struct asd_sas_port *port; /* Class:RW, driver: RO */ 361 362 struct sas_ha_struct *ha; /* may be set; the class sets it anyway */ 363 364 void *lldd_phy; /* not touched by the sas_class_code */ 365 }; 366 367 struct scsi_core { 368 struct Scsi_Host *shost; 369 370 }; 371 372 enum sas_ha_state { 373 SAS_HA_REGISTERED, 374 SAS_HA_DRAINING, 375 SAS_HA_ATA_EH_ACTIVE, 376 SAS_HA_FROZEN, 377 }; 378 379 struct sas_ha_struct { 380 /* private: */ 381 struct list_head defer_q; /* work queued while draining */ 382 struct mutex drain_mutex; 383 unsigned long state; 384 spinlock_t lock; 385 int eh_active; 386 wait_queue_head_t eh_wait_q; 387 struct list_head eh_dev_q; 388 389 struct mutex disco_mutex; 390 391 struct scsi_core core; 392 393 /* public: */ 394 char *sas_ha_name; 395 struct device *dev; /* should be set */ 396 struct module *lldd_module; /* should be set */ 397 398 struct workqueue_struct *event_q; 399 struct workqueue_struct *disco_q; 400 401 u8 *sas_addr; /* must be set */ 402 u8 hashed_sas_addr[HASHED_SAS_ADDR_SIZE]; 403 404 spinlock_t phy_port_lock; 405 struct asd_sas_phy **sas_phy; /* array of valid pointers, must be set */ 406 struct asd_sas_port **sas_port; /* array of valid pointers, must be set */ 407 int num_phys; /* must be set, gt 0, static */ 408 409 int strict_wide_ports; /* both sas_addr and attached_sas_addr must match 410 * their siblings when forming wide ports */ 411 412 /* LLDD calls these to notify the class of an event. */ 413 int (*notify_port_event)(struct asd_sas_phy *, enum port_event); 414 int (*notify_phy_event)(struct asd_sas_phy *, enum phy_event); 415 416 void *lldd_ha; /* not touched by sas class code */ 417 418 struct list_head eh_done_q; /* complete via scsi_eh_flush_done_q */ 419 struct list_head eh_ata_q; /* scmds to promote from sas to ata eh */ 420 421 int event_thres; 422 }; 423 424 #define SHOST_TO_SAS_HA(_shost) (*(struct sas_ha_struct **)(_shost)->hostdata) 425 426 static inline struct domain_device * 427 starget_to_domain_dev(struct scsi_target *starget) { 428 return starget->hostdata; 429 } 430 431 static inline struct domain_device * 432 sdev_to_domain_dev(struct scsi_device *sdev) { 433 return starget_to_domain_dev(sdev->sdev_target); 434 } 435 436 static inline struct ata_device *sas_to_ata_dev(struct domain_device *dev) 437 { 438 return &dev->sata_dev.ap->link.device[0]; 439 } 440 441 static inline struct domain_device * 442 cmd_to_domain_dev(struct scsi_cmnd *cmd) 443 { 444 return sdev_to_domain_dev(cmd->device); 445 } 446 447 void sas_hash_addr(u8 *hashed, const u8 *sas_addr); 448 449 /* Before calling a notify event, LLDD should use this function 450 * when the link is severed (possibly from its tasklet). 451 * The idea is that the Class only reads those, while the LLDD, 452 * can R/W these (thus avoiding a race). 453 */ 454 static inline void sas_phy_disconnected(struct asd_sas_phy *phy) 455 { 456 phy->oob_mode = OOB_NOT_CONNECTED; 457 phy->linkrate = SAS_LINK_RATE_UNKNOWN; 458 } 459 460 static inline unsigned int to_sas_gpio_od(int device, int bit) 461 { 462 return 3 * device + bit; 463 } 464 465 static inline void sas_put_local_phy(struct sas_phy *phy) 466 { 467 put_device(&phy->dev); 468 } 469 470 #ifdef CONFIG_SCSI_SAS_HOST_SMP 471 int try_test_sas_gpio_gp_bit(unsigned int od, u8 *data, u8 index, u8 count); 472 #else 473 static inline int try_test_sas_gpio_gp_bit(unsigned int od, u8 *data, u8 index, u8 count) 474 { 475 return -1; 476 } 477 #endif 478 479 /* ---------- Tasks ---------- */ 480 /* 481 service_response | SAS_TASK_COMPLETE | SAS_TASK_UNDELIVERED | 482 exec_status | | | 483 ---------------------+---------------------+-----------------------+ 484 SAM_... | X | | 485 DEV_NO_RESPONSE | X | X | 486 INTERRUPTED | X | | 487 QUEUE_FULL | | X | 488 DEVICE_UNKNOWN | | X | 489 SG_ERR | | X | 490 ---------------------+---------------------+-----------------------+ 491 */ 492 493 enum service_response { 494 SAS_TASK_COMPLETE, 495 SAS_TASK_UNDELIVERED = -1, 496 }; 497 498 enum exec_status { 499 /* The SAM_STAT_.. codes fit in the lower 6 bits, alias some of 500 * them here to silence 'case value not in enumerated type' warnings 501 */ 502 __SAM_STAT_CHECK_CONDITION = SAM_STAT_CHECK_CONDITION, 503 504 SAS_DEV_NO_RESPONSE = 0x80, 505 SAS_DATA_UNDERRUN, 506 SAS_DATA_OVERRUN, 507 SAS_INTERRUPTED, 508 SAS_QUEUE_FULL, 509 SAS_DEVICE_UNKNOWN, 510 SAS_SG_ERR, 511 SAS_OPEN_REJECT, 512 SAS_OPEN_TO, 513 SAS_PROTO_RESPONSE, 514 SAS_PHY_DOWN, 515 SAS_NAK_R_ERR, 516 SAS_PENDING, 517 SAS_ABORTED_TASK, 518 }; 519 520 /* When a task finishes with a response, the LLDD examines the 521 * response: 522 * - For an ATA task task_status_struct::stat is set to 523 * SAS_PROTO_RESPONSE, and the task_status_struct::buf is set to the 524 * contents of struct ata_task_resp. 525 * - For SSP tasks, if no data is present or status/TMF response 526 * is valid, task_status_struct::stat is set. If data is present 527 * (SENSE data), the LLDD copies up to SAS_STATUS_BUF_SIZE, sets 528 * task_status_struct::buf_valid_size, and task_status_struct::stat is 529 * set to SAM_CHECK_COND. 530 * 531 * "buf" has format SCSI Sense for SSP task, or struct ata_task_resp 532 * for ATA task. 533 * 534 * "frame_len" is the total frame length, which could be more or less 535 * than actually copied. 536 * 537 * Tasks ending with response, always set the residual field. 538 */ 539 struct ata_task_resp { 540 u16 frame_len; 541 u8 ending_fis[ATA_RESP_FIS_SIZE]; /* dev to host or data-in */ 542 }; 543 544 #define SAS_STATUS_BUF_SIZE 96 545 546 struct task_status_struct { 547 enum service_response resp; 548 enum exec_status stat; 549 int buf_valid_size; 550 551 u8 buf[SAS_STATUS_BUF_SIZE]; 552 553 u32 residual; 554 enum sas_open_rej_reason open_rej_reason; 555 }; 556 557 /* ATA and ATAPI task queuable to a SAS LLDD. 558 */ 559 struct sas_ata_task { 560 struct host_to_dev_fis fis; 561 u8 atapi_packet[16]; /* 0 if not ATAPI task */ 562 563 u8 retry_count; /* hardware retry, should be > 0 */ 564 565 u8 dma_xfer:1; /* PIO:0 or DMA:1 */ 566 u8 use_ncq:1; 567 u8 set_affil_pol:1; 568 u8 stp_affil_pol:1; 569 570 u8 device_control_reg_update:1; 571 }; 572 573 struct sas_smp_task { 574 struct scatterlist smp_req; 575 struct scatterlist smp_resp; 576 }; 577 578 enum task_attribute { 579 TASK_ATTR_SIMPLE = 0, 580 TASK_ATTR_HOQ = 1, 581 TASK_ATTR_ORDERED= 2, 582 TASK_ATTR_ACA = 4, 583 }; 584 585 struct sas_ssp_task { 586 u8 retry_count; /* hardware retry, should be > 0 */ 587 588 u8 LUN[8]; 589 u8 enable_first_burst:1; 590 enum task_attribute task_attr; 591 u8 task_prio; 592 struct scsi_cmnd *cmd; 593 }; 594 595 struct sas_task { 596 struct domain_device *dev; 597 598 spinlock_t task_state_lock; 599 unsigned task_state_flags; 600 601 enum sas_protocol task_proto; 602 603 union { 604 struct sas_ata_task ata_task; 605 struct sas_smp_task smp_task; 606 struct sas_ssp_task ssp_task; 607 }; 608 609 struct scatterlist *scatter; 610 int num_scatter; 611 u32 total_xfer_len; 612 u8 data_dir:2; /* Use PCI_DMA_... */ 613 614 struct task_status_struct task_status; 615 void (*task_done)(struct sas_task *); 616 617 void *lldd_task; /* for use by LLDDs */ 618 void *uldd_task; 619 struct sas_task_slow *slow_task; 620 }; 621 622 struct sas_task_slow { 623 /* standard/extra infrastructure for slow path commands (SMP and 624 * internal lldd commands 625 */ 626 struct timer_list timer; 627 struct completion completion; 628 struct sas_task *task; 629 }; 630 631 #define SAS_TASK_STATE_PENDING 1 632 #define SAS_TASK_STATE_DONE 2 633 #define SAS_TASK_STATE_ABORTED 4 634 #define SAS_TASK_NEED_DEV_RESET 8 635 #define SAS_TASK_AT_INITIATOR 16 636 637 extern struct sas_task *sas_alloc_task(gfp_t flags); 638 extern struct sas_task *sas_alloc_slow_task(gfp_t flags); 639 extern void sas_free_task(struct sas_task *task); 640 641 struct sas_domain_function_template { 642 /* The class calls these to notify the LLDD of an event. */ 643 void (*lldd_port_formed)(struct asd_sas_phy *); 644 void (*lldd_port_deformed)(struct asd_sas_phy *); 645 646 /* The class calls these when a device is found or gone. */ 647 int (*lldd_dev_found)(struct domain_device *); 648 void (*lldd_dev_gone)(struct domain_device *); 649 650 int (*lldd_execute_task)(struct sas_task *, gfp_t gfp_flags); 651 652 /* Task Management Functions. Must be called from process context. */ 653 int (*lldd_abort_task)(struct sas_task *); 654 int (*lldd_abort_task_set)(struct domain_device *, u8 *lun); 655 int (*lldd_clear_aca)(struct domain_device *, u8 *lun); 656 int (*lldd_clear_task_set)(struct domain_device *, u8 *lun); 657 int (*lldd_I_T_nexus_reset)(struct domain_device *); 658 int (*lldd_ata_check_ready)(struct domain_device *); 659 void (*lldd_ata_set_dmamode)(struct domain_device *); 660 int (*lldd_lu_reset)(struct domain_device *, u8 *lun); 661 int (*lldd_query_task)(struct sas_task *); 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_suspend_ha(struct sas_ha_struct *sas_ha); 680 681 int sas_set_phy_speed(struct sas_phy *phy, struct sas_phy_linkrates *rates); 682 int sas_phy_reset(struct sas_phy *phy, int hard_reset); 683 extern int sas_queuecommand(struct Scsi_Host *, struct scsi_cmnd *); 684 extern int sas_target_alloc(struct scsi_target *); 685 extern int sas_slave_configure(struct scsi_device *); 686 extern int sas_change_queue_depth(struct scsi_device *, int new_depth); 687 extern int sas_bios_param(struct scsi_device *, struct block_device *, 688 sector_t capacity, int *hsc); 689 extern struct scsi_transport_template * 690 sas_domain_attach_transport(struct sas_domain_function_template *); 691 extern struct device_attribute dev_attr_phy_event_threshold; 692 693 int sas_discover_root_expander(struct domain_device *); 694 695 void sas_init_ex_attr(void); 696 697 int sas_ex_revalidate_domain(struct domain_device *); 698 699 void sas_unregister_domain_devices(struct asd_sas_port *port, int gone); 700 void sas_init_disc(struct sas_discovery *disc, struct asd_sas_port *); 701 int sas_discover_event(struct asd_sas_port *, enum discover_event ev); 702 703 int sas_discover_sata(struct domain_device *); 704 int sas_discover_end_dev(struct domain_device *); 705 706 void sas_unregister_dev(struct asd_sas_port *port, struct domain_device *); 707 708 void sas_init_dev(struct domain_device *); 709 710 void sas_task_abort(struct sas_task *); 711 int sas_eh_abort_handler(struct scsi_cmnd *cmd); 712 int sas_eh_device_reset_handler(struct scsi_cmnd *cmd); 713 int sas_eh_target_reset_handler(struct scsi_cmnd *cmd); 714 715 extern void sas_target_destroy(struct scsi_target *); 716 extern int sas_slave_alloc(struct scsi_device *); 717 extern int sas_ioctl(struct scsi_device *sdev, unsigned int cmd, 718 void __user *arg); 719 extern int sas_drain_work(struct sas_ha_struct *ha); 720 721 extern void sas_ssp_task_response(struct device *dev, struct sas_task *task, 722 struct ssp_response_iu *iu); 723 struct sas_phy *sas_get_local_phy(struct domain_device *dev); 724 725 int sas_request_addr(struct Scsi_Host *shost, u8 *addr); 726 727 #endif /* _SASLIB_H_ */ 728