1
2
3
4
5
6
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 <linux/atomic.h>
17#include "zfcp_ext.h"
18#include "zfcp_dbf.h"
19#include "zfcp_fc.h"
20#include "zfcp_reqlist.h"
21
22static unsigned int default_depth = 32;
23module_param_named(queue_depth, default_depth, uint, 0600);
24MODULE_PARM_DESC(queue_depth, "Default queue depth for new SCSI devices");
25
26static bool enable_dif;
27
28#ifdef CONFIG_ZFCP_DIF
29module_param_named(dif, enable_dif, bool, 0600);
30MODULE_PARM_DESC(dif, "Enable DIF/DIX data integrity support");
31#endif
32
33static bool allow_lun_scan = 1;
34module_param(allow_lun_scan, bool, 0600);
35MODULE_PARM_DESC(allow_lun_scan, "For NPIV, scan and attach all storage LUNs");
36
37static 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
56static 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
64static 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
73static 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
80static
81int 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
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
104
105 zfcp_scsi_command_fail(scpnt, DID_ERROR);
106 return 0;
107 }
108
109 if (unlikely(!(status & ZFCP_STATUS_COMMON_UNBLOCKED))) {
110
111
112
113
114
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
129static 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
168static 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
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;
188 }
189 old_req->data = NULL;
190
191
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
231static 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
270static 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
275static 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
280static 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
295struct scsi_transport_template *zfcp_scsi_transport_template;
296
297static struct scsi_host_template zfcp_scsi_host_template = {
298 .module = THIS_MODULE,
299 .name = "zfcp",
300 .queuecommand = zfcp_scsi_queuecommand,
301 .eh_abort_handler = zfcp_scsi_eh_abort_handler,
302 .eh_device_reset_handler = zfcp_scsi_eh_device_reset_handler,
303 .eh_target_reset_handler = zfcp_scsi_eh_target_reset_handler,
304 .eh_host_reset_handler = zfcp_scsi_eh_host_reset_handler,
305 .slave_alloc = zfcp_scsi_slave_alloc,
306 .slave_configure = zfcp_scsi_slave_configure,
307 .slave_destroy = zfcp_scsi_slave_destroy,
308 .change_queue_depth = zfcp_scsi_change_queue_depth,
309 .proc_name = "zfcp",
310 .can_queue = 4096,
311 .this_id = -1,
312 .sg_tablesize = ZFCP_QDIO_MAX_SBALES_PER_REQ,
313 .max_sectors = (ZFCP_QDIO_MAX_SBALES_PER_REQ * 8),
314 .dma_boundary = ZFCP_QDIO_SBALE_LEN - 1,
315 .cmd_per_lun = 1,
316 .use_clustering = 1,
317 .shost_attrs = zfcp_sysfs_shost_attrs,
318 .sdev_attrs = zfcp_sysfs_sdev_attrs,
319};
320
321
322
323
324
325int zfcp_scsi_adapter_register(struct zfcp_adapter *adapter)
326{
327 struct ccw_dev_id dev_id;
328
329 if (adapter->scsi_host)
330 return 0;
331
332 ccw_device_get_id(adapter->ccw_device, &dev_id);
333
334 adapter->scsi_host = scsi_host_alloc(&zfcp_scsi_host_template,
335 sizeof (struct zfcp_adapter *));
336 if (!adapter->scsi_host) {
337 dev_err(&adapter->ccw_device->dev,
338 "Registering the FCP device with the "
339 "SCSI stack failed\n");
340 return -EIO;
341 }
342
343
344 adapter->scsi_host->max_id = 511;
345 adapter->scsi_host->max_lun = 0xFFFFFFFF;
346 adapter->scsi_host->max_channel = 0;
347 adapter->scsi_host->unique_id = dev_id.devno;
348 adapter->scsi_host->max_cmd_len = 16;
349 adapter->scsi_host->transportt = zfcp_scsi_transport_template;
350
351 adapter->scsi_host->hostdata[0] = (unsigned long) adapter;
352
353 if (scsi_add_host(adapter->scsi_host, &adapter->ccw_device->dev)) {
354 scsi_host_put(adapter->scsi_host);
355 return -EIO;
356 }
357
358 return 0;
359}
360
361
362
363
364
365void zfcp_scsi_adapter_unregister(struct zfcp_adapter *adapter)
366{
367 struct Scsi_Host *shost;
368 struct zfcp_port *port;
369
370 shost = adapter->scsi_host;
371 if (!shost)
372 return;
373
374 read_lock_irq(&adapter->port_list_lock);
375 list_for_each_entry(port, &adapter->port_list, list)
376 port->rport = NULL;
377 read_unlock_irq(&adapter->port_list_lock);
378
379 fc_remove_host(shost);
380 scsi_remove_host(shost);
381 scsi_host_put(shost);
382 adapter->scsi_host = NULL;
383}
384
385static struct fc_host_statistics*
386zfcp_init_fc_host_stats(struct zfcp_adapter *adapter)
387{
388 struct fc_host_statistics *fc_stats;
389
390 if (!adapter->fc_stats) {
391 fc_stats = kmalloc(sizeof(*fc_stats), GFP_KERNEL);
392 if (!fc_stats)
393 return NULL;
394 adapter->fc_stats = fc_stats;
395 }
396 memset(adapter->fc_stats, 0, sizeof(*adapter->fc_stats));
397 return adapter->fc_stats;
398}
399
400static void zfcp_adjust_fc_host_stats(struct fc_host_statistics *fc_stats,
401 struct fsf_qtcb_bottom_port *data,
402 struct fsf_qtcb_bottom_port *old)
403{
404 fc_stats->seconds_since_last_reset =
405 data->seconds_since_last_reset - old->seconds_since_last_reset;
406 fc_stats->tx_frames = data->tx_frames - old->tx_frames;
407 fc_stats->tx_words = data->tx_words - old->tx_words;
408 fc_stats->rx_frames = data->rx_frames - old->rx_frames;
409 fc_stats->rx_words = data->rx_words - old->rx_words;
410 fc_stats->lip_count = data->lip - old->lip;
411 fc_stats->nos_count = data->nos - old->nos;
412 fc_stats->error_frames = data->error_frames - old->error_frames;
413 fc_stats->dumped_frames = data->dumped_frames - old->dumped_frames;
414 fc_stats->link_failure_count = data->link_failure - old->link_failure;
415 fc_stats->loss_of_sync_count = data->loss_of_sync - old->loss_of_sync;
416 fc_stats->loss_of_signal_count =
417 data->loss_of_signal - old->loss_of_signal;
418 fc_stats->prim_seq_protocol_err_count =
419 data->psp_error_counts - old->psp_error_counts;
420 fc_stats->invalid_tx_word_count =
421 data->invalid_tx_words - old->invalid_tx_words;
422 fc_stats->invalid_crc_count = data->invalid_crcs - old->invalid_crcs;
423 fc_stats->fcp_input_requests =
424 data->input_requests - old->input_requests;
425 fc_stats->fcp_output_requests =
426 data->output_requests - old->output_requests;
427 fc_stats->fcp_control_requests =
428 data->control_requests - old->control_requests;
429 fc_stats->fcp_input_megabytes = data->input_mb - old->input_mb;
430 fc_stats->fcp_output_megabytes = data->output_mb - old->output_mb;
431}
432
433static void zfcp_set_fc_host_stats(struct fc_host_statistics *fc_stats,
434 struct fsf_qtcb_bottom_port *data)
435{
436 fc_stats->seconds_since_last_reset = data->seconds_since_last_reset;
437 fc_stats->tx_frames = data->tx_frames;
438 fc_stats->tx_words = data->tx_words;
439 fc_stats->rx_frames = data->rx_frames;
440 fc_stats->rx_words = data->rx_words;
441 fc_stats->lip_count = data->lip;
442 fc_stats->nos_count = data->nos;
443 fc_stats->error_frames = data->error_frames;
444 fc_stats->dumped_frames = data->dumped_frames;
445 fc_stats->link_failure_count = data->link_failure;
446 fc_stats->loss_of_sync_count = data->loss_of_sync;
447 fc_stats->loss_of_signal_count = data->loss_of_signal;
448 fc_stats->prim_seq_protocol_err_count = data->psp_error_counts;
449 fc_stats->invalid_tx_word_count = data->invalid_tx_words;
450 fc_stats->invalid_crc_count = data->invalid_crcs;
451 fc_stats->fcp_input_requests = data->input_requests;
452 fc_stats->fcp_output_requests = data->output_requests;
453 fc_stats->fcp_control_requests = data->control_requests;
454 fc_stats->fcp_input_megabytes = data->input_mb;
455 fc_stats->fcp_output_megabytes = data->output_mb;
456}
457
458static struct fc_host_statistics *zfcp_get_fc_host_stats(struct Scsi_Host *host)
459{
460 struct zfcp_adapter *adapter;
461 struct fc_host_statistics *fc_stats;
462 struct fsf_qtcb_bottom_port *data;
463 int ret;
464
465 adapter = (struct zfcp_adapter *)host->hostdata[0];
466 fc_stats = zfcp_init_fc_host_stats(adapter);
467 if (!fc_stats)
468 return NULL;
469
470 data = kzalloc(sizeof(*data), GFP_KERNEL);
471 if (!data)
472 return NULL;
473
474 ret = zfcp_fsf_exchange_port_data_sync(adapter->qdio, data);
475 if (ret) {
476 kfree(data);
477 return NULL;
478 }
479
480 if (adapter->stats_reset &&
481 ((jiffies/HZ - adapter->stats_reset) <
482 data->seconds_since_last_reset))
483 zfcp_adjust_fc_host_stats(fc_stats, data,
484 adapter->stats_reset_data);
485 else
486 zfcp_set_fc_host_stats(fc_stats, data);
487
488 kfree(data);
489 return fc_stats;
490}
491
492static void zfcp_reset_fc_host_stats(struct Scsi_Host *shost)
493{
494 struct zfcp_adapter *adapter;
495 struct fsf_qtcb_bottom_port *data;
496 int ret;
497
498 adapter = (struct zfcp_adapter *)shost->hostdata[0];
499 data = kzalloc(sizeof(*data), GFP_KERNEL);
500 if (!data)
501 return;
502
503 ret = zfcp_fsf_exchange_port_data_sync(adapter->qdio, data);
504 if (ret)
505 kfree(data);
506 else {
507 adapter->stats_reset = jiffies/HZ;
508 kfree(adapter->stats_reset_data);
509 adapter->stats_reset_data = data;
510
511 }
512}
513
514static void zfcp_get_host_port_state(struct Scsi_Host *shost)
515{
516 struct zfcp_adapter *adapter =
517 (struct zfcp_adapter *)shost->hostdata[0];
518 int status = atomic_read(&adapter->status);
519
520 if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
521 !(status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED))
522 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
523 else if (status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)
524 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
525 else if (status & ZFCP_STATUS_COMMON_ERP_FAILED)
526 fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
527 else
528 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
529}
530
531static void zfcp_set_rport_dev_loss_tmo(struct fc_rport *rport, u32 timeout)
532{
533 rport->dev_loss_tmo = timeout;
534}
535
536
537
538
539
540
541
542
543
544
545
546static void zfcp_scsi_terminate_rport_io(struct fc_rport *rport)
547{
548 struct zfcp_port *port;
549 struct Scsi_Host *shost = rport_to_shost(rport);
550 struct zfcp_adapter *adapter =
551 (struct zfcp_adapter *)shost->hostdata[0];
552
553 port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
554
555 if (port) {
556 zfcp_erp_port_forced_reopen(port, 0, "sctrpi1");
557 put_device(&port->dev);
558 }
559}
560
561static void zfcp_scsi_rport_register(struct zfcp_port *port)
562{
563 struct fc_rport_identifiers ids;
564 struct fc_rport *rport;
565
566 if (port->rport)
567 return;
568
569 ids.node_name = port->wwnn;
570 ids.port_name = port->wwpn;
571 ids.port_id = port->d_id;
572 ids.roles = FC_RPORT_ROLE_FCP_TARGET;
573
574 rport = fc_remote_port_add(port->adapter->scsi_host, 0, &ids);
575 if (!rport) {
576 dev_err(&port->adapter->ccw_device->dev,
577 "Registering port 0x%016Lx failed\n",
578 (unsigned long long)port->wwpn);
579 return;
580 }
581
582 rport->maxframe_size = port->maxframe_size;
583 rport->supported_classes = port->supported_classes;
584 port->rport = rport;
585 port->starget_id = rport->scsi_target_id;
586
587 zfcp_unit_queue_scsi_scan(port);
588}
589
590static void zfcp_scsi_rport_block(struct zfcp_port *port)
591{
592 struct fc_rport *rport = port->rport;
593
594 if (rport) {
595 fc_remote_port_delete(rport);
596 port->rport = NULL;
597 }
598}
599
600void zfcp_scsi_schedule_rport_register(struct zfcp_port *port)
601{
602 get_device(&port->dev);
603 port->rport_task = RPORT_ADD;
604
605 if (!queue_work(port->adapter->work_queue, &port->rport_work))
606 put_device(&port->dev);
607}
608
609void zfcp_scsi_schedule_rport_block(struct zfcp_port *port)
610{
611 get_device(&port->dev);
612 port->rport_task = RPORT_DEL;
613
614 if (port->rport && queue_work(port->adapter->work_queue,
615 &port->rport_work))
616 return;
617
618 put_device(&port->dev);
619}
620
621void zfcp_scsi_schedule_rports_block(struct zfcp_adapter *adapter)
622{
623 unsigned long flags;
624 struct zfcp_port *port;
625
626 read_lock_irqsave(&adapter->port_list_lock, flags);
627 list_for_each_entry(port, &adapter->port_list, list)
628 zfcp_scsi_schedule_rport_block(port);
629 read_unlock_irqrestore(&adapter->port_list_lock, flags);
630}
631
632void zfcp_scsi_rport_work(struct work_struct *work)
633{
634 struct zfcp_port *port = container_of(work, struct zfcp_port,
635 rport_work);
636
637 while (port->rport_task) {
638 if (port->rport_task == RPORT_ADD) {
639 port->rport_task = RPORT_NONE;
640 zfcp_scsi_rport_register(port);
641 } else {
642 port->rport_task = RPORT_NONE;
643 zfcp_scsi_rport_block(port);
644 }
645 }
646
647 put_device(&port->dev);
648}
649
650
651
652
653
654void zfcp_scsi_set_prot(struct zfcp_adapter *adapter)
655{
656 unsigned int mask = 0;
657 unsigned int data_div;
658 struct Scsi_Host *shost = adapter->scsi_host;
659
660 data_div = atomic_read(&adapter->status) &
661 ZFCP_STATUS_ADAPTER_DATA_DIV_ENABLED;
662
663 if (enable_dif &&
664 adapter->adapter_features & FSF_FEATURE_DIF_PROT_TYPE1)
665 mask |= SHOST_DIF_TYPE1_PROTECTION;
666
667 if (enable_dif && data_div &&
668 adapter->adapter_features & FSF_FEATURE_DIX_PROT_TCPIP) {
669 mask |= SHOST_DIX_TYPE1_PROTECTION;
670 scsi_host_set_guard(shost, SHOST_DIX_GUARD_IP);
671 shost->sg_prot_tablesize = ZFCP_QDIO_MAX_SBALES_PER_REQ / 2;
672 shost->sg_tablesize = ZFCP_QDIO_MAX_SBALES_PER_REQ / 2;
673 shost->max_sectors = ZFCP_QDIO_MAX_SBALES_PER_REQ * 8 / 2;
674 }
675
676 scsi_host_set_prot(shost, mask);
677}
678
679
680
681
682
683
684
685
686
687void zfcp_scsi_dif_sense_error(struct scsi_cmnd *scmd, int ascq)
688{
689 scsi_build_sense_buffer(1, scmd->sense_buffer,
690 ILLEGAL_REQUEST, 0x10, ascq);
691 set_driver_byte(scmd, DRIVER_SENSE);
692 scmd->result |= SAM_STAT_CHECK_CONDITION;
693 set_host_byte(scmd, DID_SOFT_ERROR);
694}
695
696struct fc_function_template zfcp_transport_functions = {
697 .show_starget_port_id = 1,
698 .show_starget_port_name = 1,
699 .show_starget_node_name = 1,
700 .show_rport_supported_classes = 1,
701 .show_rport_maxframe_size = 1,
702 .show_rport_dev_loss_tmo = 1,
703 .show_host_node_name = 1,
704 .show_host_port_name = 1,
705 .show_host_permanent_port_name = 1,
706 .show_host_supported_classes = 1,
707 .show_host_supported_fc4s = 1,
708 .show_host_supported_speeds = 1,
709 .show_host_maxframe_size = 1,
710 .show_host_serial_number = 1,
711 .get_fc_host_stats = zfcp_get_fc_host_stats,
712 .reset_fc_host_stats = zfcp_reset_fc_host_stats,
713 .set_rport_dev_loss_tmo = zfcp_set_rport_dev_loss_tmo,
714 .get_host_port_state = zfcp_get_host_port_state,
715 .terminate_rport_io = zfcp_scsi_terminate_rport_io,
716 .show_host_port_state = 1,
717 .show_host_active_fc4s = 1,
718 .bsg_request = zfcp_fc_exec_bsg_job,
719 .bsg_timeout = zfcp_fc_timeout_bsg_job,
720
721
722 .show_host_port_type = 1,
723 .show_host_symbolic_name = 1,
724 .show_host_speed = 1,
725 .show_host_port_id = 1,
726 .dd_bsg_size = sizeof(struct zfcp_fsf_ct_els),
727};
728
