libsas.h 19 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
/*
 * SAS host prototypes and structures header file
 *
 * Copyright (C) 2005 Adaptec, Inc.  All rights reserved.
 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
 *
 * This file is licensed under GPLv2.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 *
 */

#ifndef _LIBSAS_H_
#define _LIBSAS_H_


#include <linux/timer.h>
#include <linux/pci.h>
#include <scsi/sas.h>
33
#include <linux/libata.h>
34 35 36 37
#include <linux/list.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_transport_sas.h>
38
#include <linux/scatterlist.h>
39
#include <linux/slab.h>
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

struct block_device;

enum sas_class {
	SAS,
	EXPANDER
};

enum sas_phy_role {
	PHY_ROLE_NONE = 0,
	PHY_ROLE_TARGET = 0x40,
	PHY_ROLE_INITIATOR = 0x80,
};

enum sas_phy_type {
        PHY_TYPE_PHYSICAL,
        PHY_TYPE_VIRTUAL
};

/* The events are mnemonically described in sas_dump.c
 * so when updating/adding events here, please also
 * update the other file too.
 */
enum ha_event {
	HAE_RESET             = 0U,
	HA_NUM_EVENTS         = 1,
};

enum port_event {
	PORTE_BYTES_DMAED     = 0U,
	PORTE_BROADCAST_RCVD  = 1,
	PORTE_LINK_RESET_ERR  = 2,
	PORTE_TIMER_EVENT     = 3,
	PORTE_HARD_RESET      = 4,
	PORT_NUM_EVENTS       = 5,
};

enum phy_event {
	PHYE_LOSS_OF_SIGNAL   = 0U,
	PHYE_OOB_DONE         = 1,
	PHYE_OOB_ERROR        = 2,
	PHYE_SPINUP_HOLD      = 3, /* hot plug SATA, no COMWAKE sent */
82 83
	PHYE_RESUME_TIMEOUT   = 4,
	PHY_NUM_EVENTS        = 5,
84 85 86 87 88 89
};

enum discover_event {
	DISCE_DISCOVER_DOMAIN   = 0U,
	DISCE_REVALIDATE_DOMAIN = 1,
	DISCE_PORT_GONE         = 2,
90
	DISCE_PROBE		= 3,
91 92 93 94
	DISCE_SUSPEND		= 4,
	DISCE_RESUME		= 5,
	DISCE_DESTRUCT		= 6,
	DISC_NUM_EVENTS		= 7,
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
};

/* ---------- Expander Devices ---------- */

#define to_dom_device(_obj) container_of(_obj, struct domain_device, dev_obj)
#define to_dev_attr(_attr)  container_of(_attr, struct domain_dev_attribute,\
                                         attr)

enum routing_attribute {
	DIRECT_ROUTING,
	SUBTRACTIVE_ROUTING,
	TABLE_ROUTING,
};

enum ex_phy_state {
	PHY_EMPTY,
	PHY_VACANT,
	PHY_NOT_PRESENT,
	PHY_DEVICE_DISCOVERED
};

struct ex_phy {
	int    phy_id;

	enum ex_phy_state phy_state;

121
	enum sas_device_type attached_dev_type;
122
	enum sas_linkrate linkrate;
123 124 125 126 127

	u8   attached_sata_host:1;
	u8   attached_sata_dev:1;
	u8   attached_sata_ps:1;

128 129
	enum sas_protocol attached_tproto;
	enum sas_protocol attached_iproto;
130 131 132 133

	u8   attached_sas_addr[SAS_ADDR_SIZE];
	u8   attached_phy_id;

134
	int phy_change_count;
135 136 137 138 139 140 141 142 143 144 145 146
	enum routing_attribute routing_attr;
	u8   virtual:1;

	int  last_da_index;

	struct sas_phy *phy;
	struct sas_port *port;
};

struct expander_device {
	struct list_head children;

147
	int    ex_change_count;
148 149
	u16    max_route_indexes;
	u8     num_phys;
150 151

	u8     t2t_supp:1;
152 153
	u8     configuring:1;
	u8     conf_route_table:1;
154

155 156 157 158
	u8     enclosure_logical_id[8];

	struct ex_phy *ex_phy;
	struct sas_port *parent_port;
159 160

