4 * Interface to Linux SCSI midlayer.
6 * Copyright IBM Corporation 2002, 2009
9 #define KMSG_COMPONENT "zfcp"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13 #include <asm/atomic.h>
15 /* Find start of Sense Information in FCP response unit*/
16 char *zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu
*fcp_rsp_iu
)
18 char *fcp_sns_info_ptr
;
20 fcp_sns_info_ptr
= (unsigned char *) &fcp_rsp_iu
[1];
21 if (fcp_rsp_iu
->validity
.bits
.fcp_rsp_len_valid
)
22 fcp_sns_info_ptr
+= fcp_rsp_iu
->fcp_rsp_len
;
24 return fcp_sns_info_ptr
;
27 static void zfcp_scsi_slave_destroy(struct scsi_device
*sdpnt
)
29 struct zfcp_unit
*unit
= (struct zfcp_unit
*) sdpnt
->hostdata
;
34 static int zfcp_scsi_slave_configure(struct scsi_device
*sdp
)
36 if (sdp
->tagged_supported
)
37 scsi_adjust_queue_depth(sdp
, MSG_SIMPLE_TAG
, 32);
39 scsi_adjust_queue_depth(sdp
, 0, 1);
43 static void zfcp_scsi_command_fail(struct scsi_cmnd
*scpnt
, int result
)
45 set_host_byte(scpnt
, result
);
46 if ((scpnt
->device
!= NULL
) && (scpnt
->device
->host
!= NULL
))
47 zfcp_scsi_dbf_event_result("fail", 4,
48 (struct zfcp_adapter
*) scpnt
->device
->host
->hostdata
[0],
51 scpnt
->scsi_done(scpnt
);
54 static int zfcp_scsi_queuecommand(struct scsi_cmnd
*scpnt
,
55 void (*done
) (struct scsi_cmnd
*))
57 struct zfcp_unit
*unit
;
58 struct zfcp_adapter
*adapter
;
59 int status
, scsi_result
, ret
;
60 struct fc_rport
*rport
= starget_to_rport(scsi_target(scpnt
->device
));
62 /* reset the status for this request */
64 scpnt
->host_scribble
= NULL
;
65 scpnt
->scsi_done
= done
;
68 * figure out adapter and target device
69 * (stored there by zfcp_scsi_slave_alloc)
71 adapter
= (struct zfcp_adapter
*) scpnt
->device
->host
->hostdata
[0];
72 unit
= scpnt
->device
->hostdata
;
74 BUG_ON(!adapter
|| (adapter
!= unit
->port
->adapter
));
75 BUG_ON(!scpnt
->scsi_done
);
77 if (unlikely(!unit
)) {
78 zfcp_scsi_command_fail(scpnt
, DID_NO_CONNECT
);
82 scsi_result
= fc_remote_port_chkready(rport
);
83 if (unlikely(scsi_result
)) {
84 scpnt
->result
= scsi_result
;
85 zfcp_scsi_dbf_event_result("fail", 4, adapter
, scpnt
, NULL
);
86 scpnt
->scsi_done(scpnt
);
90 status
= atomic_read(&unit
->status
);
91 if (unlikely((status
& ZFCP_STATUS_COMMON_ERP_FAILED
) ||
92 !(status
& ZFCP_STATUS_COMMON_RUNNING
))) {
93 zfcp_scsi_command_fail(scpnt
, DID_ERROR
);
97 ret
= zfcp_fsf_send_fcp_command_task(unit
, scpnt
);
98 if (unlikely(ret
== -EBUSY
))
99 return SCSI_MLQUEUE_DEVICE_BUSY
;
100 else if (unlikely(ret
< 0))
101 return SCSI_MLQUEUE_HOST_BUSY
;
106 static struct zfcp_unit
*zfcp_unit_lookup(struct zfcp_adapter
*adapter
,
107 int channel
, unsigned int id
,
110 struct zfcp_port
*port
;
111 struct zfcp_unit
*unit
;
114 list_for_each_entry(port
, &adapter
->port_list_head
, list
) {
115 if (!port
->rport
|| (id
!= port
->rport
->scsi_target_id
))
117 list_for_each_entry(unit
, &port
->unit_list_head
, list
) {
118 scsi_lun
= scsilun_to_int(
119 (struct scsi_lun
*)&unit
->fcp_lun
);
128 static int zfcp_scsi_slave_alloc(struct scsi_device
*sdp
)
130 struct zfcp_adapter
*adapter
;
131 struct zfcp_unit
*unit
;
135 adapter
= (struct zfcp_adapter
*) sdp
->host
->hostdata
[0];
139 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
140 unit
= zfcp_unit_lookup(adapter
, sdp
->channel
, sdp
->id
, sdp
->lun
);
142 sdp
->hostdata
= unit
;
147 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
152 static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd
*scpnt
)
154 struct Scsi_Host
*scsi_host
= scpnt
->device
->host
;
155 struct zfcp_adapter
*adapter
=
156 (struct zfcp_adapter
*) scsi_host
->hostdata
[0];
157 struct zfcp_unit
*unit
= scpnt
->device
->hostdata
;
158 struct zfcp_fsf_req
*old_req
, *abrt_req
;
160 unsigned long old_req_id
= (unsigned long) scpnt
->host_scribble
;
161 int retval
= SUCCESS
;
164 /* avoid race condition between late normal completion and abort */
165 write_lock_irqsave(&adapter
->abort_lock
, flags
);
167 spin_lock(&adapter
->req_list_lock
);
168 old_req
= zfcp_reqlist_find(adapter
, old_req_id
);
169 spin_unlock(&adapter
->req_list_lock
);
171 write_unlock_irqrestore(&adapter
->abort_lock
, flags
);
172 zfcp_scsi_dbf_event_abort("lte1", adapter
, scpnt
, NULL
,
174 return FAILED
; /* completion could be in progress */
176 old_req
->data
= NULL
;
178 /* don't access old fsf_req after releasing the abort_lock */
179 write_unlock_irqrestore(&adapter
->abort_lock
, flags
);
182 abrt_req
= zfcp_fsf_abort_fcp_command(old_req_id
, unit
);
186 zfcp_erp_wait(adapter
);
187 if (!(atomic_read(&adapter
->status
) &
188 ZFCP_STATUS_COMMON_RUNNING
)) {
189 zfcp_scsi_dbf_event_abort("nres", adapter
, scpnt
, NULL
,
197 wait_event(abrt_req
->completion_wq
,
198 abrt_req
->status
& ZFCP_STATUS_FSFREQ_COMPLETED
);
200 if (abrt_req
->status
& ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED
)
201 zfcp_scsi_dbf_event_abort("okay", adapter
, scpnt
, abrt_req
, 0);
202 else if (abrt_req
->status
& ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED
)
203 zfcp_scsi_dbf_event_abort("lte2", adapter
, scpnt
, abrt_req
, 0);
205 zfcp_scsi_dbf_event_abort("fail", adapter
, scpnt
, abrt_req
, 0);
208 zfcp_fsf_req_free(abrt_req
);
212 static int zfcp_task_mgmt_function(struct scsi_cmnd
*scpnt
, u8 tm_flags
)
214 struct zfcp_unit
*unit
= scpnt
->device
->hostdata
;
215 struct zfcp_adapter
*adapter
= unit
->port
->adapter
;
216 struct zfcp_fsf_req
*fsf_req
;
217 int retval
= SUCCESS
;
221 fsf_req
= zfcp_fsf_send_fcp_ctm(unit
, tm_flags
);
225 zfcp_erp_wait(adapter
);
226 if (!(atomic_read(&adapter
->status
) &
227 ZFCP_STATUS_COMMON_RUNNING
)) {
228 zfcp_scsi_dbf_event_devreset("nres", tm_flags
, unit
,
236 wait_event(fsf_req
->completion_wq
,
237 fsf_req
->status
& ZFCP_STATUS_FSFREQ_COMPLETED
);
239 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_TMFUNCFAILED
) {
240 zfcp_scsi_dbf_event_devreset("fail", tm_flags
, unit
, scpnt
);
242 } else if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP
) {
243 zfcp_scsi_dbf_event_devreset("nsup", tm_flags
, unit
, scpnt
);
246 zfcp_scsi_dbf_event_devreset("okay", tm_flags
, unit
, scpnt
);
248 zfcp_fsf_req_free(fsf_req
);
252 static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd
*scpnt
)
254 return zfcp_task_mgmt_function(scpnt
, FCP_LOGICAL_UNIT_RESET
);
257 static int zfcp_scsi_eh_target_reset_handler(struct scsi_cmnd
*scpnt
)
259 return zfcp_task_mgmt_function(scpnt
, FCP_TARGET_RESET
);
262 static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd
*scpnt
)
264 struct zfcp_unit
*unit
= scpnt
->device
->hostdata
;
265 struct zfcp_adapter
*adapter
= unit
->port
->adapter
;
267 zfcp_erp_adapter_reopen(adapter
, 0, "schrh_1", scpnt
);
268 zfcp_erp_wait(adapter
);
273 int zfcp_adapter_scsi_register(struct zfcp_adapter
*adapter
)
275 struct ccw_dev_id dev_id
;
277 if (adapter
->scsi_host
)
280 ccw_device_get_id(adapter
->ccw_device
, &dev_id
);
281 /* register adapter as SCSI host with mid layer of SCSI stack */
282 adapter
->scsi_host
= scsi_host_alloc(&zfcp_data
.scsi_host_template
,
283 sizeof (struct zfcp_adapter
*));
284 if (!adapter
->scsi_host
) {
285 dev_err(&adapter
->ccw_device
->dev
,
286 "Registering the FCP device with the "
287 "SCSI stack failed\n");
291 /* tell the SCSI stack some characteristics of this adapter */
292 adapter
->scsi_host
->max_id
= 1;
293 adapter
->scsi_host
->max_lun
= 1;
294 adapter
->scsi_host
->max_channel
= 0;
295 adapter
->scsi_host
->unique_id
= dev_id
.devno
;
296 adapter
->scsi_host
->max_cmd_len
= 255;
297 adapter
->scsi_host
->transportt
= zfcp_data
.scsi_transport_template
;
299 adapter
->scsi_host
->hostdata
[0] = (unsigned long) adapter
;
301 if (scsi_add_host(adapter
->scsi_host
, &adapter
->ccw_device
->dev
)) {
302 scsi_host_put(adapter
->scsi_host
);
309 void zfcp_adapter_scsi_unregister(struct zfcp_adapter
*adapter
)
311 struct Scsi_Host
*shost
;
312 struct zfcp_port
*port
;
314 shost
= adapter
->scsi_host
;
318 read_lock_irq(&zfcp_data
.config_lock
);
319 list_for_each_entry(port
, &adapter
->port_list_head
, list
)
323 read_unlock_irq(&zfcp_data
.config_lock
);
324 fc_remove_host(shost
);
325 scsi_remove_host(shost
);
326 scsi_host_put(shost
);
327 adapter
->scsi_host
= NULL
;
332 static struct fc_host_statistics
*
333 zfcp_init_fc_host_stats(struct zfcp_adapter
*adapter
)
335 struct fc_host_statistics
*fc_stats
;
337 if (!adapter
->fc_stats
) {
338 fc_stats
= kmalloc(sizeof(*fc_stats
), GFP_KERNEL
);
341 adapter
->fc_stats
= fc_stats
; /* freed in adater_dequeue */
343 memset(adapter
->fc_stats
, 0, sizeof(*adapter
->fc_stats
));
344 return adapter
->fc_stats
;
347 static void zfcp_adjust_fc_host_stats(struct fc_host_statistics
*fc_stats
,
348 struct fsf_qtcb_bottom_port
*data
,
349 struct fsf_qtcb_bottom_port
*old
)
351 fc_stats
->seconds_since_last_reset
=
352 data
->seconds_since_last_reset
- old
->seconds_since_last_reset
;
353 fc_stats
->tx_frames
= data
->tx_frames
- old
->tx_frames
;
354 fc_stats
->tx_words
= data
->tx_words
- old
->tx_words
;
355 fc_stats
->rx_frames
= data
->rx_frames
- old
->rx_frames
;
356 fc_stats
->rx_words
= data
->rx_words
- old
->rx_words
;
357 fc_stats
->lip_count
= data
->lip
- old
->lip
;
358 fc_stats
->nos_count
= data
->nos
- old
->nos
;
359 fc_stats
->error_frames
= data
->error_frames
- old
->error_frames
;
360 fc_stats
->dumped_frames
= data
->dumped_frames
- old
->dumped_frames
;
361 fc_stats
->link_failure_count
= data
->link_failure
- old
->link_failure
;
362 fc_stats
->loss_of_sync_count
= data
->loss_of_sync
- old
->loss_of_sync
;
363 fc_stats
->loss_of_signal_count
=
364 data
->loss_of_signal
- old
->loss_of_signal
;
365 fc_stats
->prim_seq_protocol_err_count
=
366 data
->psp_error_counts
- old
->psp_error_counts
;
367 fc_stats
->invalid_tx_word_count
=
368 data
->invalid_tx_words
- old
->invalid_tx_words
;
369 fc_stats
->invalid_crc_count
= data
->invalid_crcs
- old
->invalid_crcs
;
370 fc_stats
->fcp_input_requests
=
371 data
->input_requests
- old
->input_requests
;
372 fc_stats
->fcp_output_requests
=
373 data
->output_requests
- old
->output_requests
;
374 fc_stats
->fcp_control_requests
=
375 data
->control_requests
- old
->control_requests
;
376 fc_stats
->fcp_input_megabytes
= data
->input_mb
- old
->input_mb
;
377 fc_stats
->fcp_output_megabytes
= data
->output_mb
- old
->output_mb
;
380 static void zfcp_set_fc_host_stats(struct fc_host_statistics
*fc_stats
,
381 struct fsf_qtcb_bottom_port
*data
)
383 fc_stats
->seconds_since_last_reset
= data
->seconds_since_last_reset
;
384 fc_stats
->tx_frames
= data
->tx_frames
;
385 fc_stats
->tx_words
= data
->tx_words
;
386 fc_stats
->rx_frames
= data
->rx_frames
;
387 fc_stats
->rx_words
= data
->rx_words
;
388 fc_stats
->lip_count
= data
->lip
;
389 fc_stats
->nos_count
= data
->nos
;
390 fc_stats
->error_frames
= data
->error_frames
;
391 fc_stats
->dumped_frames
= data
->dumped_frames
;
392 fc_stats
->link_failure_count
= data
->link_failure
;
393 fc_stats
->loss_of_sync_count
= data
->loss_of_sync
;
394 fc_stats
->loss_of_signal_count
= data
->loss_of_signal
;
395 fc_stats
->prim_seq_protocol_err_count
= data
->psp_error_counts
;
396 fc_stats
->invalid_tx_word_count
= data
->invalid_tx_words
;
397 fc_stats
->invalid_crc_count
= data
->invalid_crcs
;
398 fc_stats
->fcp_input_requests
= data
->input_requests
;
399 fc_stats
->fcp_output_requests
= data
->output_requests
;
400 fc_stats
->fcp_control_requests
= data
->control_requests
;
401 fc_stats
->fcp_input_megabytes
= data
->input_mb
;
402 fc_stats
->fcp_output_megabytes
= data
->output_mb
;
405 static struct fc_host_statistics
*zfcp_get_fc_host_stats(struct Scsi_Host
*host
)
407 struct zfcp_adapter
*adapter
;
408 struct fc_host_statistics
*fc_stats
;
409 struct fsf_qtcb_bottom_port
*data
;
412 adapter
= (struct zfcp_adapter
*)host
->hostdata
[0];
413 fc_stats
= zfcp_init_fc_host_stats(adapter
);
417 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
421 ret
= zfcp_fsf_exchange_port_data_sync(adapter
, data
);
427 if (adapter
->stats_reset
&&
428 ((jiffies
/HZ
- adapter
->stats_reset
) <
429 data
->seconds_since_last_reset
))
430 zfcp_adjust_fc_host_stats(fc_stats
, data
,
431 adapter
->stats_reset_data
);
433 zfcp_set_fc_host_stats(fc_stats
, data
);
439 static void zfcp_reset_fc_host_stats(struct Scsi_Host
*shost
)
441 struct zfcp_adapter
*adapter
;
442 struct fsf_qtcb_bottom_port
*data
;
445 adapter
= (struct zfcp_adapter
*)shost
->hostdata
[0];
446 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
450 ret
= zfcp_fsf_exchange_port_data_sync(adapter
, data
);
454 adapter
->stats_reset
= jiffies
/HZ
;
455 kfree(adapter
->stats_reset_data
);
456 adapter
->stats_reset_data
= data
; /* finally freed in
461 static void zfcp_get_host_port_state(struct Scsi_Host
*shost
)
463 struct zfcp_adapter
*adapter
=
464 (struct zfcp_adapter
*)shost
->hostdata
[0];
465 int status
= atomic_read(&adapter
->status
);
467 if ((status
& ZFCP_STATUS_COMMON_RUNNING
) &&
468 !(status
& ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
))
469 fc_host_port_state(shost
) = FC_PORTSTATE_ONLINE
;
470 else if (status
& ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
)
471 fc_host_port_state(shost
) = FC_PORTSTATE_LINKDOWN
;
472 else if (status
& ZFCP_STATUS_COMMON_ERP_FAILED
)
473 fc_host_port_state(shost
) = FC_PORTSTATE_ERROR
;
475 fc_host_port_state(shost
) = FC_PORTSTATE_UNKNOWN
;
478 static void zfcp_set_rport_dev_loss_tmo(struct fc_rport
*rport
, u32 timeout
)
480 rport
->dev_loss_tmo
= timeout
;
484 * zfcp_scsi_dev_loss_tmo_callbk - Free any reference to rport
485 * @rport: The rport that is about to be deleted.
487 static void zfcp_scsi_dev_loss_tmo_callbk(struct fc_rport
*rport
)
489 struct zfcp_port
*port
= rport
->dd_data
;
491 write_lock_irq(&zfcp_data
.config_lock
);
493 write_unlock_irq(&zfcp_data
.config_lock
);
497 * zfcp_scsi_terminate_rport_io - Terminate all I/O on a rport
498 * @rport: The FC rport where to teminate I/O
500 * Abort all pending SCSI commands for a port by closing the
501 * port. Using a reopen for avoids a conflict with a shutdown
502 * overwriting a reopen.
504 static void zfcp_scsi_terminate_rport_io(struct fc_rport
*rport
)
506 struct zfcp_port
*port
= rport
->dd_data
;
508 zfcp_erp_port_reopen(port
, 0, "sctrpi1", NULL
);
511 static void zfcp_scsi_rport_register(struct zfcp_port
*port
)
513 struct fc_rport_identifiers ids
;
514 struct fc_rport
*rport
;
516 ids
.node_name
= port
->wwnn
;
517 ids
.port_name
= port
->wwpn
;
518 ids
.port_id
= port
->d_id
;
519 ids
.roles
= FC_RPORT_ROLE_FCP_TARGET
;
521 rport
= fc_remote_port_add(port
->adapter
->scsi_host
, 0, &ids
);
523 dev_err(&port
->adapter
->ccw_device
->dev
,
524 "Registering port 0x%016Lx failed\n",
525 (unsigned long long)port
->wwpn
);
529 rport
->dd_data
= port
;
530 rport
->maxframe_size
= port
->maxframe_size
;
531 rport
->supported_classes
= port
->supported_classes
;
535 static void zfcp_scsi_rport_block(struct zfcp_port
*port
)
538 fc_remote_port_delete(port
->rport
);
541 void zfcp_scsi_schedule_rport_register(struct zfcp_port
*port
)
544 port
->rport_task
= RPORT_ADD
;
546 if (!queue_work(zfcp_data
.work_queue
, &port
->rport_work
))
550 void zfcp_scsi_schedule_rport_block(struct zfcp_port
*port
)
553 port
->rport_task
= RPORT_DEL
;
555 if (!queue_work(zfcp_data
.work_queue
, &port
->rport_work
))
559 void zfcp_scsi_schedule_rports_block(struct zfcp_adapter
*adapter
)
561 struct zfcp_port
*port
;
563 list_for_each_entry(port
, &adapter
->port_list_head
, list
)
564 zfcp_scsi_schedule_rport_block(port
);
567 void zfcp_scsi_rport_work(struct work_struct
*work
)
569 struct zfcp_port
*port
= container_of(work
, struct zfcp_port
,
572 while (port
->rport_task
) {
573 if (port
->rport_task
== RPORT_ADD
) {
574 port
->rport_task
= RPORT_NONE
;
575 zfcp_scsi_rport_register(port
);
577 port
->rport_task
= RPORT_NONE
;
578 zfcp_scsi_rport_block(port
);
586 void zfcp_scsi_scan(struct work_struct
*work
)
588 struct zfcp_unit
*unit
= container_of(work
, struct zfcp_unit
,
590 struct fc_rport
*rport
;
592 flush_work(&unit
->port
->rport_work
);
593 rport
= unit
->port
->rport
;
595 if (rport
&& rport
->port_state
== FC_PORTSTATE_ONLINE
)
596 scsi_scan_target(&rport
->dev
, 0, rport
->scsi_target_id
,
597 scsilun_to_int((struct scsi_lun
*)
603 struct fc_function_template zfcp_transport_functions
= {
604 .show_starget_port_id
= 1,
605 .show_starget_port_name
= 1,
606 .show_starget_node_name
= 1,
607 .show_rport_supported_classes
= 1,
608 .show_rport_maxframe_size
= 1,
609 .show_rport_dev_loss_tmo
= 1,
610 .show_host_node_name
= 1,
611 .show_host_port_name
= 1,
612 .show_host_permanent_port_name
= 1,
613 .show_host_supported_classes
= 1,
614 .show_host_supported_speeds
= 1,
615 .show_host_maxframe_size
= 1,
616 .show_host_serial_number
= 1,
617 .get_fc_host_stats
= zfcp_get_fc_host_stats
,
618 .reset_fc_host_stats
= zfcp_reset_fc_host_stats
,
619 .set_rport_dev_loss_tmo
= zfcp_set_rport_dev_loss_tmo
,
620 .get_host_port_state
= zfcp_get_host_port_state
,
621 .dev_loss_tmo_callbk
= zfcp_scsi_dev_loss_tmo_callbk
,
622 .terminate_rport_io
= zfcp_scsi_terminate_rport_io
,
623 .show_host_port_state
= 1,
624 /* no functions registered for following dynamic attributes but
625 directly set by LLDD */
626 .show_host_port_type
= 1,
627 .show_host_speed
= 1,
628 .show_host_port_id
= 1,
629 .disable_target_scan
= 1,
632 struct zfcp_data zfcp_data
= {
633 .scsi_host_template
= {
635 .module
= THIS_MODULE
,
637 .slave_alloc
= zfcp_scsi_slave_alloc
,
638 .slave_configure
= zfcp_scsi_slave_configure
,
639 .slave_destroy
= zfcp_scsi_slave_destroy
,
640 .queuecommand
= zfcp_scsi_queuecommand
,
641 .eh_abort_handler
= zfcp_scsi_eh_abort_handler
,
642 .eh_device_reset_handler
= zfcp_scsi_eh_device_reset_handler
,
643 .eh_target_reset_handler
= zfcp_scsi_eh_target_reset_handler
,
644 .eh_host_reset_handler
= zfcp_scsi_eh_host_reset_handler
,
647 .sg_tablesize
= ZFCP_MAX_SBALES_PER_REQ
,
650 .sdev_attrs
= zfcp_sysfs_sdev_attrs
,
651 .max_sectors
= (ZFCP_MAX_SBALES_PER_REQ
* 8),
652 .shost_attrs
= zfcp_sysfs_shost_attrs
,