[SCSI] zfcp: Add allow_lun_scan module parameter
[linux-3.10.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, 2010
7  */
8
9 #define KMSG_COMPONENT "zfcp"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11
12 #include <linux/types.h>
13 #include <linux/slab.h>
14 #include <scsi/fc/fc_fcp.h>
15 #include <scsi/scsi_eh.h>
16 #include <asm/atomic.h>
17 #include "zfcp_ext.h"
18 #include "zfcp_dbf.h"
19 #include "zfcp_fc.h"
20 #include "zfcp_reqlist.h"
21
22 static unsigned int default_depth = 32;
23 module_param_named(queue_depth, default_depth, uint, 0600);
24 MODULE_PARM_DESC(queue_depth, "Default queue depth for new SCSI devices");
25
26 static bool enable_dif;
27
28 #ifdef CONFIG_ZFCP_DIF
29 module_param_named(dif, enable_dif, bool, 0600);
30 MODULE_PARM_DESC(dif, "Enable DIF/DIX data integrity support");
31 #endif
32
33 static bool allow_lun_scan = 1;
34 module_param(allow_lun_scan, bool, 0600);
35 MODULE_PARM_DESC(allow_lun_scan, "For NPIV, scan and attach all storage LUNs");
36
37 static int zfcp_scsi_change_queue_depth(struct scsi_device *sdev, int depth,
38                                         int reason)
39 {
40         switch (reason) {
41         case SCSI_QDEPTH_DEFAULT:
42                 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
43                 break;
44         case SCSI_QDEPTH_QFULL:
45                 scsi_track_queue_full(sdev, depth);
46                 break;
47         case SCSI_QDEPTH_RAMP_UP:
48                 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
49                 break;
50         default:
51                 return -EOPNOTSUPP;
52         }
53         return sdev->queue_depth;
54 }
55
56 static void zfcp_scsi_slave_destroy(struct scsi_device *sdev)
57 {
58         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
59
60         zfcp_erp_lun_shutdown_wait(sdev, "scssd_1");
61         put_device(&zfcp_sdev->port->dev);
62 }
63
64 static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
65 {
66         if (sdp->tagged_supported)
67                 scsi_adjust_queue_depth(sdp, MSG_SIMPLE_TAG, default_depth);
68         else
69                 scsi_adjust_queue_depth(sdp, 0, 1);
70         return 0;
71 }
72
73 static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result)
74 {
75         set_host_byte(scpnt, result);
76         zfcp_dbf_scsi_fail_send(scpnt);
77         scpnt->scsi_done(scpnt);
78 }
79
80 static
81 int zfcp_scsi_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scpnt)
82 {
83         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scpnt->device);
84         struct fc_rport *rport = starget_to_rport(scsi_target(scpnt->device));
85         int    status, scsi_result, ret;
86
87         /* reset the status for this request */
88         scpnt->result = 0;
89         scpnt->host_scribble = NULL;
90
91         scsi_result = fc_remote_port_chkready(rport);
92         if (unlikely(scsi_result)) {
93                 scpnt->result = scsi_result;
94                 zfcp_dbf_scsi_fail_send(scpnt);
95                 scpnt->scsi_done(scpnt);
96                 return 0;
97         }
98
99         status = atomic_read(&zfcp_sdev->status);
100         if (unlikely(status & ZFCP_STATUS_COMMON_ERP_FAILED) &&
101                      !(atomic_read(&zfcp_sdev->port->status) &
102                        ZFCP_STATUS_COMMON_ERP_FAILED)) {
103                 /* only LUN access denied, but port is good
104                  * not covered by FC transport, have to fail here */
105                 zfcp_scsi_command_fail(scpnt, DID_ERROR);
106                 return 0;
107         }
108
109         if (unlikely(!(status & ZFCP_STATUS_COMMON_UNBLOCKED))) {
110                 /* This could be either
111                  * open LUN pending: this is temporary, will result in
112                  *      open LUN or ERP_FAILED, so retry command
113                  * call to rport_delete pending: mimic retry from
114                  *      fc_remote_port_chkready until rport is BLOCKED
115                  */
116                 zfcp_scsi_command_fail(scpnt, DID_IMM_RETRY);
117                 return 0;
118         }
119
120         ret = zfcp_fsf_fcp_cmnd(scpnt);
121         if (unlikely(ret == -EBUSY))
122                 return SCSI_MLQUEUE_DEVICE_BUSY;
123         else if (unlikely(ret < 0))
124                 return SCSI_MLQUEUE_HOST_BUSY;
125
126         return ret;
127 }
128
129 static int zfcp_scsi_slave_alloc(struct scsi_device *sdev)
130 {
131         struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
132         struct zfcp_adapter *adapter =
133                 (struct zfcp_adapter *) sdev->host->hostdata[0];
134         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
135         struct zfcp_port *port;
136         struct zfcp_unit *unit;
137         int npiv = adapter->connection_features & FSF_FEATURE_NPIV_MODE;
138
139         port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
140         if (!port)
141                 return -ENXIO;
142
143         unit = zfcp_unit_find(port, zfcp_scsi_dev_lun(sdev));
144         if (unit)
145                 put_device(&unit->dev);
146
147         if (!unit && !(allow_lun_scan && npiv)) {
148                 put_device(&port->dev);
149                 return -ENXIO;
150         }
151
152         zfcp_sdev->port = port;
153         zfcp_sdev->latencies.write.channel.min = 0xFFFFFFFF;
154         zfcp_sdev->latencies.write.fabric.min = 0xFFFFFFFF;
155         zfcp_sdev->latencies.read.channel.min = 0xFFFFFFFF;
156         zfcp_sdev->latencies.read.fabric.min = 0xFFFFFFFF;
157         zfcp_sdev->latencies.cmd.channel.min = 0xFFFFFFFF;
158         zfcp_sdev->latencies.cmd.fabric.min = 0xFFFFFFFF;
159         spin_lock_init(&zfcp_sdev->latencies.lock);
160
161         zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_RUNNING);
162         zfcp_erp_lun_reopen(sdev, 0, "scsla_1");
163         zfcp_erp_wait(port->adapter);
164
165         return 0;
166 }
167
168 static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
169 {
170         struct Scsi_Host *scsi_host = scpnt->device->host;
171         struct zfcp_adapter *adapter =
172                 (struct zfcp_adapter *) scsi_host->hostdata[0];
173         struct zfcp_fsf_req *old_req, *abrt_req;
174         unsigned long flags;
175         unsigned long old_reqid = (unsigned long) scpnt->host_scribble;
176         int retval = SUCCESS, ret;
177         int retry = 3;
178         char *dbf_tag;
179
180         /* avoid race condition between late normal completion and abort */
181         write_lock_irqsave(&adapter->abort_lock, flags);
182
183         old_req = zfcp_reqlist_find(adapter->req_list, old_reqid);
184         if (!old_req) {
185                 write_unlock_irqrestore(&adapter->abort_lock, flags);
186                 zfcp_dbf_scsi_abort("abrt_or", scpnt, NULL);
187                 return FAILED; /* completion could be in progress */
188         }
189         old_req->data = NULL;
190
191         /* don't access old fsf_req after releasing the abort_lock */
192         write_unlock_irqrestore(&adapter->abort_lock, flags);
193
194         while (retry--) {
195                 abrt_req = zfcp_fsf_abort_fcp_cmnd(scpnt);
196                 if (abrt_req)
197                         break;
198
199                 zfcp_erp_wait(adapter);
200                 ret = fc_block_scsi_eh(scpnt);
201                 if (ret) {
202                         zfcp_dbf_scsi_abort("abrt_bl", scpnt, NULL);
203                         return ret;
204                 }
205                 if (!(atomic_read(&adapter->status) &
206                       ZFCP_STATUS_COMMON_RUNNING)) {
207                         zfcp_dbf_scsi_abort("abrt_ru", scpnt, NULL);
208                         return SUCCESS;
209                 }
210         }
211         if (!abrt_req) {
212                 zfcp_dbf_scsi_abort("abrt_ar", scpnt, NULL);
213                 return FAILED;
214         }
215
216         wait_for_completion(&abrt_req->completion);
217
218         if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED)
219                 dbf_tag = "abrt_ok";
220         else if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED)
221                 dbf_tag = "abrt_nn";
222         else {
223                 dbf_tag = "abrt_fa";
224                 retval = FAILED;
225         }
226         zfcp_dbf_scsi_abort(dbf_tag, scpnt, abrt_req);
227         zfcp_fsf_req_free(abrt_req);
228         return retval;
229 }
230
231 static int zfcp_task_mgmt_function(struct scsi_cmnd *scpnt, u8 tm_flags)
232 {
233         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scpnt->device);
234         struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
235         struct zfcp_fsf_req *fsf_req = NULL;
236         int retval = SUCCESS, ret;
237         int retry = 3;
238
239         while (retry--) {
240                 fsf_req = zfcp_fsf_fcp_task_mgmt(scpnt, tm_flags);
241                 if (fsf_req)
242                         break;
243
244                 zfcp_erp_wait(adapter);
245                 ret = fc_block_scsi_eh(scpnt);
246                 if (ret)
247                         return ret;
248
249                 if (!(atomic_read(&adapter->status) &
250                       ZFCP_STATUS_COMMON_RUNNING)) {
251                         zfcp_dbf_scsi_devreset("nres", scpnt, tm_flags);
252                         return SUCCESS;
253                 }
254         }
255         if (!fsf_req)
256                 return FAILED;
257
258         wait_for_completion(&fsf_req->completion);
259
260         if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCFAILED) {
261                 zfcp_dbf_scsi_devreset("fail", scpnt, tm_flags);
262                 retval = FAILED;
263         } else
264                 zfcp_dbf_scsi_devreset("okay", scpnt, tm_flags);
265
266         zfcp_fsf_req_free(fsf_req);
267         return retval;
268 }
269
270 static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt)
271 {
272         return zfcp_task_mgmt_function(scpnt, FCP_TMF_LUN_RESET);
273 }
274
275 static int zfcp_scsi_eh_target_reset_handler(struct scsi_cmnd *scpnt)
276 {
277         return zfcp_task_mgmt_function(scpnt, FCP_TMF_TGT_RESET);
278 }
279
280 static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
281 {
282         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scpnt->device);
283         struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
284         int ret;
285
286         zfcp_erp_adapter_reopen(adapter, 0, "schrh_1");
287         zfcp_erp_wait(adapter);
288         ret = fc_block_scsi_eh(scpnt);
289         if (ret)
290                 return ret;
291
292         return SUCCESS;
293 }
294
295 int zfcp_adapter_scsi_register(struct zfcp_adapter *adapter)
296 {
297         struct ccw_dev_id dev_id;
298
299         if (adapter->scsi_host)
300                 return 0;
301
302         ccw_device_get_id(adapter->ccw_device, &dev_id);
303         /* register adapter as SCSI host with mid layer of SCSI stack */
304         adapter->scsi_host = scsi_host_alloc(&zfcp_data.scsi_host_template,
305                                              sizeof (struct zfcp_adapter *));
306         if (!adapter->scsi_host) {
307                 dev_err(&adapter->ccw_device->dev,
308                         "Registering the FCP device with the "
309                         "SCSI stack failed\n");
310                 return -EIO;
311         }
312
313         /* tell the SCSI stack some characteristics of this adapter */
314         adapter->scsi_host->max_id = 511;
315         adapter->scsi_host->max_lun = 0xFFFFFFFF;
316         adapter->scsi_host->max_channel = 0;
317         adapter->scsi_host->unique_id = dev_id.devno;
318         adapter->scsi_host->max_cmd_len = 16; /* in struct fcp_cmnd */
319         adapter->scsi_host->transportt = zfcp_data.scsi_transport_template;
320
321         adapter->scsi_host->hostdata[0] = (unsigned long) adapter;
322
323         if (scsi_add_host(adapter->scsi_host, &adapter->ccw_device->dev)) {
324                 scsi_host_put(adapter->scsi_host);
325                 return -EIO;
326         }
327
328         return 0;
329 }
330
331 void zfcp_adapter_scsi_unregister(struct zfcp_adapter *adapter)
332 {
333         struct Scsi_Host *shost;
334         struct zfcp_port *port;
335
336         shost = adapter->scsi_host;
337         if (!shost)
338                 return;
339
340         read_lock_irq(&adapter->port_list_lock);
341         list_for_each_entry(port, &adapter->port_list, list)
342                 port->rport = NULL;
343         read_unlock_irq(&adapter->port_list_lock);
344
345         fc_remove_host(shost);
346         scsi_remove_host(shost);
347         scsi_host_put(shost);
348         adapter->scsi_host = NULL;
349
350         return;
351 }
352
353 static struct fc_host_statistics*
354 zfcp_init_fc_host_stats(struct zfcp_adapter *adapter)
355 {
356         struct fc_host_statistics *fc_stats;
357
358         if (!adapter->fc_stats) {
359                 fc_stats = kmalloc(sizeof(*fc_stats), GFP_KERNEL);
360                 if (!fc_stats)
361                         return NULL;
362                 adapter->fc_stats = fc_stats; /* freed in adapter_release */
363         }
364         memset(adapter->fc_stats, 0, sizeof(*adapter->fc_stats));
365         return adapter->fc_stats;
366 }
367
368 static void zfcp_adjust_fc_host_stats(struct fc_host_statistics *fc_stats,
369                                       struct fsf_qtcb_bottom_port *data,
370                                       struct fsf_qtcb_bottom_port *old)
371 {
372         fc_stats->seconds_since_last_reset =
373                 data->seconds_since_last_reset - old->seconds_since_last_reset;
374         fc_stats->tx_frames = data->tx_frames - old->tx_frames;
375         fc_stats->tx_words = data->tx_words - old->tx_words;
376         fc_stats->rx_frames = data->rx_frames - old->rx_frames;
377         fc_stats->rx_words = data->rx_words - old->rx_words;
378         fc_stats->lip_count = data->lip - old->lip;
379         fc_stats->nos_count = data->nos - old->nos;
380         fc_stats->error_frames = data->error_frames - old->error_frames;
381         fc_stats->dumped_frames = data->dumped_frames - old->dumped_frames;
382         fc_stats->link_failure_count = data->link_failure - old->link_failure;
383         fc_stats->loss_of_sync_count = data->loss_of_sync - old->loss_of_sync;
384         fc_stats->loss_of_signal_count =
385                 data->loss_of_signal - old->loss_of_signal;
386         fc_stats->prim_seq_protocol_err_count =
387                 data->psp_error_counts - old->psp_error_counts;
388         fc_stats->invalid_tx_word_count =
389                 data->invalid_tx_words - old->invalid_tx_words;
390         fc_stats->invalid_crc_count = data->invalid_crcs - old->invalid_crcs;
391         fc_stats->fcp_input_requests =
392                 data->input_requests - old->input_requests;
393         fc_stats->fcp_output_requests =
394                 data->output_requests - old->output_requests;
395         fc_stats->fcp_control_requests =
396                 data->control_requests - old->control_requests;
397         fc_stats->fcp_input_megabytes = data->input_mb - old->input_mb;
398         fc_stats->fcp_output_megabytes = data->output_mb - old->output_mb;
399 }
400
401 static void zfcp_set_fc_host_stats(struct fc_host_statistics *fc_stats,
402                                    struct fsf_qtcb_bottom_port *data)
403 {
404         fc_stats->seconds_since_last_reset = data->seconds_since_last_reset;
405         fc_stats->tx_frames = data->tx_frames;
406         fc_stats->tx_words = data->tx_words;
407         fc_stats->rx_frames = data->rx_frames;
408         fc_stats->rx_words = data->rx_words;
409         fc_stats->lip_count = data->lip;
410         fc_stats->nos_count = data->nos;
411         fc_stats->error_frames = data->error_frames;
412         fc_stats->dumped_frames = data->dumped_frames;
413         fc_stats->link_failure_count = data->link_failure;
414         fc_stats->loss_of_sync_count = data->loss_of_sync;
415         fc_stats->loss_of_signal_count = data->loss_of_signal;
416         fc_stats->prim_seq_protocol_err_count = data->psp_error_counts;
417         fc_stats->invalid_tx_word_count = data->invalid_tx_words;
418         fc_stats->invalid_crc_count = data->invalid_crcs;
419         fc_stats->fcp_input_requests = data->input_requests;
420         fc_stats->fcp_output_requests = data->output_requests;
421         fc_stats->fcp_control_requests = data->control_requests;
422         fc_stats->fcp_input_megabytes = data->input_mb;
423         fc_stats->fcp_output_megabytes = data->output_mb;
424 }
425
426 static struct fc_host_statistics *zfcp_get_fc_host_stats(struct Scsi_Host *host)
427 {
428         struct zfcp_adapter *adapter;
429         struct fc_host_statistics *fc_stats;
430         struct fsf_qtcb_bottom_port *data;
431         int ret;
432
433         adapter = (struct zfcp_adapter *)host->hostdata[0];
434         fc_stats = zfcp_init_fc_host_stats(adapter);
435         if (!fc_stats)
436                 return NULL;
437
438         data = kzalloc(sizeof(*data), GFP_KERNEL);
439         if (!data)
440                 return NULL;
441
442         ret = zfcp_fsf_exchange_port_data_sync(adapter->qdio, data);
443         if (ret) {
444                 kfree(data);
445                 return NULL;
446         }
447
448         if (adapter->stats_reset &&
449             ((jiffies/HZ - adapter->stats_reset) <
450              data->seconds_since_last_reset))
451                 zfcp_adjust_fc_host_stats(fc_stats, data,
452                                           adapter->stats_reset_data);
453         else
454                 zfcp_set_fc_host_stats(fc_stats, data);
455
456         kfree(data);
457         return fc_stats;
458 }
459
460 static void zfcp_reset_fc_host_stats(struct Scsi_Host *shost)
461 {
462         struct zfcp_adapter *adapter;
463         struct fsf_qtcb_bottom_port *data;
464         int ret;
465
466         adapter = (struct zfcp_adapter *)shost->hostdata[0];
467         data = kzalloc(sizeof(*data), GFP_KERNEL);
468         if (!data)
469                 return;
470
471         ret = zfcp_fsf_exchange_port_data_sync(adapter->qdio, data);
472         if (ret)
473                 kfree(data);
474         else {
475                 adapter->stats_reset = jiffies/HZ;
476                 kfree(adapter->stats_reset_data);
477                 adapter->stats_reset_data = data; /* finally freed in
478                                                      adapter_release */
479         }
480 }
481
482 static void zfcp_get_host_port_state(struct Scsi_Host *shost)
483 {
484         struct zfcp_adapter *adapter =
485                 (struct zfcp_adapter *)shost->hostdata[0];
486         int status = atomic_read(&adapter->status);
487
488         if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
489             !(status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED))
490                 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
491         else if (status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)
492                 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
493         else if (status & ZFCP_STATUS_COMMON_ERP_FAILED)
494                 fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
495         else
496                 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
497 }
498
499 static void zfcp_set_rport_dev_loss_tmo(struct fc_rport *rport, u32 timeout)
500 {
501         rport->dev_loss_tmo = timeout;
502 }
503
504 /**
505  * zfcp_scsi_terminate_rport_io - Terminate all I/O on a rport
506  * @rport: The FC rport where to teminate I/O
507  *
508  * Abort all pending SCSI commands for a port by closing the
509  * port. Using a reopen avoids a conflict with a shutdown
510  * overwriting a reopen. The "forced" ensures that a disappeared port
511  * is not opened again as valid due to the cached plogi data in
512  * non-NPIV mode.
513  */
514 static void zfcp_scsi_terminate_rport_io(struct fc_rport *rport)
515 {
516         struct zfcp_port *port;
517         struct Scsi_Host *shost = rport_to_shost(rport);
518         struct zfcp_adapter *adapter =
519                 (struct zfcp_adapter *)shost->hostdata[0];
520
521         port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
522
523         if (port) {
524                 zfcp_erp_port_forced_reopen(port, 0, "sctrpi1");
525                 put_device(&port->dev);
526         }
527 }
528
529 static void zfcp_scsi_rport_register(struct zfcp_port *port)
530 {
531         struct fc_rport_identifiers ids;
532         struct fc_rport *rport;
533
534         if (port->rport)
535                 return;
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->maxframe_size = port->maxframe_size;
551         rport->supported_classes = port->supported_classes;
552         port->rport = rport;
553         port->starget_id = rport->scsi_target_id;
554
555         zfcp_unit_queue_scsi_scan(port);
556 }
557
558 static void zfcp_scsi_rport_block(struct zfcp_port *port)
559 {
560         struct fc_rport *rport = port->rport;
561
562         if (rport) {
563                 fc_remote_port_delete(rport);
564                 port->rport = NULL;
565         }
566 }
567
568 void zfcp_scsi_schedule_rport_register(struct zfcp_port *port)
569 {
570         get_device(&port->dev);
571         port->rport_task = RPORT_ADD;
572
573         if (!queue_work(port->adapter->work_queue, &port->rport_work))
574                 put_device(&port->dev);
575 }
576
577 void zfcp_scsi_schedule_rport_block(struct zfcp_port *port)
578 {
579         get_device(&port->dev);
580         port->rport_task = RPORT_DEL;
581
582         if (port->rport && queue_work(port->adapter->work_queue,
583                                       &port->rport_work))
584                 return;
585
586         put_device(&port->dev);
587 }
588
589 void zfcp_scsi_schedule_rports_block(struct zfcp_adapter *adapter)
590 {
591         unsigned long flags;
592         struct zfcp_port *port;
593
594         read_lock_irqsave(&adapter->port_list_lock, flags);
595         list_for_each_entry(port, &adapter->port_list, list)
596                 zfcp_scsi_schedule_rport_block(port);
597         read_unlock_irqrestore(&adapter->port_list_lock, flags);
598 }
599
600 void zfcp_scsi_rport_work(struct work_struct *work)
601 {
602         struct zfcp_port *port = container_of(work, struct zfcp_port,
603                                               rport_work);
604
605         while (port->rport_task) {
606                 if (port->rport_task == RPORT_ADD) {
607                         port->rport_task = RPORT_NONE;
608                         zfcp_scsi_rport_register(port);
609                 } else {
610                         port->rport_task = RPORT_NONE;
611                         zfcp_scsi_rport_block(port);
612                 }
613         }
614
615         put_device(&port->dev);
616 }
617
618 /**
619  * zfcp_scsi_set_prot - Configure DIF/DIX support in scsi_host
620  * @adapter: The adapter where to configure DIF/DIX for the SCSI host
621  */
622 void zfcp_scsi_set_prot(struct zfcp_adapter *adapter)
623 {
624         unsigned int mask = 0;
625         unsigned int data_div;
626         struct Scsi_Host *shost = adapter->scsi_host;
627
628         data_div = atomic_read(&adapter->status) &
629                    ZFCP_STATUS_ADAPTER_DATA_DIV_ENABLED;
630
631         if (enable_dif &&
632             adapter->adapter_features & FSF_FEATURE_DIF_PROT_TYPE1)
633                 mask |= SHOST_DIF_TYPE1_PROTECTION;
634
635         if (enable_dif && data_div &&
636             adapter->adapter_features & FSF_FEATURE_DIX_PROT_TCPIP) {
637                 mask |= SHOST_DIX_TYPE1_PROTECTION;
638                 scsi_host_set_guard(shost, SHOST_DIX_GUARD_IP);
639                 shost->sg_prot_tablesize = ZFCP_QDIO_MAX_SBALES_PER_REQ / 2;
640                 shost->sg_tablesize = ZFCP_QDIO_MAX_SBALES_PER_REQ / 2;
641                 shost->max_sectors = ZFCP_QDIO_MAX_SBALES_PER_REQ * 8 / 2;
642         }
643
644         scsi_host_set_prot(shost, mask);
645 }
646
647 /**
648  * zfcp_scsi_dif_sense_error - Report DIF/DIX error as driver sense error
649  * @scmd: The SCSI command to report the error for
650  * @ascq: The ASCQ to put in the sense buffer
651  *
652  * See the error handling in sd_done for the sense codes used here.
653  * Set DID_SOFT_ERROR to retry the request, if possible.
654  */
655 void zfcp_scsi_dif_sense_error(struct scsi_cmnd *scmd, int ascq)
656 {
657         scsi_build_sense_buffer(1, scmd->sense_buffer,
658                                 ILLEGAL_REQUEST, 0x10, ascq);
659         set_driver_byte(scmd, DRIVER_SENSE);
660         scmd->result |= SAM_STAT_CHECK_CONDITION;
661         set_host_byte(scmd, DID_SOFT_ERROR);
662 }
663
664 struct fc_function_template zfcp_transport_functions = {
665         .show_starget_port_id = 1,
666         .show_starget_port_name = 1,
667         .show_starget_node_name = 1,
668         .show_rport_supported_classes = 1,
669         .show_rport_maxframe_size = 1,
670         .show_rport_dev_loss_tmo = 1,
671         .show_host_node_name = 1,
672         .show_host_port_name = 1,
673         .show_host_permanent_port_name = 1,
674         .show_host_supported_classes = 1,
675         .show_host_supported_fc4s = 1,
676         .show_host_supported_speeds = 1,
677         .show_host_maxframe_size = 1,
678         .show_host_serial_number = 1,
679         .get_fc_host_stats = zfcp_get_fc_host_stats,
680         .reset_fc_host_stats = zfcp_reset_fc_host_stats,
681         .set_rport_dev_loss_tmo = zfcp_set_rport_dev_loss_tmo,
682         .get_host_port_state = zfcp_get_host_port_state,
683         .terminate_rport_io = zfcp_scsi_terminate_rport_io,
684         .show_host_port_state = 1,
685         .show_host_active_fc4s = 1,
686         .bsg_request = zfcp_fc_exec_bsg_job,
687         .bsg_timeout = zfcp_fc_timeout_bsg_job,
688         /* no functions registered for following dynamic attributes but
689            directly set by LLDD */
690         .show_host_port_type = 1,
691         .show_host_speed = 1,
692         .show_host_port_id = 1,
693         .dd_bsg_size = sizeof(struct zfcp_fsf_ct_els),
694 };
695
696 struct zfcp_data zfcp_data = {
697         .scsi_host_template = {
698                 .name                    = "zfcp",
699                 .module                  = THIS_MODULE,
700                 .proc_name               = "zfcp",
701                 .change_queue_depth      = zfcp_scsi_change_queue_depth,
702                 .slave_alloc             = zfcp_scsi_slave_alloc,
703                 .slave_configure         = zfcp_scsi_slave_configure,
704                 .slave_destroy           = zfcp_scsi_slave_destroy,
705                 .queuecommand            = zfcp_scsi_queuecommand,
706                 .eh_abort_handler        = zfcp_scsi_eh_abort_handler,
707                 .eh_device_reset_handler = zfcp_scsi_eh_device_reset_handler,
708                 .eh_target_reset_handler = zfcp_scsi_eh_target_reset_handler,
709                 .eh_host_reset_handler   = zfcp_scsi_eh_host_reset_handler,
710                 .can_queue               = 4096,
711                 .this_id                 = -1,
712                 .sg_tablesize            = ZFCP_QDIO_MAX_SBALES_PER_REQ,
713                 .cmd_per_lun             = 1,
714                 .use_clustering          = 1,
715                 .sdev_attrs              = zfcp_sysfs_sdev_attrs,
716                 .max_sectors             = (ZFCP_QDIO_MAX_SBALES_PER_REQ * 8),
717                 .dma_boundary            = ZFCP_QDIO_SBALE_LEN - 1,
718                 .shost_attrs             = zfcp_sysfs_shost_attrs,
719         },
720 };