blob: e6d8ea8051af11766c533e54176e54dabb52ad18 [file] [log] [blame]
Swen Schillig41fa2ad2007-09-07 09:15:31 +02001/*
Christof Schmitt553448f2008-06-10 18:20:58 +02002 * zfcp device driver
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Christof Schmitt553448f2008-06-10 18:20:58 +02004 * Interface to Linux SCSI midlayer.
Swen Schillig41fa2ad2007-09-07 09:15:31 +02005 *
Christof Schmitt553448f2008-06-10 18:20:58 +02006 * Copyright IBM Corporation 2002, 2008
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 */
8
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include "zfcp_ext.h"
Christof Schmitt5f852be2007-05-08 11:16:52 +020010#include <asm/atomic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011
Linus Torvalds1da177e2005-04-16 15:20:36 -070012/* Find start of Sense Information in FCP response unit*/
Martin Petermannf76af7d2008-07-02 10:56:36 +020013char *zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *fcp_rsp_iu)
Linus Torvalds1da177e2005-04-16 15:20:36 -070014{
15 char *fcp_sns_info_ptr;
16
Martin Petermannf76af7d2008-07-02 10:56:36 +020017 fcp_sns_info_ptr = (unsigned char *) &fcp_rsp_iu[1];
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 if (fcp_rsp_iu->validity.bits.fcp_rsp_len_valid)
Martin Petermannf76af7d2008-07-02 10:56:36 +020019 fcp_sns_info_ptr += fcp_rsp_iu->fcp_rsp_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -070020
21 return fcp_sns_info_ptr;
22}
23
Martin Petermannf76af7d2008-07-02 10:56:36 +020024void zfcp_set_fcp_dl(struct fcp_cmnd_iu *fcp_cmd, fcp_dl_t fcp_dl)
Linus Torvalds1da177e2005-04-16 15:20:36 -070025{
Martin Petermannf76af7d2008-07-02 10:56:36 +020026 fcp_dl_t *fcp_dl_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 /*
Swen Schillig41fa2ad2007-09-07 09:15:31 +020029 * fcp_dl_addr = start address of fcp_cmnd structure +
Linus Torvalds1da177e2005-04-16 15:20:36 -070030 * size of fixed part + size of dynamically sized add_dcp_cdb field
31 * SEE FCP-2 documentation
32 */
Martin Petermannf76af7d2008-07-02 10:56:36 +020033 fcp_dl_ptr = (fcp_dl_t *) ((unsigned char *) &fcp_cmd[1] +
34 (fcp_cmd->add_fcp_cdb_length << 2));
35 *fcp_dl_ptr = fcp_dl;
Linus Torvalds1da177e2005-04-16 15:20:36 -070036}
37
Andreas Herrmannf6c0e7a2006-08-02 11:05:52 +020038static void zfcp_scsi_slave_destroy(struct scsi_device *sdpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -070039{
40 struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata;
Christof Schmitt553448f2008-06-10 18:20:58 +020041 WARN_ON(!unit);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 if (unit) {
Andreas Herrmannad58f7d2006-03-10 00:56:16 +010043 atomic_clear_mask(ZFCP_STATUS_UNIT_REGISTERED, &unit->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 sdpnt->hostdata = NULL;
45 unit->device = NULL;
Martin Peschke1f6f7122008-04-18 12:51:55 +020046 zfcp_erp_unit_failed(unit, 12, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 zfcp_unit_put(unit);
Christof Schmitt553448f2008-06-10 18:20:58 +020048 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070049}
50
Martin Petermannf76af7d2008-07-02 10:56:36 +020051static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -070052{
53 if (sdp->tagged_supported)
Martin Petermannf76af7d2008-07-02 10:56:36 +020054 scsi_adjust_queue_depth(sdp, MSG_SIMPLE_TAG, 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 else
56 scsi_adjust_queue_depth(sdp, 0, 1);
57 return 0;
58}
59
Martin Petermannf76af7d2008-07-02 10:56:36 +020060static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result)
Linus Torvalds1da177e2005-04-16 15:20:36 -070061{
Martin Petermannfeac6a02008-07-02 10:56:35 +020062 set_host_byte(scpnt, result);
Maxim Shchetynin8a36e452005-09-13 21:50:38 +020063 if ((scpnt->device != NULL) && (scpnt->device->host != NULL))
64 zfcp_scsi_dbf_event_result("fail", 4,
65 (struct zfcp_adapter*) scpnt->device->host->hostdata[0],
Maxim Shchetynined829ad2006-02-11 01:42:58 +010066 scpnt, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 /* return directly */
68 scpnt->scsi_done(scpnt);
69}
70
Martin Petermannf76af7d2008-07-02 10:56:36 +020071static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
72 void (*done) (struct scsi_cmnd *))
Linus Torvalds1da177e2005-04-16 15:20:36 -070073{
74 struct zfcp_unit *unit;
75 struct zfcp_adapter *adapter;
Martin Petermannf76af7d2008-07-02 10:56:36 +020076 int status;
77 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
79 /* reset the status for this request */
80 scpnt->result = 0;
81 scpnt->host_scribble = NULL;
82 scpnt->scsi_done = done;
83
84 /*
85 * figure out adapter and target device
86 * (stored there by zfcp_scsi_slave_alloc)
87 */
88 adapter = (struct zfcp_adapter *) scpnt->device->host->hostdata[0];
Martin Petermannf76af7d2008-07-02 10:56:36 +020089 unit = scpnt->device->hostdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Martin Petermannf76af7d2008-07-02 10:56:36 +020091 BUG_ON(!adapter || (adapter != unit->port->adapter));
92 BUG_ON(!scpnt->scsi_done);
93
94 if (unlikely(!unit)) {
95 zfcp_scsi_command_fail(scpnt, DID_NO_CONNECT);
96 return 0;
97 }
98
99 status = atomic_read(&unit->status);
100 if (unlikely((status & ZFCP_STATUS_COMMON_ERP_FAILED) ||
101 !(status & ZFCP_STATUS_COMMON_RUNNING))) {
102 zfcp_scsi_command_fail(scpnt, DID_ERROR);
103 return 0;;
104 }
105
106 ret = zfcp_fsf_send_fcp_command_task(adapter, unit, scpnt, 0,
107 ZFCP_REQ_AUTO_CLEANUP);
108 if (unlikely(ret == -EBUSY))
109 zfcp_scsi_command_fail(scpnt, DID_NO_CONNECT);
110 else if (unlikely(ret < 0))
111 return SCSI_MLQUEUE_HOST_BUSY;
112
113 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114}
115
Martin Petermannf76af7d2008-07-02 10:56:36 +0200116static struct zfcp_unit *zfcp_unit_lookup(struct zfcp_adapter *adapter,
117 int channel, unsigned int id,
118 unsigned int lun)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119{
120 struct zfcp_port *port;
Martin Petermannf76af7d2008-07-02 10:56:36 +0200121 struct zfcp_unit *unit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122
123 list_for_each_entry(port, &adapter->port_list_head, list) {
Andreas Herrmann3859f6a2005-08-27 11:07:54 -0700124 if (!port->rport || (id != port->rport->scsi_target_id))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 continue;
Christof Schmitt6b76a722007-08-28 09:30:59 +0200126 list_for_each_entry(unit, &port->unit_list_head, list)
Martin Petermannf76af7d2008-07-02 10:56:36 +0200127 if (lun == unit->scsi_lun)
128 return unit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 }
Martin Petermannf76af7d2008-07-02 10:56:36 +0200130
131 return NULL;
132}
133
134static int zfcp_scsi_slave_alloc(struct scsi_device *sdp)
135{
136 struct zfcp_adapter *adapter;
137 struct zfcp_unit *unit;
138 unsigned long flags;
139 int retval = -ENXIO;
140
141 adapter = (struct zfcp_adapter *) sdp->host->hostdata[0];
142 if (!adapter)
143 goto out;
144
145 read_lock_irqsave(&zfcp_data.config_lock, flags);
146 unit = zfcp_unit_lookup(adapter, sdp->channel, sdp->id, sdp->lun);
147 if (unit &&
148 (atomic_read(&unit->status) & ZFCP_STATUS_UNIT_REGISTERED)) {
149 sdp->hostdata = unit;
150 unit->device = sdp;
151 zfcp_unit_get(unit);
152 retval = 0;
153 }
154 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
155out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 return retval;
157}
158
Heiko Carstens2b67fc42007-02-05 21:16:47 +0100159static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160{
Andreas Herrmann059c97d2005-09-13 21:47:52 +0200161 struct Scsi_Host *scsi_host;
162 struct zfcp_adapter *adapter;
163 struct zfcp_unit *unit;
Andreas Herrmann4eff4a32006-09-18 22:29:20 +0200164 struct zfcp_fsf_req *fsf_req;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 unsigned long flags;
Martin Petermannf76af7d2008-07-02 10:56:36 +0200166 unsigned long old_req_id = (unsigned long) scpnt->host_scribble;
Andreas Herrmann4eff4a32006-09-18 22:29:20 +0200167 int retval = SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
Andreas Herrmann059c97d2005-09-13 21:47:52 +0200169 scsi_host = scpnt->device->host;
170 adapter = (struct zfcp_adapter *) scsi_host->hostdata[0];
Martin Petermannf76af7d2008-07-02 10:56:36 +0200171 unit = scpnt->device->hostdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
Andreas Herrmann059c97d2005-09-13 21:47:52 +0200173 /* avoid race condition between late normal completion and abort */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 write_lock_irqsave(&adapter->abort_lock, flags);
175
Andreas Herrmann4eff4a32006-09-18 22:29:20 +0200176 /* Check whether corresponding fsf_req is still pending */
177 spin_lock(&adapter->req_list_lock);
Martin Petermannf76af7d2008-07-02 10:56:36 +0200178 fsf_req = zfcp_reqlist_find(adapter, old_req_id);
Andreas Herrmann4eff4a32006-09-18 22:29:20 +0200179 spin_unlock(&adapter->req_list_lock);
180 if (!fsf_req) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 write_unlock_irqrestore(&adapter->abort_lock, flags);
Andreas Herrmann4eff4a32006-09-18 22:29:20 +0200182 zfcp_scsi_dbf_event_abort("lte1", adapter, scpnt, NULL, 0);
Martin Petermannf76af7d2008-07-02 10:56:36 +0200183 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 }
Andreas Herrmann4eff4a32006-09-18 22:29:20 +0200185 fsf_req->data = 0;
186 fsf_req->status |= ZFCP_STATUS_FSFREQ_ABORTING;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
Andreas Herrmann4eff4a32006-09-18 22:29:20 +0200188 /* don't access old fsf_req after releasing the abort_lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 write_unlock_irqrestore(&adapter->abort_lock, flags);
Andreas Herrmann4eff4a32006-09-18 22:29:20 +0200190
191 fsf_req = zfcp_fsf_abort_fcp_command(old_req_id, adapter, unit, 0);
192 if (!fsf_req) {
Maxim Shchetynined829ad2006-02-11 01:42:58 +0100193 zfcp_scsi_dbf_event_abort("nres", adapter, scpnt, NULL,
Andreas Herrmann4eff4a32006-09-18 22:29:20 +0200194 old_req_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 retval = FAILED;
Martin Petermannf76af7d2008-07-02 10:56:36 +0200196 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 }
198
Andreas Herrmann4eff4a32006-09-18 22:29:20 +0200199 __wait_event(fsf_req->completion_wq,
200 fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
Andreas Herrmann059c97d2005-09-13 21:47:52 +0200201
Andreas Herrmann4eff4a32006-09-18 22:29:20 +0200202 if (fsf_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED) {
203 zfcp_scsi_dbf_event_abort("okay", adapter, scpnt, fsf_req, 0);
Andreas Herrmann4eff4a32006-09-18 22:29:20 +0200204 } else if (fsf_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED) {
205 zfcp_scsi_dbf_event_abort("lte2", adapter, scpnt, fsf_req, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 } else {
Andreas Herrmann4eff4a32006-09-18 22:29:20 +0200207 zfcp_scsi_dbf_event_abort("fail", adapter, scpnt, fsf_req, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 retval = FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 }
Andreas Herrmann4eff4a32006-09-18 22:29:20 +0200210 zfcp_fsf_req_free(fsf_req);
Martin Petermannf76af7d2008-07-02 10:56:36 +0200211
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 return retval;
213}
214
Martin Petermannf76af7d2008-07-02 10:56:36 +0200215static int zfcp_task_mgmt_function(struct zfcp_unit *unit, u8 tm_flags,
216 struct scsi_cmnd *scpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217{
218 struct zfcp_adapter *adapter = unit->port->adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 struct zfcp_fsf_req *fsf_req;
Martin Petermannf76af7d2008-07-02 10:56:36 +0200220 int retval = SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
222 /* issue task management function */
223 fsf_req = zfcp_fsf_send_fcp_command_task_management
224 (adapter, unit, tm_flags, 0);
225 if (!fsf_req) {
Maxim Shchetynin8a36e452005-09-13 21:50:38 +0200226 zfcp_scsi_dbf_event_devreset("nres", tm_flags, unit, scpnt);
Martin Petermannf76af7d2008-07-02 10:56:36 +0200227 return FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 }
229
Andreas Herrmann77eb1692005-09-13 21:48:33 +0200230 __wait_event(fsf_req->completion_wq,
231 fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
232
Maxim Shchetynin8a36e452005-09-13 21:50:38 +0200233 /*
234 * check completion status of task management function
235 */
236 if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCFAILED) {
237 zfcp_scsi_dbf_event_devreset("fail", tm_flags, unit, scpnt);
Martin Petermannf76af7d2008-07-02 10:56:36 +0200238 retval = FAILED;
Maxim Shchetynin8a36e452005-09-13 21:50:38 +0200239 } else if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP) {
240 zfcp_scsi_dbf_event_devreset("nsup", tm_flags, unit, scpnt);
Martin Petermannf76af7d2008-07-02 10:56:36 +0200241 retval = FAILED;
Maxim Shchetynin8a36e452005-09-13 21:50:38 +0200242 } else
243 zfcp_scsi_dbf_event_devreset("okay", tm_flags, unit, scpnt);
Andreas Herrmann77eb1692005-09-13 21:48:33 +0200244
245 zfcp_fsf_req_free(fsf_req);
Martin Petermannf76af7d2008-07-02 10:56:36 +0200246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 return retval;
248}
249
Martin Petermannf76af7d2008-07-02 10:56:36 +0200250static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt)
251{
252 struct zfcp_unit *unit = scpnt->device->hostdata;
253
254 if (!unit) {
255 WARN_ON(1);
256 return SUCCESS;
257 }
258 return zfcp_task_mgmt_function(unit, FCP_LOGICAL_UNIT_RESET, scpnt);
259}
260
261static int zfcp_scsi_eh_target_reset_handler(struct scsi_cmnd *scpnt)
262{
263 struct zfcp_unit *unit = scpnt->device->hostdata;
264
265 if (!unit) {
266 WARN_ON(1);
267 return SUCCESS;
268 }
269 return zfcp_task_mgmt_function(unit, FCP_TARGET_RESET, scpnt);
270}
271
Heiko Carstens2b67fc42007-02-05 21:16:47 +0100272static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273{
Andreas Herrmannf6c0e7a2006-08-02 11:05:52 +0200274 struct zfcp_unit *unit;
275 struct zfcp_adapter *adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
Martin Petermannf76af7d2008-07-02 10:56:36 +0200277 unit = scpnt->device->hostdata;
Andreas Herrmannf6c0e7a2006-08-02 11:05:52 +0200278 adapter = unit->port->adapter;
Martin Peschke1f6f7122008-04-18 12:51:55 +0200279 zfcp_erp_adapter_reopen(adapter, 0, 141, scpnt);
Andreas Herrmann81654282006-09-18 22:30:36 +0200280 zfcp_erp_wait(adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
Andreas Herrmann810f1e3e2005-09-13 21:49:52 +0200282 return SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283}
284
Martin Petermannf76af7d2008-07-02 10:56:36 +0200285int zfcp_adapter_scsi_register(struct zfcp_adapter *adapter)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286{
Martin Petermannf76af7d2008-07-02 10:56:36 +0200287 struct ccw_dev_id dev_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
Michael Loehr9f287452007-05-09 11:01:24 +0200289 if (adapter->scsi_host)
Martin Petermannf76af7d2008-07-02 10:56:36 +0200290 return 0;
Michael Loehr9f287452007-05-09 11:01:24 +0200291
Martin Petermannf76af7d2008-07-02 10:56:36 +0200292 ccw_device_get_id(adapter->ccw_device, &dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 /* register adapter as SCSI host with mid layer of SCSI stack */
294 adapter->scsi_host = scsi_host_alloc(&zfcp_data.scsi_host_template,
295 sizeof (struct zfcp_adapter *));
296 if (!adapter->scsi_host) {
Christof Schmitt553448f2008-06-10 18:20:58 +0200297 dev_err(&adapter->ccw_device->dev,
298 "registration with SCSI stack failed.");
Martin Petermannf76af7d2008-07-02 10:56:36 +0200299 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
302 /* tell the SCSI stack some characteristics of this adapter */
303 adapter->scsi_host->max_id = 1;
304 adapter->scsi_host->max_lun = 1;
305 adapter->scsi_host->max_channel = 0;
Martin Petermannf76af7d2008-07-02 10:56:36 +0200306 adapter->scsi_host->unique_id = dev_id.devno;
307 adapter->scsi_host->max_cmd_len = 255;
Heiko Carstensdd52e0e2006-09-18 22:28:49 +0200308 adapter->scsi_host->transportt = zfcp_data.scsi_transport_template;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 adapter->scsi_host->hostdata[0] = (unsigned long) adapter;
311
312 if (scsi_add_host(adapter->scsi_host, &adapter->ccw_device->dev)) {
313 scsi_host_put(adapter->scsi_host);
Martin Petermannf76af7d2008-07-02 10:56:36 +0200314 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 }
316 atomic_set_mask(ZFCP_STATUS_ADAPTER_REGISTERED, &adapter->status);
Martin Petermannf76af7d2008-07-02 10:56:36 +0200317
318 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319}
320
Martin Petermannf76af7d2008-07-02 10:56:36 +0200321void zfcp_adapter_scsi_unregister(struct zfcp_adapter *adapter)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322{
323 struct Scsi_Host *shost;
Andreas Herrmann13e1e1f2005-09-19 16:56:17 +0200324 struct zfcp_port *port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
326 shost = adapter->scsi_host;
327 if (!shost)
328 return;
Martin Petermannf76af7d2008-07-02 10:56:36 +0200329
Andreas Herrmann13e1e1f2005-09-19 16:56:17 +0200330 read_lock_irq(&zfcp_data.config_lock);
331 list_for_each_entry(port, &adapter->port_list_head, list)
332 if (port->rport)
333 port->rport = NULL;
Martin Petermannf76af7d2008-07-02 10:56:36 +0200334
Andreas Herrmann13e1e1f2005-09-19 16:56:17 +0200335 read_unlock_irq(&zfcp_data.config_lock);
Andreas Herrmann3859f6a2005-08-27 11:07:54 -0700336 fc_remove_host(shost);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 scsi_remove_host(shost);
338 scsi_host_put(shost);
339 adapter->scsi_host = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 atomic_clear_mask(ZFCP_STATUS_ADAPTER_REGISTERED, &adapter->status);
341
342 return;
343}
344
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100345static struct fc_host_statistics*
346zfcp_init_fc_host_stats(struct zfcp_adapter *adapter)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347{
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100348 struct fc_host_statistics *fc_stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100350 if (!adapter->fc_stats) {
351 fc_stats = kmalloc(sizeof(*fc_stats), GFP_KERNEL);
352 if (!fc_stats)
353 return NULL;
354 adapter->fc_stats = fc_stats; /* freed in adater_dequeue */
355 }
356 memset(adapter->fc_stats, 0, sizeof(*adapter->fc_stats));
357 return adapter->fc_stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358}
359
Martin Petermannf76af7d2008-07-02 10:56:36 +0200360static void zfcp_adjust_fc_host_stats(struct fc_host_statistics *fc_stats,
361 struct fsf_qtcb_bottom_port *data,
362 struct fsf_qtcb_bottom_port *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363{
Martin Petermannf76af7d2008-07-02 10:56:36 +0200364 fc_stats->seconds_since_last_reset =
365 data->seconds_since_last_reset - old->seconds_since_last_reset;
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100366 fc_stats->tx_frames = data->tx_frames - old->tx_frames;
367 fc_stats->tx_words = data->tx_words - old->tx_words;
368 fc_stats->rx_frames = data->rx_frames - old->rx_frames;
369 fc_stats->rx_words = data->rx_words - old->rx_words;
370 fc_stats->lip_count = data->lip - old->lip;
371 fc_stats->nos_count = data->nos - old->nos;
372 fc_stats->error_frames = data->error_frames - old->error_frames;
373 fc_stats->dumped_frames = data->dumped_frames - old->dumped_frames;
374 fc_stats->link_failure_count = data->link_failure - old->link_failure;
375 fc_stats->loss_of_sync_count = data->loss_of_sync - old->loss_of_sync;
Martin Petermannf76af7d2008-07-02 10:56:36 +0200376 fc_stats->loss_of_signal_count =
377 data->loss_of_signal - old->loss_of_signal;
378 fc_stats->prim_seq_protocol_err_count =
379 data->psp_error_counts - old->psp_error_counts;
380 fc_stats->invalid_tx_word_count =
381 data->invalid_tx_words - old->invalid_tx_words;
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100382 fc_stats->invalid_crc_count = data->invalid_crcs - old->invalid_crcs;
Martin Petermannf76af7d2008-07-02 10:56:36 +0200383 fc_stats->fcp_input_requests =
384 data->input_requests - old->input_requests;
385 fc_stats->fcp_output_requests =
386 data->output_requests - old->output_requests;
387 fc_stats->fcp_control_requests =
388 data->control_requests - old->control_requests;
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100389 fc_stats->fcp_input_megabytes = data->input_mb - old->input_mb;
390 fc_stats->fcp_output_megabytes = data->output_mb - old->output_mb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391}
392
Martin Petermannf76af7d2008-07-02 10:56:36 +0200393static void zfcp_set_fc_host_stats(struct fc_host_statistics *fc_stats,
394 struct fsf_qtcb_bottom_port *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395{
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100396 fc_stats->seconds_since_last_reset = data->seconds_since_last_reset;
397 fc_stats->tx_frames = data->tx_frames;
398 fc_stats->tx_words = data->tx_words;
399 fc_stats->rx_frames = data->rx_frames;
400 fc_stats->rx_words = data->rx_words;
401 fc_stats->lip_count = data->lip;
402 fc_stats->nos_count = data->nos;
403 fc_stats->error_frames = data->error_frames;
404 fc_stats->dumped_frames = data->dumped_frames;
405 fc_stats->link_failure_count = data->link_failure;
406 fc_stats->loss_of_sync_count = data->loss_of_sync;
407 fc_stats->loss_of_signal_count = data->loss_of_signal;
408 fc_stats->prim_seq_protocol_err_count = data->psp_error_counts;
409 fc_stats->invalid_tx_word_count = data->invalid_tx_words;
410 fc_stats->invalid_crc_count = data->invalid_crcs;
411 fc_stats->fcp_input_requests = data->input_requests;
412 fc_stats->fcp_output_requests = data->output_requests;
413 fc_stats->fcp_control_requests = data->control_requests;
414 fc_stats->fcp_input_megabytes = data->input_mb;
415 fc_stats->fcp_output_megabytes = data->output_mb;
416}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
Martin Petermannf76af7d2008-07-02 10:56:36 +0200418static struct fc_host_statistics *zfcp_get_fc_host_stats(struct Scsi_Host *host)
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100419{
420 struct zfcp_adapter *adapter;
421 struct fc_host_statistics *fc_stats;
422 struct fsf_qtcb_bottom_port *data;
423 int ret;
424
Martin Petermannf76af7d2008-07-02 10:56:36 +0200425 adapter = (struct zfcp_adapter *)host->hostdata[0];
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100426 fc_stats = zfcp_init_fc_host_stats(adapter);
427 if (!fc_stats)
428 return NULL;
429
Andreas Herrmannec4081c2006-05-22 18:17:30 +0200430 data = kzalloc(sizeof(*data), GFP_KERNEL);
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100431 if (!data)
432 return NULL;
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100433
Swen Schillig52ef11a2007-08-28 09:31:09 +0200434 ret = zfcp_fsf_exchange_port_data_sync(adapter, data);
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100435 if (ret) {
436 kfree(data);
Martin Petermannf76af7d2008-07-02 10:56:36 +0200437 return NULL;
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100438 }
439
440 if (adapter->stats_reset &&
441 ((jiffies/HZ - adapter->stats_reset) <
Martin Petermannf76af7d2008-07-02 10:56:36 +0200442 data->seconds_since_last_reset))
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100443 zfcp_adjust_fc_host_stats(fc_stats, data,
444 adapter->stats_reset_data);
Martin Petermannf76af7d2008-07-02 10:56:36 +0200445 else
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100446 zfcp_set_fc_host_stats(fc_stats, data);
447
448 kfree(data);
449 return fc_stats;
450}
451
Martin Petermannf76af7d2008-07-02 10:56:36 +0200452static void zfcp_reset_fc_host_stats(struct Scsi_Host *shost)
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100453{
454 struct zfcp_adapter *adapter;
Martin Petermannf76af7d2008-07-02 10:56:36 +0200455 struct fsf_qtcb_bottom_port *data;
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100456 int ret;
457
458 adapter = (struct zfcp_adapter *)shost->hostdata[0];
Andreas Herrmannec4081c2006-05-22 18:17:30 +0200459 data = kzalloc(sizeof(*data), GFP_KERNEL);
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100460 if (!data)
461 return;
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100462
Swen Schillig52ef11a2007-08-28 09:31:09 +0200463 ret = zfcp_fsf_exchange_port_data_sync(adapter, data);
Martin Petermannf76af7d2008-07-02 10:56:36 +0200464 if (ret)
Heiko Carstens83f6d6d2007-08-08 10:47:02 +0200465 kfree(data);
Martin Petermannf76af7d2008-07-02 10:56:36 +0200466 else {
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100467 adapter->stats_reset = jiffies/HZ;
Martin Petermannf76af7d2008-07-02 10:56:36 +0200468 kfree(adapter->stats_reset_data);
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100469 adapter->stats_reset_data = data; /* finally freed in
Martin Petermannf76af7d2008-07-02 10:56:36 +0200470 adapter_dequeue */
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100471 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472}
473
Sven Schuetz85a82392008-06-10 18:20:59 +0200474static void zfcp_get_host_port_state(struct Scsi_Host *shost)
475{
476 struct zfcp_adapter *adapter =
477 (struct zfcp_adapter *)shost->hostdata[0];
478 int status = atomic_read(&adapter->status);
479
480 if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
481 !(status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED))
482 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
483 else if (status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)
484 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
485 else if (status & ZFCP_STATUS_COMMON_ERP_FAILED)
486 fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
487 else
488 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
489}
490
Andreas Herrmann338151e2006-05-22 18:25:56 +0200491static void zfcp_set_rport_dev_loss_tmo(struct fc_rport *rport, u32 timeout)
492{
493 rport->dev_loss_tmo = timeout;
494}
495
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496struct fc_function_template zfcp_transport_functions = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 .show_starget_port_id = 1,
498 .show_starget_port_name = 1,
499 .show_starget_node_name = 1,
Andreas Herrmann3859f6a2005-08-27 11:07:54 -0700500 .show_rport_supported_classes = 1,
Ralph Wuerthner75bfc282006-05-22 18:24:33 +0200501 .show_rport_maxframe_size = 1,
Andreas Herrmann338151e2006-05-22 18:25:56 +0200502 .show_rport_dev_loss_tmo = 1,
Andreas Herrmann3859f6a2005-08-27 11:07:54 -0700503 .show_host_node_name = 1,
504 .show_host_port_name = 1,
Andreas Herrmannad757cd2006-01-13 02:26:11 +0100505 .show_host_permanent_port_name = 1,
Andreas Herrmann3859f6a2005-08-27 11:07:54 -0700506 .show_host_supported_classes = 1,
Andreas Herrmannad757cd2006-01-13 02:26:11 +0100507 .show_host_supported_speeds = 1,
Andreas Herrmann13e1e1f2005-09-19 16:56:17 +0200508 .show_host_maxframe_size = 1,
Andreas Herrmann3859f6a2005-08-27 11:07:54 -0700509 .show_host_serial_number = 1,
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100510 .get_fc_host_stats = zfcp_get_fc_host_stats,
511 .reset_fc_host_stats = zfcp_reset_fc_host_stats,
Andreas Herrmann338151e2006-05-22 18:25:56 +0200512 .set_rport_dev_loss_tmo = zfcp_set_rport_dev_loss_tmo,
Sven Schuetz85a82392008-06-10 18:20:59 +0200513 .get_host_port_state = zfcp_get_host_port_state,
514 .show_host_port_state = 1,
Andreas Herrmannf6cd94b2006-01-05 09:59:34 +0100515 /* no functions registered for following dynamic attributes but
516 directly set by LLDD */
Andreas Herrmannad757cd2006-01-13 02:26:11 +0100517 .show_host_port_type = 1,
Andreas Herrmann13e1e1f2005-09-19 16:56:17 +0200518 .show_host_speed = 1,
519 .show_host_port_id = 1,
Swen Schillig52ef11a2007-08-28 09:31:09 +0200520 .disable_target_scan = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521};
522
Martin Petermannf76af7d2008-07-02 10:56:36 +0200523struct zfcp_data zfcp_data = {
524 .scsi_host_template = {
525 .name = "zfcp",
526 .module = THIS_MODULE,
527 .proc_name = "zfcp",
528 .slave_alloc = zfcp_scsi_slave_alloc,
529 .slave_configure = zfcp_scsi_slave_configure,
530 .slave_destroy = zfcp_scsi_slave_destroy,
531 .queuecommand = zfcp_scsi_queuecommand,
532 .eh_abort_handler = zfcp_scsi_eh_abort_handler,
533 .eh_device_reset_handler = zfcp_scsi_eh_device_reset_handler,
534 .eh_target_reset_handler = zfcp_scsi_eh_target_reset_handler,
535 .eh_host_reset_handler = zfcp_scsi_eh_host_reset_handler,
536 .can_queue = 4096,
537 .this_id = -1,
538 .sg_tablesize = ZFCP_MAX_SBALES_PER_REQ,
539 .cmd_per_lun = 1,
540 .use_clustering = 1,
541 .sdev_attrs = zfcp_sysfs_sdev_attrs,
542 .max_sectors = (ZFCP_MAX_SBALES_PER_REQ * 8),
Swen Schillig60221922008-07-02 10:56:38 +0200543 .shost_attrs = zfcp_sysfs_shost_attrs,
Martin Petermannf76af7d2008-07-02 10:56:36 +0200544 },
545};