3 * linux/drivers/s390/scsi/zfcp_scsi.c
5 * FCP adapter driver for IBM eServer zSeries
7 * (C) Copyright IBM Corp. 2002, 2004
9 * Author(s): Martin Peschke <mpeschke@de.ibm.com>
10 * Raimund Schroeder <raimund.schroeder@de.ibm.com>
13 * Stefan Bader <stefan.bader@de.ibm.com>
14 * Heiko Carstens <heiko.carstens@de.ibm.com>
15 * Andreas Herrmann <aherrman@de.ibm.com>
17 * This program is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation; either version 2, or (at your option)
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
32 #define ZFCP_LOG_AREA ZFCP_LOG_AREA_SCSI
34 #define ZFCP_SCSI_REVISION "$Revision: 1.74 $"
38 static void zfcp_scsi_slave_destroy(struct scsi_device
*sdp
);
39 static int zfcp_scsi_slave_alloc(struct scsi_device
*sdp
);
40 static int zfcp_scsi_slave_configure(struct scsi_device
*sdp
);
41 static int zfcp_scsi_queuecommand(struct scsi_cmnd
*,
42 void (*done
) (struct scsi_cmnd
*));
43 static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd
*);
44 static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd
*);
45 static int zfcp_scsi_eh_bus_reset_handler(struct scsi_cmnd
*);
46 static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd
*);
47 static int zfcp_task_management_function(struct zfcp_unit
*, u8
,
50 static struct zfcp_unit
*zfcp_unit_lookup(struct zfcp_adapter
*, int, scsi_id_t
,
52 static struct zfcp_port
*zfcp_port_lookup(struct zfcp_adapter
*, int,
55 static struct device_attribute
*zfcp_sysfs_sdev_attrs
[];
57 struct scsi_transport_template
*zfcp_transport_template
;
59 struct zfcp_data zfcp_data
= {
60 .scsi_host_template
= {
65 slave_alloc
: zfcp_scsi_slave_alloc
,
66 slave_configure
: zfcp_scsi_slave_configure
,
67 slave_destroy
: zfcp_scsi_slave_destroy
,
68 queuecommand
: zfcp_scsi_queuecommand
,
69 eh_abort_handler
: zfcp_scsi_eh_abort_handler
,
70 eh_device_reset_handler
: zfcp_scsi_eh_device_reset_handler
,
71 eh_bus_reset_handler
: zfcp_scsi_eh_bus_reset_handler
,
72 eh_host_reset_handler
: zfcp_scsi_eh_host_reset_handler
,
73 /* FIXME(openfcp): Tune */
78 * one less? can zfcp_create_sbale cope with it?
80 sg_tablesize
: ZFCP_MAX_SBALES_PER_REQ
,
84 sdev_attrs
: zfcp_sysfs_sdev_attrs
,
86 .driver_version
= ZFCP_VERSION
,
87 /* rest initialised with zeros */
90 /* Find start of Response Information in FCP response unit*/
92 zfcp_get_fcp_rsp_info_ptr(struct fcp_rsp_iu
*fcp_rsp_iu
)
94 char *fcp_rsp_info_ptr
;
97 (unsigned char *) fcp_rsp_iu
+ (sizeof (struct fcp_rsp_iu
));
99 return fcp_rsp_info_ptr
;
102 /* Find start of Sense Information in FCP response unit*/
104 zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu
*fcp_rsp_iu
)
106 char *fcp_sns_info_ptr
;
109 (unsigned char *) fcp_rsp_iu
+ (sizeof (struct fcp_rsp_iu
));
110 if (fcp_rsp_iu
->validity
.bits
.fcp_rsp_len_valid
)
111 fcp_sns_info_ptr
= (char *) fcp_sns_info_ptr
+
112 fcp_rsp_iu
->fcp_rsp_len
;
114 return fcp_sns_info_ptr
;
118 zfcp_get_fcp_dl_ptr(struct fcp_cmnd_iu
* fcp_cmd
)
120 int additional_length
= fcp_cmd
->add_fcp_cdb_length
<< 2;
121 fcp_dl_t
*fcp_dl_addr
;
123 fcp_dl_addr
= (fcp_dl_t
*)
124 ((unsigned char *) fcp_cmd
+
125 sizeof (struct fcp_cmnd_iu
) + additional_length
);
127 * fcp_dl_addr = start address of fcp_cmnd structure +
128 * size of fixed part + size of dynamically sized add_dcp_cdb field
129 * SEE FCP-2 documentation
135 zfcp_get_fcp_dl(struct fcp_cmnd_iu
* fcp_cmd
)
137 return *zfcp_get_fcp_dl_ptr(fcp_cmd
);
141 zfcp_set_fcp_dl(struct fcp_cmnd_iu
*fcp_cmd
, fcp_dl_t fcp_dl
)
143 *zfcp_get_fcp_dl_ptr(fcp_cmd
) = fcp_dl
;
147 * note: it's a bit-or operation not an assignment
148 * regarding the specified byte
151 set_byte(u32
* result
, char status
, char pos
)
153 *result
|= status
<< (pos
* 8);
157 set_host_byte(u32
* result
, char status
)
159 set_byte(result
, status
, 2);
163 set_driver_byte(u32
* result
, char status
)
165 set_byte(result
, status
, 3);
169 * function: zfcp_scsi_slave_alloc
177 zfcp_scsi_slave_alloc(struct scsi_device
*sdp
)
179 struct zfcp_adapter
*adapter
;
180 struct zfcp_unit
*unit
;
182 int retval
= -ENODEV
;
184 adapter
= (struct zfcp_adapter
*) sdp
->host
->hostdata
[0];
188 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
189 unit
= zfcp_unit_lookup(adapter
, sdp
->channel
, sdp
->id
, sdp
->lun
);
191 sdp
->hostdata
= unit
;
196 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
202 * function: zfcp_scsi_slave_destroy
210 zfcp_scsi_slave_destroy(struct scsi_device
*sdpnt
)
212 struct zfcp_unit
*unit
= (struct zfcp_unit
*) sdpnt
->hostdata
;
215 sdpnt
->hostdata
= NULL
;
219 ZFCP_LOG_NORMAL("bug: no unit associated with SCSI device at "
220 "address %p\n", sdpnt
);
225 * called from scsi midlayer to allow finetuning of a device.
228 zfcp_scsi_slave_configure(struct scsi_device
*sdp
)
230 if (sdp
->tagged_supported
)
231 scsi_adjust_queue_depth(sdp
, MSG_SIMPLE_TAG
, ZFCP_CMND_PER_LUN
);
233 scsi_adjust_queue_depth(sdp
, 0, 1);
238 * zfcp_scsi_command_fail - set result in scsi_cmnd and call scsi_done function
239 * @scpnt: pointer to struct scsi_cmnd where result is set
240 * @result: result to be set in scpnt (e.g. DID_ERROR)
243 zfcp_scsi_command_fail(struct scsi_cmnd
*scpnt
, int result
)
245 set_host_byte(&scpnt
->result
, result
);
246 if ((scpnt
->device
!= NULL
) && (scpnt
->device
->host
!= NULL
))
247 zfcp_scsi_dbf_event_result("fail", 4,
248 (struct zfcp_adapter
*) scpnt
->device
->host
->hostdata
[0],
250 /* return directly */
251 scpnt
->scsi_done(scpnt
);
255 * zfcp_scsi_command_async - worker for zfcp_scsi_queuecommand and
256 * zfcp_scsi_command_sync
257 * @adapter: adapter where scsi command is issued
258 * @unit: unit to which scsi command is sent
259 * @scpnt: scsi command to be sent
260 * @timer: timer to be started if request is successfully initiated
262 * Note: In scsi_done function must be set in scpnt.
265 zfcp_scsi_command_async(struct zfcp_adapter
*adapter
, struct zfcp_unit
*unit
,
266 struct scsi_cmnd
*scpnt
, struct timer_list
*timer
)
273 BUG_ON((adapter
== NULL
) || (adapter
!= unit
->port
->adapter
));
274 BUG_ON(scpnt
->scsi_done
== NULL
);
276 if (unlikely(NULL
== unit
)) {
277 zfcp_scsi_command_fail(scpnt
, DID_NO_CONNECT
);
282 atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED
, &unit
->status
) ||
283 !atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING
, &unit
->status
))) {
284 ZFCP_LOG_DEBUG("stopping SCSI I/O on unit 0x%016Lx on port "
285 "0x%016Lx on adapter %s\n",
286 unit
->fcp_lun
, unit
->port
->wwpn
,
287 zfcp_get_busid_by_adapter(adapter
));
288 zfcp_scsi_command_fail(scpnt
, DID_ERROR
);
293 !atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED
, &unit
->status
))) {
294 ZFCP_LOG_DEBUG("adapter %s not ready or unit 0x%016Lx "
295 "on port 0x%016Lx in recovery\n",
296 zfcp_get_busid_by_unit(unit
),
297 unit
->fcp_lun
, unit
->port
->wwpn
);
298 retval
= SCSI_MLQUEUE_DEVICE_BUSY
;
302 tmp
= zfcp_fsf_send_fcp_command_task(adapter
, unit
, scpnt
, timer
,
303 ZFCP_REQ_AUTO_CLEANUP
);
305 if (unlikely(tmp
< 0)) {
306 ZFCP_LOG_DEBUG("error: initiation of Send FCP Cmnd failed\n");
307 retval
= SCSI_MLQUEUE_HOST_BUSY
;
315 zfcp_scsi_command_sync_handler(struct scsi_cmnd
*scpnt
)
317 struct completion
*wait
= (struct completion
*) scpnt
->SCp
.ptr
;
323 * zfcp_scsi_command_sync - send a SCSI command and wait for completion
324 * @unit: unit where command is sent to
325 * @scpnt: scsi command to be sent
326 * @timer: timer to be started if request is successfully initiated
329 * Errors are indicated in scpnt->result
332 zfcp_scsi_command_sync(struct zfcp_unit
*unit
, struct scsi_cmnd
*scpnt
,
333 struct timer_list
*timer
)
336 DECLARE_COMPLETION(wait
);
338 scpnt
->SCp
.ptr
= (void *) &wait
; /* silent re-use */
339 scpnt
->scsi_done
= zfcp_scsi_command_sync_handler
;
340 ret
= zfcp_scsi_command_async(unit
->port
->adapter
, unit
, scpnt
, timer
);
342 wait_for_completion(&wait
);
344 scpnt
->SCp
.ptr
= NULL
;
350 * function: zfcp_scsi_queuecommand
352 * purpose: enqueues a SCSI command to the specified target device
354 * returns: 0 - success, SCSI command enqueued
358 zfcp_scsi_queuecommand(struct scsi_cmnd
*scpnt
,
359 void (*done
) (struct scsi_cmnd
*))
361 struct zfcp_unit
*unit
;
362 struct zfcp_adapter
*adapter
;
364 /* reset the status for this request */
366 scpnt
->host_scribble
= NULL
;
367 scpnt
->scsi_done
= done
;
370 * figure out adapter and target device
371 * (stored there by zfcp_scsi_slave_alloc)
373 adapter
= (struct zfcp_adapter
*) scpnt
->device
->host
->hostdata
[0];
374 unit
= (struct zfcp_unit
*) scpnt
->device
->hostdata
;
376 return zfcp_scsi_command_async(adapter
, unit
, scpnt
, NULL
);
380 * function: zfcp_unit_lookup
388 static struct zfcp_unit
*
389 zfcp_unit_lookup(struct zfcp_adapter
*adapter
, int channel
, scsi_id_t id
,
392 struct zfcp_port
*port
;
393 struct zfcp_unit
*unit
, *retval
= NULL
;
395 list_for_each_entry(port
, &adapter
->port_list_head
, list
) {
396 if (!port
->rport
|| (id
!= port
->rport
->scsi_target_id
))
398 list_for_each_entry(unit
, &port
->unit_list_head
, list
) {
399 if (lun
== unit
->scsi_lun
) {
409 static struct zfcp_port
*
410 zfcp_port_lookup(struct zfcp_adapter
*adapter
, int channel
, scsi_id_t id
)
412 struct zfcp_port
*port
;
414 list_for_each_entry(port
, &adapter
->port_list_head
, list
) {
415 if (port
->rport
&& (id
== port
->rport
->scsi_target_id
))
418 return (struct zfcp_port
*) NULL
;
422 * zfcp_scsi_eh_abort_handler - abort the specified SCSI command
423 * @scpnt: pointer to scsi_cmnd to be aborted
424 * Return: SUCCESS - command has been aborted and cleaned up in internal
425 * bookkeeping, SCSI stack won't be called for aborted command
428 * We do not need to care for a SCSI command which completes normally
429 * but late during this abort routine runs. We are allowed to return
430 * late commands to the SCSI stack. It tracks the state of commands and
431 * will handle late commands. (Usually, the normal completion of late
432 * commands is ignored with respect to the running abort operation.)
435 zfcp_scsi_eh_abort_handler(struct scsi_cmnd
*scpnt
)
437 struct Scsi_Host
*scsi_host
;
438 struct zfcp_adapter
*adapter
;
439 struct zfcp_unit
*unit
;
440 int retval
= SUCCESS
;
441 struct zfcp_fsf_req
*new_fsf_req
= NULL
;
442 struct zfcp_fsf_req
*old_fsf_req
;
445 scsi_host
= scpnt
->device
->host
;
446 adapter
= (struct zfcp_adapter
*) scsi_host
->hostdata
[0];
447 unit
= (struct zfcp_unit
*) scpnt
->device
->hostdata
;
449 ZFCP_LOG_INFO("aborting scsi_cmnd=%p on adapter %s\n",
450 scpnt
, zfcp_get_busid_by_adapter(adapter
));
452 /* avoid race condition between late normal completion and abort */
453 write_lock_irqsave(&adapter
->abort_lock
, flags
);
456 * Check whether command has just completed and can not be aborted.
457 * Even if the command has just been completed late, we can access
458 * scpnt since the SCSI stack does not release it at least until
459 * this routine returns. (scpnt is parameter passed to this routine
460 * and must not disappear during abort even on late completion.)
462 old_fsf_req
= (struct zfcp_fsf_req
*) scpnt
->host_scribble
;
464 write_unlock_irqrestore(&adapter
->abort_lock
, flags
);
465 zfcp_scsi_dbf_event_abort("lte1", adapter
, scpnt
, new_fsf_req
);
469 old_fsf_req
->data
= 0;
470 old_fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ABORTING
;
472 /* don't access old_fsf_req after releasing the abort_lock */
473 write_unlock_irqrestore(&adapter
->abort_lock
, flags
);
474 /* call FSF routine which does the abort */
475 new_fsf_req
= zfcp_fsf_abort_fcp_command((unsigned long) old_fsf_req
,
478 ZFCP_LOG_INFO("error: initiation of Abort FCP Cmnd failed\n");
483 /* wait for completion of abort */
484 __wait_event(new_fsf_req
->completion_wq
,
485 new_fsf_req
->status
& ZFCP_STATUS_FSFREQ_COMPLETED
);
487 /* status should be valid since signals were not permitted */
488 if (new_fsf_req
->status
& ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED
) {
489 zfcp_scsi_dbf_event_abort("okay", adapter
, scpnt
, new_fsf_req
);
491 } else if (new_fsf_req
->status
& ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED
) {
492 zfcp_scsi_dbf_event_abort("lte2", adapter
, scpnt
, new_fsf_req
);
495 zfcp_scsi_dbf_event_abort("fail", adapter
, scpnt
, new_fsf_req
);
498 zfcp_fsf_req_free(new_fsf_req
);
504 * function: zfcp_scsi_eh_device_reset_handler
511 zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd
*scpnt
)
514 struct zfcp_unit
*unit
= (struct zfcp_unit
*) scpnt
->device
->hostdata
;
517 ZFCP_LOG_NORMAL("bug: Tried reset for nonexistent unit\n");
521 ZFCP_LOG_NORMAL("resetting unit 0x%016Lx\n", unit
->fcp_lun
);
524 * If we do not know whether the unit supports 'logical unit reset'
525 * then try 'logical unit reset' and proceed with 'target reset'
526 * if 'logical unit reset' fails.
527 * If the unit is known not to support 'logical unit reset' then
528 * skip 'logical unit reset' and try 'target reset' immediately.
530 if (!atomic_test_mask(ZFCP_STATUS_UNIT_NOTSUPPUNITRESET
,
532 retval
= zfcp_task_management_function(unit
,
533 FCP_LOGICAL_UNIT_RESET
,
536 ZFCP_LOG_DEBUG("unit reset failed (unit=%p)\n", unit
);
537 if (retval
== -ENOTSUPP
)
539 (ZFCP_STATUS_UNIT_NOTSUPPUNITRESET
,
541 /* fall through and try 'target reset' next */
543 ZFCP_LOG_DEBUG("unit reset succeeded (unit=%p)\n",
545 /* avoid 'target reset' */
550 retval
= zfcp_task_management_function(unit
, FCP_TARGET_RESET
, scpnt
);
552 ZFCP_LOG_DEBUG("target reset failed (unit=%p)\n", unit
);
555 ZFCP_LOG_DEBUG("target reset succeeded (unit=%p)\n", unit
);
563 zfcp_task_management_function(struct zfcp_unit
*unit
, u8 tm_flags
,
564 struct scsi_cmnd
*scpnt
)
566 struct zfcp_adapter
*adapter
= unit
->port
->adapter
;
567 struct zfcp_fsf_req
*fsf_req
;
570 /* issue task management function */
571 fsf_req
= zfcp_fsf_send_fcp_command_task_management
572 (adapter
, unit
, tm_flags
, 0);
574 ZFCP_LOG_INFO("error: creation of task management request "
575 "failed for unit 0x%016Lx on port 0x%016Lx on "
576 "adapter %s\n", unit
->fcp_lun
, unit
->port
->wwpn
,
577 zfcp_get_busid_by_adapter(adapter
));
578 zfcp_scsi_dbf_event_devreset("nres", tm_flags
, unit
, scpnt
);
583 __wait_event(fsf_req
->completion_wq
,
584 fsf_req
->status
& ZFCP_STATUS_FSFREQ_COMPLETED
);
587 * check completion status of task management function
589 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_TMFUNCFAILED
) {
590 zfcp_scsi_dbf_event_devreset("fail", tm_flags
, unit
, scpnt
);
592 } else if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP
) {
593 zfcp_scsi_dbf_event_devreset("nsup", tm_flags
, unit
, scpnt
);
596 zfcp_scsi_dbf_event_devreset("okay", tm_flags
, unit
, scpnt
);
598 zfcp_fsf_req_free(fsf_req
);
604 * zfcp_scsi_eh_bus_reset_handler - reset bus (reopen adapter)
607 zfcp_scsi_eh_bus_reset_handler(struct scsi_cmnd
*scpnt
)
609 struct zfcp_unit
*unit
= (struct zfcp_unit
*) scpnt
->device
->hostdata
;
610 struct zfcp_adapter
*adapter
= unit
->port
->adapter
;
612 ZFCP_LOG_NORMAL("bus reset because of problems with "
613 "unit 0x%016Lx\n", unit
->fcp_lun
);
614 zfcp_erp_adapter_reopen(adapter
, 0);
615 zfcp_erp_wait(adapter
);
621 * zfcp_scsi_eh_host_reset_handler - reset host (reopen adapter)
624 zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd
*scpnt
)
626 struct zfcp_unit
*unit
= (struct zfcp_unit
*) scpnt
->device
->hostdata
;
627 struct zfcp_adapter
*adapter
= unit
->port
->adapter
;
629 ZFCP_LOG_NORMAL("host reset because of problems with "
630 "unit 0x%016Lx\n", unit
->fcp_lun
);
631 zfcp_erp_adapter_reopen(adapter
, 0);
632 zfcp_erp_wait(adapter
);
645 zfcp_adapter_scsi_register(struct zfcp_adapter
*adapter
)
648 static unsigned int unique_id
= 0;
650 /* register adapter as SCSI host with mid layer of SCSI stack */
651 adapter
->scsi_host
= scsi_host_alloc(&zfcp_data
.scsi_host_template
,
652 sizeof (struct zfcp_adapter
*));
653 if (!adapter
->scsi_host
) {
654 ZFCP_LOG_NORMAL("error: registration with SCSI stack failed "
656 zfcp_get_busid_by_adapter(adapter
));
660 ZFCP_LOG_DEBUG("host registered, scsi_host=%p\n", adapter
->scsi_host
);
662 /* tell the SCSI stack some characteristics of this adapter */
663 adapter
->scsi_host
->max_id
= 1;
664 adapter
->scsi_host
->max_lun
= 1;
665 adapter
->scsi_host
->max_channel
= 0;
666 adapter
->scsi_host
->unique_id
= unique_id
++; /* FIXME */
667 adapter
->scsi_host
->max_cmd_len
= ZFCP_MAX_SCSI_CMND_LENGTH
;
668 adapter
->scsi_host
->transportt
= zfcp_transport_template
;
670 * Reverse mapping of the host number to avoid race condition
672 adapter
->scsi_host_no
= adapter
->scsi_host
->host_no
;
675 * save a pointer to our own adapter data structure within
676 * hostdata field of SCSI host data structure
678 adapter
->scsi_host
->hostdata
[0] = (unsigned long) adapter
;
680 if (scsi_add_host(adapter
->scsi_host
, &adapter
->ccw_device
->dev
)) {
681 scsi_host_put(adapter
->scsi_host
);
685 atomic_set_mask(ZFCP_STATUS_ADAPTER_REGISTERED
, &adapter
->status
);
698 zfcp_adapter_scsi_unregister(struct zfcp_adapter
*adapter
)
700 struct Scsi_Host
*shost
;
701 struct zfcp_port
*port
;
703 shost
= adapter
->scsi_host
;
706 read_lock_irq(&zfcp_data
.config_lock
);
707 list_for_each_entry(port
, &adapter
->port_list_head
, list
)
710 read_unlock_irq(&zfcp_data
.config_lock
);
711 fc_remove_host(shost
);
712 scsi_remove_host(shost
);
713 scsi_host_put(shost
);
714 adapter
->scsi_host
= NULL
;
715 adapter
->scsi_host_no
= 0;
716 atomic_clear_mask(ZFCP_STATUS_ADAPTER_REGISTERED
, &adapter
->status
);
723 zfcp_fsf_start_scsi_er_timer(struct zfcp_adapter
*adapter
)
725 adapter
->scsi_er_timer
.function
= zfcp_fsf_scsi_er_timeout_handler
;
726 adapter
->scsi_er_timer
.data
= (unsigned long) adapter
;
727 adapter
->scsi_er_timer
.expires
= jiffies
+ ZFCP_SCSI_ER_TIMEOUT
;
728 add_timer(&adapter
->scsi_er_timer
);
732 * Support functions for FC transport class
735 zfcp_get_port_id(struct scsi_target
*starget
)
737 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
738 struct zfcp_adapter
*adapter
= (struct zfcp_adapter
*)shost
->hostdata
[0];
739 struct zfcp_port
*port
;
742 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
743 port
= zfcp_port_lookup(adapter
, starget
->channel
, starget
->id
);
745 fc_starget_port_id(starget
) = port
->d_id
;
747 fc_starget_port_id(starget
) = -1;
748 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
752 zfcp_get_port_name(struct scsi_target
*starget
)
754 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
755 struct zfcp_adapter
*adapter
= (struct zfcp_adapter
*)shost
->hostdata
[0];
756 struct zfcp_port
*port
;
759 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
760 port
= zfcp_port_lookup(adapter
, starget
->channel
, starget
->id
);
762 fc_starget_port_name(starget
) = port
->wwpn
;
764 fc_starget_port_name(starget
) = -1;
765 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
769 zfcp_get_node_name(struct scsi_target
*starget
)
771 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
772 struct zfcp_adapter
*adapter
= (struct zfcp_adapter
*)shost
->hostdata
[0];
773 struct zfcp_port
*port
;
776 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
777 port
= zfcp_port_lookup(adapter
, starget
->channel
, starget
->id
);
779 fc_starget_node_name(starget
) = port
->wwnn
;
781 fc_starget_node_name(starget
) = -1;
782 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
785 struct fc_function_template zfcp_transport_functions
= {
786 .get_starget_port_id
= zfcp_get_port_id
,
787 .get_starget_port_name
= zfcp_get_port_name
,
788 .get_starget_node_name
= zfcp_get_node_name
,
789 .show_starget_port_id
= 1,
790 .show_starget_port_name
= 1,
791 .show_starget_node_name
= 1,
792 .show_rport_supported_classes
= 1,
793 .show_host_node_name
= 1,
794 .show_host_port_name
= 1,
795 .show_host_supported_classes
= 1,
796 .show_host_maxframe_size
= 1,
797 .show_host_serial_number
= 1,
798 .show_host_speed
= 1,
799 .show_host_port_id
= 1,
803 * ZFCP_DEFINE_SCSI_ATTR
804 * @_name: name of show attribute
805 * @_format: format string
806 * @_value: value to print
808 * Generates attribute for a unit.
810 #define ZFCP_DEFINE_SCSI_ATTR(_name, _format, _value) \
811 static ssize_t zfcp_sysfs_scsi_##_name##_show(struct device *dev, struct device_attribute *attr, \
814 struct scsi_device *sdev; \
815 struct zfcp_unit *unit; \
817 sdev = to_scsi_device(dev); \
818 unit = sdev->hostdata; \
819 return sprintf(buf, _format, _value); \
822 static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_scsi_##_name##_show, NULL);
824 ZFCP_DEFINE_SCSI_ATTR(hba_id
, "%s\n", zfcp_get_busid_by_unit(unit
));
825 ZFCP_DEFINE_SCSI_ATTR(wwpn
, "0x%016llx\n", unit
->port
->wwpn
);
826 ZFCP_DEFINE_SCSI_ATTR(fcp_lun
, "0x%016llx\n", unit
->fcp_lun
);
828 static struct device_attribute
*zfcp_sysfs_sdev_attrs
[] = {