diff options
Diffstat (limited to 'include/scsi')
-rw-r--r-- | include/scsi/libiscsi.h | 6 | ||||
-rw-r--r-- | include/scsi/libsas.h | 627 | ||||
-rw-r--r-- | include/scsi/sas.h | 631 | ||||
-rw-r--r-- | include/scsi/scsi.h | 16 | ||||
-rw-r--r-- | include/scsi/scsi_cmnd.h | 14 | ||||
-rw-r--r-- | include/scsi/scsi_host.h | 7 | ||||
-rw-r--r-- | include/scsi/scsi_netlink.h | 87 | ||||
-rw-r--r-- | include/scsi/scsi_netlink_fc.h | 71 | ||||
-rw-r--r-- | include/scsi/scsi_tcq.h | 15 | ||||
-rw-r--r-- | include/scsi/scsi_transport_fc.h | 80 | ||||
-rw-r--r-- | include/scsi/scsi_transport_sas.h | 37 | ||||
-rw-r--r-- | include/scsi/scsi_transport_spi.h | 3 |
12 files changed, 1545 insertions, 49 deletions
diff --git a/include/scsi/libiscsi.h b/include/scsi/libiscsi.h index 41904f611d12..401192e56e50 100644 --- a/include/scsi/libiscsi.h +++ b/include/scsi/libiscsi.h | |||
@@ -102,6 +102,8 @@ struct iscsi_cmd_task { | |||
102 | uint32_t unsol_datasn; | 102 | uint32_t unsol_datasn; |
103 | int imm_count; /* imm-data (bytes) */ | 103 | int imm_count; /* imm-data (bytes) */ |
104 | int unsol_count; /* unsolicited (bytes)*/ | 104 | int unsol_count; /* unsolicited (bytes)*/ |
105 | /* offset in unsolicited stream (bytes); */ | ||
106 | int unsol_offset; | ||
105 | int data_count; /* remaining Data-Out */ | 107 | int data_count; /* remaining Data-Out */ |
106 | struct scsi_cmnd *sc; /* associated SCSI cmd*/ | 108 | struct scsi_cmnd *sc; /* associated SCSI cmd*/ |
107 | int total_length; | 109 | int total_length; |
@@ -110,6 +112,7 @@ struct iscsi_cmd_task { | |||
110 | 112 | ||
111 | /* state set/tested under session->lock */ | 113 | /* state set/tested under session->lock */ |
112 | int state; | 114 | int state; |
115 | atomic_t refcount; | ||
113 | struct list_head running; /* running cmd list */ | 116 | struct list_head running; /* running cmd list */ |
114 | void *dd_data; /* driver/transport data */ | 117 | void *dd_data; /* driver/transport data */ |
115 | }; | 118 | }; |
@@ -290,8 +293,7 @@ extern int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, | |||
290 | extern int iscsi_check_assign_cmdsn(struct iscsi_session *, | 293 | extern int iscsi_check_assign_cmdsn(struct iscsi_session *, |
291 | struct iscsi_nopin *); | 294 | struct iscsi_nopin *); |
292 | extern void iscsi_prep_unsolicit_data_pdu(struct iscsi_cmd_task *, | 295 | extern void iscsi_prep_unsolicit_data_pdu(struct iscsi_cmd_task *, |
293 | struct iscsi_data *hdr, | 296 | struct iscsi_data *hdr); |
294 | int transport_data_cnt); | ||
295 | extern int iscsi_conn_send_pdu(struct iscsi_cls_conn *, struct iscsi_hdr *, | 297 | extern int iscsi_conn_send_pdu(struct iscsi_cls_conn *, struct iscsi_hdr *, |
296 | char *, uint32_t); | 298 | char *, uint32_t); |
297 | extern int iscsi_complete_pdu(struct iscsi_conn *, struct iscsi_hdr *, | 299 | extern int iscsi_complete_pdu(struct iscsi_conn *, struct iscsi_hdr *, |
diff --git a/include/scsi/libsas.h b/include/scsi/libsas.h new file mode 100644 index 000000000000..8e39982fc3db --- /dev/null +++ b/include/scsi/libsas.h | |||
@@ -0,0 +1,627 @@ | |||
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 | |||
39 | struct block_device; | ||
40 | |||
41 | enum sas_class { | ||
42 | SAS, | ||
43 | EXPANDER | ||
44 | }; | ||
45 | |||
46 | enum sas_phy_role { | ||
47 | PHY_ROLE_NONE = 0, | ||
48 | PHY_ROLE_TARGET = 0x40, | ||
49 | PHY_ROLE_INITIATOR = 0x80, | ||
50 | }; | ||
51 | |||
52 | enum sas_phy_type { | ||
53 | PHY_TYPE_PHYSICAL, | ||
54 | PHY_TYPE_VIRTUAL | ||
55 | }; | ||
56 | |||
57 | /* The events are mnemonically described in sas_dump.c | ||
58 | * so when updating/adding events here, please also | ||
59 | * update the other file too. | ||
60 | */ | ||
61 | enum ha_event { | ||
62 | HAE_RESET = 0U, | ||
63 | HA_NUM_EVENTS = 1, | ||
64 | }; | ||
65 | |||
66 | enum port_event { | ||
67 | PORTE_BYTES_DMAED = 0U, | ||
68 | PORTE_BROADCAST_RCVD = 1, | ||
69 | PORTE_LINK_RESET_ERR = 2, | ||
70 | PORTE_TIMER_EVENT = 3, | ||
71 | PORTE_HARD_RESET = 4, | ||
72 | PORT_NUM_EVENTS = 5, | ||
73 | }; | ||
74 | |||
75 | enum phy_event { | ||
76 | PHYE_LOSS_OF_SIGNAL = 0U, | ||
77 | PHYE_OOB_DONE = 1, | ||
78 | PHYE_OOB_ERROR = 2, | ||
79 | PHYE_SPINUP_HOLD = 3, /* hot plug SATA, no COMWAKE sent */ | ||
80 | PHY_NUM_EVENTS = 4, | ||
81 | }; | ||
82 | |||
83 | enum discover_event { | ||
84 | DISCE_DISCOVER_DOMAIN = 0U, | ||
85 | DISCE_REVALIDATE_DOMAIN = 1, | ||
86 | DISCE_PORT_GONE = 2, | ||
87 | DISC_NUM_EVENTS = 3, | ||
88 | }; | ||
89 | |||
90 | /* ---------- Expander Devices ---------- */ | ||
91 | |||
92 | #define ETASK 0xFA | ||
93 | |||
94 | #define to_dom_device(_obj) container_of(_obj, struct domain_device, dev_obj) | ||
95 | #define to_dev_attr(_attr) container_of(_attr, struct domain_dev_attribute,\ | ||
96 | attr) | ||
97 | |||
98 | enum routing_attribute { | ||
99 | DIRECT_ROUTING, | ||
100 | SUBTRACTIVE_ROUTING, | ||
101 | TABLE_ROUTING, | ||
102 | }; | ||
103 | |||
104 | enum ex_phy_state { | ||
105 | PHY_EMPTY, | ||
106 | PHY_VACANT, | ||
107 | PHY_NOT_PRESENT, | ||
108 | PHY_DEVICE_DISCOVERED | ||
109 | }; | ||
110 | |||
111 | struct ex_phy { | ||
112 | int phy_id; | ||
113 | |||
114 | enum ex_phy_state phy_state; | ||
115 | |||
116 | enum sas_dev_type attached_dev_type; | ||
117 | enum sas_linkrate linkrate; | ||
118 | |||
119 | u8 attached_sata_host:1; | ||
120 | u8 attached_sata_dev:1; | ||
121 | u8 attached_sata_ps:1; | ||
122 | |||
123 | enum sas_proto attached_tproto; | ||
124 | enum sas_proto attached_iproto; | ||
125 | |||
126 | u8 attached_sas_addr[SAS_ADDR_SIZE]; | ||
127 | u8 attached_phy_id; | ||
128 | |||
129 | u8 phy_change_count; | ||
130 | enum routing_attribute routing_attr; | ||
131 | u8 virtual:1; | ||
132 | |||
133 | int last_da_index; | ||
134 | |||
135 | struct sas_phy *phy; | ||
136 | struct sas_port *port; | ||
137 | }; | ||
138 | |||
139 | struct expander_device { | ||
140 | struct list_head children; | ||
141 | |||
142 | u16 ex_change_count; | ||
143 | u16 max_route_indexes; | ||
144 | u8 num_phys; | ||
145 | u8 configuring:1; | ||
146 | u8 conf_route_table:1; | ||
147 | u8 enclosure_logical_id[8]; | ||
148 | |||
149 | struct ex_phy *ex_phy; | ||
150 | struct sas_port *parent_port; | ||
151 | }; | ||
152 | |||
153 | /* ---------- SATA device ---------- */ | ||
154 | enum ata_command_set { | ||
155 | ATA_COMMAND_SET = 0, | ||
156 | ATAPI_COMMAND_SET = 1, | ||
157 | }; | ||
158 | |||
159 | struct sata_device { | ||
160 | enum ata_command_set command_set; | ||
161 | struct smp_resp rps_resp; /* report_phy_sata_resp */ | ||
162 | __le16 *identify_device; | ||
163 | __le16 *identify_packet_device; | ||
164 | |||
165 | u8 port_no; /* port number, if this is a PM (Port) */ | ||
166 | struct list_head children; /* PM Ports if this is a PM */ | ||
167 | }; | ||
168 | |||
169 | /* ---------- Domain device ---------- */ | ||
170 | struct domain_device { | ||
171 | enum sas_dev_type dev_type; | ||
172 | |||
173 | enum sas_linkrate linkrate; | ||
174 | enum sas_linkrate min_linkrate; | ||
175 | enum sas_linkrate max_linkrate; | ||
176 | |||
177 | int pathways; | ||
178 | |||
179 | struct domain_device *parent; | ||
180 | struct list_head siblings; /* devices on the same level */ | ||
181 | struct asd_sas_port *port; /* shortcut to root of the tree */ | ||
182 | |||
183 | struct list_head dev_list_node; | ||
184 | |||
185 | enum sas_proto iproto; | ||
186 | enum sas_proto tproto; | ||
187 | |||
188 | struct sas_rphy *rphy; | ||
189 | |||
190 | u8 sas_addr[SAS_ADDR_SIZE]; | ||
191 | u8 hashed_sas_addr[HASHED_SAS_ADDR_SIZE]; | ||
192 | |||
193 | u8 frame_rcvd[32]; | ||
194 | |||
195 | union { | ||
196 | struct expander_device ex_dev; | ||
197 | struct sata_device sata_dev; /* STP & directly attached */ | ||
198 | }; | ||
199 | |||
200 | void *lldd_dev; | ||
201 | }; | ||
202 | |||
203 | struct sas_discovery { | ||
204 | spinlock_t disc_event_lock; | ||
205 | struct work_struct disc_work[DISC_NUM_EVENTS]; | ||
206 | unsigned long pending; | ||
207 | u8 fanout_sas_addr[8]; | ||
208 | u8 eeds_a[8]; | ||
209 | u8 eeds_b[8]; | ||
210 | int max_level; | ||
211 | }; | ||
212 | |||
213 | |||
214 | /* The port struct is Class:RW, driver:RO */ | ||
215 | struct asd_sas_port { | ||
216 | /* private: */ | ||
217 | struct completion port_gone_completion; | ||
218 | |||
219 | struct sas_discovery disc; | ||
220 | struct domain_device *port_dev; | ||
221 | spinlock_t dev_list_lock; | ||
222 | struct list_head dev_list; | ||
223 | enum sas_linkrate linkrate; | ||
224 | |||
225 | struct sas_phy *phy; | ||
226 | struct work_struct work; | ||
227 | |||
228 | /* public: */ | ||
229 | int id; | ||
230 | |||
231 | enum sas_class class; | ||
232 | u8 sas_addr[SAS_ADDR_SIZE]; | ||
233 | u8 attached_sas_addr[SAS_ADDR_SIZE]; | ||
234 | enum sas_proto iproto; | ||
235 | enum sas_proto tproto; | ||
236 | |||
237 | enum sas_oob_mode oob_mode; | ||
238 | |||
239 | spinlock_t phy_list_lock; | ||
240 | struct list_head phy_list; | ||
241 | int num_phys; | ||
242 | u32 phy_mask; | ||
243 | |||
244 | struct sas_ha_struct *ha; | ||
245 | |||
246 | struct sas_port *port; | ||
247 | |||
248 | void *lldd_port; /* not touched by the sas class code */ | ||
249 | }; | ||
250 | |||
251 | /* The phy pretty much is controlled by the LLDD. | ||
252 | * The class only reads those fields. | ||
253 | */ | ||
254 | struct asd_sas_phy { | ||
255 | /* private: */ | ||
256 | /* protected by ha->event_lock */ | ||
257 | struct work_struct port_events[PORT_NUM_EVENTS]; | ||
258 | struct work_struct phy_events[PHY_NUM_EVENTS]; | ||
259 | |||
260 | unsigned long port_events_pending; | ||
261 | unsigned long phy_events_pending; | ||
262 | |||
263 | int error; | ||
264 | |||
265 | struct sas_phy *phy; | ||
266 | |||
267 | /* public: */ | ||
268 | /* The following are class:RO, driver:R/W */ | ||
269 | int enabled; /* must be set */ | ||
270 | |||
271 | int id; /* must be set */ | ||
272 | enum sas_class class; | ||
273 | enum sas_proto iproto; | ||
274 | enum sas_proto tproto; | ||
275 | |||
276 | enum sas_phy_type type; | ||
277 | enum sas_phy_role role; | ||
278 | enum sas_oob_mode oob_mode; | ||
279 | enum sas_linkrate linkrate; | ||
280 | |||
281 | u8 *sas_addr; /* must be set */ | ||
282 | u8 attached_sas_addr[SAS_ADDR_SIZE]; /* class:RO, driver: R/W */ | ||
283 | |||
284 | spinlock_t frame_rcvd_lock; | ||
285 | u8 *frame_rcvd; /* must be set */ | ||
286 | int frame_rcvd_size; | ||
287 | |||
288 | spinlock_t sas_prim_lock; | ||
289 | u32 sas_prim; | ||
290 | |||
291 | struct list_head port_phy_el; /* driver:RO */ | ||
292 | struct asd_sas_port *port; /* Class:RW, driver: RO */ | ||
293 | |||
294 | struct sas_ha_struct *ha; /* may be set; the class sets it anyway */ | ||
295 | |||
296 | void *lldd_phy; /* not touched by the sas_class_code */ | ||
297 | }; | ||
298 | |||
299 | struct scsi_core { | ||
300 | struct Scsi_Host *shost; | ||
301 | |||
302 | spinlock_t task_queue_lock; | ||
303 | struct list_head task_queue; | ||
304 | int task_queue_size; | ||
305 | |||
306 | struct semaphore queue_thread_sema; | ||
307 | int queue_thread_kill; | ||
308 | }; | ||
309 | |||
310 | struct sas_ha_struct { | ||
311 | /* private: */ | ||
312 | spinlock_t event_lock; | ||
313 | struct work_struct ha_events[HA_NUM_EVENTS]; | ||
314 | unsigned long pending; | ||
315 | |||
316 | struct scsi_core core; | ||
317 | |||
318 | /* public: */ | ||
319 | char *sas_ha_name; | ||
320 | struct pci_dev *pcidev; /* should be set */ | ||
321 | struct module *lldd_module; /* should be set */ | ||
322 | |||
323 | u8 *sas_addr; /* must be set */ | ||
324 | u8 hashed_sas_addr[HASHED_SAS_ADDR_SIZE]; | ||
325 | |||
326 | spinlock_t phy_port_lock; | ||
327 | struct asd_sas_phy **sas_phy; /* array of valid pointers, must be set */ | ||
328 | struct asd_sas_port **sas_port; /* array of valid pointers, must be set */ | ||
329 | int num_phys; /* must be set, gt 0, static */ | ||
330 | |||
331 | /* The class calls this to send a task for execution. */ | ||
332 | int lldd_max_execute_num; | ||
333 | int lldd_queue_size; | ||
334 | |||
335 | /* LLDD calls these to notify the class of an event. */ | ||
336 | void (*notify_ha_event)(struct sas_ha_struct *, enum ha_event); | ||
337 | void (*notify_port_event)(struct asd_sas_phy *, enum port_event); | ||
338 | void (*notify_phy_event)(struct asd_sas_phy *, enum phy_event); | ||
339 | |||
340 | void *lldd_ha; /* not touched by sas class code */ | ||
341 | }; | ||
342 | |||
343 | #define SHOST_TO_SAS_HA(_shost) (*(struct sas_ha_struct **)(_shost)->hostdata) | ||
344 | |||
345 | static inline struct domain_device * | ||
346 | starget_to_domain_dev(struct scsi_target *starget) { | ||
347 | return starget->hostdata; | ||
348 | } | ||
349 | |||
350 | static inline struct domain_device * | ||
351 | sdev_to_domain_dev(struct scsi_device *sdev) { | ||
352 | return starget_to_domain_dev(sdev->sdev_target); | ||
353 | } | ||
354 | |||
355 | static inline struct domain_device * | ||
356 | cmd_to_domain_dev(struct scsi_cmnd *cmd) | ||
357 | { | ||
358 | return sdev_to_domain_dev(cmd->device); | ||
359 | } | ||
360 | |||
361 | void sas_hash_addr(u8 *hashed, const u8 *sas_addr); | ||
362 | |||
363 | /* Before calling a notify event, LLDD should use this function | ||
364 | * when the link is severed (possibly from its tasklet). | ||
365 | * The idea is that the Class only reads those, while the LLDD, | ||
366 | * can R/W these (thus avoiding a race). | ||
367 | */ | ||
368 | static inline void sas_phy_disconnected(struct asd_sas_phy *phy) | ||
369 | { | ||
370 | phy->oob_mode = OOB_NOT_CONNECTED; | ||
371 | phy->linkrate = SAS_LINK_RATE_UNKNOWN; | ||
372 | } | ||
373 | |||
374 | /* ---------- Tasks ---------- */ | ||
375 | /* | ||
376 | service_response | SAS_TASK_COMPLETE | SAS_TASK_UNDELIVERED | | ||
377 | exec_status | | | | ||
378 | ---------------------+---------------------+-----------------------+ | ||
379 | SAM_... | X | | | ||
380 | DEV_NO_RESPONSE | X | X | | ||
381 | INTERRUPTED | X | | | ||
382 | QUEUE_FULL | | X | | ||
383 | DEVICE_UNKNOWN | | X | | ||
384 | SG_ERR | | X | | ||
385 | ---------------------+---------------------+-----------------------+ | ||
386 | */ | ||
387 | |||
388 | enum service_response { | ||
389 | SAS_TASK_COMPLETE, | ||
390 | SAS_TASK_UNDELIVERED = -1, | ||
391 | }; | ||
392 | |||
393 | enum exec_status { | ||
394 | SAM_GOOD = 0, | ||
395 | SAM_CHECK_COND = 2, | ||
396 | SAM_COND_MET = 4, | ||
397 | SAM_BUSY = 8, | ||
398 | SAM_INTERMEDIATE = 0x10, | ||
399 | SAM_IM_COND_MET = 0x12, | ||
400 | SAM_RESV_CONFLICT= 0x14, | ||
401 | SAM_TASK_SET_FULL= 0x28, | ||
402 | SAM_ACA_ACTIVE = 0x30, | ||
403 | SAM_TASK_ABORTED = 0x40, | ||
404 | |||
405 | SAS_DEV_NO_RESPONSE = 0x80, | ||
406 | SAS_DATA_UNDERRUN, | ||
407 | SAS_DATA_OVERRUN, | ||
408 | SAS_INTERRUPTED, | ||
409 | SAS_QUEUE_FULL, | ||
410 | SAS_DEVICE_UNKNOWN, | ||
411 | SAS_SG_ERR, | ||
412 | SAS_OPEN_REJECT, | ||
413 | SAS_OPEN_TO, | ||
414 | SAS_PROTO_RESPONSE, | ||
415 | SAS_PHY_DOWN, | ||
416 | SAS_NAK_R_ERR, | ||
417 | SAS_PENDING, | ||
418 | SAS_ABORTED_TASK, | ||
419 | }; | ||
420 | |||
421 | /* When a task finishes with a response, the LLDD examines the | ||
422 | * response: | ||
423 | * - For an ATA task task_status_struct::stat is set to | ||
424 | * SAS_PROTO_RESPONSE, and the task_status_struct::buf is set to the | ||
425 | * contents of struct ata_task_resp. | ||
426 | * - For SSP tasks, if no data is present or status/TMF response | ||
427 | * is valid, task_status_struct::stat is set. If data is present | ||
428 | * (SENSE data), the LLDD copies up to SAS_STATUS_BUF_SIZE, sets | ||
429 | * task_status_struct::buf_valid_size, and task_status_struct::stat is | ||
430 | * set to SAM_CHECK_COND. | ||
431 | * | ||
432 | * "buf" has format SCSI Sense for SSP task, or struct ata_task_resp | ||
433 | * for ATA task. | ||
434 | * | ||
435 | * "frame_len" is the total frame length, which could be more or less | ||
436 | * than actually copied. | ||
437 | * | ||
438 | * Tasks ending with response, always set the residual field. | ||
439 | */ | ||
440 | struct ata_task_resp { | ||
441 | u16 frame_len; | ||
442 | u8 ending_fis[24]; /* dev to host or data-in */ | ||
443 | u32 sstatus; | ||
444 | u32 serror; | ||
445 | u32 scontrol; | ||
446 | u32 sactive; | ||
447 | }; | ||
448 | |||
449 | #define SAS_STATUS_BUF_SIZE 96 | ||
450 | |||
451 | struct task_status_struct { | ||
452 | enum service_response resp; | ||
453 | enum exec_status stat; | ||
454 | int buf_valid_size; | ||
455 | |||
456 | u8 buf[SAS_STATUS_BUF_SIZE]; | ||
457 | |||
458 | u32 residual; | ||
459 | enum sas_open_rej_reason open_rej_reason; | ||
460 | }; | ||
461 | |||
462 | /* ATA and ATAPI task queuable to a SAS LLDD. | ||
463 | */ | ||
464 | struct sas_ata_task { | ||
465 | struct host_to_dev_fis fis; | ||
466 | u8 atapi_packet[16]; /* 0 if not ATAPI task */ | ||
467 | |||
468 | u8 retry_count; /* hardware retry, should be > 0 */ | ||
469 | |||
470 | u8 dma_xfer:1; /* PIO:0 or DMA:1 */ | ||
471 | u8 use_ncq:1; | ||
472 | u8 set_affil_pol:1; | ||
473 | u8 stp_affil_pol:1; | ||
474 | |||
475 | u8 device_control_reg_update:1; | ||
476 | }; | ||
477 | |||
478 | struct sas_smp_task { | ||
479 | struct scatterlist smp_req; | ||
480 | struct scatterlist smp_resp; | ||
481 | }; | ||
482 | |||
483 | enum task_attribute { | ||
484 | TASK_ATTR_SIMPLE = 0, | ||
485 | TASK_ATTR_HOQ = 1, | ||
486 | TASK_ATTR_ORDERED= 2, | ||
487 | TASK_ATTR_ACA = 4, | ||
488 | }; | ||
489 | |||
490 | struct sas_ssp_task { | ||
491 | u8 retry_count; /* hardware retry, should be > 0 */ | ||
492 | |||
493 | u8 LUN[8]; | ||
494 | u8 enable_first_burst:1; | ||
495 | enum task_attribute task_attr; | ||
496 | u8 task_prio; | ||
497 | u8 cdb[16]; | ||
498 | }; | ||
499 | |||
500 | struct sas_task { | ||
501 | struct domain_device *dev; | ||
502 | struct list_head list; | ||
503 | |||
504 | spinlock_t task_state_lock; | ||
505 | unsigned task_state_flags; | ||
506 | |||
507 | enum sas_proto task_proto; | ||
508 | |||
509 | /* Used by the discovery code. */ | ||
510 | struct timer_list timer; | ||
511 | struct completion completion; | ||
512 | |||
513 | union { | ||
514 | struct sas_ata_task ata_task; | ||
515 | struct sas_smp_task smp_task; | ||
516 | struct sas_ssp_task ssp_task; | ||
517 | }; | ||
518 | |||
519 | struct scatterlist *scatter; | ||
520 | int num_scatter; | ||
521 | u32 total_xfer_len; | ||
522 | u8 data_dir:2; /* Use PCI_DMA_... */ | ||
523 | |||
524 | struct task_status_struct task_status; | ||
525 | void (*task_done)(struct sas_task *); | ||
526 | |||
527 | void *lldd_task; /* for use by LLDDs */ | ||
528 | void *uldd_task; | ||
529 | }; | ||
530 | |||
531 | |||
532 | |||
533 | #define SAS_TASK_STATE_PENDING 1 | ||
534 | #define SAS_TASK_STATE_DONE 2 | ||
535 | #define SAS_TASK_STATE_ABORTED 4 | ||
536 | |||
537 | static inline struct sas_task *sas_alloc_task(unsigned long flags) | ||
538 | { | ||
539 | extern kmem_cache_t *sas_task_cache; | ||
540 | struct sas_task *task = kmem_cache_alloc(sas_task_cache, flags); | ||
541 | |||
542 | if (task) { | ||
543 | memset(task, 0, sizeof(*task)); | ||
544 | INIT_LIST_HEAD(&task->list); | ||
545 | spin_lock_init(&task->task_state_lock); | ||
546 | task->task_state_flags = SAS_TASK_STATE_PENDING; | ||
547 | init_timer(&task->timer); | ||
548 | init_completion(&task->completion); | ||
549 | } | ||
550 | |||
551 | return task; | ||
552 | } | ||
553 | |||
554 | static inline void sas_free_task(struct sas_task *task) | ||
555 | { | ||
556 | if (task) { | ||
557 | extern kmem_cache_t *sas_task_cache; | ||
558 | BUG_ON(!list_empty(&task->list)); | ||
559 | kmem_cache_free(sas_task_cache, task); | ||
560 | } | ||
561 | } | ||
562 | |||
563 | struct sas_domain_function_template { | ||
564 | /* The class calls these to notify the LLDD of an event. */ | ||
565 | void (*lldd_port_formed)(struct asd_sas_phy *); | ||
566 | void (*lldd_port_deformed)(struct asd_sas_phy *); | ||
567 | |||
568 | /* The class calls these when a device is found or gone. */ | ||
569 | int (*lldd_dev_found)(struct domain_device *); | ||
570 | void (*lldd_dev_gone)(struct domain_device *); | ||
571 | |||
572 | int (*lldd_execute_task)(struct sas_task *, int num, | ||
573 | unsigned long gfp_flags); | ||
574 | |||
575 | /* Task Management Functions. Must be called from process context. */ | ||
576 | int (*lldd_abort_task)(struct sas_task *); | ||
577 | int (*lldd_abort_task_set)(struct domain_device *, u8 *lun); | ||
578 | int (*lldd_clear_aca)(struct domain_device *, u8 *lun); | ||
579 | int (*lldd_clear_task_set)(struct domain_device *, u8 *lun); | ||
580 | int (*lldd_I_T_nexus_reset)(struct domain_device *); | ||
581 | int (*lldd_lu_reset)(struct domain_device *, u8 *lun); | ||
582 | int (*lldd_query_task)(struct sas_task *); | ||
583 | |||
584 | /* Port and Adapter management */ | ||
585 | int (*lldd_clear_nexus_port)(struct asd_sas_port *); | ||
586 | int (*lldd_clear_nexus_ha)(struct sas_ha_struct *); | ||
587 | |||
588 | /* Phy management */ | ||
589 | int (*lldd_control_phy)(struct asd_sas_phy *, enum phy_func, void *); | ||
590 | }; | ||
591 | |||
592 | extern int sas_register_ha(struct sas_ha_struct *); | ||
593 | extern int sas_unregister_ha(struct sas_ha_struct *); | ||
594 | |||
595 | extern int sas_queuecommand(struct scsi_cmnd *, | ||
596 | void (*scsi_done)(struct scsi_cmnd *)); | ||
597 | extern int sas_target_alloc(struct scsi_target *); | ||
598 | extern int sas_slave_alloc(struct scsi_device *); | ||
599 | extern int sas_slave_configure(struct scsi_device *); | ||
600 | extern void sas_slave_destroy(struct scsi_device *); | ||
601 | extern int sas_change_queue_depth(struct scsi_device *, int new_depth); | ||
602 | extern int sas_change_queue_type(struct scsi_device *, int qt); | ||
603 | extern int sas_bios_param(struct scsi_device *, | ||
604 | struct block_device *, | ||
605 | sector_t capacity, int *hsc); | ||
606 | extern struct scsi_transport_template * | ||
607 | sas_domain_attach_transport(struct sas_domain_function_template *); | ||
608 | extern void sas_domain_release_transport(struct scsi_transport_template *); | ||
609 | |||
610 | int sas_discover_root_expander(struct domain_device *); | ||
611 | |||
612 | void sas_init_ex_attr(void); | ||
613 | |||
614 | int sas_ex_revalidate_domain(struct domain_device *); | ||
615 | |||
616 | void sas_unregister_domain_devices(struct asd_sas_port *port); | ||
617 | void sas_init_disc(struct sas_discovery *disc, struct asd_sas_port *); | ||
618 | int sas_discover_event(struct asd_sas_port *, enum discover_event ev); | ||
619 | |||
620 | int sas_discover_sata(struct domain_device *); | ||
621 | int sas_discover_end_dev(struct domain_device *); | ||
622 | |||
623 | void sas_unregister_dev(struct domain_device *); | ||
624 | |||
625 | void sas_init_dev(struct domain_device *); | ||
626 | |||
627 | #endif /* _SASLIB_H_ */ | ||
diff --git a/include/scsi/sas.h b/include/scsi/sas.h new file mode 100644 index 000000000000..2f4b6afa34fc --- /dev/null +++ b/include/scsi/sas.h | |||
@@ -0,0 +1,631 @@ | |||
1 | /* | ||
2 | * SAS structures and definitions 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 _SAS_H_ | ||
27 | #define _SAS_H_ | ||
28 | |||
29 | #include <linux/types.h> | ||
30 | #include <asm/byteorder.h> | ||
31 | |||
32 | #define SAS_ADDR_SIZE 8 | ||
33 | #define HASHED_SAS_ADDR_SIZE 3 | ||
34 | #define SAS_ADDR(_sa) ((unsigned long long) be64_to_cpu(*(__be64 *)(_sa))) | ||
35 | |||
36 | #define SMP_REQUEST 0x40 | ||
37 | #define SMP_RESPONSE 0x41 | ||
38 | |||
39 | #define SSP_DATA 0x01 | ||
40 | #define SSP_XFER_RDY 0x05 | ||
41 | #define SSP_COMMAND 0x06 | ||
42 | #define SSP_RESPONSE 0x07 | ||
43 | #define SSP_TASK 0x16 | ||
44 | |||
45 | #define SMP_REPORT_GENERAL 0x00 | ||
46 | #define SMP_REPORT_MANUF_INFO 0x01 | ||
47 | #define SMP_READ_GPIO_REG 0x02 | ||
48 | #define SMP_DISCOVER 0x10 | ||
49 | #define SMP_REPORT_PHY_ERR_LOG 0x11 | ||
50 | #define SMP_REPORT_PHY_SATA 0x12 | ||
51 | #define SMP_REPORT_ROUTE_INFO 0x13 | ||
52 | #define SMP_WRITE_GPIO_REG 0x82 | ||
53 | #define SMP_CONF_ROUTE_INFO 0x90 | ||
54 | #define SMP_PHY_CONTROL 0x91 | ||
55 | #define SMP_PHY_TEST_FUNCTION 0x92 | ||
56 | |||
57 | #define SMP_RESP_FUNC_ACC 0x00 | ||
58 | #define SMP_RESP_FUNC_UNK 0x01 | ||
59 | #define SMP_RESP_FUNC_FAILED 0x02 | ||
60 | #define SMP_RESP_INV_FRM_LEN 0x03 | ||
61 | #define SMP_RESP_NO_PHY 0x10 | ||
62 | #define SMP_RESP_NO_INDEX 0x11 | ||
63 | #define SMP_RESP_PHY_NO_SATA 0x12 | ||
64 | #define SMP_RESP_PHY_UNK_OP 0x13 | ||
65 | #define SMP_RESP_PHY_UNK_TESTF 0x14 | ||
66 | #define SMP_RESP_PHY_TEST_INPROG 0x15 | ||
67 | #define SMP_RESP_PHY_VACANT 0x16 | ||
68 | |||
69 | /* SAM TMFs */ | ||
70 | #define TMF_ABORT_TASK 0x01 | ||
71 | #define TMF_ABORT_TASK_SET 0x02 | ||
72 | #define TMF_CLEAR_TASK_SET 0x04 | ||
73 | #define TMF_LU_RESET 0x08 | ||
74 | #define TMF_CLEAR_ACA 0x40 | ||
75 | #define TMF_QUERY_TASK 0x80 | ||
76 | |||
77 | /* SAS TMF responses */ | ||
78 | #define TMF_RESP_FUNC_COMPLETE 0x00 | ||
79 | #define TMF_RESP_INVALID_FRAME 0x02 | ||
80 | #define TMF_RESP_FUNC_ESUPP 0x04 | ||
81 | #define TMF_RESP_FUNC_FAILED 0x05 | ||
82 | #define TMF_RESP_FUNC_SUCC 0x08 | ||
83 | #define TMF_RESP_NO_LUN 0x09 | ||
84 | #define TMF_RESP_OVERLAPPED_TAG 0x0A | ||
85 | |||
86 | enum sas_oob_mode { | ||
87 | OOB_NOT_CONNECTED, | ||
88 | SATA_OOB_MODE, | ||
89 | SAS_OOB_MODE | ||
90 | }; | ||
91 | |||
92 | /* See sas_discover.c if you plan on changing these. | ||
93 | */ | ||
94 | enum sas_dev_type { | ||
95 | NO_DEVICE = 0, /* protocol */ | ||
96 | SAS_END_DEV = 1, /* protocol */ | ||
97 | EDGE_DEV = 2, /* protocol */ | ||
98 | FANOUT_DEV = 3, /* protocol */ | ||
99 | SAS_HA = 4, | ||
100 | SATA_DEV = 5, | ||
101 | SATA_PM = 7, | ||
102 | SATA_PM_PORT= 8, | ||
103 | }; | ||
104 | |||
105 | /* Partly from IDENTIFY address frame. */ | ||
106 | enum sas_proto { | ||
107 | SATA_PROTO = 1, | ||
108 | SAS_PROTO_SMP = 2, /* protocol */ | ||
109 | SAS_PROTO_STP = 4, /* protocol */ | ||
110 | SAS_PROTO_SSP = 8, /* protocol */ | ||
111 | SAS_PROTO_ALL = 0xE, | ||
112 | }; | ||
113 | |||
114 | /* From the spec; local phys only */ | ||
115 | enum phy_func { | ||
116 | PHY_FUNC_NOP, | ||
117 | PHY_FUNC_LINK_RESET, /* Enables the phy */ | ||
118 | PHY_FUNC_HARD_RESET, | ||
119 | PHY_FUNC_DISABLE, | ||
120 | PHY_FUNC_CLEAR_ERROR_LOG = 5, | ||
121 | PHY_FUNC_CLEAR_AFFIL, | ||
122 | PHY_FUNC_TX_SATA_PS_SIGNAL, | ||
123 | PHY_FUNC_RELEASE_SPINUP_HOLD = 0x10, /* LOCAL PORT ONLY! */ | ||
124 | PHY_FUNC_SET_LINK_RATE, | ||
125 | }; | ||
126 | |||
127 | /* SAS LLDD would need to report only _very_few_ of those, like BROADCAST. | ||
128 | * Most of those are here for completeness. | ||
129 | */ | ||
130 | enum sas_prim { | ||
131 | SAS_PRIM_AIP_NORMAL = 1, | ||
132 | SAS_PRIM_AIP_R0 = 2, | ||
133 | SAS_PRIM_AIP_R1 = 3, | ||
134 | SAS_PRIM_AIP_R2 = 4, | ||
135 | SAS_PRIM_AIP_WC = 5, | ||
136 | SAS_PRIM_AIP_WD = 6, | ||
137 | SAS_PRIM_AIP_WP = 7, | ||
138 | SAS_PRIM_AIP_RWP = 8, | ||
139 | |||
140 | SAS_PRIM_BC_CH = 9, | ||
141 | SAS_PRIM_BC_RCH0 = 10, | ||
142 | SAS_PRIM_BC_RCH1 = 11, | ||
143 | SAS_PRIM_BC_R0 = 12, | ||
144 | SAS_PRIM_BC_R1 = 13, | ||
145 | SAS_PRIM_BC_R2 = 14, | ||
146 | SAS_PRIM_BC_R3 = 15, | ||
147 | SAS_PRIM_BC_R4 = 16, | ||
148 | |||
149 | SAS_PRIM_NOTIFY_ENSP= 17, | ||
150 | SAS_PRIM_NOTIFY_R0 = 18, | ||
151 | SAS_PRIM_NOTIFY_R1 = 19, | ||
152 | SAS_PRIM_NOTIFY_R2 = 20, | ||
153 | |||
154 | SAS_PRIM_CLOSE_CLAF = 21, | ||
155 | SAS_PRIM_CLOSE_NORM = 22, | ||
156 | SAS_PRIM_CLOSE_R0 = 23, | ||
157 | SAS_PRIM_CLOSE_R1 = 24, | ||
158 | |||
159 | SAS_PRIM_OPEN_RTRY = 25, | ||
160 | SAS_PRIM_OPEN_RJCT = 26, | ||
161 | SAS_PRIM_OPEN_ACPT = 27, | ||
162 | |||
163 | SAS_PRIM_DONE = 28, | ||
164 | SAS_PRIM_BREAK = 29, | ||
165 | |||
166 | SATA_PRIM_DMAT = 33, | ||
167 | SATA_PRIM_PMNAK = 34, | ||
168 | SATA_PRIM_PMACK = 35, | ||
169 | SATA_PRIM_PMREQ_S = 36, | ||
170 | SATA_PRIM_PMREQ_P = 37, | ||
171 | SATA_SATA_R_ERR = 38, | ||
172 | }; | ||
173 | |||
174 | enum sas_open_rej_reason { | ||
175 | /* Abandon open */ | ||
176 | SAS_OREJ_UNKNOWN = 0, | ||
177 | SAS_OREJ_BAD_DEST = 1, | ||
178 | SAS_OREJ_CONN_RATE = 2, | ||
179 | SAS_OREJ_EPROTO = 3, | ||
180 | SAS_OREJ_RESV_AB0 = 4, | ||
181 | SAS_OREJ_RESV_AB1 = 5, | ||
182 | SAS_OREJ_RESV_AB2 = 6, | ||
183 | SAS_OREJ_RESV_AB3 = 7, | ||
184 | SAS_OREJ_WRONG_DEST= 8, | ||
185 | SAS_OREJ_STP_NORES = 9, | ||
186 | |||
187 | /* Retry open */ | ||
188 | SAS_OREJ_NO_DEST = 10, | ||
189 | SAS_OREJ_PATH_BLOCKED = 11, | ||
190 | SAS_OREJ_RSVD_CONT0 = 12, | ||
191 | SAS_OREJ_RSVD_CONT1 = 13, | ||
192 | SAS_OREJ_RSVD_INIT0 = 14, | ||
193 | SAS_OREJ_RSVD_INIT1 = 15, | ||
194 | SAS_OREJ_RSVD_STOP0 = 16, | ||
195 | SAS_OREJ_RSVD_STOP1 = 17, | ||
196 | SAS_OREJ_RSVD_RETRY = 18, | ||
197 | }; | ||
198 | |||
199 | struct dev_to_host_fis { | ||
200 | u8 fis_type; /* 0x34 */ | ||
201 | u8 flags; | ||
202 | u8 status; | ||
203 | u8 error; | ||
204 | |||
205 | u8 lbal; | ||
206 | union { u8 lbam; u8 byte_count_low; }; | ||
207 | union { u8 lbah; u8 byte_count_high; }; | ||
208 | u8 device; | ||
209 | |||
210 | u8 lbal_exp; | ||
211 | u8 lbam_exp; | ||
212 | u8 lbah_exp; | ||
213 | u8 _r_a; | ||
214 | |||
215 | union { u8 sector_count; u8 interrupt_reason; }; | ||
216 | u8 sector_count_exp; | ||
217 | u8 _r_b; | ||
218 | u8 _r_c; | ||
219 | |||
220 | u32 _r_d; | ||
221 | } __attribute__ ((packed)); | ||
222 | |||
223 | struct host_to_dev_fis { | ||
224 | u8 fis_type; /* 0x27 */ | ||
225 | u8 flags; | ||
226 | u8 command; | ||
227 | u8 features; | ||
228 | |||
229 | u8 lbal; | ||
230 | union { u8 lbam; u8 byte_count_low; }; | ||
231 | union { u8 lbah; u8 byte_count_high; }; | ||
232 | u8 device; | ||
233 | |||
234 | u8 lbal_exp; | ||
235 | u8 lbam_exp; | ||
236 | u8 lbah_exp; | ||
237 | u8 features_exp; | ||
238 | |||
239 | union { u8 sector_count; u8 interrupt_reason; }; | ||
240 | u8 sector_count_exp; | ||
241 | u8 _r_a; | ||
242 | u8 control; | ||
243 | |||
244 | u32 _r_b; | ||
245 | } __attribute__ ((packed)); | ||
246 | |||
247 | /* Prefer to have code clarity over header file clarity. | ||
248 | */ | ||
249 | #ifdef __LITTLE_ENDIAN_BITFIELD | ||
250 | struct sas_identify_frame { | ||
251 | /* Byte 0 */ | ||
252 | u8 frame_type:4; | ||
253 | u8 dev_type:3; | ||
254 | u8 _un0:1; | ||
255 | |||
256 | /* Byte 1 */ | ||
257 | u8 _un1; | ||
258 | |||
259 | /* Byte 2 */ | ||
260 | union { | ||
261 | struct { | ||
262 | u8 _un20:1; | ||
263 | u8 smp_iport:1; | ||
264 | u8 stp_iport:1; | ||
265 | u8 ssp_iport:1; | ||
266 | u8 _un247:4; | ||
267 | }; | ||
268 | u8 initiator_bits; | ||
269 | }; | ||
270 | |||
271 | /* Byte 3 */ | ||
272 | union { | ||
273 | struct { | ||
274 | u8 _un30:1; | ||
275 | u8 smp_tport:1; | ||
276 | u8 stp_tport:1; | ||
277 | u8 ssp_tport:1; | ||
278 | u8 _un347:4; | ||
279 | }; | ||
280 | u8 target_bits; | ||
281 | }; | ||
282 | |||
283 | /* Byte 4 - 11 */ | ||
284 | u8 _un4_11[8]; | ||
285 | |||
286 | /* Byte 12 - 19 */ | ||
287 | u8 sas_addr[SAS_ADDR_SIZE]; | ||
288 | |||
289 | /* Byte 20 */ | ||
290 | u8 phy_id; | ||
291 | |||
292 | u8 _un21_27[7]; | ||
293 | |||
294 | __be32 crc; | ||
295 | } __attribute__ ((packed)); | ||
296 | |||
297 | struct ssp_frame_hdr { | ||
298 | u8 frame_type; | ||
299 | u8 hashed_dest_addr[HASHED_SAS_ADDR_SIZE]; | ||
300 | u8 _r_a; | ||
301 | u8 hashed_src_addr[HASHED_SAS_ADDR_SIZE]; | ||
302 | __be16 _r_b; | ||
303 | |||
304 | u8 changing_data_ptr:1; | ||
305 | u8 retransmit:1; | ||
306 | u8 retry_data_frames:1; | ||
307 | u8 _r_c:5; | ||
308 | |||
309 | u8 num_fill_bytes:2; | ||
310 | u8 _r_d:6; | ||
311 | |||
312 | u32 _r_e; | ||
313 | __be16 tag; | ||
314 | __be16 tptt; | ||
315 | __be32 data_offs; | ||
316 | } __attribute__ ((packed)); | ||
317 | |||
318 | struct ssp_response_iu { | ||
319 | u8 _r_a[10]; | ||
320 | |||
321 | u8 datapres:2; | ||
322 | u8 _r_b:6; | ||
323 | |||
324 | u8 status; | ||
325 | |||
326 | u32 _r_c; | ||
327 | |||
328 | __be32 sense_data_len; | ||
329 | __be32 response_data_len; | ||
330 | |||
331 | u8 resp_data[0]; | ||
332 | u8 sense_data[0]; | ||
333 | } __attribute__ ((packed)); | ||
334 | |||
335 | /* ---------- SMP ---------- */ | ||
336 | |||
337 | struct report_general_resp { | ||
338 | __be16 change_count; | ||
339 | __be16 route_indexes; | ||
340 | u8 _r_a; | ||
341 | u8 num_phys; | ||
342 | |||
343 | u8 conf_route_table:1; | ||
344 | u8 configuring:1; | ||
345 | u8 _r_b:6; | ||
346 | |||
347 | u8 _r_c; | ||
348 | |||
349 | u8 enclosure_logical_id[8]; | ||
350 | |||
351 | u8 _r_d[12]; | ||
352 | } __attribute__ ((packed)); | ||
353 | |||
354 | struct discover_resp { | ||
355 | u8 _r_a[5]; | ||
356 | |||
357 | u8 phy_id; | ||
358 | __be16 _r_b; | ||
359 | |||
360 | u8 _r_c:4; | ||
361 | u8 attached_dev_type:3; | ||
362 | u8 _r_d:1; | ||
363 | |||
364 | u8 linkrate:4; | ||
365 | u8 _r_e:4; | ||
366 | |||
367 | u8 attached_sata_host:1; | ||
368 | u8 iproto:3; | ||
369 | u8 _r_f:4; | ||
370 | |||
371 | u8 attached_sata_dev:1; | ||
372 | u8 tproto:3; | ||
373 | u8 _r_g:3; | ||
374 | u8 attached_sata_ps:1; | ||
375 | |||
376 | u8 sas_addr[8]; | ||
377 | u8 attached_sas_addr[8]; | ||
378 | u8 attached_phy_id; | ||
379 | |||
380 | u8 _r_h[7]; | ||
381 | |||
382 | u8 hmin_linkrate:4; | ||
383 | u8 pmin_linkrate:4; | ||
384 | u8 hmax_linkrate:4; | ||
385 | u8 pmax_linkrate:4; | ||
386 | |||
387 | u8 change_count; | ||
388 | |||
389 | u8 pptv:4; | ||
390 | u8 _r_i:3; | ||
391 | u8 virtual:1; | ||
392 | |||
393 | u8 routing_attr:4; | ||
394 | u8 _r_j:4; | ||
395 | |||
396 | u8 conn_type; | ||
397 | u8 conn_el_index; | ||
398 | u8 conn_phy_link; | ||
399 | |||
400 | u8 _r_k[8]; | ||
401 | } __attribute__ ((packed)); | ||
402 | |||
403 | struct report_phy_sata_resp { | ||
404 | u8 _r_a[5]; | ||
405 | |||
406 | u8 phy_id; | ||
407 | u8 _r_b; | ||
408 | |||
409 | u8 affil_valid:1; | ||
410 | u8 affil_supp:1; | ||
411 | u8 _r_c:6; | ||
412 | |||
413 | u32 _r_d; | ||
414 | |||
415 | u8 stp_sas_addr[8]; | ||
416 | |||
417 | struct dev_to_host_fis fis; | ||
418 | |||
419 | u32 _r_e; | ||
420 | |||
421 | u8 affil_stp_ini_addr[8]; | ||
422 | |||
423 | __be32 crc; | ||
424 | } __attribute__ ((packed)); | ||
425 | |||
426 | struct smp_resp { | ||
427 | u8 frame_type; | ||
428 | u8 function; | ||
429 | u8 result; | ||
430 | u8 reserved; | ||
431 | union { | ||
432 | struct report_general_resp rg; | ||
433 | struct discover_resp disc; | ||
434 | struct report_phy_sata_resp rps; | ||
435 | }; | ||
436 | } __attribute__ ((packed)); | ||
437 | |||
438 | #elif defined(__BIG_ENDIAN_BITFIELD) | ||
439 | struct sas_identify_frame { | ||
440 | /* Byte 0 */ | ||
441 | u8 _un0:1; | ||
442 | u8 dev_type:3; | ||
443 | u8 frame_type:4; | ||
444 | |||
445 | /* Byte 1 */ | ||
446 | u8 _un1; | ||
447 | |||
448 | /* Byte 2 */ | ||
449 | union { | ||
450 | struct { | ||
451 | u8 _un247:4; | ||
452 | u8 ssp_iport:1; | ||
453 | u8 stp_iport:1; | ||
454 | u8 smp_iport:1; | ||
455 | u8 _un20:1; | ||
456 | }; | ||
457 | u8 initiator_bits; | ||
458 | }; | ||
459 | |||
460 | /* Byte 3 */ | ||
461 | union { | ||
462 | struct { | ||
463 | u8 _un347:4; | ||
464 | u8 ssp_tport:1; | ||
465 | u8 stp_tport:1; | ||
466 | u8 smp_tport:1; | ||
467 | u8 _un30:1; | ||
468 | }; | ||
469 | u8 target_bits; | ||
470 | }; | ||
471 | |||
472 | /* Byte 4 - 11 */ | ||
473 | u8 _un4_11[8]; | ||
474 | |||
475 | /* Byte 12 - 19 */ | ||
476 | u8 sas_addr[SAS_ADDR_SIZE]; | ||
477 | |||
478 | /* Byte 20 */ | ||
479 | u8 phy_id; | ||
480 | |||
481 | u8 _un21_27[7]; | ||
482 | |||
483 | __be32 crc; | ||
484 | } __attribute__ ((packed)); | ||
485 | |||
486 | struct ssp_frame_hdr { | ||
487 | u8 frame_type; | ||
488 | u8 hashed_dest_addr[HASHED_SAS_ADDR_SIZE]; | ||
489 | u8 _r_a; | ||
490 | u8 hashed_src_addr[HASHED_SAS_ADDR_SIZE]; | ||
491 | __be16 _r_b; | ||
492 | |||
493 | u8 _r_c:5; | ||
494 | u8 retry_data_frames:1; | ||
495 | u8 retransmit:1; | ||
496 | u8 changing_data_ptr:1; | ||
497 | |||
498 | u8 _r_d:6; | ||
499 | u8 num_fill_bytes:2; | ||
500 | |||
501 | u32 _r_e; | ||
502 | __be16 tag; | ||
503 | __be16 tptt; | ||
504 | __be32 data_offs; | ||
505 | } __attribute__ ((packed)); | ||
506 | |||
507 | struct ssp_response_iu { | ||
508 | u8 _r_a[10]; | ||
509 | |||
510 | u8 _r_b:6; | ||
511 | u8 datapres:2; | ||
512 | |||
513 | u8 status; | ||
514 | |||
515 | u32 _r_c; | ||
516 | |||
517 | __be32 sense_data_len; | ||
518 | __be32 response_data_len; | ||
519 | |||
520 | u8 resp_data[0]; | ||
521 | u8 sense_data[0]; | ||
522 | } __attribute__ ((packed)); | ||
523 | |||
524 | /* ---------- SMP ---------- */ | ||
525 | |||
526 | struct report_general_resp { | ||
527 | __be16 change_count; | ||
528 | __be16 route_indexes; | ||
529 | u8 _r_a; | ||
530 | u8 num_phys; | ||
531 | |||
532 | u8 _r_b:6; | ||
533 | u8 configuring:1; | ||
534 | u8 conf_route_table:1; | ||
535 | |||
536 | u8 _r_c; | ||
537 | |||
538 | u8 enclosure_logical_id[8]; | ||
539 | |||
540 | u8 _r_d[12]; | ||
541 | } __attribute__ ((packed)); | ||
542 | |||
543 | struct discover_resp { | ||
544 | u8 _r_a[5]; | ||
545 | |||
546 | u8 phy_id; | ||
547 | __be16 _r_b; | ||
548 | |||
549 | u8 _r_d:1; | ||
550 | u8 attached_dev_type:3; | ||
551 | u8 _r_c:4; | ||
552 | |||
553 | u8 _r_e:4; | ||
554 | u8 linkrate:4; | ||
555 | |||
556 | u8 _r_f:4; | ||
557 | u8 iproto:3; | ||
558 | u8 attached_sata_host:1; | ||
559 | |||
560 | u8 attached_sata_ps:1; | ||
561 | u8 _r_g:3; | ||
562 | u8 tproto:3; | ||
563 | u8 attached_sata_dev:1; | ||
564 | |||
565 | u8 sas_addr[8]; | ||
566 | u8 attached_sas_addr[8]; | ||
567 | u8 attached_phy_id; | ||
568 | |||
569 | u8 _r_h[7]; | ||
570 | |||
571 | u8 pmin_linkrate:4; | ||
572 | u8 hmin_linkrate:4; | ||
573 | u8 pmax_linkrate:4; | ||
574 | u8 hmax_linkrate:4; | ||
575 | |||
576 | u8 change_count; | ||
577 | |||
578 | u8 virtual:1; | ||
579 | u8 _r_i:3; | ||
580 | u8 pptv:4; | ||
581 | |||
582 | u8 _r_j:4; | ||
583 | u8 routing_attr:4; | ||
584 | |||
585 | u8 conn_type; | ||
586 | u8 conn_el_index; | ||
587 | u8 conn_phy_link; | ||
588 | |||
589 | u8 _r_k[8]; | ||
590 | } __attribute__ ((packed)); | ||
591 | |||
592 | struct report_phy_sata_resp { | ||
593 | u8 _r_a[5]; | ||
594 | |||
595 | u8 phy_id; | ||
596 | u8 _r_b; | ||
597 | |||
598 | u8 _r_c:6; | ||
599 | u8 affil_supp:1; | ||
600 | u8 affil_valid:1; | ||
601 | |||
602 | u32 _r_d; | ||
603 | |||
604 | u8 stp_sas_addr[8]; | ||
605 | |||
606 | struct dev_to_host_fis fis; | ||
607 | |||
608 | u32 _r_e; | ||
609 | |||
610 | u8 affil_stp_ini_addr[8]; | ||
611 | |||
612 | __be32 crc; | ||
613 | } __attribute__ ((packed)); | ||
614 | |||
615 | struct smp_resp { | ||
616 | u8 frame_type; | ||
617 | u8 function; | ||
618 | u8 result; | ||
619 | u8 reserved; | ||
620 | union { | ||
621 | struct report_general_resp rg; | ||
622 | struct discover_resp disc; | ||
623 | struct report_phy_sata_resp rps; | ||
624 | }; | ||
625 | } __attribute__ ((packed)); | ||
626 | |||
627 | #else | ||
628 | #error "Bitfield order not defined!" | ||
629 | #endif | ||
630 | |||
631 | #endif /* _SAS_H_ */ | ||
diff --git a/include/scsi/scsi.h b/include/scsi/scsi.h index c60b8ff2f5e4..84a6d5fe0920 100644 --- a/include/scsi/scsi.h +++ b/include/scsi/scsi.h | |||
@@ -25,13 +25,6 @@ extern const unsigned char scsi_command_size[8]; | |||
25 | #define COMMAND_SIZE(opcode) scsi_command_size[((opcode) >> 5) & 7] | 25 | #define COMMAND_SIZE(opcode) scsi_command_size[((opcode) >> 5) & 7] |
26 | 26 | ||
27 | /* | 27 | /* |
28 | * SCSI device types | ||
29 | */ | ||
30 | |||
31 | #define MAX_SCSI_DEVICE_CODE 15 | ||
32 | extern const char *const scsi_device_types[MAX_SCSI_DEVICE_CODE]; | ||
33 | |||
34 | /* | ||
35 | * Special value for scanning to specify scanning or rescanning of all | 28 | * Special value for scanning to specify scanning or rescanning of all |
36 | * possible channels, (target) ids, or luns on a given shost. | 29 | * possible channels, (target) ids, or luns on a given shost. |
37 | */ | 30 | */ |
@@ -225,6 +218,9 @@ static inline int scsi_status_is_good(int status) | |||
225 | #define TYPE_RBC 0x0e | 218 | #define TYPE_RBC 0x0e |
226 | #define TYPE_NO_LUN 0x7f | 219 | #define TYPE_NO_LUN 0x7f |
227 | 220 | ||
221 | /* Returns a human-readable name for the device */ | ||
222 | extern const char * scsi_device_type(unsigned type); | ||
223 | |||
228 | /* | 224 | /* |
229 | * standard mode-select header prepended to all mode-select commands | 225 | * standard mode-select header prepended to all mode-select commands |
230 | */ | 226 | */ |
@@ -433,4 +429,10 @@ struct scsi_lun { | |||
433 | /* Used to obtain the PCI location of a device */ | 429 | /* Used to obtain the PCI location of a device */ |
434 | #define SCSI_IOCTL_GET_PCI 0x5387 | 430 | #define SCSI_IOCTL_GET_PCI 0x5387 |
435 | 431 | ||
432 | /* Pull a u32 out of a SCSI message (using BE SCSI conventions) */ | ||
433 | static inline u32 scsi_to_u32(u8 *ptr) | ||
434 | { | ||
435 | return (ptr[0]<<24) + (ptr[1]<<16) + (ptr[2]<<8) + ptr[3]; | ||
436 | } | ||
437 | |||
436 | #endif /* _SCSI_SCSI_H */ | 438 | #endif /* _SCSI_SCSI_H */ |
diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h index 58e6444eebee..be117f812deb 100644 --- a/include/scsi/scsi_cmnd.h +++ b/include/scsi/scsi_cmnd.h | |||
@@ -118,20 +118,6 @@ struct scsi_cmnd { | |||
118 | unsigned long pid; /* Process ID, starts at 0. Unique per host. */ | 118 | unsigned long pid; /* Process ID, starts at 0. Unique per host. */ |
119 | }; | 119 | }; |
120 | 120 | ||
121 | /* | ||
122 | * These are the values that scsi_cmd->state can take. | ||
123 | */ | ||
124 | #define SCSI_STATE_TIMEOUT 0x1000 | ||
125 | #define SCSI_STATE_FINISHED 0x1001 | ||
126 | #define SCSI_STATE_FAILED 0x1002 | ||
127 | #define SCSI_STATE_QUEUED 0x1003 | ||
128 | #define SCSI_STATE_UNUSED 0x1006 | ||
129 | #define SCSI_STATE_DISCONNECTING 0x1008 | ||
130 | #define SCSI_STATE_INITIALIZING 0x1009 | ||
131 | #define SCSI_STATE_BHQUEUE 0x100a | ||
132 | #define SCSI_STATE_MLQUEUE 0x100b | ||
133 | |||
134 | |||
135 | extern struct scsi_cmnd *scsi_get_command(struct scsi_device *, gfp_t); | 121 | extern struct scsi_cmnd *scsi_get_command(struct scsi_device *, gfp_t); |
136 | extern void scsi_put_command(struct scsi_cmnd *); | 122 | extern void scsi_put_command(struct scsi_cmnd *); |
137 | extern void scsi_io_completion(struct scsi_cmnd *, unsigned int); | 123 | extern void scsi_io_completion(struct scsi_cmnd *, unsigned int); |
diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h index b3dd90f3e858..39c6f8cc20c3 100644 --- a/include/scsi/scsi_host.h +++ b/include/scsi/scsi_host.h | |||
@@ -16,6 +16,7 @@ struct scsi_target; | |||
16 | struct Scsi_Host; | 16 | struct Scsi_Host; |
17 | struct scsi_host_cmd_pool; | 17 | struct scsi_host_cmd_pool; |
18 | struct scsi_transport_template; | 18 | struct scsi_transport_template; |
19 | struct blk_queue_tags; | ||
19 | 20 | ||
20 | 21 | ||
21 | /* | 22 | /* |
@@ -466,6 +467,12 @@ struct Scsi_Host { | |||
466 | struct scsi_transport_template *transportt; | 467 | struct scsi_transport_template *transportt; |
467 | 468 | ||
468 | /* | 469 | /* |
470 | * area to keep a shared tag map (if needed, will be | ||
471 | * NULL if not) | ||
472 | */ | ||
473 | struct blk_queue_tag *bqt; | ||
474 | |||
475 | /* | ||
469 | * The following two fields are protected with host_lock; | 476 | * The following two fields are protected with host_lock; |
470 | * however, eh routines can safely access during eh processing | 477 | * however, eh routines can safely access during eh processing |
471 | * without acquiring the lock. | 478 | * without acquiring the lock. |
diff --git a/include/scsi/scsi_netlink.h b/include/scsi/scsi_netlink.h new file mode 100644 index 000000000000..8c1470cc8209 --- /dev/null +++ b/include/scsi/scsi_netlink.h | |||
@@ -0,0 +1,87 @@ | |||
1 | /* | ||
2 | * SCSI Transport Netlink Interface | ||
3 | * Used for the posting of outbound SCSI transport events | ||
4 | * | ||
5 | * Copyright (C) 2006 James Smart, Emulex Corporation | ||
6 | * | ||
7 | * This program is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License as published by | ||
9 | * the Free Software Foundation; either version 2 of the License, or | ||
10 | * (at your option) any later version. | ||
11 | * | ||
12 | * This program is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
15 | * GNU General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU General Public License | ||
18 | * along with this program; if not, write to the Free Software | ||
19 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
20 | * | ||
21 | */ | ||
22 | #ifndef SCSI_NETLINK_H | ||
23 | #define SCSI_NETLINK_H | ||
24 | |||
25 | /* | ||
26 | * This file intended to be included by both kernel and user space | ||
27 | */ | ||
28 | |||
29 | /* Single Netlink Message type to send all SCSI Transport messages */ | ||
30 | #define SCSI_TRANSPORT_MSG NLMSG_MIN_TYPE + 1 | ||
31 | |||
32 | /* SCSI Transport Broadcast Groups */ | ||
33 | /* leaving groups 0 and 1 unassigned */ | ||
34 | #define SCSI_NL_GRP_FC_EVENTS (1<<2) /* Group 2 */ | ||
35 | #define SCSI_NL_GRP_CNT 3 | ||
36 | |||
37 | |||
38 | /* SCSI_TRANSPORT_MSG event message header */ | ||
39 | struct scsi_nl_hdr { | ||
40 | uint8_t version; | ||
41 | uint8_t transport; | ||
42 | uint16_t magic; | ||
43 | uint16_t msgtype; | ||
44 | uint16_t msglen; | ||
45 | } __attribute__((aligned(sizeof(uint64_t)))); | ||
46 | |||
47 | /* scsi_nl_hdr->version value */ | ||
48 | #define SCSI_NL_VERSION 1 | ||
49 | |||
50 | /* scsi_nl_hdr->magic value */ | ||
51 | #define SCSI_NL_MAGIC 0xA1B2 | ||
52 | |||
53 | /* scsi_nl_hdr->transport value */ | ||
54 | #define SCSI_NL_TRANSPORT 0 | ||
55 | #define SCSI_NL_TRANSPORT_FC 1 | ||
56 | #define SCSI_NL_MAX_TRANSPORTS 2 | ||
57 | |||
58 | /* scsi_nl_hdr->msgtype values are defined in each transport */ | ||
59 | |||
60 | |||
61 | /* | ||
62 | * Vendor ID: | ||
63 | * If transports post vendor-unique events, they must pass a well-known | ||
64 | * 32-bit vendor identifier. This identifier consists of 8 bits indicating | ||
65 | * the "type" of identifier contained, and 24 bits of id data. | ||
66 | * | ||
67 | * Identifiers for each type: | ||
68 | * PCI : ID data is the 16 bit PCI Registered Vendor ID | ||
69 | */ | ||
70 | #define SCSI_NL_VID_TYPE_SHIFT 56 | ||
71 | #define SCSI_NL_VID_TYPE_MASK ((u64)0xFF << SCSI_NL_VID_TYPE_SHIFT) | ||
72 | #define SCSI_NL_VID_TYPE_PCI ((u64)0x01 << SCSI_NL_VID_TYPE_SHIFT) | ||
73 | #define SCSI_NL_VID_ID_MASK (~ SCSI_NL_VID_TYPE_MASK) | ||
74 | |||
75 | |||
76 | #define INIT_SCSI_NL_HDR(hdr, t, mtype, mlen) \ | ||
77 | { \ | ||
78 | (hdr)->version = SCSI_NL_VERSION; \ | ||
79 | (hdr)->transport = t; \ | ||
80 | (hdr)->magic = SCSI_NL_MAGIC; \ | ||
81 | (hdr)->msgtype = mtype; \ | ||
82 | (hdr)->msglen = mlen; \ | ||
83 | } | ||
84 | |||
85 | |||
86 | #endif /* SCSI_NETLINK_H */ | ||
87 | |||
diff --git a/include/scsi/scsi_netlink_fc.h b/include/scsi/scsi_netlink_fc.h new file mode 100644 index 000000000000..cbf76e479761 --- /dev/null +++ b/include/scsi/scsi_netlink_fc.h | |||
@@ -0,0 +1,71 @@ | |||
1 | /* | ||
2 | * FC Transport Netlink Interface | ||
3 | * | ||
4 | * Copyright (C) 2006 James Smart, Emulex Corporation | ||
5 | * | ||
6 | * This program is free software; you can redistribute it and/or modify | ||
7 | * it under the terms of the GNU General Public License as published by | ||
8 | * the Free Software Foundation; either version 2 of the License, or | ||
9 | * (at your option) any later version. | ||
10 | * | ||
11 | * This program is distributed in the hope that it will be useful, | ||
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
14 | * GNU General Public License for more details. | ||
15 | * | ||
16 | * You should have received a copy of the GNU General Public License | ||
17 | * along with this program; if not, write to the Free Software | ||
18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
19 | * | ||
20 | */ | ||
21 | #ifndef SCSI_NETLINK_FC_H | ||
22 | #define SCSI_NETLINK_FC_H | ||
23 | |||
24 | #include <scsi/scsi_netlink.h> | ||
25 | |||
26 | /* | ||
27 | * This file intended to be included by both kernel and user space | ||
28 | */ | ||
29 | |||
30 | /* | ||
31 | * FC Transport Message Types | ||
32 | */ | ||
33 | /* kernel -> user */ | ||
34 | #define FC_NL_ASYNC_EVENT 0x0100 | ||
35 | /* user -> kernel */ | ||
36 | /* none */ | ||
37 | |||
38 | |||
39 | /* | ||
40 | * Message Structures : | ||
41 | */ | ||
42 | |||
43 | /* macro to round up message lengths to 8byte boundary */ | ||
44 | #define FC_NL_MSGALIGN(len) (((len) + 7) & ~7) | ||
45 | |||
46 | |||
47 | /* | ||
48 | * FC Transport Broadcast Event Message : | ||
49 | * FC_NL_ASYNC_EVENT | ||
50 | * | ||
51 | * Note: if Vendor Unique message, &event_data will be start of | ||
52 | * vendor unique payload, and the length of the payload is | ||
53 | * per event_datalen | ||
54 | * | ||
55 | * Note: When specifying vendor_id, be sure to read the Vendor Type and ID | ||
56 | * formatting requirements specified in scsi_netlink.h | ||
57 | */ | ||
58 | struct fc_nl_event { | ||
59 | struct scsi_nl_hdr snlh; /* must be 1st element ! */ | ||
60 | uint64_t seconds; | ||
61 | uint64_t vendor_id; | ||
62 | uint16_t host_no; | ||
63 | uint16_t event_datalen; | ||
64 | uint32_t event_num; | ||
65 | uint32_t event_code; | ||
66 | uint32_t event_data; | ||
67 | } __attribute__((aligned(sizeof(uint64_t)))); | ||
68 | |||
69 | |||
70 | #endif /* SCSI_NETLINK_FC_H */ | ||
71 | |||
diff --git a/include/scsi/scsi_tcq.h b/include/scsi/scsi_tcq.h index e47e36a4ef49..d04d05adfa9b 100644 --- a/include/scsi/scsi_tcq.h +++ b/include/scsi/scsi_tcq.h | |||
@@ -4,6 +4,7 @@ | |||
4 | #include <linux/blkdev.h> | 4 | #include <linux/blkdev.h> |
5 | #include <scsi/scsi_cmnd.h> | 5 | #include <scsi/scsi_cmnd.h> |
6 | #include <scsi/scsi_device.h> | 6 | #include <scsi/scsi_device.h> |
7 | #include <scsi/scsi_host.h> | ||
7 | 8 | ||
8 | 9 | ||
9 | #define MSG_SIMPLE_TAG 0x20 | 10 | #define MSG_SIMPLE_TAG 0x20 |
@@ -66,7 +67,8 @@ static inline void scsi_activate_tcq(struct scsi_device *sdev, int depth) | |||
66 | return; | 67 | return; |
67 | 68 | ||
68 | if (!blk_queue_tagged(sdev->request_queue)) | 69 | if (!blk_queue_tagged(sdev->request_queue)) |
69 | blk_queue_init_tags(sdev->request_queue, depth, NULL); | 70 | blk_queue_init_tags(sdev->request_queue, depth, |
71 | sdev->host->bqt); | ||
70 | 72 | ||
71 | scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth); | 73 | scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth); |
72 | } | 74 | } |
@@ -131,4 +133,15 @@ static inline struct scsi_cmnd *scsi_find_tag(struct scsi_device *sdev, int tag) | |||
131 | return sdev->current_cmnd; | 133 | return sdev->current_cmnd; |
132 | } | 134 | } |
133 | 135 | ||
136 | /** | ||
137 | * scsi_init_shared_tag_map - create a shared tag map | ||
138 | * @shost: the host to share the tag map among all devices | ||
139 | * @depth: the total depth of the map | ||
140 | */ | ||
141 | static inline int scsi_init_shared_tag_map(struct Scsi_Host *shost, int depth) | ||
142 | { | ||
143 | shost->bqt = blk_init_tags(depth); | ||
144 | return shost->bqt ? 0 : -ENOMEM; | ||
145 | } | ||
146 | |||
134 | #endif /* _SCSI_SCSI_TCQ_H */ | 147 | #endif /* _SCSI_SCSI_TCQ_H */ |
diff --git a/include/scsi/scsi_transport_fc.h b/include/scsi/scsi_transport_fc.h index 6d28b0317657..fd352323378b 100644 --- a/include/scsi/scsi_transport_fc.h +++ b/include/scsi/scsi_transport_fc.h | |||
@@ -29,6 +29,7 @@ | |||
29 | 29 | ||
30 | #include <linux/sched.h> | 30 | #include <linux/sched.h> |
31 | #include <scsi/scsi.h> | 31 | #include <scsi/scsi.h> |
32 | #include <scsi/scsi_netlink.h> | ||
32 | 33 | ||
33 | struct scsi_transport_template; | 34 | struct scsi_transport_template; |
34 | 35 | ||
@@ -194,6 +195,7 @@ struct fc_rport { /* aka fc_starget_attrs */ | |||
194 | u32 roles; | 195 | u32 roles; |
195 | enum fc_port_state port_state; /* Will only be ONLINE or UNKNOWN */ | 196 | enum fc_port_state port_state; /* Will only be ONLINE or UNKNOWN */ |
196 | u32 scsi_target_id; | 197 | u32 scsi_target_id; |
198 | u32 fast_io_fail_tmo; | ||
197 | 199 | ||
198 | /* exported data */ | 200 | /* exported data */ |
199 | void *dd_data; /* Used for driver-specific storage */ | 201 | void *dd_data; /* Used for driver-specific storage */ |
@@ -206,6 +208,7 @@ struct fc_rport { /* aka fc_starget_attrs */ | |||
206 | struct device dev; | 208 | struct device dev; |
207 | struct work_struct dev_loss_work; | 209 | struct work_struct dev_loss_work; |
208 | struct work_struct scan_work; | 210 | struct work_struct scan_work; |
211 | struct work_struct fail_io_work; | ||
209 | struct work_struct stgt_delete_work; | 212 | struct work_struct stgt_delete_work; |
210 | struct work_struct rport_delete_work; | 213 | struct work_struct rport_delete_work; |
211 | } __attribute__((aligned(sizeof(unsigned long)))); | 214 | } __attribute__((aligned(sizeof(unsigned long)))); |
@@ -284,6 +287,30 @@ struct fc_host_statistics { | |||
284 | 287 | ||
285 | 288 | ||
286 | /* | 289 | /* |
290 | * FC Event Codes - Polled and Async, following FC HBAAPI v2.0 guidelines | ||
291 | */ | ||
292 | |||
293 | /* | ||
294 | * fc_host_event_code: If you alter this, you also need to alter | ||
295 | * scsi_transport_fc.c (for the ascii descriptions). | ||
296 | */ | ||
297 | enum fc_host_event_code { | ||
298 | FCH_EVT_LIP = 0x1, | ||
299 | FCH_EVT_LINKUP = 0x2, | ||
300 | FCH_EVT_LINKDOWN = 0x3, | ||
301 | FCH_EVT_LIPRESET = 0x4, | ||
302 | FCH_EVT_RSCN = 0x5, | ||
303 | FCH_EVT_ADAPTER_CHANGE = 0x103, | ||
304 | FCH_EVT_PORT_UNKNOWN = 0x200, | ||
305 | FCH_EVT_PORT_OFFLINE = 0x201, | ||
306 | FCH_EVT_PORT_ONLINE = 0x202, | ||
307 | FCH_EVT_PORT_FABRIC = 0x204, | ||
308 | FCH_EVT_LINK_UNKNOWN = 0x500, | ||
309 | FCH_EVT_VENDOR_UNIQUE = 0xffff, | ||
310 | }; | ||
311 | |||
312 | |||
313 | /* | ||
287 | * FC Local Port (Host) Attributes | 314 | * FC Local Port (Host) Attributes |
288 | * | 315 | * |
289 | * Attributes are based on HBAAPI V2.0 definitions. | 316 | * Attributes are based on HBAAPI V2.0 definitions. |
@@ -312,7 +339,6 @@ struct fc_host_attrs { | |||
312 | u64 permanent_port_name; | 339 | u64 permanent_port_name; |
313 | u32 supported_classes; | 340 | u32 supported_classes; |
314 | u8 supported_fc4s[FC_FC4_LIST_SIZE]; | 341 | u8 supported_fc4s[FC_FC4_LIST_SIZE]; |
315 | char symbolic_name[FC_SYMBOLIC_NAME_SIZE]; | ||
316 | u32 supported_speeds; | 342 | u32 supported_speeds; |
317 | u32 maxframe_size; | 343 | u32 maxframe_size; |
318 | char serial_number[FC_SERIAL_NUMBER_SIZE]; | 344 | char serial_number[FC_SERIAL_NUMBER_SIZE]; |
@@ -324,6 +350,8 @@ struct fc_host_attrs { | |||
324 | u8 active_fc4s[FC_FC4_LIST_SIZE]; | 350 | u8 active_fc4s[FC_FC4_LIST_SIZE]; |
325 | u32 speed; | 351 | u32 speed; |
326 | u64 fabric_name; | 352 | u64 fabric_name; |
353 | char symbolic_name[FC_SYMBOLIC_NAME_SIZE]; | ||
354 | char system_hostname[FC_SYMBOLIC_NAME_SIZE]; | ||
327 | 355 | ||
328 | /* Private (Transport-managed) Attributes */ | 356 | /* Private (Transport-managed) Attributes */ |
329 | enum fc_tgtid_binding_type tgtid_bind_type; | 357 | enum fc_tgtid_binding_type tgtid_bind_type; |
@@ -354,8 +382,6 @@ struct fc_host_attrs { | |||
354 | (((struct fc_host_attrs *)(x)->shost_data)->supported_classes) | 382 | (((struct fc_host_attrs *)(x)->shost_data)->supported_classes) |
355 | #define fc_host_supported_fc4s(x) \ | 383 | #define fc_host_supported_fc4s(x) \ |
356 | (((struct fc_host_attrs *)(x)->shost_data)->supported_fc4s) | 384 | (((struct fc_host_attrs *)(x)->shost_data)->supported_fc4s) |
357 | #define fc_host_symbolic_name(x) \ | ||
358 | (((struct fc_host_attrs *)(x)->shost_data)->symbolic_name) | ||
359 | #define fc_host_supported_speeds(x) \ | 385 | #define fc_host_supported_speeds(x) \ |
360 | (((struct fc_host_attrs *)(x)->shost_data)->supported_speeds) | 386 | (((struct fc_host_attrs *)(x)->shost_data)->supported_speeds) |
361 | #define fc_host_maxframe_size(x) \ | 387 | #define fc_host_maxframe_size(x) \ |
@@ -374,6 +400,10 @@ struct fc_host_attrs { | |||
374 | (((struct fc_host_attrs *)(x)->shost_data)->speed) | 400 | (((struct fc_host_attrs *)(x)->shost_data)->speed) |
375 | #define fc_host_fabric_name(x) \ | 401 | #define fc_host_fabric_name(x) \ |
376 | (((struct fc_host_attrs *)(x)->shost_data)->fabric_name) | 402 | (((struct fc_host_attrs *)(x)->shost_data)->fabric_name) |
403 | #define fc_host_symbolic_name(x) \ | ||
404 | (((struct fc_host_attrs *)(x)->shost_data)->symbolic_name) | ||
405 | #define fc_host_system_hostname(x) \ | ||
406 | (((struct fc_host_attrs *)(x)->shost_data)->system_hostname) | ||
377 | #define fc_host_tgtid_bind_type(x) \ | 407 | #define fc_host_tgtid_bind_type(x) \ |
378 | (((struct fc_host_attrs *)(x)->shost_data)->tgtid_bind_type) | 408 | (((struct fc_host_attrs *)(x)->shost_data)->tgtid_bind_type) |
379 | #define fc_host_rports(x) \ | 409 | #define fc_host_rports(x) \ |
@@ -409,12 +439,17 @@ struct fc_function_template { | |||
409 | void (*get_host_active_fc4s)(struct Scsi_Host *); | 439 | void (*get_host_active_fc4s)(struct Scsi_Host *); |
410 | void (*get_host_speed)(struct Scsi_Host *); | 440 | void (*get_host_speed)(struct Scsi_Host *); |
411 | void (*get_host_fabric_name)(struct Scsi_Host *); | 441 | void (*get_host_fabric_name)(struct Scsi_Host *); |
442 | void (*get_host_symbolic_name)(struct Scsi_Host *); | ||
443 | void (*set_host_system_hostname)(struct Scsi_Host *); | ||
412 | 444 | ||
413 | struct fc_host_statistics * (*get_fc_host_stats)(struct Scsi_Host *); | 445 | struct fc_host_statistics * (*get_fc_host_stats)(struct Scsi_Host *); |
414 | void (*reset_fc_host_stats)(struct Scsi_Host *); | 446 | void (*reset_fc_host_stats)(struct Scsi_Host *); |
415 | 447 | ||
416 | int (*issue_fc_host_lip)(struct Scsi_Host *); | 448 | int (*issue_fc_host_lip)(struct Scsi_Host *); |
417 | 449 | ||
450 | void (*dev_loss_tmo_callbk)(struct fc_rport *); | ||
451 | void (*terminate_rport_io)(struct fc_rport *); | ||
452 | |||
418 | /* allocation lengths for host-specific data */ | 453 | /* allocation lengths for host-specific data */ |
419 | u32 dd_fcrport_size; | 454 | u32 dd_fcrport_size; |
420 | 455 | ||
@@ -445,7 +480,6 @@ struct fc_function_template { | |||
445 | unsigned long show_host_permanent_port_name:1; | 480 | unsigned long show_host_permanent_port_name:1; |
446 | unsigned long show_host_supported_classes:1; | 481 | unsigned long show_host_supported_classes:1; |
447 | unsigned long show_host_supported_fc4s:1; | 482 | unsigned long show_host_supported_fc4s:1; |
448 | unsigned long show_host_symbolic_name:1; | ||
449 | unsigned long show_host_supported_speeds:1; | 483 | unsigned long show_host_supported_speeds:1; |
450 | unsigned long show_host_maxframe_size:1; | 484 | unsigned long show_host_maxframe_size:1; |
451 | unsigned long show_host_serial_number:1; | 485 | unsigned long show_host_serial_number:1; |
@@ -456,6 +490,8 @@ struct fc_function_template { | |||
456 | unsigned long show_host_active_fc4s:1; | 490 | unsigned long show_host_active_fc4s:1; |
457 | unsigned long show_host_speed:1; | 491 | unsigned long show_host_speed:1; |
458 | unsigned long show_host_fabric_name:1; | 492 | unsigned long show_host_fabric_name:1; |
493 | unsigned long show_host_symbolic_name:1; | ||
494 | unsigned long show_host_system_hostname:1; | ||
459 | }; | 495 | }; |
460 | 496 | ||
461 | 497 | ||
@@ -491,6 +527,25 @@ fc_remote_port_chkready(struct fc_rport *rport) | |||
491 | return result; | 527 | return result; |
492 | } | 528 | } |
493 | 529 | ||
530 | static inline u64 wwn_to_u64(u8 *wwn) | ||
531 | { | ||
532 | return (u64)wwn[0] << 56 | (u64)wwn[1] << 48 | | ||
533 | (u64)wwn[2] << 40 | (u64)wwn[3] << 32 | | ||
534 | (u64)wwn[4] << 24 | (u64)wwn[5] << 16 | | ||
535 | (u64)wwn[6] << 8 | (u64)wwn[7]; | ||
536 | } | ||
537 | |||
538 | static inline void u64_to_wwn(u64 inm, u8 *wwn) | ||
539 | { | ||
540 | wwn[0] = (inm >> 56) & 0xff; | ||
541 | wwn[1] = (inm >> 48) & 0xff; | ||
542 | wwn[2] = (inm >> 40) & 0xff; | ||
543 | wwn[3] = (inm >> 32) & 0xff; | ||
544 | wwn[4] = (inm >> 24) & 0xff; | ||
545 | wwn[5] = (inm >> 16) & 0xff; | ||
546 | wwn[6] = (inm >> 8) & 0xff; | ||
547 | wwn[7] = inm & 0xff; | ||
548 | } | ||
494 | 549 | ||
495 | struct scsi_transport_template *fc_attach_transport( | 550 | struct scsi_transport_template *fc_attach_transport( |
496 | struct fc_function_template *); | 551 | struct fc_function_template *); |
@@ -501,13 +556,14 @@ struct fc_rport *fc_remote_port_add(struct Scsi_Host *shost, | |||
501 | void fc_remote_port_delete(struct fc_rport *rport); | 556 | void fc_remote_port_delete(struct fc_rport *rport); |
502 | void fc_remote_port_rolechg(struct fc_rport *rport, u32 roles); | 557 | void fc_remote_port_rolechg(struct fc_rport *rport, u32 roles); |
503 | int scsi_is_fc_rport(const struct device *); | 558 | int scsi_is_fc_rport(const struct device *); |
504 | 559 | u32 fc_get_event_number(void); | |
505 | static inline u64 wwn_to_u64(u8 *wwn) | 560 | void fc_host_post_event(struct Scsi_Host *shost, u32 event_number, |
506 | { | 561 | enum fc_host_event_code event_code, u32 event_data); |
507 | return (u64)wwn[0] << 56 | (u64)wwn[1] << 48 | | 562 | void fc_host_post_vendor_event(struct Scsi_Host *shost, u32 event_number, |
508 | (u64)wwn[2] << 40 | (u64)wwn[3] << 32 | | 563 | u32 data_len, char * data_buf, u64 vendor_id); |
509 | (u64)wwn[4] << 24 | (u64)wwn[5] << 16 | | 564 | /* Note: when specifying vendor_id to fc_host_post_vendor_event() |
510 | (u64)wwn[6] << 8 | (u64)wwn[7]; | 565 | * be sure to read the Vendor Type and ID formatting requirements |
511 | } | 566 | * specified in scsi_netlink.h |
567 | */ | ||
512 | 568 | ||
513 | #endif /* SCSI_TRANSPORT_FC_H */ | 569 | #endif /* SCSI_TRANSPORT_FC_H */ |
diff --git a/include/scsi/scsi_transport_sas.h b/include/scsi/scsi_transport_sas.h index 6cc2314098cf..53024377f3b8 100644 --- a/include/scsi/scsi_transport_sas.h +++ b/include/scsi/scsi_transport_sas.h | |||
@@ -24,15 +24,23 @@ enum sas_protocol { | |||
24 | }; | 24 | }; |
25 | 25 | ||
26 | enum sas_linkrate { | 26 | enum sas_linkrate { |
27 | SAS_LINK_RATE_UNKNOWN, | 27 | /* These Values are defined in the SAS standard */ |
28 | SAS_PHY_DISABLED, | 28 | SAS_LINK_RATE_UNKNOWN = 0, |
29 | SAS_LINK_RATE_FAILED, | 29 | SAS_PHY_DISABLED = 1, |
30 | SAS_SATA_SPINUP_HOLD, | 30 | SAS_PHY_RESET_PROBLEM = 2, |
31 | SAS_SATA_PORT_SELECTOR, | 31 | SAS_SATA_SPINUP_HOLD = 3, |
32 | SAS_LINK_RATE_1_5_GBPS, | 32 | SAS_SATA_PORT_SELECTOR = 4, |
33 | SAS_LINK_RATE_3_0_GBPS, | 33 | SAS_PHY_RESET_IN_PROGRESS = 5, |
34 | SAS_LINK_RATE_6_0_GBPS, | 34 | SAS_LINK_RATE_1_5_GBPS = 8, |
35 | SAS_LINK_VIRTUAL, | 35 | SAS_LINK_RATE_G1 = SAS_LINK_RATE_1_5_GBPS, |
36 | SAS_LINK_RATE_3_0_GBPS = 9, | ||
37 | SAS_LINK_RATE_G2 = SAS_LINK_RATE_3_0_GBPS, | ||
38 | SAS_LINK_RATE_6_0_GBPS = 10, | ||
39 | /* These are virtual to the transport class and may never | ||
40 | * be signalled normally since the standard defined field | ||
41 | * is only 4 bits */ | ||
42 | SAS_LINK_RATE_FAILED = 0x10, | ||
43 | SAS_PHY_VIRTUAL = 0x11, | ||
36 | }; | 44 | }; |
37 | 45 | ||
38 | struct sas_identify { | 46 | struct sas_identify { |
@@ -57,9 +65,6 @@ struct sas_phy { | |||
57 | enum sas_linkrate maximum_linkrate_hw; | 65 | enum sas_linkrate maximum_linkrate_hw; |
58 | enum sas_linkrate maximum_linkrate; | 66 | enum sas_linkrate maximum_linkrate; |
59 | 67 | ||
60 | /* internal state */ | ||
61 | unsigned int local_attached : 1; | ||
62 | |||
63 | /* link error statistics */ | 68 | /* link error statistics */ |
64 | u32 invalid_dword_count; | 69 | u32 invalid_dword_count; |
65 | u32 running_disparity_error_count; | 70 | u32 running_disparity_error_count; |
@@ -145,12 +150,18 @@ struct sas_port { | |||
145 | #define transport_class_to_sas_port(cdev) \ | 150 | #define transport_class_to_sas_port(cdev) \ |
146 | dev_to_sas_port((cdev)->dev) | 151 | dev_to_sas_port((cdev)->dev) |
147 | 152 | ||
153 | struct sas_phy_linkrates { | ||
154 | enum sas_linkrate maximum_linkrate; | ||
155 | enum sas_linkrate minimum_linkrate; | ||
156 | }; | ||
157 | |||
148 | /* The functions by which the transport class and the driver communicate */ | 158 | /* The functions by which the transport class and the driver communicate */ |
149 | struct sas_function_template { | 159 | struct sas_function_template { |
150 | int (*get_linkerrors)(struct sas_phy *); | 160 | int (*get_linkerrors)(struct sas_phy *); |
151 | int (*get_enclosure_identifier)(struct sas_rphy *, u64 *); | 161 | int (*get_enclosure_identifier)(struct sas_rphy *, u64 *); |
152 | int (*get_bay_identifier)(struct sas_rphy *); | 162 | int (*get_bay_identifier)(struct sas_rphy *); |
153 | int (*phy_reset)(struct sas_phy *, int); | 163 | int (*phy_reset)(struct sas_phy *, int); |
164 | int (*set_phy_speed)(struct sas_phy *, struct sas_phy_linkrates *); | ||
154 | }; | 165 | }; |
155 | 166 | ||
156 | 167 | ||
@@ -196,4 +207,6 @@ scsi_is_sas_expander_device(struct device *dev) | |||
196 | rphy->identify.device_type == SAS_EDGE_EXPANDER_DEVICE; | 207 | rphy->identify.device_type == SAS_EDGE_EXPANDER_DEVICE; |
197 | } | 208 | } |
198 | 209 | ||
210 | #define scsi_is_sas_phy_local(phy) scsi_is_host_device((phy)->dev.parent) | ||
211 | |||
199 | #endif /* SCSI_TRANSPORT_SAS_H */ | 212 | #endif /* SCSI_TRANSPORT_SAS_H */ |
diff --git a/include/scsi/scsi_transport_spi.h b/include/scsi/scsi_transport_spi.h index 302680c0c0de..da180f738477 100644 --- a/include/scsi/scsi_transport_spi.h +++ b/include/scsi/scsi_transport_spi.h | |||
@@ -53,7 +53,8 @@ struct spi_transport_attrs { | |||
53 | unsigned int support_ius; /* support Information Units */ | 53 | unsigned int support_ius; /* support Information Units */ |
54 | unsigned int support_qas; /* supports quick arbitration and selection */ | 54 | unsigned int support_qas; /* supports quick arbitration and selection */ |
55 | /* Private Fields */ | 55 | /* Private Fields */ |
56 | unsigned int dv_pending:1; /* Internal flag */ | 56 | unsigned int dv_pending:1; /* Internal flag: DV Requested */ |
57 | unsigned int dv_in_progress:1; /* Internal: DV started */ | ||
57 | struct mutex dv_mutex; /* semaphore to serialise dv */ | 58 | struct mutex dv_mutex; /* semaphore to serialise dv */ |
58 | }; | 59 | }; |
59 | 60 | ||