[SCSI] zfcp: erp failed status bit will not be set
[linux-2.6.git] / drivers / s390 / scsi / zfcp_scsi.c
1 /*
2  * zfcp device driver
3  *
4  * Interface to Linux SCSI midlayer.
5  *
6  * Copyright IBM Corporation 2002, 2009
7  */
8
9 #define KMSG_COMPONENT "zfcp"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11
12 #include "zfcp_ext.h"
13 #include <asm/atomic.h>
14
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)
17 {
18         char *fcp_sns_info_ptr;
19
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;
23
24         return fcp_sns_info_ptr;
25 }
26
27 static void zfcp_scsi_slave_destroy(struct scsi_device *sdpnt)
28 {
29         struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata;
30         unit->device = NULL;
31         zfcp_unit_put(unit);
32 }
33
34 static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
35 {
36         if (sdp->tagged_supported)
37                 scsi_adjust_queue_depth(sdp, MSG_SIMPLE_TAG, 32);
38         else
39                 scsi_adjust_queue_depth(sdp, 0, 1);
40         return 0;
41 }
42
43 static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result)
44 {
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],
49                         scpnt, NULL);
50         /* return directly */
51         scpnt->scsi_done(scpnt);
52 }
53
54 static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
55                                   void (*done) (struct scsi_cmnd *))
56 {
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));
61
62         /* reset the status for this request */
63         scpnt->result = 0;
64         scpnt->host_scribble = NULL;
65         scpnt->scsi_done = done;
66
67         /*
68          * figure out adapter and target device
69          * (stored there by zfcp_scsi_slave_alloc)
70          */
71         adapter = (struct zfcp_adapter *) scpnt->device->host->hostdata[0];
72         unit = scpnt->device->hostdata;
73
74         BUG_ON(!adapter || (adapter != unit->port->adapter));
75         BUG_ON(!scpnt->scsi_done);
76
77         if (unlikely(!unit)) {
78                 zfcp_scsi_command_fail(scpnt, DID_NO_CONNECT);
79                 return 0;
80         }
81
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);
87                 return 0;
88         }
89
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);
94                 return 0;;
95         }
96
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;
102
103         return ret;
104 }
105
106 static struct zfcp_unit *zfcp_unit_lookup(struct zfcp_adapter *adapter,
107                                           int channel, unsigned int id,
108                                           unsigned int lun)
109 {
110         struct zfcp_port *port;
111         struct zfcp_unit *unit;
112         int scsi_lun;
113
114         list_for_each_entry(port, &adapter->port_list_head, list) {
115                 if (!port->rport || (id != port->rport->scsi_target_id))
116                         continue;
117                 list_for_each_entry(unit, &port->unit_list_head, list) {
118                         scsi_lun = scsilun_to_int(
119                                 (struct scsi_lun *)&unit->fcp_lun);
120                         if (lun == scsi_lun)
121                                 return unit;
122                 }
123         }
124
125         return NULL;
126 }
127
128 static int zfcp_scsi_slave_alloc(struct scsi_device *sdp)
129 {
130         struct zfcp_adapter *adapter;
131         struct zfcp_unit *unit;
132         unsigned long flags;
133         int retval = -ENXIO;
134
135         adapter = (struct zfcp_adapter *) sdp->host->hostdata[0];
136         if (!adapter)
137                 goto out;
138
139         read_lock_irqsave(&zfcp_data.config_lock, flags);
140         unit = zfcp_unit_lookup(adapter, sdp->channel, sdp->id, sdp->lun);
141         if (unit) {
142                 sdp->hostdata = unit;
143                 unit->device = sdp;
144                 zfcp_unit_get(unit);
145                 retval = 0;
146         }
147         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
148 out:
149         return retval;
150 }
151
152 static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
153 {
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;
159         unsigned long flags;
160         unsigned long old_req_id = (unsigned long) scpnt->host_scribble;
161         int retval = SUCCESS;
162         int retry = 3;
163
164         /* avoid race condition between late normal completion and abort */
165         write_lock_irqsave(&adapter->abort_lock, flags);
166
167         spin_lock(&adapter->req_list_lock);
168         old_req = zfcp_reqlist_find(adapter, old_req_id);
169         spin_unlock(&adapter->req_list_lock);
170         if (!old_req) {
171                 write_unlock_irqrestore(&adapter->abort_lock, flags);
172                 zfcp_scsi_dbf_event_abort("lte1", adapter, scpnt, NULL,
173                                           old_req_id);
174                 return SUCCESS;
175         }
176         old_req->data = NULL;
177
178         /* don't access old fsf_req after releasing the abort_lock */
179         write_unlock_irqrestore(&adapter->abort_lock, flags);
180
181         while (retry--) {
182                 abrt_req = zfcp_fsf_abort_fcp_command(old_req_id, unit);
183                 if (abrt_req)
184                         break;
185
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,
190                                                   old_req_id);
191                         return SUCCESS;
192                 }
193         }
194         if (!abrt_req)
195                 return FAILED;
196
197         wait_event(abrt_req->completion_wq,
198                    abrt_req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
199
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);
204         else {
205                 zfcp_scsi_dbf_event_abort("fail", adapter, scpnt, abrt_req, 0);
206                 retval = FAILED;
207         }
208         zfcp_fsf_req_free(abrt_req);
209         return retval;
210 }
211
212 static int zfcp_task_mgmt_function(struct scsi_cmnd *scpnt, u8 tm_flags)
213 {
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;
218         int retry = 3;
219
220         while (retry--) {
221                 fsf_req = zfcp_fsf_send_fcp_ctm(unit, tm_flags);
222                 if (fsf_req)
223                         break;
224
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,
229                                                      scpnt);
230                         return SUCCESS;
231                 }
232         }
233         if (!fsf_req)
234                 return FAILED;
235
236         wait_event(fsf_req->completion_wq,
237                    fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
238
239         if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCFAILED) {
240                 zfcp_scsi_dbf_event_devreset("fail", tm_flags, unit, scpnt);
241                 retval = FAILED;
242         } else if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP) {
243                 zfcp_scsi_dbf_event_devreset("nsup", tm_flags, unit, scpnt);
244                 retval = FAILED;
245         } else
246                 zfcp_scsi_dbf_event_devreset("okay", tm_flags, unit, scpnt);
247
248         zfcp_fsf_req_free(fsf_req);
249         return retval;
250 }
251
252 static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt)
253 {
254         return zfcp_task_mgmt_function(scpnt, FCP_LOGICAL_UNIT_RESET);
255 }
256
257 static int zfcp_scsi_eh_target_reset_handler(struct scsi_cmnd *scpnt)
258 {
259         return zfcp_task_mgmt_function(scpnt, FCP_TARGET_RESET);
260 }
261
262 static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
263 {
264         struct zfcp_unit *unit = scpnt->device->hostdata;
265         struct zfcp_adapter *adapter = unit->port->adapter;
266
267         zfcp_erp_adapter_reopen(adapter, 0, "schrh_1", scpnt);
268         zfcp_erp_wait(adapter);
269
270         return SUCCESS;
271 }
272
273 int zfcp_adapter_scsi_register(struct zfcp_adapter *adapter)
274 {
275         struct ccw_dev_id dev_id;
276
277         if (adapter->scsi_host)
278                 return 0;
279
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");
288                 return -EIO;
289         }
290
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;
298
299         adapter->scsi_host->hostdata[0] = (unsigned long) adapter;
300
301         if (scsi_add_host(adapter->scsi_host, &adapter->ccw_device->dev)) {
302                 scsi_host_put(adapter->scsi_host);
303                 return -EIO;
304         }
305
306         return 0;
307 }
308
309 void zfcp_adapter_scsi_unregister(struct zfcp_adapter *adapter)
310 {
311         struct Scsi_Host *shost;
312         struct zfcp_port *port;
313
314         shost = adapter->scsi_host;
315         if (!shost)
316                 return;
317
318         read_lock_irq(&zfcp_data.config_lock);
319         list_for_each_entry(port, &adapter->port_list_head, list)
320                 if (port->rport)
321                         port->rport = NULL;
322
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;
328
329         return;
330 }
331
332 static struct fc_host_statistics*
333 zfcp_init_fc_host_stats(struct zfcp_adapter *adapter)
334 {
335         struct fc_host_statistics *fc_stats;
336
337         if (!adapter->fc_stats) {
338                 fc_stats = kmalloc(sizeof(*fc_stats), GFP_KERNEL);
339                 if (!fc_stats)
340                         return NULL;
341                 adapter->fc_stats = fc_stats; /* freed in adater_dequeue */
342         }
343         memset(adapter->fc_stats, 0, sizeof(*adapter->fc_stats));
344         return adapter->fc_stats;
345 }
346
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)
350 {
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;
378 }
379
380 static void zfcp_set_fc_host_stats(struct fc_host_statistics *fc_stats,
381                                    struct fsf_qtcb_bottom_port *data)
382 {
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;
403 }
404
405 static struct fc_host_statistics *zfcp_get_fc_host_stats(struct Scsi_Host *host)
406 {
407         struct zfcp_adapter *adapter;
408         struct fc_host_statistics *fc_stats;
409         struct fsf_qtcb_bottom_port *data;
410         int ret;
411
412         adapter = (struct zfcp_adapter *)host->hostdata[0];
413         fc_stats = zfcp_init_fc_host_stats(adapter);
414         if (!fc_stats)
415                 return NULL;
416
417         data = kzalloc(sizeof(*data), GFP_KERNEL);
418         if (!data)
419                 return NULL;
420
421         ret = zfcp_fsf_exchange_port_data_sync(adapter, data);
422         if (ret) {
423                 kfree(data);
424                 return NULL;
425         }
426
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);
432         else
433                 zfcp_set_fc_host_stats(fc_stats, data);
434
435         kfree(data);
436         return fc_stats;
437 }
438
439 static void zfcp_reset_fc_host_stats(struct Scsi_Host *shost)
440 {
441         struct zfcp_adapter *adapter;
442         struct fsf_qtcb_bottom_port *data;
443         int ret;
444
445         adapter = (struct zfcp_adapter *)shost->hostdata[0];
446         data = kzalloc(sizeof(*data), GFP_KERNEL);
447         if (!data)
448                 return;
449
450         ret = zfcp_fsf_exchange_port_data_sync(adapter, data);
451         if (ret)
452                 kfree(data);
453         else {
454                 adapter->stats_reset = jiffies/HZ;
455                 kfree(adapter->stats_reset_data);
456                 adapter->stats_reset_data = data; /* finally freed in
457                                                      adapter_dequeue */
458         }
459 }
460
461 static void zfcp_get_host_port_state(struct Scsi_Host *shost)
462 {
463         struct zfcp_adapter *adapter =
464                 (struct zfcp_adapter *)shost->hostdata[0];
465         int status = atomic_read(&adapter->status);
466
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;
474         else
475                 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
476 }
477
478 static void zfcp_set_rport_dev_loss_tmo(struct fc_rport *rport, u32 timeout)
479 {
480         rport->dev_loss_tmo = timeout;
481 }
482
483 /**
484  * zfcp_scsi_dev_loss_tmo_callbk - Free any reference to rport
485  * @rport: The rport that is about to be deleted.
486  */
487 static void zfcp_scsi_dev_loss_tmo_callbk(struct fc_rport *rport)
488 {
489         struct zfcp_port *port = rport->dd_data;
490
491         write_lock_irq(&zfcp_data.config_lock);
492         port->rport = NULL;
493         write_unlock_irq(&zfcp_data.config_lock);
494 }
495
496 /**
497  * zfcp_scsi_terminate_rport_io - Terminate all I/O on a rport
498  * @rport: The FC rport where to teminate I/O
499  *
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.
503  */
504 static void zfcp_scsi_terminate_rport_io(struct fc_rport *rport)
505 {
506         struct zfcp_port *port = rport->dd_data;
507
508         zfcp_erp_port_reopen(port, 0, "sctrpi1", NULL);
509 }
510
511 static void zfcp_scsi_rport_register(struct zfcp_port *port)
512 {
513         struct fc_rport_identifiers ids;
514         struct fc_rport *rport;
515
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;
520
521         rport = fc_remote_port_add(port->adapter->scsi_host, 0, &ids);
522         if (!rport) {
523                 dev_err(&port->adapter->ccw_device->dev,
524                         "Registering port 0x%016Lx failed\n",
525                         (unsigned long long)port->wwpn);
526                 return;
527         }
528
529         rport->dd_data = port;
530         rport->maxframe_size = port->maxframe_size;
531         rport->supported_classes = port->supported_classes;
532         port->rport = rport;
533 }
534
535 static void zfcp_scsi_rport_block(struct zfcp_port *port)
536 {
537         if (port->rport)
538                 fc_remote_port_delete(port->rport);
539 }
540
541 void zfcp_scsi_schedule_rport_register(struct zfcp_port *port)
542 {
543         zfcp_port_get(port);
544         port->rport_task = RPORT_ADD;
545
546         if (!queue_work(zfcp_data.work_queue, &port->rport_work))
547                 zfcp_port_put(port);
548 }
549
550 void zfcp_scsi_schedule_rport_block(struct zfcp_port *port)
551 {
552         zfcp_port_get(port);
553         port->rport_task = RPORT_DEL;
554
555         if (!queue_work(zfcp_data.work_queue, &port->rport_work))
556                 zfcp_port_put(port);
557 }
558
559 void zfcp_scsi_schedule_rports_block(struct zfcp_adapter *adapter)
560 {
561         struct zfcp_port *port;
562
563         list_for_each_entry(port, &adapter->port_list_head, list)
564                 zfcp_scsi_schedule_rport_block(port);
565 }
566
567 void zfcp_scsi_rport_work(struct work_struct *work)
568 {
569         struct zfcp_port *port = container_of(work, struct zfcp_port,
570                                               rport_work);
571
572         while (port->rport_task) {
573                 if (port->rport_task == RPORT_ADD) {
574                         port->rport_task = RPORT_NONE;
575                         zfcp_scsi_rport_register(port);
576                 } else {
577                         port->rport_task = RPORT_NONE;
578                         zfcp_scsi_rport_block(port);
579                 }
580         }
581
582         zfcp_port_put(port);
583 }
584
585
586 struct fc_function_template zfcp_transport_functions = {
587         .show_starget_port_id = 1,
588         .show_starget_port_name = 1,
589         .show_starget_node_name = 1,
590         .show_rport_supported_classes = 1,
591         .show_rport_maxframe_size = 1,
592         .show_rport_dev_loss_tmo = 1,
593         .show_host_node_name = 1,
594         .show_host_port_name = 1,
595         .show_host_permanent_port_name = 1,
596         .show_host_supported_classes = 1,
597         .show_host_supported_speeds = 1,
598         .show_host_maxframe_size = 1,
599         .show_host_serial_number = 1,
600         .get_fc_host_stats = zfcp_get_fc_host_stats,
601         .reset_fc_host_stats = zfcp_reset_fc_host_stats,
602         .set_rport_dev_loss_tmo = zfcp_set_rport_dev_loss_tmo,
603         .get_host_port_state = zfcp_get_host_port_state,
604         .dev_loss_tmo_callbk = zfcp_scsi_dev_loss_tmo_callbk,
605         .terminate_rport_io = zfcp_scsi_terminate_rport_io,
606         .show_host_port_state = 1,
607         /* no functions registered for following dynamic attributes but
608            directly set by LLDD */
609         .show_host_port_type = 1,
610         .show_host_speed = 1,
611         .show_host_port_id = 1,
612         .disable_target_scan = 1,
613 };
614
615 struct zfcp_data zfcp_data = {
616         .scsi_host_template = {
617                 .name                    = "zfcp",
618                 .module                  = THIS_MODULE,
619                 .proc_name               = "zfcp",
620                 .slave_alloc             = zfcp_scsi_slave_alloc,
621                 .slave_configure         = zfcp_scsi_slave_configure,
622                 .slave_destroy           = zfcp_scsi_slave_destroy,
623                 .queuecommand            = zfcp_scsi_queuecommand,
624                 .eh_abort_handler        = zfcp_scsi_eh_abort_handler,
625                 .eh_device_reset_handler = zfcp_scsi_eh_device_reset_handler,
626                 .eh_target_reset_handler = zfcp_scsi_eh_target_reset_handler,
627                 .eh_host_reset_handler   = zfcp_scsi_eh_host_reset_handler,
628                 .can_queue               = 4096,
629                 .this_id                 = -1,
630                 .sg_tablesize            = ZFCP_MAX_SBALES_PER_REQ,
631                 .cmd_per_lun             = 1,
632                 .use_clustering          = 1,
633                 .sdev_attrs              = zfcp_sysfs_sdev_attrs,
634                 .max_sectors             = (ZFCP_MAX_SBALES_PER_REQ * 8),
635                 .shost_attrs             = zfcp_sysfs_shost_attrs,
636         },
637 };