	struct mutex cmd_mutex;
161 162 163
};

/* ---------- SATA device ---------- */
164 165
#define ATA_RESP_FIS_SIZE 24

166
struct sata_device {
167 168 169
	unsigned int class;
	struct smp_resp        rps_resp; /* report_phy_sata_resp */
	u8     port_no;        /* port number, if this is a PM (Port) */
170 171 172

	struct ata_port *ap;
	struct ata_host ata_host;
173
	u8     fis[ATA_RESP_FIS_SIZE];
174 175
};

176 177 178 179 180
struct ssp_device {
	struct list_head eh_list_node; /* pending a user requested eh action */
	struct scsi_lun reset_lun;
};

181 182
enum {
	SAS_DEV_GONE,
183
	SAS_DEV_FOUND, /* device notified to lldd */
184
	SAS_DEV_DESTROY,
185
	SAS_DEV_EH_PENDING,
186 187
	SAS_DEV_LU_RESET,
	SAS_DEV_RESET,
188 189
};

190
struct domain_device {
191
	spinlock_t done_lock;
192
	enum sas_device_type dev_type;
193

194 195 196
        enum sas_linkrate linkrate;
        enum sas_linkrate min_linkrate;
        enum sas_linkrate max_linkrate;
197 198 199 200 201 202

        int  pathways;

        struct domain_device *parent;
        struct list_head siblings; /* devices on the same level */
        struct asd_sas_port *port;        /* shortcut to root of the tree */
203
	struct sas_phy *phy;
204 205

        struct list_head dev_list_node;
206
	struct list_head disco_list_node; /* awaiting probe or destruct */
207

208 209
        enum sas_protocol    iproto;
        enum sas_protocol    tproto;
210 211 212 213 214 215 216 217 218 219 220

        struct sas_rphy *rphy;

        u8  sas_addr[SAS_ADDR_SIZE];
        u8  hashed_sas_addr[HASHED_SAS_ADDR_SIZE];

        u8  frame_rcvd[32];

        union {
                struct expander_device ex_dev;
                struct sata_device     sata_dev; /* STP & directly attached */
221
		struct ssp_device      ssp_dev;
222 223 224
        };

        void *lldd_dev;
225
	unsigned long state;
226
	struct kref kref;
227 228
};

229 230
struct sas_work {
	struct list_head drain_node;
231
	struct work_struct work;
232 233 234 235 236 237 238 239 240 241
};

static inline void INIT_SAS_WORK(struct sas_work *sw, void (*fn)(struct work_struct *))
{
	INIT_WORK(&sw->work, fn);
	INIT_LIST_HEAD(&sw->drain_node);
}

struct sas_discovery_event {
	struct sas_work work;
242 243 244
	struct asd_sas_port *port;
};

245 246 247 248 249 250 251
static inline struct sas_discovery_event *to_sas_discovery_event(struct work_struct *work)
{
	struct sas_discovery_event *ev = container_of(work, typeof(*ev), work.work);

	return ev;
}

252
struct sas_discovery {
253
	struct sas_discovery_event disc_work[DISC_NUM_EVENTS];
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
	unsigned long    pending;
	u8     fanout_sas_addr[8];
	u8     eeds_a[8];
	u8     eeds_b[8];
	int    max_level;
};

/* The port struct is Class:RW, driver:RO */
struct asd_sas_port {
/* private: */
	struct completion port_gone_completion;

	struct sas_discovery disc;
	struct domain_device *port_dev;
	spinlock_t dev_list_lock;
	struct list_head dev_list;
270 271
	struct list_head disco_list;
	struct list_head destroy_list;
272
	enum   sas_linkrate linkrate;
273

274
	struct sas_work work;
275
	int suspended;
276 277 278 279 280 281 282

/* public: */
	int id;

	enum sas_class   class;
	u8               sas_addr[SAS_ADDR_SIZE];
	u8               attached_sas_addr[SAS_ADDR_SIZE];
283 284
	enum sas_protocol   iproto;
	enum sas_protocol   tproto;
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299

	enum sas_oob_mode oob_mode;

	spinlock_t       phy_list_lock;
	struct list_head phy_list;
	int              num_phys;
	u32              phy_mask;

