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
);
49 static struct zfcp_unit
*zfcp_unit_lookup(struct zfcp_adapter
*, int, scsi_id_t
,
51 static struct zfcp_port
*zfcp_port_lookup(struct zfcp_adapter
*, int,
54 static struct device_attribute
*zfcp_sysfs_sdev_attrs
[];
56 struct scsi_transport_template
*zfcp_transport_template
;
58 struct zfcp_data zfcp_data
= {
59 .scsi_host_template
= {
64 slave_alloc
: zfcp_scsi_slave_alloc
,
65 slave_configure
: zfcp_scsi_slave_configure
,
66 slave_destroy
: zfcp_scsi_slave_destroy
,
67 queuecommand
: zfcp_scsi_queuecommand
,
68 eh_abort_handler
: zfcp_scsi_eh_abort_handler
,
69 eh_device_reset_handler
: zfcp_scsi_eh_device_reset_handler
,
70 eh_bus_reset_handler
: zfcp_scsi_eh_bus_reset_handler
,
71 eh_host_reset_handler
: zfcp_scsi_eh_host_reset_handler
,
72 /* FIXME(openfcp): Tune */
77 * one less? can zfcp_create_sbale cope with it?
79 sg_tablesize
: ZFCP_MAX_SBALES_PER_REQ
,
83 sdev_attrs
: zfcp_sysfs_sdev_attrs
,
85 .driver_version
= ZFCP_VERSION
,
86 /* rest initialised with zeros */
89 /* Find start of Response Information in FCP response unit*/
91 zfcp_get_fcp_rsp_info_ptr(struct fcp_rsp_iu
*fcp_rsp_iu
)
93 char *fcp_rsp_info_ptr
;
96 (unsigned char *) fcp_rsp_iu
+ (sizeof (struct fcp_rsp_iu
));
98 return fcp_rsp_info_ptr
;
101 /* Find start of Sense Information in FCP response unit*/
103 zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu
*fcp_rsp_iu
)
105 char *fcp_sns_info_ptr
;
108 (unsigned char *) fcp_rsp_iu
+ (sizeof (struct fcp_rsp_iu
));
109 if (fcp_rsp_iu
->validity
.bits
.fcp_rsp_len_valid
)
110 fcp_sns_info_ptr
= (char *) fcp_sns_info_ptr
+
111 fcp_rsp_iu
->fcp_rsp_len
;
113 return fcp_sns_info_ptr
;
117 zfcp_get_fcp_dl_ptr(struct fcp_cmnd_iu
* fcp_cmd
)
119 int additional_length
= fcp_cmd
->add_fcp_cdb_length
<< 2;
120 fcp_dl_t
*fcp_dl_addr
;
122 fcp_dl_addr
= (fcp_dl_t
*)
123 ((unsigned char *) fcp_cmd
+
124 sizeof (struct fcp_cmnd_iu
) + additional_length
);
126 * fcp_dl_addr = start address of fcp_cmnd structure +
127 * size of fixed part + size of dynamically sized add_dcp_cdb field
128 * SEE FCP-2 documentation
134 zfcp_get_fcp_dl(struct fcp_cmnd_iu
* fcp_cmd
)
136 return *zfcp_get_fcp_dl_ptr(fcp_cmd
);
140 zfcp_set_fcp_dl(struct fcp_cmnd_iu
*fcp_cmd
, fcp_dl_t fcp_dl
)
142 *zfcp_get_fcp_dl_ptr(fcp_cmd
) = fcp_dl
;
146 * note: it's a bit-or operation not an assignment
147 * regarding the specified byte
150 set_byte(u32
* result
, char status
, char pos
)
152 *result
|= status
<< (pos
* 8);
156 set_host_byte(u32
* result
, char status
)
158 set_byte(result
, status
, 2);
162 set_driver_byte(u32
* result
, char status
)
164 set_byte(result
, status
, 3);
168 * function: zfcp_scsi_slave_alloc
176 zfcp_scsi_slave_alloc(struct scsi_device
*sdp
)
178 struct zfcp_adapter
*adapter
;
179 struct zfcp_unit
*unit
;
181 int retval
= -ENODEV
;
183 adapter
= (struct zfcp_adapter
*) sdp
->host
->hostdata
[0];
187 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
188 unit
= zfcp_unit_lookup(adapter
, sdp
->channel
, sdp
->id
, sdp
->lun
);
190 sdp
->hostdata
= unit
;
195 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
201 * function: zfcp_scsi_slave_destroy
209 zfcp_scsi_slave_destroy(struct scsi_device
*sdpnt
)
211 struct zfcp_unit
*unit
= (struct zfcp_unit
*) sdpnt
->hostdata
;
214 sdpnt
->hostdata
= NULL
;
218 ZFCP_LOG_NORMAL("bug: no unit associated with SCSI device at "
219 "address %p\n", sdpnt
);
224 * called from scsi midlayer to allow finetuning of a device.
227 zfcp_scsi_slave_configure(struct scsi_device
*sdp
)
229 if (sdp
->tagged_supported
)
230 scsi_adjust_queue_depth(sdp
, MSG_SIMPLE_TAG
, ZFCP_CMND_PER_LUN
);
232 scsi_adjust_queue_depth(sdp
, 0, 1);
237 * zfcp_scsi_command_fail - set result in scsi_cmnd and call scsi_done function
238 * @scpnt: pointer to struct scsi_cmnd where result is set
239 * @result: result to be set in scpnt (e.g. DID_ERROR)
242 zfcp_scsi_command_fail(struct scsi_cmnd
*scpnt
, int result
)
244 set_host_byte(&scpnt
->result
, result
);
245 zfcp_cmd_dbf_event_scsi("failing", scpnt
);
246 /* return directly */
247 scpnt
->scsi_done(scpnt
);
251 * zfcp_scsi_command_async - worker for zfcp_scsi_queuecommand and
252 * zfcp_scsi_command_sync
253 * @adapter: adapter where scsi command is issued
254 * @unit: unit to which scsi command is sent
255 * @scpnt: scsi command to be sent
256 * @timer: timer to be started if request is successfully initiated
258 * Note: In scsi_done function must be set in scpnt.
261 zfcp_scsi_command_async(struct zfcp_adapter
*adapter
, struct zfcp_unit
*unit
,
262 struct scsi_cmnd
*scpnt
, struct timer_list
*timer
)
269 BUG_ON((adapter
== NULL
) || (adapter
!= unit
->port
->adapter
));
270 BUG_ON(scpnt
->scsi_done
== NULL
);
272 if (unlikely(NULL
== unit
)) {
273 zfcp_scsi_command_fail(scpnt
, DID_NO_CONNECT
);
278 atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED
, &unit
->status
) ||
279 !atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING
, &unit
->status
))) {
280 ZFCP_LOG_DEBUG("stopping SCSI I/O on unit 0x%016Lx on port "
281 "0x%016Lx on adapter %s\n",
282 unit
->fcp_lun
, unit
->port
->wwpn
,
283 zfcp_get_busid_by_adapter(adapter
));
284 zfcp_scsi_command_fail(scpnt
, DID_ERROR
);
289 !atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED
, &unit
->status
))) {
290 ZFCP_LOG_DEBUG("adapter %s not ready or unit 0x%016Lx "
291 "on port 0x%016Lx in recovery\n",
292 zfcp_get_busid_by_unit(unit
),
293 unit
->fcp_lun
, unit
->port
->wwpn
);
294 retval
= SCSI_MLQUEUE_DEVICE_BUSY
;
298 tmp
= zfcp_fsf_send_fcp_command_task(adapter
, unit
, scpnt
, timer
,
299 ZFCP_REQ_AUTO_CLEANUP
);
301 if (unlikely(tmp
< 0)) {
302 ZFCP_LOG_DEBUG("error: initiation of Send FCP Cmnd failed\n");
303 retval
= SCSI_MLQUEUE_HOST_BUSY
;
311 zfcp_scsi_command_sync_handler(struct scsi_cmnd
*scpnt
)
313 struct completion
*wait
= (struct completion
*) scpnt
->SCp
.ptr
;
319 * zfcp_scsi_command_sync - send a SCSI command and wait for completion
320 * @unit: unit where command is sent to
321 * @scpnt: scsi command to be sent
322 * @timer: timer to be started if request is successfully initiated
325 * Errors are indicated in scpnt->result
328 zfcp_scsi_command_sync(struct zfcp_unit
*unit
, struct scsi_cmnd
*scpnt
,
329 struct timer_list
*timer
)
332 DECLARE_COMPLETION(wait
);
334 scpnt
->SCp
.ptr
= (void *) &wait
; /* silent re-use */
335 scpnt
->scsi_done
= zfcp_scsi_command_sync_handler
;
336 ret
= zfcp_scsi_command_async(unit
->port
->adapter
, unit
, scpnt
, timer
);
338 wait_for_completion(&wait
);
340 scpnt
->SCp
.ptr
= NULL
;
346 * function: zfcp_scsi_queuecommand
348 * purpose: enqueues a SCSI command to the specified target device
350 * returns: 0 - success, SCSI command enqueued
354 zfcp_scsi_queuecommand(struct scsi_cmnd
*scpnt
,
355 void (*done
) (struct scsi_cmnd
*))
357 struct zfcp_unit
*unit
;
358 struct zfcp_adapter
*adapter
;
360 /* reset the status for this request */
362 scpnt
->host_scribble
= NULL
;
363 scpnt
->scsi_done
= done
;
366 * figure out adapter and target device
367 * (stored there by zfcp_scsi_slave_alloc)
369 adapter
= (struct zfcp_adapter
*) scpnt
->device
->host
->hostdata
[0];
370 unit
= (struct zfcp_unit
*) scpnt
->device
->hostdata
;
372 return zfcp_scsi_command_async(adapter
, unit
, scpnt
, NULL
);
376 * function: zfcp_unit_lookup
384 static struct zfcp_unit
*
385 zfcp_unit_lookup(struct zfcp_adapter
*adapter
, int channel
, scsi_id_t id
,
388 struct zfcp_port
*port
;
389 struct zfcp_unit
*unit
, *retval
= NULL
;
391 list_for_each_entry(port
, &adapter
->port_list_head
, list
) {
392 if (!port
->rport
|| (id
!= port
->rport
->scsi_target_id
))
394 list_for_each_entry(unit
, &port
->unit_list_head
, list
) {
395 if (lun
== unit
->scsi_lun
) {
405 static struct zfcp_port
*
406 zfcp_port_lookup(struct zfcp_adapter
*adapter
, int channel
, scsi_id_t id
)
408 struct zfcp_port
*port
;
410 list_for_each_entry(port
, &adapter
->port_list_head
, list
) {
411 if (port
->rport
&& (id
== port
->rport
->scsi_target_id
))
414 return (struct zfcp_port
*) NULL
;
418 * zfcp_scsi_eh_abort_handler - abort the specified SCSI command
419 * @scpnt: pointer to scsi_cmnd to be aborted
420 * Return: SUCCESS - command has been aborted and cleaned up in internal
421 * bookkeeping, SCSI stack won't be called for aborted command
424 * We do not need to care for a SCSI command which completes normally
425 * but late during this abort routine runs. We are allowed to return
426 * late commands to the SCSI stack. It tracks the state of commands and
427 * will handle late commands. (Usually, the normal completion of late
428 * commands is ignored with respect to the running abort operation.)
431 zfcp_scsi_eh_abort_handler(struct scsi_cmnd
*scpnt
)
433 struct Scsi_Host
*scsi_host
;
434 struct zfcp_adapter
*adapter
;
435 struct zfcp_unit
*unit
;
436 int retval
= SUCCESS
;
437 struct zfcp_fsf_req
*new_fsf_req
, *old_fsf_req
;
440 scsi_host
= scpnt
->device
->host
;
441 adapter
= (struct zfcp_adapter
*) scsi_host
->hostdata
[0];
442 unit
= (struct zfcp_unit
*) scpnt
->device
->hostdata
;
444 ZFCP_LOG_INFO("aborting scsi_cmnd=%p on adapter %s\n",
445 scpnt
, zfcp_get_busid_by_adapter(adapter
));
447 /* avoid race condition between late normal completion and abort */
448 write_lock_irqsave(&adapter
->abort_lock
, flags
);
451 * Check whether command has just completed and can not be aborted.
452 * Even if the command has just been completed late, we can access
453 * scpnt since the SCSI stack does not release it at least until
454 * this routine returns. (scpnt is parameter passed to this routine
455 * and must not disappear during abort even on late completion.)
457 old_fsf_req
= (struct zfcp_fsf_req
*) scpnt
->host_scribble
;
459 write_unlock_irqrestore(&adapter
->abort_lock
, flags
);
460 ZFCP_LOG_NORMAL("bug: no old fsf request found\n");
461 ZFCP_LOG_NORMAL("scsi_cmnd:\n");
462 ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL
,
463 (char *) scpnt
, sizeof (struct scsi_cmnd
));
467 old_fsf_req
->data
= 0;
468 old_fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ABORTING
;
470 /* don't access old_fsf_req after releasing the abort_lock */
471 write_unlock_irqrestore(&adapter
->abort_lock
, flags
);
472 /* call FSF routine which does the abort */
473 new_fsf_req
= zfcp_fsf_abort_fcp_command((unsigned long) old_fsf_req
,
477 ZFCP_LOG_NORMAL("error: initiation of Abort FCP Cmnd "
482 /* wait for completion of abort */
483 __wait_event(new_fsf_req
->completion_wq
,
484 new_fsf_req
->status
& ZFCP_STATUS_FSFREQ_COMPLETED
);
485 zfcp_fsf_req_free(new_fsf_req
);
487 /* status should be valid since signals were not permitted */
488 if (new_fsf_req
->status
& ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED
) {
490 } else if (new_fsf_req
->status
& ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED
) {
500 * function: zfcp_scsi_eh_device_reset_handler
507 zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd
*scpnt
)
510 struct zfcp_unit
*unit
= (struct zfcp_unit
*) scpnt
->device
->hostdata
;
513 ZFCP_LOG_NORMAL("bug: Tried reset for nonexistent unit\n");
517 ZFCP_LOG_NORMAL("resetting unit 0x%016Lx\n", unit
->fcp_lun
);
520 * If we do not know whether the unit supports 'logical unit reset'
521 * then try 'logical unit reset' and proceed with 'target reset'
522 * if 'logical unit reset' fails.
523 * If the unit is known not to support 'logical unit reset' then
524 * skip 'logical unit reset' and try 'target reset' immediately.
526 if (!atomic_test_mask(ZFCP_STATUS_UNIT_NOTSUPPUNITRESET
,
529 zfcp_task_management_function(unit
, FCP_LOGICAL_UNIT_RESET
);
531 ZFCP_LOG_DEBUG("unit reset failed (unit=%p)\n", unit
);
532 if (retval
== -ENOTSUPP
)
534 (ZFCP_STATUS_UNIT_NOTSUPPUNITRESET
,
536 /* fall through and try 'target reset' next */
538 ZFCP_LOG_DEBUG("unit reset succeeded (unit=%p)\n",
540 /* avoid 'target reset' */
545 retval
= zfcp_task_management_function(unit
, FCP_TARGET_RESET
);
547 ZFCP_LOG_DEBUG("target reset failed (unit=%p)\n", unit
);
550 ZFCP_LOG_DEBUG("target reset succeeded (unit=%p)\n", unit
);
558 zfcp_task_management_function(struct zfcp_unit
*unit
, u8 tm_flags
)
560 struct zfcp_adapter
*adapter
= unit
->port
->adapter
;
563 struct zfcp_fsf_req
*fsf_req
;
565 /* issue task management function */
566 fsf_req
= zfcp_fsf_send_fcp_command_task_management
567 (adapter
, unit
, tm_flags
, 0);
569 ZFCP_LOG_INFO("error: creation of task management request "
570 "failed for unit 0x%016Lx on port 0x%016Lx on "
571 "adapter %s\n", unit
->fcp_lun
, unit
->port
->wwpn
,
572 zfcp_get_busid_by_adapter(adapter
));
577 retval
= zfcp_fsf_req_wait_and_cleanup(fsf_req
,
578 ZFCP_UNINTERRUPTIBLE
, &status
);
580 * check completion status of task management function
581 * (status should always be valid since no signals permitted)
583 if (status
& ZFCP_STATUS_FSFREQ_TMFUNCFAILED
)
585 else if (status
& ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP
)
594 * function: zfcp_scsi_eh_bus_reset_handler
601 zfcp_scsi_eh_bus_reset_handler(struct scsi_cmnd
*scpnt
)
604 struct zfcp_unit
*unit
;
606 unit
= (struct zfcp_unit
*) scpnt
->device
->hostdata
;
607 ZFCP_LOG_NORMAL("bus reset because of problems with "
608 "unit 0x%016Lx\n", unit
->fcp_lun
);
609 zfcp_erp_adapter_reopen(unit
->port
->adapter
, 0);
610 zfcp_erp_wait(unit
->port
->adapter
);
617 * function: zfcp_scsi_eh_host_reset_handler
624 zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd
*scpnt
)
627 struct zfcp_unit
*unit
;
629 unit
= (struct zfcp_unit
*) scpnt
->device
->hostdata
;
630 ZFCP_LOG_NORMAL("host reset because of problems with "
631 "unit 0x%016Lx\n", unit
->fcp_lun
);
632 zfcp_erp_adapter_reopen(unit
->port
->adapter
, 0);
633 zfcp_erp_wait(unit
->port
->adapter
);
647 zfcp_adapter_scsi_register(struct zfcp_adapter
*adapter
)
650 static unsigned int unique_id
= 0;
652 /* register adapter as SCSI host with mid layer of SCSI stack */
653 adapter
->scsi_host
= scsi_host_alloc(&zfcp_data
.scsi_host_template
,
654 sizeof (struct zfcp_adapter
*));
655 if (!adapter
->scsi_host
) {
656 ZFCP_LOG_NORMAL("error: registration with SCSI stack failed "
658 zfcp_get_busid_by_adapter(adapter
));
662 ZFCP_LOG_DEBUG("host registered, scsi_host=%p\n", adapter
->scsi_host
);
664 /* tell the SCSI stack some characteristics of this adapter */
665 adapter
->scsi_host
->max_id
= 1;
666 adapter
->scsi_host
->max_lun
= 1;
667 adapter
->scsi_host
->max_channel
= 0;
668 adapter
->scsi_host
->unique_id
= unique_id
++; /* FIXME */
669 adapter
->scsi_host
->max_cmd_len
= ZFCP_MAX_SCSI_CMND_LENGTH
;
670 adapter
->scsi_host
->transportt
= zfcp_transport_template
;
672 * Reverse mapping of the host number to avoid race condition
674 adapter
->scsi_host_no
= adapter
->scsi_host
->host_no
;
677 * save a pointer to our own adapter data structure within
678 * hostdata field of SCSI host data structure
680 adapter
->scsi_host
->hostdata
[0] = (unsigned long) adapter
;
682 if (scsi_add_host(adapter
->scsi_host
, &adapter
->ccw_device
->dev
)) {
683 scsi_host_put(adapter
->scsi_host
);
687 atomic_set_mask(ZFCP_STATUS_ADAPTER_REGISTERED
, &adapter
->status
);
700 zfcp_adapter_scsi_unregister(struct zfcp_adapter
*adapter
)
702 struct Scsi_Host
*shost
;
704 shost
= adapter
->scsi_host
;
707 fc_remove_host(shost
);
708 scsi_remove_host(shost
);
709 scsi_host_put(shost
);
710 adapter
->scsi_host
= NULL
;
711 adapter
->scsi_host_no
= 0;
712 atomic_clear_mask(ZFCP_STATUS_ADAPTER_REGISTERED
, &adapter
->status
);
719 zfcp_fsf_start_scsi_er_timer(struct zfcp_adapter
*adapter
)
721 adapter
->scsi_er_timer
.function
= zfcp_fsf_scsi_er_timeout_handler
;
722 adapter
->scsi_er_timer
.data
= (unsigned long) adapter
;
723 adapter
->scsi_er_timer
.expires
= jiffies
+ ZFCP_SCSI_ER_TIMEOUT
;
724 add_timer(&adapter
->scsi_er_timer
);
728 * Support functions for FC transport class
731 zfcp_get_port_id(struct scsi_target
*starget
)
733 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
734 struct zfcp_adapter
*adapter
= (struct zfcp_adapter
*)shost
->hostdata
[0];
735 struct zfcp_port
*port
;
738 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
739 port
= zfcp_port_lookup(adapter
, starget
->channel
, starget
->id
);
741 fc_starget_port_id(starget
) = port
->d_id
;
743 fc_starget_port_id(starget
) = -1;
744 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
748 zfcp_get_port_name(struct scsi_target
*starget
)
750 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
751 struct zfcp_adapter
*adapter
= (struct zfcp_adapter
*)shost
->hostdata
[0];
752 struct zfcp_port
*port
;
755 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
756 port
= zfcp_port_lookup(adapter
, starget
->channel
, starget
->id
);
758 fc_starget_port_name(starget
) = port
->wwpn
;
760 fc_starget_port_name(starget
) = -1;
761 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
765 zfcp_get_node_name(struct scsi_target
*starget
)
767 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
768 struct zfcp_adapter
*adapter
= (struct zfcp_adapter
*)shost
->hostdata
[0];
769 struct zfcp_port
*port
;
772 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
773 port
= zfcp_port_lookup(adapter
, starget
->channel
, starget
->id
);
775 fc_starget_node_name(starget
) = port
->wwnn
;
777 fc_starget_node_name(starget
) = -1;
778 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
782 zfcp_set_fc_host_attrs(struct zfcp_adapter
*adapter
)
784 struct Scsi_Host
*shost
= adapter
->scsi_host
;
786 fc_host_node_name(shost
) = adapter
->wwnn
;
787 fc_host_port_name(shost
) = adapter
->wwpn
;
788 strncpy(fc_host_serial_number(shost
), adapter
->serial_number
,
789 min(FC_SERIAL_NUMBER_SIZE
, 32));
790 fc_host_supported_classes(shost
) = FC_COS_CLASS2
| FC_COS_CLASS3
;
793 struct fc_function_template zfcp_transport_functions
= {
794 .get_starget_port_id
= zfcp_get_port_id
,
795 .get_starget_port_name
= zfcp_get_port_name
,
796 .get_starget_node_name
= zfcp_get_node_name
,
797 .show_starget_port_id
= 1,
798 .show_starget_port_name
= 1,
799 .show_starget_node_name
= 1,
800 .show_rport_supported_classes
= 1,
801 .show_host_node_name
= 1,
802 .show_host_port_name
= 1,
803 .show_host_supported_classes
= 1,
804 .show_host_serial_number
= 1,
808 * ZFCP_DEFINE_SCSI_ATTR
809 * @_name: name of show attribute
810 * @_format: format string
811 * @_value: value to print
813 * Generates attribute for a unit.
815 #define ZFCP_DEFINE_SCSI_ATTR(_name, _format, _value) \
816 static ssize_t zfcp_sysfs_scsi_##_name##_show(struct device *dev, struct device_attribute *attr, \
819 struct scsi_device *sdev; \
820 struct zfcp_unit *unit; \
822 sdev = to_scsi_device(dev); \
823 unit = sdev->hostdata; \
824 return sprintf(buf, _format, _value); \
827 static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_scsi_##_name##_show, NULL);
829 ZFCP_DEFINE_SCSI_ATTR(hba_id
, "%s\n", zfcp_get_busid_by_unit(unit
));
830 ZFCP_DEFINE_SCSI_ATTR(wwpn
, "0x%016llx\n", unit
->port
->wwpn
);
831 ZFCP_DEFINE_SCSI_ATTR(fcp_lun
, "0x%016llx\n", unit
->fcp_lun
);
833 static struct device_attribute
*zfcp_sysfs_sdev_attrs
[] = {