xref: /openbmc/linux/include/scsi/libsas.h (revision 64c70b1c)
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/list.h>
34 #include <asm/semaphore.h>
35 #include <scsi/scsi_device.h>
36 #include <scsi/scsi_cmnd.h>
37 #include <scsi/scsi_transport_sas.h>
38 #include <asm/scatterlist.h>
39 
40 struct block_device;
41 
42 enum sas_class {
43 	SAS,
44 	EXPANDER
45 };
46 
47 enum sas_phy_role {
48 	PHY_ROLE_NONE = 0,
49 	PHY_ROLE_TARGET = 0x40,
50 	PHY_ROLE_INITIATOR = 0x80,
51 };
52 
53 enum sas_phy_type {
54         PHY_TYPE_PHYSICAL,
55         PHY_TYPE_VIRTUAL
56 };
57 
58 /* The events are mnemonically described in sas_dump.c
59  * so when updating/adding events here, please also
60  * update the other file too.
61  */
62 enum ha_event {
63 	HAE_RESET             = 0U,
64 	HA_NUM_EVENTS         = 1,
65 };
66 
67 enum port_event {
68 	PORTE_BYTES_DMAED     = 0U,
69 	PORTE_BROADCAST_RCVD  = 1,
70 	PORTE_LINK_RESET_ERR  = 2,
71 	PORTE_TIMER_EVENT     = 3,
72 	PORTE_HARD_RESET      = 4,
73 	PORT_NUM_EVENTS       = 5,
74 };
75 
76 enum phy_event {
77 	PHYE_LOSS_OF_SIGNAL   = 0U,
78 	PHYE_OOB_DONE         = 1,
79 	PHYE_OOB_ERROR        = 2,
80 	PHYE_SPINUP_HOLD      = 3, /* hot plug SATA, no COMWAKE sent */
81 	PHY_NUM_EVENTS        = 4,
82 };
83 
84 enum discover_event {
85 	DISCE_DISCOVER_DOMAIN   = 0U,
86 	DISCE_REVALIDATE_DOMAIN = 1,
87 	DISCE_PORT_GONE         = 2,
88 	DISC_NUM_EVENTS 	= 3,
89 };
90 
91 /* ---------- Expander Devices ---------- */
92 
93 #define ETASK 0xFA
94 
95 #define to_dom_device(_obj) container_of(_obj, struct domain_device, dev_obj)
96 #define to_dev_attr(_attr)  container_of(_attr, struct domain_dev_attribute,\
97                                          attr)
98 
99 enum routing_attribute {
100 	DIRECT_ROUTING,
101 	SUBTRACTIVE_ROUTING,
102 	TABLE_ROUTING,
103 };
104 
105 enum ex_phy_state {
106 	PHY_EMPTY,
107 	PHY_VACANT,
108 	PHY_NOT_PRESENT,
109 	PHY_DEVICE_DISCOVERED
110 };
111 
112 struct ex_phy {
113 	int    phy_id;
114 
115 	enum ex_phy_state phy_state;
116 
117 	enum sas_dev_type attached_dev_type;
118 	enum sas_linkrate linkrate;
119 
120 	u8   attached_sata_host:1;
121 	u8   attached_sata_dev:1;
122 	u8   attached_sata_ps:1;
123 
124 	enum sas_proto attached_tproto;
125 	enum sas_proto attached_iproto;
126 
127 	u8   attached_sas_addr[SAS_ADDR_SIZE];
128 	u8   attached_phy_id;
129 
130 	u8   phy_change_count;
131 	enum routing_attribute routing_attr;
132 	u8   virtual:1;
133 
134 	int  last_da_index;
135 
136 	struct sas_phy *phy;
137 	struct sas_port *port;
138 };
139 
140 struct expander_device {
141 	struct list_head children;
142 
143 	u16    ex_change_count;
144 	u16    max_route_indexes;
145 	u8     num_phys;
146 	u8     configuring:1;
147 	u8     conf_route_table:1;
148 	u8     enclosure_logical_id[8];
149 
150 	struct ex_phy *ex_phy;
151 	struct sas_port *parent_port;
152 };
153 
154 /* ---------- SATA device ---------- */
155 enum ata_command_set {
156         ATA_COMMAND_SET   = 0,
157         ATAPI_COMMAND_SET = 1,
158 };
159 
160 struct sata_device {
161         enum   ata_command_set command_set;
162         struct smp_resp        rps_resp; /* report_phy_sata_resp */
163         __le16 *identify_device;
164         __le16 *identify_packet_device;
165 
166         u8     port_no;        /* port number, if this is a PM (Port) */
167         struct list_head children; /* PM Ports if this is a PM */
168 };
169 
170 /* ---------- Domain device ---------- */
171 struct domain_device {
172         enum sas_dev_type dev_type;
173 
174         enum sas_linkrate linkrate;
175         enum sas_linkrate min_linkrate;
176         enum sas_linkrate max_linkrate;
177 
178         int  pathways;
179 
180         struct domain_device *parent;
181         struct list_head siblings; /* devices on the same level */
182         struct asd_sas_port *port;        /* shortcut to root of the tree */
183 
184         struct list_head dev_list_node;
185 
186         enum sas_proto    iproto;
187         enum sas_proto    tproto;
188 
189         struct sas_rphy *rphy;
190 
191         u8  sas_addr[SAS_ADDR_SIZE];
192         u8  hashed_sas_addr[HASHED_SAS_ADDR_SIZE];
193 
194         u8  frame_rcvd[32];
195 
196         union {
197                 struct expander_device ex_dev;
198                 struct sata_device     sata_dev; /* STP & directly attached */
199         };
200 
201         void *lldd_dev;
202 };
203 
204 struct sas_discovery_event {
205 	struct work_struct work;
206 	struct asd_sas_port *port;
207 };
208 
209 struct sas_discovery {
210 	spinlock_t disc_event_lock;
211 	struct sas_discovery_event disc_work[DISC_NUM_EVENTS];
212 	unsigned long    pending;
213 	u8     fanout_sas_addr[8];
214 	u8     eeds_a[8];
215 	u8     eeds_b[8];
216 	int    max_level;
217 };
218 
219 
220 /* The port struct is Class:RW, driver:RO */
221 struct asd_sas_port {
222 /* private: */
223 	struct completion port_gone_completion;
224 
225 	struct sas_discovery disc;
226 	struct domain_device *port_dev;
227 	spinlock_t dev_list_lock;
228 	struct list_head dev_list;
229 	enum   sas_linkrate linkrate;
230 
231 	struct sas_phy *phy;
232 	struct work_struct work;
233 
234 /* public: */
235 	int id;
236 
237 	enum sas_class   class;
238 	u8               sas_addr[SAS_ADDR_SIZE];
239 	u8               attached_sas_addr[SAS_ADDR_SIZE];
240 	enum sas_proto   iproto;
241 	enum sas_proto   tproto;
242 
243 	enum sas_oob_mode oob_mode;
244 
245 	spinlock_t       phy_list_lock;
246 	struct list_head phy_list;
247 	int              num_phys;
248 	u32              phy_mask;
249 
250 	struct sas_ha_struct *ha;
251 
252 	struct sas_port	*port;
253 
254 	void *lldd_port;	  /* not touched by the sas class code */
255 };
256 
257 struct asd_sas_event {
258 	struct work_struct work;
259 	struct asd_sas_phy *phy;
260 };
261 
262 /* The phy pretty much is controlled by the LLDD.
263  * The class only reads those fields.
264  */
265 struct asd_sas_phy {
266 /* private: */
267 	/* protected by ha->event_lock */
268 	struct asd_sas_event   port_events[PORT_NUM_EVENTS];
269 	struct asd_sas_event   phy_events[PHY_NUM_EVENTS];
270 
271 	unsigned long port_events_pending;
272 	unsigned long phy_events_pending;
273 
274 	int error;
275 
276 	struct sas_phy *phy;
277 
278 /* public: */
279 	/* The following are class:RO, driver:R/W */
280 	int            enabled;	  /* must be set */
281 
282 	int            id;	  /* must be set */
283 	enum sas_class class;
284 	enum sas_proto iproto;
285 	enum sas_proto tproto;
286 
287 	enum sas_phy_type  type;
288 	enum sas_phy_role  role;
289 	enum sas_oob_mode  oob_mode;
290 	enum sas_linkrate linkrate;
291 
292 	u8   *sas_addr;		  /* must be set */
293 	u8   attached_sas_addr[SAS_ADDR_SIZE]; /* class:RO, driver: R/W */
294 
295 	spinlock_t     frame_rcvd_lock;
296 	u8             *frame_rcvd; /* must be set */
297 	int            frame_rcvd_size;
298 
299 	spinlock_t     sas_prim_lock;
300 	u32            sas_prim;
301 
302 	struct list_head port_phy_el; /* driver:RO */
303 	struct asd_sas_port      *port; /* Class:RW, driver: RO */
304 
305 	struct sas_ha_struct *ha; /* may be set; the class sets it anyway */
306 
307 	void *lldd_phy;		  /* not touched by the sas_class_code */
308 };
309 
310 struct scsi_core {
311 	struct Scsi_Host *shost;
312 
313 	spinlock_t        task_queue_lock;
314 	struct list_head  task_queue;
315 	int               task_queue_size;
316 
317 	struct task_struct *queue_thread;
318 };
319 
320 struct sas_ha_event {
321 	struct work_struct work;
322 	struct sas_ha_struct *ha;
323 };
324 
325 enum sas_ha_state {
326 	SAS_HA_REGISTERED,
327 	SAS_HA_UNREGISTERED
328 };
329 
330 struct sas_ha_struct {
331 /* private: */
332 	spinlock_t       event_lock;
333 	struct sas_ha_event ha_events[HA_NUM_EVENTS];
334 	unsigned long	 pending;
335 
336 	enum sas_ha_state state;
337 	spinlock_t 	  state_lock;
338 
339 	struct scsi_core core;
340 
341 /* public: */
342 	char *sas_ha_name;
343 	struct pci_dev *pcidev;	  /* should be set */
344 	struct module *lldd_module; /* should be set */
345 
346 	u8 *sas_addr;		  /* must be set */
347 	u8 hashed_sas_addr[HASHED_SAS_ADDR_SIZE];
348 
349 	spinlock_t      phy_port_lock;
350 	struct asd_sas_phy  **sas_phy; /* array of valid pointers, must be set */
351 	struct asd_sas_port **sas_port; /* array of valid pointers, must be set */
352 	int             num_phys; /* must be set, gt 0, static */
353 
354 	/* The class calls this to send a task for execution. */
355 	int lldd_max_execute_num;
356 	int lldd_queue_size;
357 
358 	/* LLDD calls these to notify the class of an event. */
359 	void (*notify_ha_event)(struct sas_ha_struct *, enum ha_event);
360 	void (*notify_port_event)(struct asd_sas_phy *, enum port_event);
361 	void (*notify_phy_event)(struct asd_sas_phy *, enum phy_event);
362 
363 	void *lldd_ha;		  /* not touched by sas class code */
364 
365 	struct list_head eh_done_q;
366 };
367 
368 #define SHOST_TO_SAS_HA(_shost) (*(struct sas_ha_struct **)(_shost)->hostdata)
369 
370 static inline struct domain_device *
371 starget_to_domain_dev(struct scsi_target *starget) {
372 	return starget->hostdata;
373 }
374 
375 static inline struct domain_device *
376 sdev_to_domain_dev(struct scsi_device *sdev) {
377 	return starget_to_domain_dev(sdev->sdev_target);
378 }
379 
380 static inline struct domain_device *
381 cmd_to_domain_dev(struct scsi_cmnd *cmd)
382 {
383 	return sdev_to_domain_dev(cmd->device);
384 }
385 
386 void sas_hash_addr(u8 *hashed, const u8 *sas_addr);
387 
388 /* Before calling a notify event, LLDD should use this function
389  * when the link is severed (possibly from its tasklet).
390  * The idea is that the Class only reads those, while the LLDD,
391  * can R/W these (thus avoiding a race).
392  */
393 static inline void sas_phy_disconnected(struct asd_sas_phy *phy)
394 {
395 	phy->oob_mode = OOB_NOT_CONNECTED;
396 	phy->linkrate = SAS_LINK_RATE_UNKNOWN;
397 }
398 
399 /* ---------- Tasks ---------- */
400 /*
401       service_response |  SAS_TASK_COMPLETE  |  SAS_TASK_UNDELIVERED |
402   exec_status          |                     |                       |
403   ---------------------+---------------------+-----------------------+
404        SAM_...         |         X           |                       |
405        DEV_NO_RESPONSE |         X           |           X           |
406        INTERRUPTED     |         X           |                       |
407        QUEUE_FULL      |                     |           X           |
408        DEVICE_UNKNOWN  |                     |           X           |
409        SG_ERR          |                     |           X           |
410   ---------------------+---------------------+-----------------------+
411  */
412 
413 enum service_response {
414 	SAS_TASK_COMPLETE,
415 	SAS_TASK_UNDELIVERED = -1,
416 };
417 
418 enum exec_status {
419 	SAM_GOOD         = 0,
420 	SAM_CHECK_COND   = 2,
421 	SAM_COND_MET     = 4,
422 	SAM_BUSY         = 8,
423 	SAM_INTERMEDIATE = 0x10,
424 	SAM_IM_COND_MET  = 0x12,
425 	SAM_RESV_CONFLICT= 0x14,
426 	SAM_TASK_SET_FULL= 0x28,
427 	SAM_ACA_ACTIVE   = 0x30,
428 	SAM_TASK_ABORTED = 0x40,
429 
430 	SAS_DEV_NO_RESPONSE = 0x80,
431 	SAS_DATA_UNDERRUN,
432 	SAS_DATA_OVERRUN,
433 	SAS_INTERRUPTED,
434 	SAS_QUEUE_FULL,
435 	SAS_DEVICE_UNKNOWN,
436 	SAS_SG_ERR,
437 	SAS_OPEN_REJECT,
438 	SAS_OPEN_TO,
439 	SAS_PROTO_RESPONSE,
440 	SAS_PHY_DOWN,
441 	SAS_NAK_R_ERR,
442 	SAS_PENDING,
443 	SAS_ABORTED_TASK,
444 };
445 
446 /* When a task finishes with a response, the LLDD examines the
447  * response:
448  * 	- For an ATA task task_status_struct::stat is set to
449  * SAS_PROTO_RESPONSE, and the task_status_struct::buf is set to the
450  * contents of struct ata_task_resp.
451  * 	- For SSP tasks, if no data is present or status/TMF response
452  * is valid, task_status_struct::stat is set.  If data is present
453  * (SENSE data), the LLDD copies up to SAS_STATUS_BUF_SIZE, sets
454  * task_status_struct::buf_valid_size, and task_status_struct::stat is
455  * set to SAM_CHECK_COND.
456  *
457  * "buf" has format SCSI Sense for SSP task, or struct ata_task_resp
458  * for ATA task.
459  *
460  * "frame_len" is the total frame length, which could be more or less
461  * than actually copied.
462  *
463  * Tasks ending with response, always set the residual field.
464  */
465 struct ata_task_resp {
466 	u16  frame_len;
467 	u8   ending_fis[24];	  /* dev to host or data-in */
468 	u32  sstatus;
469 	u32  serror;
470 	u32  scontrol;
471 	u32  sactive;
472 };
473 
474 #define SAS_STATUS_BUF_SIZE 96
475 
476 struct task_status_struct {
477 	enum service_response resp;
478 	enum exec_status      stat;
479 	int  buf_valid_size;
480 
481 	u8   buf[SAS_STATUS_BUF_SIZE];
482 
483 	u32  residual;
484 	enum sas_open_rej_reason open_rej_reason;
485 };
486 
487 /* ATA and ATAPI task queuable to a SAS LLDD.
488  */
489 struct sas_ata_task {
490 	struct host_to_dev_fis fis;
491 	u8     atapi_packet[16];  /* 0 if not ATAPI task */
492 
493 	u8     retry_count;	  /* hardware retry, should be > 0 */
494 
495 	u8     dma_xfer:1;	  /* PIO:0 or DMA:1 */
496 	u8     use_ncq:1;
497 	u8     set_affil_pol:1;
498 	u8     stp_affil_pol:1;
499 
500 	u8     device_control_reg_update:1;
501 };
502 
503 struct sas_smp_task {
504 	struct scatterlist smp_req;
505 	struct scatterlist smp_resp;
506 };
507 
508 enum task_attribute {
509 	TASK_ATTR_SIMPLE = 0,
510 	TASK_ATTR_HOQ    = 1,
511 	TASK_ATTR_ORDERED= 2,
512 	TASK_ATTR_ACA    = 4,
513 };
514 
515 struct sas_ssp_task {
516 	u8     retry_count;	  /* hardware retry, should be > 0 */
517 
518 	u8     LUN[8];
519 	u8     enable_first_burst:1;
520 	enum   task_attribute task_attr;
521 	u8     task_prio;
522 	u8     cdb[16];
523 };
524 
525 struct sas_task {
526 	struct domain_device *dev;
527 	struct list_head      list;
528 
529 	spinlock_t   task_state_lock;
530 	unsigned     task_state_flags;
531 
532 	enum   sas_proto      task_proto;
533 
534 	/* Used by the discovery code. */
535 	struct timer_list     timer;
536 	struct completion     completion;
537 
538 	union {
539 		struct sas_ata_task ata_task;
540 		struct sas_smp_task smp_task;
541 		struct sas_ssp_task ssp_task;
542 	};
543 
544 	struct scatterlist *scatter;
545 	int    num_scatter;
546 	u32    total_xfer_len;
547 	u8     data_dir:2;	  /* Use PCI_DMA_... */
548 
549 	struct task_status_struct task_status;
550 	void   (*task_done)(struct sas_task *);
551 
552 	void   *lldd_task;	  /* for use by LLDDs */
553 	void   *uldd_task;
554 
555 	struct work_struct abort_work;
556 };
557 
558 
559 
560 #define SAS_TASK_STATE_PENDING      1
561 #define SAS_TASK_STATE_DONE         2
562 #define SAS_TASK_STATE_ABORTED      4
563 #define SAS_TASK_NEED_DEV_RESET     8
564 #define SAS_TASK_AT_INITIATOR       16
565 
566 static inline struct sas_task *sas_alloc_task(gfp_t flags)
567 {
568 	extern struct kmem_cache *sas_task_cache;
569 	struct sas_task *task = kmem_cache_zalloc(sas_task_cache, flags);
570 
571 	if (task) {
572 		INIT_LIST_HEAD(&task->list);
573 		spin_lock_init(&task->task_state_lock);
574 		task->task_state_flags = SAS_TASK_STATE_PENDING;
575 		init_timer(&task->timer);
576 		init_completion(&task->completion);
577 	}
578 
579 	return task;
580 }
581 
582 static inline void sas_free_task(struct sas_task *task)
583 {
584 	if (task) {
585 		extern struct kmem_cache *sas_task_cache;
586 		BUG_ON(!list_empty(&task->list));
587 		kmem_cache_free(sas_task_cache, task);
588 	}
589 }
590 
591 struct sas_domain_function_template {
592 	/* The class calls these to notify the LLDD of an event. */
593 	void (*lldd_port_formed)(struct asd_sas_phy *);
594 	void (*lldd_port_deformed)(struct asd_sas_phy *);
595 
596 	/* The class calls these when a device is found or gone. */
597 	int  (*lldd_dev_found)(struct domain_device *);
598 	void (*lldd_dev_gone)(struct domain_device *);
599 
600 	int (*lldd_execute_task)(struct sas_task *, int num,
601 				 gfp_t gfp_flags);
602 
603 	/* Task Management Functions. Must be called from process context. */
604 	int (*lldd_abort_task)(struct sas_task *);
605 	int (*lldd_abort_task_set)(struct domain_device *, u8 *lun);
606 	int (*lldd_clear_aca)(struct domain_device *, u8 *lun);
607 	int (*lldd_clear_task_set)(struct domain_device *, u8 *lun);
608 	int (*lldd_I_T_nexus_reset)(struct domain_device *);
609 	int (*lldd_lu_reset)(struct domain_device *, u8 *lun);
610 	int (*lldd_query_task)(struct sas_task *);
611 
612 	/* Port and Adapter management */
613 	int (*lldd_clear_nexus_port)(struct asd_sas_port *);
614 	int (*lldd_clear_nexus_ha)(struct sas_ha_struct *);
615 
616 	/* Phy management */
617 	int (*lldd_control_phy)(struct asd_sas_phy *, enum phy_func, void *);
618 };
619 
620 extern int sas_register_ha(struct sas_ha_struct *);
621 extern int sas_unregister_ha(struct sas_ha_struct *);
622 
623 int sas_set_phy_speed(struct sas_phy *phy,
624 		      struct sas_phy_linkrates *rates);
625 int sas_phy_enable(struct sas_phy *phy, int enabled);
626 int sas_phy_reset(struct sas_phy *phy, int hard_reset);
627 extern int sas_queuecommand(struct scsi_cmnd *,
628 		     void (*scsi_done)(struct scsi_cmnd *));
629 extern int sas_target_alloc(struct scsi_target *);
630 extern int sas_slave_alloc(struct scsi_device *);
631 extern int sas_slave_configure(struct scsi_device *);
632 extern void sas_slave_destroy(struct scsi_device *);
633 extern int sas_change_queue_depth(struct scsi_device *, int new_depth);
634 extern int sas_change_queue_type(struct scsi_device *, int qt);
635 extern int sas_bios_param(struct scsi_device *,
636 			  struct block_device *,
637 			  sector_t capacity, int *hsc);
638 extern struct scsi_transport_template *
639 sas_domain_attach_transport(struct sas_domain_function_template *);
640 extern void sas_domain_release_transport(struct scsi_transport_template *);
641 
642 int  sas_discover_root_expander(struct domain_device *);
643 
644 void sas_init_ex_attr(void);
645 
646 int  sas_ex_revalidate_domain(struct domain_device *);
647 
648 void sas_unregister_domain_devices(struct asd_sas_port *port);
649 void sas_init_disc(struct sas_discovery *disc, struct asd_sas_port *);
650 int  sas_discover_event(struct asd_sas_port *, enum discover_event ev);
651 
652 int  sas_discover_sata(struct domain_device *);
653 int  sas_discover_end_dev(struct domain_device *);
654 
655 void sas_unregister_dev(struct domain_device *);
656 
657 void sas_init_dev(struct domain_device *);
658 
659 void sas_task_abort(struct sas_task *);
660 int __sas_task_abort(struct sas_task *);
661 int sas_eh_device_reset_handler(struct scsi_cmnd *cmd);
662 int sas_eh_bus_reset_handler(struct scsi_cmnd *cmd);
663 
664 #endif /* _SASLIB_H_ */
665