	struct sas_ha_struct *ha;

	struct sas_port	*port;

	void *lldd_port;	  /* not touched by the sas class code */
};

300
struct asd_sas_event {
301
	struct sas_work work;
302 303 304
	struct asd_sas_phy *phy;
};

305 306 307 308 309 310 311
static inline struct asd_sas_event *to_asd_sas_event(struct work_struct *work)
{
	struct asd_sas_event *ev = container_of(work, typeof(*ev), work.work);

	return ev;
}

312 313 314 315 316
/* The phy pretty much is controlled by the LLDD.
 * The class only reads those fields.
 */
struct asd_sas_phy {
/* private: */
317 318
	struct asd_sas_event   port_events[PORT_NUM_EVENTS];
	struct asd_sas_event   phy_events[PHY_NUM_EVENTS];
319 320 321 322 323

	unsigned long port_events_pending;
	unsigned long phy_events_pending;

	int error;
324
	int suspended;
325 326 327 328 329 330 331 332 333

	struct sas_phy *phy;

/* public: */
	/* The following are class:RO, driver:R/W */
	int            enabled;	  /* must be set */

	int            id;	  /* must be set */
	enum sas_class class;
334 335
	enum sas_protocol iproto;
	enum sas_protocol tproto;
336 337 338 339

	enum sas_phy_type  type;
	enum sas_phy_role  role;
	enum sas_oob_mode  oob_mode;
340
	enum sas_linkrate linkrate;
341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364

	u8   *sas_addr;		  /* must be set */
	u8   attached_sas_addr[SAS_ADDR_SIZE]; /* class:RO, driver: R/W */

	spinlock_t     frame_rcvd_lock;
	u8             *frame_rcvd; /* must be set */
	int            frame_rcvd_size;

	spinlock_t     sas_prim_lock;
	u32            sas_prim;

	struct list_head port_phy_el; /* driver:RO */
	struct asd_sas_port      *port; /* Class:RW, driver: RO */

	struct sas_ha_struct *ha; /* may be set; the class sets it anyway */

	void *lldd_phy;		  /* not touched by the sas_class_code */
};

struct scsi_core {
	struct Scsi_Host *shost;

};

365
struct sas_ha_event {
366
	struct sas_work work;
367 368 369
	struct sas_ha_struct *ha;
};

370 371 372 373 374 375 376
static inline struct sas_ha_event *to_sas_ha_event(struct work_struct *work)
{
	struct sas_ha_event *ev = container_of(work, typeof(*ev), work.work);

	return ev;
}

377 378
enum sas_ha_state {
	SAS_HA_REGISTERED,
379
	SAS_HA_DRAINING,
380
	SAS_HA_ATA_EH_ACTIVE,
381
	SAS_HA_FROZEN,
382 383
};

384 385
struct sas_ha_struct {
/* private: */
386
	struct sas_ha_event ha_events[HA_NUM_EVENTS];
387 388
	unsigned long	 pending;

389 390
	struct list_head  defer_q; /* work queued while draining */
	struct mutex	  drain_mutex;
391
	unsigned long	  state;
392 393
	spinlock_t	  lock;
	int		  eh_active;
394 395
	wait_queue_head_t eh_wait_q;
	struct list_head  eh_dev_q;
396

397 398
	struct mutex disco_mutex;

399 400 401 402
	struct scsi_core core;

/* public: */
	char *sas_ha_name;
403
	struct device *dev;	  /* should be set */
404 405 406 407 408 409 410 411 412 413
	struct module *lldd_module; /* should be set */

	u8 *sas_addr;		  /* must be set */
	u8 hashed_sas_addr[HASHED_SAS_ADDR_SIZE];

	spinlock_t      phy_port_lock;
	struct asd_sas_phy  **sas_phy; /* array of valid pointers, must be set */
	struct asd_sas_port **sas_port; /* array of valid pointers, must be set */
	int             num_phys; /* must be set, gt 0, static */

414 415
	int strict_wide_ports; /* both sas_addr and attached_sas_addr must match
				* their siblings when forming wide ports */
416 417 418 419 420 421 422

