Merge branch 'for-linus' of git://neil.brown.name/md
[linux-2.6] / 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 static unsigned int default_depth = 32;
16 module_param_named(queue_depth, default_depth, uint, 0600);
17 MODULE_PARM_DESC(queue_depth, "Default queue depth for new SCSI devices");
18
19 /* Find start of Sense Information in FCP response unit*/
20 char *zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *fcp_rsp_iu)
21 {
22         char *fcp_sns_info_ptr;
23
24         fcp_sns_info_ptr = (unsigned char *) &fcp_rsp_iu[1];
25         if (fcp_rsp_iu->validity.bits.fcp_rsp_len_valid)
26                 fcp_sns_info_ptr += fcp_rsp_iu->fcp_rsp_len;
27
28         return fcp_sns_info_ptr;
29 }
30
31 static int zfcp_scsi_change_queue_depth(struct scsi_device *sdev, int depth)
32 {
33         scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
34         return sdev->queue_depth;
35 }
36
37 static void zfcp_scsi_slave_destroy(struct scsi_device *sdpnt)
38 {
39         struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata;
40         unit->device = NULL;
41         zfcp_unit_put(unit);
42 }
43
44 static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
45 {
46         if (sdp->tagged_supported)
47                 scsi_adjust_queue_depth(sdp, MSG_SIMPLE_TAG, default_depth);
48         else
49                 scsi_adjust_queue_depth(sdp, 0, 1);
50         return 0;
51 }
52
53 static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result)
54 {
55         set_host_byte(scpnt, result);
56         if ((scpnt->device != NULL) && (scpnt->device->host != NULL))
57                 zfcp_scsi_dbf_event_result("fail", 4,
58                         (struct zfcp_adapter*) scpnt->device->host->hostdata[0],
59                         scpnt, NULL);
60         /* return directly */
61         scpnt->scsi_done(scpnt);
62 }
63
64 static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
65                                   void (*done) (struct scsi_cmnd *))
66 {
67         struct zfcp_unit *unit;
68         struct zfcp_adapter *adapter;
69         int    status, scsi_result, ret;
70         struct fc_rport *rport = starget_to_rport(scsi_target(scpnt->device));
71
72         /* reset the status for this request */
73         scpnt->result = 0;
74         scpnt->host_scribble = NULL;
75         scpnt->scsi_done = done;
76
77         /*
78          * figure out adapter and target device
79          * (stored there by zfcp_scsi_slave_alloc)
80          */
81         adapter = (struct zfcp_adapter *) scpnt->device->host->hostdata[0];
82         unit = scpnt->device->hostdata;
83
84         BUG_ON(!adapter || (adapter != unit->port->adapter));
85         BUG_ON(!scpnt->scsi_done);
86
87         if (unlikely(!unit)) {
88                 zfcp_scsi_command_fail(scpnt, DID_NO_CONNECT);
89                 return 0;
90         }
91
92         scsi_result = fc_remote_port_chkready(rport);
93         if (unlikely(scsi_result)) {
94                 scpnt->result = scsi_result;
95                 zfcp_scsi_dbf_event_result("fail", 4, adapter, scpnt, NULL);
96                 scpnt->scsi_done(scpnt);
97                 return 0;
98         }
99
100         status = atomic_read(&unit->status);
101         if (unlikely((status & ZFCP_STATUS_COMMON_ERP_FAILED) ||
102                      !(status & ZFCP_STATUS_COMMON_RUNNING))) {
103                 zfcp_scsi_command_fail(scpnt, DID_ERROR);
104                 return 0;;
105         }
106
107         ret = zfcp_fsf_send_fcp_command_task(unit, scpnt);
108         if (unlikely(ret == -EBUSY))
109                 return SCSI_MLQUEUE_DEVICE_BUSY;
110         else if (unlikely(ret < 0))
111                 return SCSI_MLQUEUE_HOST_BUSY;
112
113         return ret;
114 }
115
116 static struct zfcp_unit *zfcp_unit_lookup(struct zfcp_adapter *adapter,
117                                           int channel, unsigned int id,
118                                           unsigned int lun)
119 {
120         struct zfcp_port *port;
121         struct zfcp_unit *unit;
122         int scsi_lun;
123
124         list_for_each_entry(port, &adapter->port_list_head, list) {
125                 if (!port->rport || (id != port->rport->scsi_target_id))
126                         continue;
127                 list_for_each_entry(unit, &port->unit_list_head, list) {
128                         scsi_lun = scsilun_to_int(
129                                 (struct scsi_lun *)&unit->fcp_lun);
130                         if (lun == scsi_lun)
131                                 return unit;
132                 }
133         }
134
135         return NULL;
136 }
137
138 static int zfcp_scsi_slave_alloc(struct scsi_device *sdp)
139 {
140         struct zfcp_adapter *adapter;
141         struct zfcp_unit *unit;
142         unsigned long flags;
143         int retval = -ENXIO;
144
145         adapter = (struct zfcp_adapter *) sdp->host->hostdata[0];
146         if (!adapter)
147                 goto out;
148
149         read_lock_irqsave(&zfcp_data.config_lock, flags);
150         unit = zfcp_unit_lookup(adapter, sdp->channel, sdp->id, sdp->lun);
151         if (unit) {
152                 sdp->hostdata = unit;
153                 unit->device = sdp;
154                 zfcp_unit_get(unit);
155                 retval = 0;
156         }
157         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
158 out:
159         return retval;
160 }
161
162 static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
163 {
164         struct Scsi_Host *scsi_host = scpnt->device->host;
165         struct zfcp_adapter *adapter =
166                 (struct zfcp_adapter *) scsi_host->hostdata[0];
167         struct zfcp_unit *unit = scpnt->device->hostdata;
168         struct zfcp_fsf_req *old_req, *abrt_req;
169         unsigned long flags;
170         unsigned long old_req_id = (unsigned long) scpnt->host_scribble;
171         int retval = SUCCESS;
172         int retry = 3;
173
174         /* avoid race condition between late normal completion and abort */
175         write_lock_irqsave(&adapter->abort_lock, flags);
176
177         spin_lock(&adapter->req_list_lock);
178         old_req = zfcp_reqlist_find(adapter, old_req_id);
179         spin_unlock(&adapter->req_list_lock);
180         if (!old_req) {
181                 write_unlock_irqrestore(&adapter->abort_lock, flags);
182                 zfcp_scsi_dbf_event_abort("lte1", adapter, scpnt, NULL,
183                                           old_req_id);
184                 return FAILED; /* completion could be in progress */
185         }
186         old_req->data = NULL;
187
188         /* don't access old fsf_req after releasing the abort_lock */
189         write_unlock_irqrestore(&adapter->abort_lock, flags);
190
191         while (retry--) {
192                 abrt_req = zfcp_fsf_abort_fcp_command(old_req_id, unit);
193                 if (abrt_req)
194                         break;
195
196                 zfcp_erp_wait(adapter);
197                 if (!(atomic_read(&adapter->status) &
198                       ZFCP_STATUS_COMMON_RUNNING)) {
199                         zfcp_scsi_dbf_event_abort("nres", adapter, scpnt, NULL,
200                                                   old_req_id);
201                         return SUCCESS;
202                 }
203         }
204         if (!abrt_req)
205                 return FAILED;
206
207         wait_event(abrt_req->completion_wq,
208                    abrt_req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
209
210         if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED)
211                 zfcp_scsi_dbf_event_abort("okay", adapter, scpnt, abrt_req, 0);
212         else if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED)
213                 zfcp_scsi_dbf_event_abort("lte2", adapter, scpnt, abrt_req, 0);
214         else {
215                 zfcp_scsi_dbf_event_abort("fail", adapter, scpnt, abrt_req, 0);
216                 retval = FAILED;
217         }
218         zfcp_fsf_req_free(abrt_req);
219         return retval;
220 }
221
222 static int zfcp_task_mgmt_function(struct scsi_cmnd *scpnt, u8 tm_flags)
223 {
224         struct zfcp_unit *unit = scpnt->device->hostdata;
225         struct zfcp_adapter *adapter = unit->port->adapter;
226         struct zfcp_fsf_req *fsf_req;
227         int retval = SUCCESS;
228         int retry = 3;
229
230         while (retry--) {
231                 fsf_req = zfcp_fsf_send_fcp_ctm(unit, tm_flags);
232                 if (fsf_req)
233                         break;
234
235                 zfcp_erp_wait(adapter);
236                 if (!(atomic_read(&adapter->status) &
237                       ZFCP_STATUS_COMMON_RUNNING)) {
238                         zfcp_scsi_dbf_event_devreset("nres", tm_flags, unit,
239                                                      scpnt);
240                         return SUCCESS;
241                 }
242         }
243         if (!fsf_req)
244                 return FAILED;
245
246         wait_event(fsf_req->completion_wq,
247                    fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
248
249         if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCFAILED) {
250                 zfcp_scsi_dbf_event_devreset("fail", tm_flags, unit, scpnt);
251                 retval = FAILED;
252         } else if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP) {
253                 zfcp_scsi_dbf_event_devreset("nsup", tm_flags, unit, scpnt);
254                 retval = FAILED;
255         } else
256                 zfcp_scsi_dbf_event_devreset("okay", tm_flags, unit, scpnt);
257
258         zfcp_fsf_req_free(fsf_req);
259         return retval;
260 }
261
262 static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt)
263 {
264         return zfcp_task_mgmt_function(scpnt, FCP_LOGICAL_UNIT_RESET);
265 }
266
267 static int zfcp_scsi_eh_target_reset_handler(struct scsi_cmnd *scpnt)
268 {
269         return zfcp_task_mgmt_function(scpnt, FCP_TARGET_RESET);
270 }
271
272 static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
273 {
274         struct zfcp_unit *unit = scpnt->device->hostdata;
275         struct zfcp_adapter *adapter = unit->port->adapter;
276
277         zfcp_erp_adapter_reopen(adapter, 0, "schrh_1", scpnt);
278         zfcp_erp_wait(adapter);
279
280         return SUCCESS;
281 }
282
283 int zfcp_adapter_scsi_register(struct zfcp_adapter *adapter)
284 {
285         struct ccw_dev_id dev_id;
286
287         if (adapter->scsi_host)
288                 return 0;
289
290         ccw_device_get_id(adapter->ccw_device, &dev_id);
291         /* register adapter as SCSI host with mid layer of SCSI stack */
292         adapter->scsi_host = scsi_host_alloc(&zfcp_data.scsi_host_template,
293                                              sizeof (struct zfcp_adapter *));
294         if (!adapter->scsi_host) {
295                 dev_err(&adapter->ccw_device->dev,
296                         "Registering the FCP device with the "
297                         "SCSI stack failed\n");
298                 return -EIO;
299         }
300
301         /* tell the SCSI stack some characteristics of this adapter */
302         adapter->scsi_host->max_id = 1;
303         adapter->scsi_host->max_lun = 1;
304         adapter->scsi_host->max_channel = 0;
305         adapter->scsi_host->unique_id = dev_id.devno;
306         adapter->scsi_host->max_cmd_len = 255;
307         adapter->scsi_host->transportt = zfcp_data.scsi_transport_template;
308
309         adapter->scsi_host->hostdata[0] = (unsigned long) adapter;
310
311         if (scsi_add_host(adapter->scsi_host, &adapter->ccw_device->dev)) {
312                 scsi_host_put(adapter->scsi_host);
313                 return -EIO;
314         }
315
316         return 0;
317 }
318
319 void zfcp_adapter_scsi_unregister(struct zfcp_adapter *adapter)
320 {
321         struct Scsi_Host *shost;
322         struct zfcp_port *port;
323
324         shost = adapter->scsi_host;
325         if (!shost)
326                 return;
327
328         read_lock_irq(&zfcp_data.config_lock);
329         list_for_each_entry(port, &adapter->port_list_head, list)
330                 if (port->rport)
331                         port->rport = NULL;
332
333         read_unlock_irq(&zfcp_data.config_lock);
334         fc_remove_host(shost);
335         scsi_remove_host(shost);
336         scsi_host_put(shost);
337         adapter->scsi_host = NULL;
338
339         return;
340 }
341
342 static struct fc_host_statistics*
343 zfcp_init_fc_host_stats(struct zfcp_adapter *adapter)
344 {
345         struct fc_host_statistics *fc_stats;
346
347         if (!adapter->fc_stats) {
348                 fc_stats = kmalloc(sizeof(*fc_stats), GFP_KERNEL);
349                 if (!fc_stats)
350                         return NULL;
351                 adapter->fc_stats = fc_stats; /* freed in adater_dequeue */
352         }
353         memset(adapter->fc_stats, 0, sizeof(*adapter->fc_stats));
354         return adapter->fc_stats;
355 }
356
357 static void zfcp_adjust_fc_host_stats(struct fc_host_statistics *fc_stats,
358                                       struct fsf_qtcb_bottom_port *data,
359                                       struct fsf_qtcb_bottom_port *old)
360 {
361         fc_stats->seconds_since_last_reset =
362                 data->seconds_since_last_reset - old->seconds_since_last_reset;
363         fc_stats->tx_frames = data->tx_frames - old->tx_frames;
364         fc_stats->tx_words = data->tx_words - old->tx_words;
365         fc_stats->rx_frames = data->rx_frames - old->rx_frames;
366         fc_stats->rx_words = data->rx_words - old->rx_words;
367         fc_stats->lip_count = data->lip - old->lip;
368         fc_stats->nos_count = data->nos - old->nos;
369         fc_stats->error_frames = data->error_frames - old->error_frames;
370         fc_stats->dumped_frames = data->dumped_frames - old->dumped_frames;
371         fc_stats->link_failure_count = data->link_failure - old->link_failure;
372         fc_stats->loss_of_sync_count = data->loss_of_sync - old->loss_of_sync;
373         fc_stats->loss_of_signal_count =
374                 data->loss_of_signal - old->loss_of_signal;
375         fc_stats->prim_seq_protocol_err_count =
376                 data->psp_error_counts - old->psp_error_counts;
377         fc_stats->invalid_tx_word_count =
378                 data->invalid_tx_words - old->invalid_tx_words;
379         fc_stats->invalid_crc_count = data->invalid_crcs - old->invalid_crcs;
380         fc_stats->fcp_input_requests =
381                 data->input_requests - old->input_requests;
382         fc_stats->fcp_output_requests =
383                 data->output_requests - old->output_requests;
384         fc_stats->fcp_control_requests =
385                 data->control_requests - old->control_requests;
386         fc_stats->fcp_input_megabytes = data->input_mb - old->input_mb;
387         fc_stats->fcp_output_megabytes = data->output_mb - old->output_mb;
388 }
389
390 static void zfcp_set_fc_host_stats(struct fc_host_statistics *fc_stats,
391                                    struct fsf_qtcb_bottom_port *data)
392 {
393         fc_stats->seconds_since_last_reset = data->seconds_since_last_reset;
394         fc_stats->tx_frames = data->tx_frames;
395         fc_stats->tx_words = data->tx_words;
396         fc_stats->rx_frames = data->rx_frames;
397         fc_stats->rx_words = data->rx_words;
398         fc_stats->lip_count = data->lip;
399         fc_stats->nos_count = data->nos;
400         fc_stats->error_frames = data->error_frames;
401         fc_stats->dumped_frames = data->dumped_frames;
402         fc_stats->link_failure_count = data->link_failure;
403         fc_stats->loss_of_sync_count = data->loss_of_sync;
404         fc_stats->loss_of_signal_count = data->loss_of_signal;
405         fc_stats->prim_seq_protocol_err_count = data->psp_error_counts;
406         fc_stats->invalid_tx_word_count = data->invalid_tx_words;
407         fc_stats->invalid_crc_count = data->invalid_crcs;
408         fc_stats->fcp_input_requests = data->input_requests;
409         fc_stats->fcp_output_requests = data->output_requests;
410         fc_stats->fcp_control_requests = data->control_requests;
411         fc_stats->fcp_input_megabytes = data->input_mb;
412         fc_stats->fcp_output_megabytes = data->output_mb;
413 }
414
415 static struct fc_host_statistics *zfcp_get_fc_host_stats(struct Scsi_Host *host)
416 {
417         struct zfcp_adapter *adapter;
418         struct fc_host_statistics *fc_stats;
419         struct fsf_qtcb_bottom_port *data;
420         int ret;
421
422         adapter = (struct zfcp_adapter *)host->hostdata[0];
423         fc_stats = zfcp_init_fc_host_stats(adapter);
424         if (!fc_stats)
425                 return NULL;
426
427         data = kzalloc(sizeof(*data), GFP_KERNEL);
428         if (!data)
429                 return NULL;
430
431         ret = zfcp_fsf_exchange_port_data_sync(adapter, data);
432         if (ret) {
433                 kfree(data);
434                 return NULL;
435         }
436
437         if (adapter->stats_reset &&
438             ((jiffies/HZ - adapter->stats_reset) <
439              data->seconds_since_last_reset))
440                 zfcp_adjust_fc_host_stats(fc_stats, data,
441                                           adapter->stats_reset_data);
442         else
443                 zfcp_set_fc_host_stats(fc_stats, data);
444
445         kfree(data);
446         return fc_stats;
447 }
448
449 static void zfcp_reset_fc_host_stats(struct Scsi_Host *shost)
450 {
451         struct zfcp_adapter *adapter;
452         struct fsf_qtcb_bottom_port *data;
453         int ret;
454
455         adapter = (struct zfcp_adapter *)shost->hostdata[0];
456         data = kzalloc(sizeof(*data), GFP_KERNEL);
457         if (!data)
458                 return;
459
460         ret = zfcp_fsf_exchange_port_data_sync(adapter, data);
461         if (ret)
462                 kfree(data);
463         else {
464                 adapter->stats_reset = jiffies/HZ;
465                 kfree(adapter->stats_reset_data);
466                 adapter->stats_reset_data = data; /* finally freed in
467                                                      adapter_dequeue */
468         }
469 }
470
471 static void zfcp_get_host_port_state(struct Scsi_Host *shost)
472 {
473         struct zfcp_adapter *adapter =
474                 (struct zfcp_adapter *)shost->hostdata[0];
475         int status = atomic_read(&adapter->status);
476
477         if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
478             !(status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED))
479                 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
480         else if (status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)
481                 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
482         else if (status & ZFCP_STATUS_COMMON_ERP_FAILED)
483                 fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
484         else
485                 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
486 }
487
488 static void zfcp_set_rport_dev_loss_tmo(struct fc_rport *rport, u32 timeout)
489 {
490         rport->dev_loss_tmo = timeout;
491 }
492
493 /**
494  * zfcp_scsi_dev_loss_tmo_callbk - Free any reference to rport
495  * @rport: The rport that is about to be deleted.
496  */
497 static void zfcp_scsi_dev_loss_tmo_callbk(struct fc_rport *rport)
498 {
499         struct zfcp_port *port;
500
501         write_lock_irq(&zfcp_data.config_lock);
502         port = rport->dd_data;
503         if (port)
504                 port->rport = NULL;
505         write_unlock_irq(&zfcp_data.config_lock);
506 }
507
508 /**
509  * zfcp_scsi_terminate_rport_io - Terminate all I/O on a rport
510  * @rport: The FC rport where to teminate I/O
511  *
512  * Abort all pending SCSI commands for a port by closing the
513  * port. Using a reopen for avoids a conflict with a shutdown
514  * overwriting a reopen.
515  */
516 static void zfcp_scsi_terminate_rport_io(struct fc_rport *rport)
517 {
518         struct zfcp_port *port;
519
520         write_lock_irq(&zfcp_data.config_lock);
521         port = rport->dd_data;
522         if (port)
523                 zfcp_port_get(port);
524         write_unlock_irq(&zfcp_data.config_lock);
525
526         if (port) {
527                 zfcp_erp_port_reopen(port, 0, "sctrpi1", NULL);
528                 zfcp_port_put(port);
529         }
530 }
531
532 static void zfcp_scsi_rport_register(struct zfcp_port *port)
533 {
534         struct fc_rport_identifiers ids;
535         struct fc_rport *rport;
536
537         ids.node_name = port->wwnn;
538         ids.port_name = port->wwpn;
539         ids.port_id = port->d_id;
540         ids.roles = FC_RPORT_ROLE_FCP_TARGET;
541
542         rport = fc_remote_port_add(port->adapter->scsi_host, 0, &ids);
543         if (!rport) {
544                 dev_err(&port->adapter->ccw_device->dev,
545                         "Registering port 0x%016Lx failed\n",
546                         (unsigned long long)port->wwpn);
547                 return;
548         }
549
550         rport->dd_data = port;
551         rport->maxframe_size = port->maxframe_size;
552         rport->supported_classes = port->supported_classes;
553         port->rport = rport;
554 }
555
556 static void zfcp_scsi_rport_block(struct zfcp_port *port)
557 {
558         struct fc_rport *rport = port->rport;
559
560         if (rport)
561                 fc_remote_port_delete(rport);
562 }
563
564 void zfcp_scsi_schedule_rport_register(struct zfcp_port *port)
565 {
566         zfcp_port_get(port);
567         port->rport_task = RPORT_ADD;
568
569         if (!queue_work(zfcp_data.work_queue, &port->rport_work))
570                 zfcp_port_put(port);
571 }
572
573 void zfcp_scsi_schedule_rport_block(struct zfcp_port *port)
574 {
575         zfcp_port_get(port);
576         port->rport_task = RPORT_DEL;
577
578         if (!queue_work(zfcp_data.work_queue, &port->rport_work))
579                 zfcp_port_put(port);
580 }
581
582 void zfcp_scsi_schedule_rports_block(struct zfcp_adapter *adapter)
583 {
584         struct zfcp_port *port;
585
586         list_for_each_entry(port, &adapter->port_list_head, list)
587                 zfcp_scsi_schedule_rport_block(port);
588 }
589
590 void zfcp_scsi_rport_work(struct work_struct *work)
591 {
592         struct zfcp_port *port = container_of(work, struct zfcp_port,
593                                               rport_work);
594
595         while (port->rport_task) {
596                 if (port->rport_task == RPORT_ADD) {
597                         port->rport_task = RPORT_NONE;
598                         zfcp_scsi_rport_register(port);
599                 } else {
600                         port->rport_task = RPORT_NONE;
601                         zfcp_scsi_rport_block(port);
602                 }
603         }
604
605         zfcp_port_put(port);
606 }
607
608
609 void zfcp_scsi_scan(struct work_struct *work)
610 {
611         struct zfcp_unit *unit = container_of(work, struct zfcp_unit,
612                                               scsi_work);
613         struct fc_rport *rport;
614
615         flush_work(&unit->port->rport_work);
616         rport = unit->port->rport;
617
618         if (rport && rport->port_state == FC_PORTSTATE_ONLINE)
619                 scsi_scan_target(&rport->dev, 0, rport->scsi_target_id,
620                                  scsilun_to_int((struct scsi_lun *)
621                                                 &unit->fcp_lun), 0);
622
623         zfcp_unit_put(unit);
624 }
625
626 static int zfcp_execute_fc_job(struct fc_bsg_job *job)
627 {
628         switch (job->request->msgcode) {
629         case FC_BSG_RPT_ELS:
630         case FC_BSG_HST_ELS_NOLOGIN:
631                 return zfcp_fc_execute_els_fc_job(job);
632         case FC_BSG_RPT_CT:
633         case FC_BSG_HST_CT:
634                 return zfcp_fc_execute_ct_fc_job(job);
635         default:
636                 return -EINVAL;
637         }
638 }
639
640 struct fc_function_template zfcp_transport_functions = {
641         .show_starget_port_id = 1,
642         .show_starget_port_name = 1,
643         .show_starget_node_name = 1,
644         .show_rport_supported_classes = 1,
645         .show_rport_maxframe_size = 1,
646         .show_rport_dev_loss_tmo = 1,
647         .show_host_node_name = 1,
648         .show_host_port_name = 1,
649         .show_host_permanent_port_name = 1,
650         .show_host_supported_classes = 1,
651         .show_host_supported_speeds = 1,
652         .show_host_maxframe_size = 1,
653         .show_host_serial_number = 1,
654         .get_fc_host_stats = zfcp_get_fc_host_stats,
655         .reset_fc_host_stats = zfcp_reset_fc_host_stats,
656         .set_rport_dev_loss_tmo = zfcp_set_rport_dev_loss_tmo,
657         .get_host_port_state = zfcp_get_host_port_state,
658         .dev_loss_tmo_callbk = zfcp_scsi_dev_loss_tmo_callbk,
659         .terminate_rport_io = zfcp_scsi_terminate_rport_io,
660         .show_host_port_state = 1,
661         .bsg_request = zfcp_execute_fc_job,
662         /* no functions registered for following dynamic attributes but
663            directly set by LLDD */
664         .show_host_port_type = 1,
665         .show_host_speed = 1,
666         .show_host_port_id = 1,
667         .disable_target_scan = 1,
668 };
669
670 struct zfcp_data zfcp_data = {
671         .scsi_host_template = {
672                 .name                    = "zfcp",
673                 .module                  = THIS_MODULE,
674                 .proc_name               = "zfcp",
675                 .change_queue_depth      = zfcp_scsi_change_queue_depth,
676                 .slave_alloc             = zfcp_scsi_slave_alloc,
677                 .slave_configure         = zfcp_scsi_slave_configure,
678                 .slave_destroy           = zfcp_scsi_slave_destroy,
679                 .queuecommand            = zfcp_scsi_queuecommand,
680                 .eh_abort_handler        = zfcp_scsi_eh_abort_handler,
681                 .eh_device_reset_handler = zfcp_scsi_eh_device_reset_handler,
682                 .eh_target_reset_handler = zfcp_scsi_eh_target_reset_handler,
683                 .eh_host_reset_handler   = zfcp_scsi_eh_host_reset_handler,
684                 .can_queue               = 4096,
685                 .this_id                 = -1,
686                 .sg_tablesize            = ZFCP_MAX_SBALES_PER_REQ,
687                 .cmd_per_lun             = 1,
688                 .use_clustering          = 1,
689                 .sdev_attrs              = zfcp_sysfs_sdev_attrs,
690                 .max_sectors             = (ZFCP_MAX_SBALES_PER_REQ * 8),
691                 .shost_attrs             = zfcp_sysfs_shost_attrs,
692         },
693 };