	/* LLDD calls these to notify the class of an event. */
	void (*notify_ha_event)(struct sas_ha_struct *, enum ha_event);
	void (*notify_port_event)(struct asd_sas_phy *, enum port_event);
	void (*notify_phy_event)(struct asd_sas_phy *, enum phy_event);

	void *lldd_ha;		  /* not touched by sas class code */
423

424 425
	struct list_head eh_done_q;  /* complete via scsi_eh_flush_done_q */
	struct list_head eh_ata_q; /* scmds to promote from sas to ata eh */
426 427 428 429 430 431 432 433 434 435 436 437 438 439
};

#define SHOST_TO_SAS_HA(_shost) (*(struct sas_ha_struct **)(_shost)->hostdata)

static inline struct domain_device *
starget_to_domain_dev(struct scsi_target *starget) {
	return starget->hostdata;
}

static inline struct domain_device *
sdev_to_domain_dev(struct scsi_device *sdev) {
	return starget_to_domain_dev(sdev->sdev_target);
}

440 441 442 443 444
static inline struct ata_device *sas_to_ata_dev(struct domain_device *dev)
{
	return &dev->sata_dev.ap->link.device[0];
}

445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
static inline struct domain_device *
cmd_to_domain_dev(struct scsi_cmnd *cmd)
{
	return sdev_to_domain_dev(cmd->device);
}

void sas_hash_addr(u8 *hashed, const u8 *sas_addr);

/* Before calling a notify event, LLDD should use this function
 * when the link is severed (possibly from its tasklet).
 * The idea is that the Class only reads those, while the LLDD,
 * can R/W these (thus avoiding a race).
 */
static inline void sas_phy_disconnected(struct asd_sas_phy *phy)
{
	phy->oob_mode = OOB_NOT_CONNECTED;
461
	phy->linkrate = SAS_LINK_RATE_UNKNOWN;
462 463
}

464 465 466 467 468
static inline unsigned int to_sas_gpio_od(int device, int bit)
{
	return 3 * device + bit;
}

469 470 471 472 473
static inline void sas_put_local_phy(struct sas_phy *phy)
{
	put_device(&phy->dev);
}

474
#ifdef CONFIG_SCSI_SAS_HOST_SMP
475
int try_test_sas_gpio_gp_bit(unsigned int od, u8 *data, u8 index, u8 count);
476 477 478 479 480 481
#else
static inline int try_test_sas_gpio_gp_bit(unsigned int od, u8 *data, u8 index, u8 count)
{
	return -1;
}
#endif
482

483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502
/* ---------- Tasks ---------- */
/*
      service_response |  SAS_TASK_COMPLETE  |  SAS_TASK_UNDELIVERED |
  exec_status          |                     |                       |
  ---------------------+---------------------+-----------------------+
       SAM_...         |         X           |                       |
       DEV_NO_RESPONSE |         X           |           X           |
       INTERRUPTED     |         X           |                       |
       QUEUE_FULL      |                     |           X           |
       DEVICE_UNKNOWN  |                     |           X           |
       SG_ERR          |                     |           X           |
  ---------------------+---------------------+-----------------------+
 */

enum service_response {
	SAS_TASK_COMPLETE,
	SAS_TASK_UNDELIVERED = -1,
};

enum exec_status {
503 504 505 506
	/* The SAM_STAT_.. codes fit in the lower 6 bits, alias some of
	 * them here to silence 'case value not in enumerated type' warnings
	 */
	__SAM_STAT_CHECK_CONDITION = SAM_STAT_CHECK_CONDITION,
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544

	SAS_DEV_NO_RESPONSE = 0x80,
	SAS_DATA_UNDERRUN,
	SAS_DATA_OVERRUN,
	SAS_INTERRUPTED,
	SAS_QUEUE_FULL,
	SAS_DEVICE_UNKNOWN,
	SAS_SG_ERR,
	SAS_OPEN_REJECT,
	SAS_OPEN_TO,
	SAS_PROTO_RESPONSE,
	SAS_PHY_DOWN,
	SAS_NAK_R_ERR,
	SAS_PENDING,
	SAS_ABORTED_TASK,
};

/* When a task finishes with a response, the LLDD examines the
 * response:
 * 	- For an ATA task task_status_struct::stat is set to
 * SAS_PROTO_RESPONSE, and the task_status_struct::buf is set to the
 * contents of struct ata_task_resp.
 * 	- For SSP tasks, if no data is present or status/TMF response
 * is valid, task_status_struct::stat is set.  If data is present
 * (SENSE data), the LLDD copies up to SAS_STATUS_BUF_SIZE, sets
 * task_status_struct::buf_valid_size, and task_status_struct::stat is
 * set to SAM_CHECK_COND.
 *
 * "buf" has format SCSI Sense for SSP task, or struct ata_task_resp
 * for ATA task.
 *
 * "frame_len" is the total frame length, which could be more or less
 * than actually copied.
 *
 * Tasks ending with response, always set the residual field.
 */
struct ata_task_resp {
	u16  frame_len;
545
	u8   ending_fis[ATA_RESP_FIS_SIZE];	  /* dev to host or data-in */
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
};

#define SAS_STATUS_BUF_SIZE 96

struct task_status_struct {
	enum service_response resp;
	enum exec_status      stat;
	int  buf_valid_size;

	u8   buf[SAS_STATUS_BUF_SIZE];

	u32  residual;
	enum sas_open_rej_reason open_rej_reason;
};

/* ATA and ATAPI task queuable to a SAS LLDD.
 */
struct sas_ata_task {
	struct host_to_dev_fis fis;
	u8     atapi_packet[16];  /* 0 if not ATAPI task */

	u8     retry_count;	  /* hardware retry, should be > 0 */

	u8     dma_xfer:1;	  /* PIO:0 or DMA:1 */
	u8     use_ncq:1;
	u8     set_affil_pol:1;
	u8     stp_affil_pol:1;

	u8     device_control_reg_update:1;
};

struct sas_smp_task {
	struct scatterlist smp_req;
	struct scatterlist smp_resp;
};

enum task_attribute {
	TASK_ATTR_SIMPLE = 0,
	TASK_ATTR_HOQ    = 1,
	TASK_ATTR_ORDERED= 2,
	TASK_ATTR_ACA    = 4,
};

struct sas_ssp_task {
	u8     retry_count;	  /* hardware retry, should be > 0 */

	u8     LUN[8];
	u8     enable_first_burst:1;
	enum   task_attribute task_attr;
	u8     task_prio;
596
	struct scsi_cmnd *cmd;
597 598 599 600 601 602 603 604
};

struct sas_task {
	struct domain_device *dev;

	spinlock_t   task_state_lock;
	unsigned     task_state_flags;

605
	enum   sas_protocol      task_proto;
606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622

	union {
		struct sas_ata_task ata_task;
		struct sas_smp_task smp_task;
		struct sas_ssp_task ssp_task;
	};

	struct scatterlist *scatter;
	int    num_scatter;
	u32    total_xfer_len;
	u8     data_dir:2;	  /* Use PCI_DMA_... */

	struct task_status_struct task_status;
	void   (*task_done)(struct sas_task *);

	void   *lldd_task;	  /* for use by LLDDs */
	void   *uldd_task;
623 624
	struct sas_task_slow *slow_task;
};
625

626 627 628 629 630 631
struct sas_task_slow {
	/* standard/extra infrastructure for slow path commands (SMP and
	 * internal lldd commands
	 */
	struct timer_list     timer;
	struct completion     completion;
632 633
};

634 635 636
#define SAS_TASK_STATE_PENDING      1
#define SAS_TASK_STATE_DONE         2
#define SAS_TASK_STATE_ABORTED      4
637
#define SAS_TASK_NEED_DEV_RESET     8
638
#define SAS_TASK_AT_INITIATOR       16
639

640
extern struct sas_task *sas_alloc_task(gfp_t flags);
641
extern struct sas_task *sas_alloc_slow_task(gfp_t flags);
642
extern void sas_free_task(struct sas_task *task);
643 644 645 646 647 648 649 650 651 652

struct sas_domain_function_template {
	/* The class calls these to notify the LLDD of an event. */
	void (*lldd_port_formed)(struct asd_sas_phy *);
	void (*lldd_port_deformed)(struct asd_sas_phy *);

	/* The class calls these when a device is found or gone. */
	int  (*lldd_dev_found)(struct domain_device *);
	void (*lldd_dev_gone)(struct domain_device *);

653
	int (*lldd_execute_task)(struct sas_task *, gfp_t gfp_flags);
654 655 656 657 658 659 660

	/* Task Management Functions. Must be called from process context. */
	int (*lldd_abort_task)(struct sas_task *);
	int (*lldd_abort_task_set)(struct domain_device *, u8 *lun);
	int (*lldd_clear_aca)(struct domain_device *, u8 *lun);
	int (*lldd_clear_task_set)(struct domain_device *, u8 *lun);
	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 664 665 666 667 668 669 670
	int (*lldd_lu_reset)(struct domain_device *, u8 *lun);
	int (*lldd_query_task)(struct sas_task *);

	/* Port and Adapter management */
	int (*lldd_clear_nexus_port)(struct asd_sas_port *);
	int (*lldd_clear_nexus_ha)(struct sas_ha_struct *);

	/* Phy management */
671
	int (*lldd_control_phy)(struct asd_sas_phy *, enum phy_func, void *);
672 673 674 675

	/* GPIO support */
	int (*lldd_write_gpio)(struct sas_ha_struct *, u8 reg_type,
			       u8 reg_index, u8 reg_count, u8 *write_data);
676 677 678 679
};

extern int sas_register_ha(struct sas_ha_struct *);
extern int sas_unregister_ha(struct sas_ha_struct *);
680 681 682
extern void sas_prep_resume_ha(struct sas_ha_struct *sas_ha);
extern void sas_resume_ha(struct sas_ha_struct *sas_ha);
extern void sas_suspend_ha(struct sas_ha_struct *sas_ha);
683

684 685
int sas_set_phy_speed(struct sas_phy *phy,
		      struct sas_phy_linkrates *rates);
686
int sas_phy_reset(struct sas_phy *phy, int hard_reset);
Jeff Garzik's avatar
Jeff Garzik committed
687
extern int sas_queuecommand(struct Scsi_Host * ,struct scsi_cmnd *);
688 689
extern int sas_target_alloc(struct scsi_target *);
extern int sas_slave_configure(struct scsi_device *);
690
extern int sas_change_queue_depth(struct scsi_device *, int new_depth);
691 692 693 694 695 696 697 698 699 700 701 702 703
extern int sas_bios_param(struct scsi_device *,
			  struct block_device *,
			  sector_t capacity, int *hsc);
extern struct scsi_transport_template *
sas_domain_attach_transport(struct sas_domain_function_template *);
extern void sas_domain_release_transport(struct scsi_transport_template *);

int  sas_discover_root_expander(struct domain_device *);

void sas_init_ex_attr(void);

int  sas_ex_revalidate_domain(struct domain_device *);

704
void sas_unregister_domain_devices(struct asd_sas_port *port, int gone);
705 706 707 708 709 710
void sas_init_disc(struct sas_discovery *disc, struct asd_sas_port *);
int  sas_discover_event(struct asd_sas_port *, enum discover_event ev);

int  sas_discover_sata(struct domain_device *);
int  sas_discover_end_dev(struct domain_device *);

711
void sas_unregister_dev(struct asd_sas_port *port, struct domain_device *);
712 713 714

void sas_init_dev(struct domain_device *);

715
void sas_task_abort(struct sas_task *);
716
int sas_eh_abort_handler(struct scsi_cmnd *cmd);
717
int sas_eh_device_reset_handler(struct scsi_cmnd *cmd);
718
int sas_eh_bus_reset_handler(struct scsi_cmnd *cmd);
719

720 721 722
extern void sas_target_destroy(struct scsi_target *);
extern int sas_slave_alloc(struct scsi_device *);
extern int sas_ioctl(struct scsi_device *sdev, int cmd, void __user *arg);
723
extern int sas_drain_work(struct sas_ha_struct *ha);
724

725 726
extern int sas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
			   struct request *req);
727 728 729

extern void sas_ssp_task_response(struct device *dev, struct sas_task *task,
				  struct ssp_response_iu *iu);
730
struct sas_phy *sas_get_local_phy(struct domain_device *dev);
731

732 733
int sas_request_addr(struct Scsi_Host *shost, u8 *addr);

734
#endif /* _SASLIB_H_ */