Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ieee1394...
[linux-2.6] / drivers / s390 / scsi / zfcp_fsf.c
1 /*
2  * zfcp device driver
3  *
4  * Implementation of FSF commands.
5  *
6  * Copyright IBM Corporation 2002, 2008
7  */
8
9 #include "zfcp_ext.h"
10
11 static void zfcp_fsf_request_timeout_handler(unsigned long data)
12 {
13         struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
14         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 62,
15                                 NULL);
16 }
17
18 static void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req,
19                                  unsigned long timeout)
20 {
21         fsf_req->timer.function = zfcp_fsf_request_timeout_handler;
22         fsf_req->timer.data = (unsigned long) fsf_req->adapter;
23         fsf_req->timer.expires = jiffies + timeout;
24         add_timer(&fsf_req->timer);
25 }
26
27 static void zfcp_fsf_start_erp_timer(struct zfcp_fsf_req *fsf_req)
28 {
29         BUG_ON(!fsf_req->erp_action);
30         fsf_req->timer.function = zfcp_erp_timeout_handler;
31         fsf_req->timer.data = (unsigned long) fsf_req->erp_action;
32         fsf_req->timer.expires = jiffies + 30 * HZ;
33         add_timer(&fsf_req->timer);
34 }
35
36 /* association between FSF command and FSF QTCB type */
37 static u32 fsf_qtcb_type[] = {
38         [FSF_QTCB_FCP_CMND] =             FSF_IO_COMMAND,
39         [FSF_QTCB_ABORT_FCP_CMND] =       FSF_SUPPORT_COMMAND,
40         [FSF_QTCB_OPEN_PORT_WITH_DID] =   FSF_SUPPORT_COMMAND,
41         [FSF_QTCB_OPEN_LUN] =             FSF_SUPPORT_COMMAND,
42         [FSF_QTCB_CLOSE_LUN] =            FSF_SUPPORT_COMMAND,
43         [FSF_QTCB_CLOSE_PORT] =           FSF_SUPPORT_COMMAND,
44         [FSF_QTCB_CLOSE_PHYSICAL_PORT] =  FSF_SUPPORT_COMMAND,
45         [FSF_QTCB_SEND_ELS] =             FSF_SUPPORT_COMMAND,
46         [FSF_QTCB_SEND_GENERIC] =         FSF_SUPPORT_COMMAND,
47         [FSF_QTCB_EXCHANGE_CONFIG_DATA] = FSF_CONFIG_COMMAND,
48         [FSF_QTCB_EXCHANGE_PORT_DATA] =   FSF_PORT_COMMAND,
49         [FSF_QTCB_DOWNLOAD_CONTROL_FILE] = FSF_SUPPORT_COMMAND,
50         [FSF_QTCB_UPLOAD_CONTROL_FILE] =  FSF_SUPPORT_COMMAND
51 };
52
53 static const char *zfcp_act_subtable_type[] = {
54         "unknown", "OS", "WWPN", "DID", "LUN"
55 };
56
57 static void zfcp_act_eval_err(struct zfcp_adapter *adapter, u32 table)
58 {
59         u16 subtable = table >> 16;
60         u16 rule = table & 0xffff;
61
62         if (subtable && subtable < ARRAY_SIZE(zfcp_act_subtable_type))
63                 dev_warn(&adapter->ccw_device->dev,
64                          "Access denied in subtable %s, rule %d.\n",
65                          zfcp_act_subtable_type[subtable], rule);
66 }
67
68 static void zfcp_fsf_access_denied_port(struct zfcp_fsf_req *req,
69                                         struct zfcp_port *port)
70 {
71         struct fsf_qtcb_header *header = &req->qtcb->header;
72         dev_warn(&req->adapter->ccw_device->dev,
73                  "Access denied, cannot send command to port 0x%016Lx.\n",
74                  port->wwpn);
75         zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
76         zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
77         zfcp_erp_port_access_denied(port, 55, req);
78         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
79 }
80
81 static void zfcp_fsf_access_denied_unit(struct zfcp_fsf_req *req,
82                                         struct zfcp_unit *unit)
83 {
84         struct fsf_qtcb_header *header = &req->qtcb->header;
85         dev_warn(&req->adapter->ccw_device->dev,
86                  "Access denied for unit 0x%016Lx on port 0x%016Lx.\n",
87                  unit->fcp_lun, unit->port->wwpn);
88         zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
89         zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
90         zfcp_erp_unit_access_denied(unit, 59, req);
91         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
92 }
93
94 static void zfcp_fsf_class_not_supp(struct zfcp_fsf_req *req)
95 {
96         dev_err(&req->adapter->ccw_device->dev,
97                 "Required FC class not supported by adapter, "
98                 "shutting down adapter.\n");
99         zfcp_erp_adapter_shutdown(req->adapter, 0, 123, req);
100         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
101 }
102
103 /**
104  * zfcp_fsf_req_free - free memory used by fsf request
105  * @fsf_req: pointer to struct zfcp_fsf_req
106  */
107 void zfcp_fsf_req_free(struct zfcp_fsf_req *req)
108 {
109         if (likely(req->pool)) {
110                 mempool_free(req, req->pool);
111                 return;
112         }
113
114         if (req->qtcb) {
115                 kmem_cache_free(zfcp_data.fsf_req_qtcb_cache, req);
116                 return;
117         }
118 }
119
120 /**
121  * zfcp_fsf_req_dismiss_all - dismiss all fsf requests
122  * @adapter: pointer to struct zfcp_adapter
123  *
124  * Never ever call this without shutting down the adapter first.
125  * Otherwise the adapter would continue using and corrupting s390 storage.
126  * Included BUG_ON() call to ensure this is done.
127  * ERP is supposed to be the only user of this function.
128  */
129 void zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter)
130 {
131         struct zfcp_fsf_req *req, *tmp;
132         unsigned long flags;
133         LIST_HEAD(remove_queue);
134         unsigned int i;
135
136         BUG_ON(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP);
137         spin_lock_irqsave(&adapter->req_list_lock, flags);
138         for (i = 0; i < REQUEST_LIST_SIZE; i++)
139                 list_splice_init(&adapter->req_list[i], &remove_queue);
140         spin_unlock_irqrestore(&adapter->req_list_lock, flags);
141
142         list_for_each_entry_safe(req, tmp, &remove_queue, list) {
143                 list_del(&req->list);
144                 req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
145                 zfcp_fsf_req_complete(req);
146         }
147 }
148
149 static void zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *req)
150 {
151         struct fsf_status_read_buffer *sr_buf = req->data;
152         struct zfcp_adapter *adapter = req->adapter;
153         struct zfcp_port *port;
154         int d_id = sr_buf->d_id & ZFCP_DID_MASK;
155         unsigned long flags;
156
157         read_lock_irqsave(&zfcp_data.config_lock, flags);
158         list_for_each_entry(port, &adapter->port_list_head, list)
159                 if (port->d_id == d_id) {
160                         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
161                         switch (sr_buf->status_subtype) {
162                         case FSF_STATUS_READ_SUB_CLOSE_PHYS_PORT:
163                                 zfcp_erp_port_reopen(port, 0, 101, req);
164                                 break;
165                         case FSF_STATUS_READ_SUB_ERROR_PORT:
166                                 zfcp_erp_port_shutdown(port, 0, 122, req);
167                                 break;
168                         }
169                         return;
170                 }
171         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
172 }
173
174 static void zfcp_fsf_bit_error_threshold(struct zfcp_fsf_req *req)
175 {
176         struct zfcp_adapter *adapter = req->adapter;
177         struct fsf_status_read_buffer *sr_buf = req->data;
178         struct fsf_bit_error_payload *err = &sr_buf->payload.bit_error;
179
180         dev_warn(&adapter->ccw_device->dev,
181                  "Warning: bit error threshold data "
182                  "received for the adapter: "
183                  "link failures = %i, loss of sync errors = %i, "
184                  "loss of signal errors = %i, "
185                  "primitive sequence errors = %i, "
186                  "invalid transmission word errors = %i, "
187                  "CRC errors = %i).\n",
188                  err->link_failure_error_count,
189                  err->loss_of_sync_error_count,
190                  err->loss_of_signal_error_count,
191                  err->primitive_sequence_error_count,
192                  err->invalid_transmission_word_error_count,
193                  err->crc_error_count);
194         dev_warn(&adapter->ccw_device->dev,
195                  "Additional bit error threshold data of the adapter: "
196                  "primitive sequence event time-outs = %i, "
197                  "elastic buffer overrun errors = %i, "
198                  "advertised receive buffer-to-buffer credit = %i, "
199                  "current receice buffer-to-buffer credit = %i, "
200                  "advertised transmit buffer-to-buffer credit = %i, "
201                  "current transmit buffer-to-buffer credit = %i).\n",
202                  err->primitive_sequence_event_timeout_count,
203                  err->elastic_buffer_overrun_error_count,
204                  err->advertised_receive_b2b_credit,
205                  err->current_receive_b2b_credit,
206                  err->advertised_transmit_b2b_credit,
207                  err->current_transmit_b2b_credit);
208 }
209
210 static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req *req, u8 id,
211                                          struct fsf_link_down_info *link_down)
212 {
213         struct zfcp_adapter *adapter = req->adapter;
214
215         if (atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)
216                 return;
217
218         atomic_set_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
219
220         if (!link_down)
221                 goto out;
222
223         switch (link_down->error_code) {
224         case FSF_PSQ_LINK_NO_LIGHT:
225                 dev_warn(&req->adapter->ccw_device->dev,
226                          "The local link is down: no light detected.\n");
227                 break;
228         case FSF_PSQ_LINK_WRAP_PLUG:
229                 dev_warn(&req->adapter->ccw_device->dev,
230                          "The local link is down: wrap plug detected.\n");
231                 break;
232         case FSF_PSQ_LINK_NO_FCP:
233                 dev_warn(&req->adapter->ccw_device->dev,
234                          "The local link is down: "
235                          "adjacent node on link does not support FCP.\n");
236                 break;
237         case FSF_PSQ_LINK_FIRMWARE_UPDATE:
238                 dev_warn(&req->adapter->ccw_device->dev,
239                          "The local link is down: "
240                          "firmware update in progress.\n");
241                 break;
242         case FSF_PSQ_LINK_INVALID_WWPN:
243                 dev_warn(&req->adapter->ccw_device->dev,
244                          "The local link is down: "
245                          "duplicate or invalid WWPN detected.\n");
246                 break;
247         case FSF_PSQ_LINK_NO_NPIV_SUPPORT:
248                 dev_warn(&req->adapter->ccw_device->dev,
249                          "The local link is down: "
250                          "no support for NPIV by Fabric.\n");
251                 break;
252         case FSF_PSQ_LINK_NO_FCP_RESOURCES:
253                 dev_warn(&req->adapter->ccw_device->dev,
254                          "The local link is down: "
255                          "out of resource in FCP daughtercard.\n");
256                 break;
257         case FSF_PSQ_LINK_NO_FABRIC_RESOURCES:
258                 dev_warn(&req->adapter->ccw_device->dev,
259                          "The local link is down: "
260                          "out of resource in Fabric.\n");
261                 break;
262         case FSF_PSQ_LINK_FABRIC_LOGIN_UNABLE:
263                 dev_warn(&req->adapter->ccw_device->dev,
264                          "The local link is down: "
265                          "unable to login to Fabric.\n");
266                 break;
267         case FSF_PSQ_LINK_WWPN_ASSIGNMENT_CORRUPTED:
268                 dev_warn(&req->adapter->ccw_device->dev,
269                          "WWPN assignment file corrupted on adapter.\n");
270                 break;
271         case FSF_PSQ_LINK_MODE_TABLE_CURRUPTED:
272                 dev_warn(&req->adapter->ccw_device->dev,
273                          "Mode table corrupted on adapter.\n");
274                 break;
275         case FSF_PSQ_LINK_NO_WWPN_ASSIGNMENT:
276                 dev_warn(&req->adapter->ccw_device->dev,
277                          "No WWPN for assignment table on adapter.\n");
278                 break;
279         default:
280                 dev_warn(&req->adapter->ccw_device->dev,
281                          "The local link to adapter is down.\n");
282         }
283 out:
284         zfcp_erp_adapter_failed(adapter, id, req);
285 }
286
287 static void zfcp_fsf_status_read_link_down(struct zfcp_fsf_req *req)
288 {
289         struct zfcp_adapter *adapter = req->adapter;
290         struct fsf_status_read_buffer *sr_buf = req->data;
291         struct fsf_link_down_info *ldi =
292                 (struct fsf_link_down_info *) &sr_buf->payload;
293
294         switch (sr_buf->status_subtype) {
295         case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK:
296                 dev_warn(&adapter->ccw_device->dev,
297                          "Physical link is down.\n");
298                 zfcp_fsf_link_down_info_eval(req, 38, ldi);
299                 break;
300         case FSF_STATUS_READ_SUB_FDISC_FAILED:
301                 dev_warn(&adapter->ccw_device->dev,
302                          "Local link is down "
303                          "due to failed FDISC login.\n");
304                 zfcp_fsf_link_down_info_eval(req, 39, ldi);
305                 break;
306         case FSF_STATUS_READ_SUB_FIRMWARE_UPDATE:
307                 dev_warn(&adapter->ccw_device->dev,
308                          "Local link is down "
309                          "due to firmware update on adapter.\n");
310                 zfcp_fsf_link_down_info_eval(req, 40, NULL);
311         };
312 }
313
314 static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
315 {
316         struct zfcp_adapter *adapter = req->adapter;
317         struct fsf_status_read_buffer *sr_buf = req->data;
318
319         if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
320                 zfcp_hba_dbf_event_fsf_unsol("dism", adapter, sr_buf);
321                 mempool_free(sr_buf, adapter->pool.data_status_read);
322                 zfcp_fsf_req_free(req);
323                 return;
324         }
325
326         zfcp_hba_dbf_event_fsf_unsol("read", adapter, sr_buf);
327
328         switch (sr_buf->status_type) {
329         case FSF_STATUS_READ_PORT_CLOSED:
330                 zfcp_fsf_status_read_port_closed(req);
331                 break;
332         case FSF_STATUS_READ_INCOMING_ELS:
333                 zfcp_fc_incoming_els(req);
334                 break;
335         case FSF_STATUS_READ_SENSE_DATA_AVAIL:
336                 break;
337         case FSF_STATUS_READ_BIT_ERROR_THRESHOLD:
338                 zfcp_fsf_bit_error_threshold(req);
339                 break;
340         case FSF_STATUS_READ_LINK_DOWN:
341                 zfcp_fsf_status_read_link_down(req);
342                 break;
343         case FSF_STATUS_READ_LINK_UP:
344                 dev_info(&adapter->ccw_device->dev,
345                          "Local link was replugged.\n");
346                 /* All ports should be marked as ready to run again */
347                 zfcp_erp_modify_adapter_status(adapter, 30, NULL,
348                                                ZFCP_STATUS_COMMON_RUNNING,
349                                                ZFCP_SET);
350                 zfcp_erp_adapter_reopen(adapter,
351                                         ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
352                                         ZFCP_STATUS_COMMON_ERP_FAILED,
353                                         102, req);
354                 break;
355         case FSF_STATUS_READ_NOTIFICATION_LOST:
356                 if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_ACT_UPDATED)
357                         zfcp_erp_adapter_access_changed(adapter, 135, req);
358                 if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_INCOMING_ELS)
359                         schedule_work(&adapter->scan_work);
360                 break;
361         case FSF_STATUS_READ_CFDC_UPDATED:
362                 zfcp_erp_adapter_access_changed(adapter, 136, req);
363                 break;
364         case FSF_STATUS_READ_FEATURE_UPDATE_ALERT:
365                 adapter->adapter_features = sr_buf->payload.word[0];
366                 break;
367         }
368
369         mempool_free(sr_buf, adapter->pool.data_status_read);
370         zfcp_fsf_req_free(req);
371
372         atomic_inc(&adapter->stat_miss);
373         schedule_work(&adapter->stat_work);
374 }
375
376 static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *req)
377 {
378         switch (req->qtcb->header.fsf_status_qual.word[0]) {
379         case FSF_SQ_FCP_RSP_AVAILABLE:
380         case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
381         case FSF_SQ_NO_RETRY_POSSIBLE:
382         case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
383                 return;
384         case FSF_SQ_COMMAND_ABORTED:
385                 req->status |= ZFCP_STATUS_FSFREQ_ABORTED;
386                 break;
387         case FSF_SQ_NO_RECOM:
388                 dev_err(&req->adapter->ccw_device->dev,
389                         "No recommendation could be given for a "
390                         "problem on the adapter.\n");
391                 zfcp_erp_adapter_shutdown(req->adapter, 0, 121, req);
392                 break;
393         }
394         /* all non-return stats set FSFREQ_ERROR*/
395         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
396 }
397
398 static void zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *req)
399 {
400         if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
401                 return;
402
403         switch (req->qtcb->header.fsf_status) {
404         case FSF_UNKNOWN_COMMAND:
405                 dev_err(&req->adapter->ccw_device->dev,
406                         "Command issued by the device driver (0x%x) is "
407                         "not known by the adapter.\n",
408                         req->qtcb->header.fsf_command);
409                 zfcp_erp_adapter_shutdown(req->adapter, 0, 120, req);
410                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
411                 break;
412         case FSF_ADAPTER_STATUS_AVAILABLE:
413                 zfcp_fsf_fsfstatus_qual_eval(req);
414                 break;
415         }
416 }
417
418 static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
419 {
420         struct zfcp_adapter *adapter = req->adapter;
421         struct fsf_qtcb *qtcb = req->qtcb;
422         union fsf_prot_status_qual *psq = &qtcb->prefix.prot_status_qual;
423
424         zfcp_hba_dbf_event_fsf_response(req);
425
426         if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
427                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
428                         ZFCP_STATUS_FSFREQ_RETRY; /* only for SCSI cmnds. */
429                 return;
430         }
431
432         switch (qtcb->prefix.prot_status) {
433         case FSF_PROT_GOOD:
434         case FSF_PROT_FSF_STATUS_PRESENTED:
435                 return;
436         case FSF_PROT_QTCB_VERSION_ERROR:
437                 dev_err(&adapter->ccw_device->dev,
438                         "The QTCB version requested by zfcp (0x%x) is not "
439                         "supported by the FCP adapter (lowest supported "
440                         "0x%x, highest supported 0x%x).\n",
441                         FSF_QTCB_CURRENT_VERSION, psq->word[0],
442                         psq->word[1]);
443                 zfcp_erp_adapter_shutdown(adapter, 0, 117, req);
444                 break;
445         case FSF_PROT_ERROR_STATE:
446         case FSF_PROT_SEQ_NUMB_ERROR:
447                 zfcp_erp_adapter_reopen(adapter, 0, 98, req);
448                 req->status |= ZFCP_STATUS_FSFREQ_RETRY;
449                 break;
450         case FSF_PROT_UNSUPP_QTCB_TYPE:
451                 dev_err(&adapter->ccw_device->dev,
452                         "Packet header type used by the device driver is "
453                         "incompatible with that used on the adapter.\n");
454                 zfcp_erp_adapter_shutdown(adapter, 0, 118, req);
455                 break;
456         case FSF_PROT_HOST_CONNECTION_INITIALIZING:
457                 atomic_set_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
458                                 &adapter->status);
459                 break;
460         case FSF_PROT_DUPLICATE_REQUEST_ID:
461                 dev_err(&adapter->ccw_device->dev,
462                         "The request identifier 0x%Lx is ambiguous.\n",
463                         (unsigned long long)qtcb->bottom.support.req_handle);
464                 zfcp_erp_adapter_shutdown(adapter, 0, 78, req);
465                 break;
466         case FSF_PROT_LINK_DOWN:
467                 zfcp_fsf_link_down_info_eval(req, 37, &psq->link_down_info);
468                 /* FIXME: reopening adapter now? better wait for link up */
469                 zfcp_erp_adapter_reopen(adapter, 0, 79, req);
470                 break;
471         case FSF_PROT_REEST_QUEUE:
472                 /* All ports should be marked as ready to run again */
473                 zfcp_erp_modify_adapter_status(adapter, 28, NULL,
474                                                ZFCP_STATUS_COMMON_RUNNING,
475                                                ZFCP_SET);
476                 zfcp_erp_adapter_reopen(adapter,
477                                         ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
478                                         ZFCP_STATUS_COMMON_ERP_FAILED, 99, req);
479                 break;
480         default:
481                 dev_err(&adapter->ccw_device->dev,
482                         "Transfer protocol status information"
483                         "provided by the adapter (0x%x) "
484                         "is not compatible with the device driver.\n",
485                         qtcb->prefix.prot_status);
486                 zfcp_erp_adapter_shutdown(adapter, 0, 119, req);
487         }
488         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
489 }
490
491 /**
492  * zfcp_fsf_req_complete - process completion of a FSF request
493  * @fsf_req: The FSF request that has been completed.
494  *
495  * When a request has been completed either from the FCP adapter,
496  * or it has been dismissed due to a queue shutdown, this function
497  * is called to process the completion status and trigger further
498  * events related to the FSF request.
499  */
500 void zfcp_fsf_req_complete(struct zfcp_fsf_req *req)
501 {
502         if (unlikely(req->fsf_command == FSF_QTCB_UNSOLICITED_STATUS)) {
503                 zfcp_fsf_status_read_handler(req);
504                 return;
505         }
506
507         del_timer(&req->timer);
508         zfcp_fsf_protstatus_eval(req);
509         zfcp_fsf_fsfstatus_eval(req);
510         req->handler(req);
511
512         if (req->erp_action)
513                 zfcp_erp_notify(req->erp_action, 0);
514         req->status |= ZFCP_STATUS_FSFREQ_COMPLETED;
515
516         if (likely(req->status & ZFCP_STATUS_FSFREQ_CLEANUP))
517                 zfcp_fsf_req_free(req);
518         else
519         /* notify initiator waiting for the requests completion */
520         /*
521          * FIXME: Race! We must not access fsf_req here as it might have been
522          * cleaned up already due to the set ZFCP_STATUS_FSFREQ_COMPLETED
523          * flag. It's an improbable case. But, we have the same paranoia for
524          * the cleanup flag already.
525          * Might better be handled using complete()?
526          * (setting the flag and doing wakeup ought to be atomic
527          *  with regard to checking the flag as long as waitqueue is
528          *  part of the to be released structure)
529          */
530                 wake_up(&req->completion_wq);
531 }
532
533 static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *req)
534 {
535         struct fsf_qtcb_bottom_config *bottom;
536         struct zfcp_adapter *adapter = req->adapter;
537         struct Scsi_Host *shost = adapter->scsi_host;
538
539         bottom = &req->qtcb->bottom.config;
540
541         if (req->data)
542                 memcpy(req->data, bottom, sizeof(*bottom));
543
544         fc_host_node_name(shost) = bottom->nport_serv_param.wwnn;
545         fc_host_port_name(shost) = bottom->nport_serv_param.wwpn;
546         fc_host_port_id(shost) = bottom->s_id & ZFCP_DID_MASK;
547         fc_host_speed(shost) = bottom->fc_link_speed;
548         fc_host_supported_classes(shost) = FC_COS_CLASS2 | FC_COS_CLASS3;
549
550         adapter->hydra_version = bottom->adapter_type;
551         adapter->timer_ticks = bottom->timer_interval;
552
553         if (fc_host_permanent_port_name(shost) == -1)
554                 fc_host_permanent_port_name(shost) = fc_host_port_name(shost);
555
556         switch (bottom->fc_topology) {
557         case FSF_TOPO_P2P:
558                 adapter->peer_d_id = bottom->peer_d_id & ZFCP_DID_MASK;
559                 adapter->peer_wwpn = bottom->plogi_payload.wwpn;
560                 adapter->peer_wwnn = bottom->plogi_payload.wwnn;
561                 fc_host_port_type(shost) = FC_PORTTYPE_PTP;
562                 if (req->erp_action)
563                         dev_info(&adapter->ccw_device->dev,
564                                  "Point-to-Point fibrechannel "
565                                  "configuration detected.\n");
566                 break;
567         case FSF_TOPO_FABRIC:
568                 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
569                 if (req->erp_action)
570                         dev_info(&adapter->ccw_device->dev,
571                                  "Switched fabric fibrechannel "
572                                  "network detected.\n");
573                 break;
574         case FSF_TOPO_AL:
575                 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
576                 dev_err(&adapter->ccw_device->dev,
577                         "Unsupported arbitrated loop fibrechannel "
578                         "topology detected, shutting down "
579                         "adapter.\n");
580                 zfcp_erp_adapter_shutdown(adapter, 0, 127, req);
581                 return -EIO;
582         default:
583                 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
584                 dev_err(&adapter->ccw_device->dev,
585                         "The fibrechannel topology reported by the"
586                         " adapter is not known by the zfcp driver,"
587                         " shutting down adapter.\n");
588                 zfcp_erp_adapter_shutdown(adapter, 0, 128, req);
589                 return -EIO;
590         }
591
592         return 0;
593 }
594
595 static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
596 {
597         struct zfcp_adapter *adapter = req->adapter;
598         struct fsf_qtcb *qtcb = req->qtcb;
599         struct fsf_qtcb_bottom_config *bottom = &qtcb->bottom.config;
600         struct Scsi_Host *shost = adapter->scsi_host;
601
602         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
603                 return;
604
605         adapter->fsf_lic_version = bottom->lic_version;
606         adapter->adapter_features = bottom->adapter_features;
607         adapter->connection_features = bottom->connection_features;
608         adapter->peer_wwpn = 0;
609         adapter->peer_wwnn = 0;
610         adapter->peer_d_id = 0;
611
612         switch (qtcb->header.fsf_status) {
613         case FSF_GOOD:
614                 if (zfcp_fsf_exchange_config_evaluate(req))
615                         return;
616
617                 if (bottom->max_qtcb_size < sizeof(struct fsf_qtcb)) {
618                         dev_err(&adapter->ccw_device->dev,
619                                 "Maximum QTCB size (%d bytes) allowed by "
620                                 "the adapter is lower than the minimum "
621                                 "required by the driver (%ld bytes).\n",
622                                 bottom->max_qtcb_size,
623                                 sizeof(struct fsf_qtcb));
624                         zfcp_erp_adapter_shutdown(adapter, 0, 129, req);
625                         return;
626                 }
627                 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
628                                 &adapter->status);
629                 break;
630         case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
631                 fc_host_node_name(shost) = 0;
632                 fc_host_port_name(shost) = 0;
633                 fc_host_port_id(shost) = 0;
634                 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
635                 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
636                 adapter->hydra_version = 0;
637
638                 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
639                                 &adapter->status);
640
641                 zfcp_fsf_link_down_info_eval(req, 42,
642                         &qtcb->header.fsf_status_qual.link_down_info);
643                 break;
644         default:
645                 zfcp_erp_adapter_shutdown(adapter, 0, 130, req);
646                 return;
647         }
648
649         if (adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT) {
650                 adapter->hardware_version = bottom->hardware_version;
651                 memcpy(fc_host_serial_number(shost), bottom->serial_number,
652                        min(FC_SERIAL_NUMBER_SIZE, 17));
653                 EBCASC(fc_host_serial_number(shost),
654                        min(FC_SERIAL_NUMBER_SIZE, 17));
655         }
656
657         if (FSF_QTCB_CURRENT_VERSION < bottom->low_qtcb_version) {
658                 dev_err(&adapter->ccw_device->dev,
659                         "The adapter only supports newer control block "
660                         "versions, try updated device driver.\n");
661                 zfcp_erp_adapter_shutdown(adapter, 0, 125, req);
662                 return;
663         }
664         if (FSF_QTCB_CURRENT_VERSION > bottom->high_qtcb_version) {
665                 dev_err(&adapter->ccw_device->dev,
666                         "The adapter only supports older control block "
667                         "versions, consider a microcode upgrade.\n");
668                 zfcp_erp_adapter_shutdown(adapter, 0, 126, req);
669         }
670 }
671
672 static void zfcp_fsf_exchange_port_evaluate(struct zfcp_fsf_req *req)
673 {
674         struct zfcp_adapter *adapter = req->adapter;
675         struct fsf_qtcb_bottom_port *bottom = &req->qtcb->bottom.port;
676         struct Scsi_Host *shost = adapter->scsi_host;
677
678         if (req->data)
679                 memcpy(req->data, bottom, sizeof(*bottom));
680
681         if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
682                 fc_host_permanent_port_name(shost) = bottom->wwpn;
683         else
684                 fc_host_permanent_port_name(shost) = fc_host_port_name(shost);
685         fc_host_maxframe_size(shost) = bottom->maximum_frame_size;
686         fc_host_supported_speeds(shost) = bottom->supported_speed;
687 }
688
689 static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req)
690 {
691         struct zfcp_adapter *adapter = req->adapter;
692         struct fsf_qtcb *qtcb = req->qtcb;
693
694         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
695                 return;
696
697         switch (qtcb->header.fsf_status) {
698         case FSF_GOOD:
699                 zfcp_fsf_exchange_port_evaluate(req);
700                 atomic_set_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status);
701                 break;
702         case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
703                 zfcp_fsf_exchange_port_evaluate(req);
704                 atomic_set_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status);
705                 zfcp_fsf_link_down_info_eval(req, 43,
706                         &qtcb->header.fsf_status_qual.link_down_info);
707                 break;
708         }
709 }
710
711 static int zfcp_fsf_sbal_check(struct zfcp_qdio_queue *queue)
712 {
713         spin_lock(&queue->lock);
714         if (atomic_read(&queue->count))
715                 return 1;
716         spin_unlock(&queue->lock);
717         return 0;
718 }
719
720 static int zfcp_fsf_req_sbal_get(struct zfcp_adapter *adapter)
721 {
722         long ret;
723         struct zfcp_qdio_queue *req_q = &adapter->req_q;
724
725         spin_unlock(&req_q->lock);
726         ret = wait_event_interruptible_timeout(adapter->request_wq,
727                                         zfcp_fsf_sbal_check(req_q), 5 * HZ);
728         if (ret > 0)
729                 return 0;
730
731         spin_lock(&req_q->lock);
732         return -EIO;
733 }
734
735 static struct zfcp_fsf_req *zfcp_fsf_alloc_noqtcb(mempool_t *pool)
736 {
737         struct zfcp_fsf_req *req;
738         req = mempool_alloc(pool, GFP_ATOMIC);
739         if (!req)
740                 return NULL;
741         memset(req, 0, sizeof(*req));
742         return req;
743 }
744
745 static struct zfcp_fsf_req *zfcp_fsf_alloc_qtcb(mempool_t *pool)
746 {
747         struct zfcp_fsf_req_qtcb *qtcb;
748
749         if (likely(pool))
750                 qtcb = mempool_alloc(pool, GFP_ATOMIC);
751         else
752                 qtcb = kmem_cache_alloc(zfcp_data.fsf_req_qtcb_cache,
753                                         GFP_ATOMIC);
754         if (unlikely(!qtcb))
755                 return NULL;
756
757         memset(qtcb, 0, sizeof(*qtcb));
758         qtcb->fsf_req.qtcb = &qtcb->qtcb;
759         qtcb->fsf_req.pool = pool;
760
761         return &qtcb->fsf_req;
762 }
763
764 static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_adapter *adapter,
765                                                 u32 fsf_cmd, int req_flags,
766                                                 mempool_t *pool)
767 {
768         volatile struct qdio_buffer_element *sbale;
769
770         struct zfcp_fsf_req *req;
771         struct zfcp_qdio_queue *req_q = &adapter->req_q;
772
773         if (req_flags & ZFCP_REQ_NO_QTCB)
774                 req = zfcp_fsf_alloc_noqtcb(pool);
775         else
776                 req = zfcp_fsf_alloc_qtcb(pool);
777
778         if (unlikely(!req))
779                 return ERR_PTR(-EIO);
780
781         if (adapter->req_no == 0)
782                 adapter->req_no++;
783
784         INIT_LIST_HEAD(&req->list);
785         init_timer(&req->timer);
786         init_waitqueue_head(&req->completion_wq);
787
788         req->adapter = adapter;
789         req->fsf_command = fsf_cmd;
790         req->req_id = adapter->req_no++;
791         req->sbal_number = 1;
792         req->sbal_first = req_q->first;
793         req->sbal_last = req_q->first;
794         req->sbale_curr = 1;
795
796         sbale = zfcp_qdio_sbale_req(req);
797         sbale[0].addr = (void *) req->req_id;
798         sbale[0].flags |= SBAL_FLAGS0_COMMAND;
799
800         if (likely(req->qtcb)) {
801                 req->qtcb->prefix.req_seq_no = req->adapter->fsf_req_seq_no;
802                 req->qtcb->prefix.req_id = req->req_id;
803                 req->qtcb->prefix.ulp_info = 26;
804                 req->qtcb->prefix.qtcb_type = fsf_qtcb_type[req->fsf_command];
805                 req->qtcb->prefix.qtcb_version = FSF_QTCB_CURRENT_VERSION;
806                 req->qtcb->header.req_handle = req->req_id;
807                 req->qtcb->header.fsf_command = req->fsf_command;
808                 req->seq_no = adapter->fsf_req_seq_no;
809                 req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no;
810                 sbale[1].addr = (void *) req->qtcb;
811                 sbale[1].length = sizeof(struct fsf_qtcb);
812         }
813
814         if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP)) {
815                 zfcp_fsf_req_free(req);
816                 return ERR_PTR(-EIO);
817         }
818
819         if (likely(req_flags & ZFCP_REQ_AUTO_CLEANUP))
820                 req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
821
822         return req;
823 }
824
825 static int zfcp_fsf_req_send(struct zfcp_fsf_req *req)
826 {
827         struct zfcp_adapter *adapter = req->adapter;
828         struct zfcp_qdio_queue *req_q = &adapter->req_q;
829         int idx;
830
831         /* put allocated FSF request into hash table */
832         spin_lock(&adapter->req_list_lock);
833         idx = zfcp_reqlist_hash(req->req_id);
834         list_add_tail(&req->list, &adapter->req_list[idx]);
835         spin_unlock(&adapter->req_list_lock);
836
837         req->issued = get_clock();
838         if (zfcp_qdio_send(req)) {
839                 /* Queues are down..... */
840                 del_timer(&req->timer);
841                 spin_lock(&adapter->req_list_lock);
842                 zfcp_reqlist_remove(adapter, req);
843                 spin_unlock(&adapter->req_list_lock);
844                 /* undo changes in request queue made for this request */
845                 atomic_add(req->sbal_number, &req_q->count);
846                 req_q->first -= req->sbal_number;
847                 req_q->first += QDIO_MAX_BUFFERS_PER_Q;
848                 req_q->first %= QDIO_MAX_BUFFERS_PER_Q; /* wrap */
849                 zfcp_erp_adapter_reopen(adapter, 0, 116, req);
850                 return -EIO;
851         }
852
853         /* Don't increase for unsolicited status */
854         if (req->qtcb)
855                 adapter->fsf_req_seq_no++;
856
857         return 0;
858 }
859
860 /**
861  * zfcp_fsf_status_read - send status read request
862  * @adapter: pointer to struct zfcp_adapter
863  * @req_flags: request flags
864  * Returns: 0 on success, ERROR otherwise
865  */
866 int zfcp_fsf_status_read(struct zfcp_adapter *adapter)
867 {
868         struct zfcp_fsf_req *req;
869         struct fsf_status_read_buffer *sr_buf;
870         volatile struct qdio_buffer_element *sbale;
871         int retval = -EIO;
872
873         spin_lock(&adapter->req_q.lock);
874         if (zfcp_fsf_req_sbal_get(adapter))
875                 goto out;
876
877         req = zfcp_fsf_req_create(adapter, FSF_QTCB_UNSOLICITED_STATUS,
878                                   ZFCP_REQ_NO_QTCB,
879                                   adapter->pool.fsf_req_status_read);
880         if (unlikely(IS_ERR(req))) {
881                 retval = PTR_ERR(req);
882                 goto out;
883         }
884
885         sbale = zfcp_qdio_sbale_req(req);
886         sbale[0].flags |= SBAL_FLAGS0_TYPE_STATUS;
887         sbale[2].flags |= SBAL_FLAGS_LAST_ENTRY;
888         req->sbale_curr = 2;
889
890         sr_buf = mempool_alloc(adapter->pool.data_status_read, GFP_ATOMIC);
891         if (!sr_buf) {
892                 retval = -ENOMEM;
893                 goto failed_buf;
894         }
895         memset(sr_buf, 0, sizeof(*sr_buf));
896         req->data = sr_buf;
897         sbale = zfcp_qdio_sbale_curr(req);
898         sbale->addr = (void *) sr_buf;
899         sbale->length = sizeof(*sr_buf);
900
901         retval = zfcp_fsf_req_send(req);
902         if (retval)
903                 goto failed_req_send;
904
905         goto out;
906
907 failed_req_send:
908         mempool_free(sr_buf, adapter->pool.data_status_read);
909 failed_buf:
910         zfcp_fsf_req_free(req);
911         zfcp_hba_dbf_event_fsf_unsol("fail", adapter, NULL);
912 out:
913         spin_unlock(&adapter->req_q.lock);
914         return retval;
915 }
916
917 static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
918 {
919         struct zfcp_unit *unit = req->data;
920         union fsf_status_qual *fsq = &req->qtcb->header.fsf_status_qual;
921
922         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
923                 return;
924
925         switch (req->qtcb->header.fsf_status) {
926         case FSF_PORT_HANDLE_NOT_VALID:
927                 if (fsq->word[0] == fsq->word[1]) {
928                         zfcp_erp_adapter_reopen(unit->port->adapter, 0, 104,
929                                                 req);
930                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
931                 }
932                 break;
933         case FSF_LUN_HANDLE_NOT_VALID:
934                 if (fsq->word[0] == fsq->word[1]) {
935                         zfcp_erp_port_reopen(unit->port, 0, 105, req);
936                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
937                 }
938                 break;
939         case FSF_FCP_COMMAND_DOES_NOT_EXIST:
940                 req->status |= ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED;
941                 break;
942         case FSF_PORT_BOXED:
943                 zfcp_erp_port_boxed(unit->port, 47, req);
944                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
945                                ZFCP_STATUS_FSFREQ_RETRY;
946                 break;
947         case FSF_LUN_BOXED:
948                 zfcp_erp_unit_boxed(unit, 48, req);
949                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
950                                ZFCP_STATUS_FSFREQ_RETRY;
951                 break;
952         case FSF_ADAPTER_STATUS_AVAILABLE:
953                 switch (fsq->word[0]) {
954                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
955                         zfcp_test_link(unit->port);
956                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
957                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
958                         break;
959                 }
960                 break;
961         case FSF_GOOD:
962                 req->status |= ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED;
963                 break;
964         }
965 }
966
967 /**
968  * zfcp_fsf_abort_fcp_command - abort running SCSI command
969  * @old_req_id: unsigned long
970  * @adapter: pointer to struct zfcp_adapter
971  * @unit: pointer to struct zfcp_unit
972  * @req_flags: integer specifying the request flags
973  * Returns: pointer to struct zfcp_fsf_req
974  *
975  * FIXME(design): should be watched by a timeout !!!
976  */
977
978 struct zfcp_fsf_req *zfcp_fsf_abort_fcp_command(unsigned long old_req_id,
979                                                 struct zfcp_adapter *adapter,
980                                                 struct zfcp_unit *unit,
981                                                 int req_flags)
982 {
983         volatile struct qdio_buffer_element *sbale;
984         struct zfcp_fsf_req *req = NULL;
985
986         spin_lock(&adapter->req_q.lock);
987         if (!atomic_read(&adapter->req_q.count))
988                 goto out;
989         req = zfcp_fsf_req_create(adapter, FSF_QTCB_ABORT_FCP_CMND,
990                                   req_flags, adapter->pool.fsf_req_abort);
991         if (unlikely(IS_ERR(req)))
992                 goto out;
993
994         if (unlikely(!(atomic_read(&unit->status) &
995                        ZFCP_STATUS_COMMON_UNBLOCKED)))
996                 goto out_error_free;
997
998         sbale = zfcp_qdio_sbale_req(req);
999         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1000         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1001
1002         req->data = unit;
1003         req->handler = zfcp_fsf_abort_fcp_command_handler;
1004         req->qtcb->header.lun_handle = unit->handle;
1005         req->qtcb->header.port_handle = unit->port->handle;
1006         req->qtcb->bottom.support.req_handle = (u64) old_req_id;
1007
1008         zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT);
1009         if (!zfcp_fsf_req_send(req))
1010                 goto out;
1011
1012 out_error_free:
1013         zfcp_fsf_req_free(req);
1014         req = NULL;
1015 out:
1016         spin_unlock(&adapter->req_q.lock);
1017         return req;
1018 }
1019
1020 static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
1021 {
1022         struct zfcp_adapter *adapter = req->adapter;
1023         struct zfcp_send_ct *send_ct = req->data;
1024         struct zfcp_port *port = send_ct->port;
1025         struct fsf_qtcb_header *header = &req->qtcb->header;
1026
1027         send_ct->status = -EINVAL;
1028
1029         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1030                 goto skip_fsfstatus;
1031
1032         switch (header->fsf_status) {
1033         case FSF_GOOD:
1034                 zfcp_san_dbf_event_ct_response(req);
1035                 send_ct->status = 0;
1036                 break;
1037         case FSF_SERVICE_CLASS_NOT_SUPPORTED:
1038                 zfcp_fsf_class_not_supp(req);
1039                 break;
1040         case FSF_ADAPTER_STATUS_AVAILABLE:
1041                 switch (header->fsf_status_qual.word[0]){
1042                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1043                         zfcp_test_link(port);
1044                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1045                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1046                         break;
1047                 }
1048                 break;
1049         case FSF_ACCESS_DENIED:
1050                 zfcp_fsf_access_denied_port(req, port);
1051                 break;
1052         case FSF_PORT_BOXED:
1053                 zfcp_erp_port_boxed(port, 49, req);
1054                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
1055                                ZFCP_STATUS_FSFREQ_RETRY;
1056                 break;
1057         case FSF_PORT_HANDLE_NOT_VALID:
1058                 zfcp_erp_adapter_reopen(adapter, 0, 106, req);
1059         case FSF_GENERIC_COMMAND_REJECTED:
1060         case FSF_PAYLOAD_SIZE_MISMATCH:
1061         case FSF_REQUEST_SIZE_TOO_LARGE:
1062         case FSF_RESPONSE_SIZE_TOO_LARGE:
1063         case FSF_SBAL_MISMATCH:
1064                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1065                 break;
1066         }
1067
1068 skip_fsfstatus:
1069         if (send_ct->handler)
1070                 send_ct->handler(send_ct->handler_data);
1071 }
1072
1073 static int zfcp_fsf_setup_sbals(struct zfcp_fsf_req *req,
1074                                 struct scatterlist *sg_req,
1075                                 struct scatterlist *sg_resp, int max_sbals)
1076 {
1077         int bytes;
1078
1079         bytes = zfcp_qdio_sbals_from_sg(req, SBAL_FLAGS0_TYPE_WRITE_READ,
1080                                         sg_req, max_sbals);
1081         if (bytes <= 0)
1082                 return -ENOMEM;
1083         req->qtcb->bottom.support.req_buf_length = bytes;
1084         req->sbale_curr = ZFCP_LAST_SBALE_PER_SBAL;
1085
1086         bytes = zfcp_qdio_sbals_from_sg(req, SBAL_FLAGS0_TYPE_WRITE_READ,
1087                                         sg_resp, max_sbals);
1088         if (bytes <= 0)
1089                 return -ENOMEM;
1090         req->qtcb->bottom.support.resp_buf_length = bytes;
1091
1092         return 0;
1093 }
1094
1095 /**
1096  * zfcp_fsf_send_ct - initiate a Generic Service request (FC-GS)
1097  * @ct: pointer to struct zfcp_send_ct with data for request
1098  * @pool: if non-null this mempool is used to allocate struct zfcp_fsf_req
1099  * @erp_action: if non-null the Generic Service request sent within ERP
1100  */
1101 int zfcp_fsf_send_ct(struct zfcp_send_ct *ct, mempool_t *pool,
1102                      struct zfcp_erp_action *erp_action)
1103 {
1104         struct zfcp_port *port = ct->port;
1105         struct zfcp_adapter *adapter = port->adapter;
1106         struct zfcp_fsf_req *req;
1107         int ret = -EIO;
1108
1109         spin_lock(&adapter->req_q.lock);
1110         if (zfcp_fsf_req_sbal_get(adapter))
1111                 goto out;
1112
1113         req = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_GENERIC,
1114                                   ZFCP_REQ_AUTO_CLEANUP, pool);
1115         if (unlikely(IS_ERR(req))) {
1116                 ret = PTR_ERR(req);
1117                 goto out;
1118         }
1119
1120         ret = zfcp_fsf_setup_sbals(req, ct->req, ct->resp,
1121                                    FSF_MAX_SBALS_PER_REQ);
1122         if (ret)
1123                 goto failed_send;
1124
1125         req->handler = zfcp_fsf_send_ct_handler;
1126         req->qtcb->header.port_handle = port->handle;
1127         req->qtcb->bottom.support.service_class = FSF_CLASS_3;
1128         req->qtcb->bottom.support.timeout = ct->timeout;
1129         req->data = ct;
1130
1131         zfcp_san_dbf_event_ct_request(req);
1132
1133         if (erp_action) {
1134                 erp_action->fsf_req = req;
1135                 req->erp_action = erp_action;
1136                 zfcp_fsf_start_erp_timer(req);
1137         } else
1138                 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1139
1140         ret = zfcp_fsf_req_send(req);
1141         if (ret)
1142                 goto failed_send;
1143
1144         goto out;
1145
1146 failed_send:
1147         zfcp_fsf_req_free(req);
1148         if (erp_action)
1149                 erp_action->fsf_req = NULL;
1150 out:
1151         spin_unlock(&adapter->req_q.lock);
1152         return ret;
1153 }
1154
1155 static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req *req)
1156 {
1157         struct zfcp_send_els *send_els = req->data;
1158         struct zfcp_port *port = send_els->port;
1159         struct fsf_qtcb_header *header = &req->qtcb->header;
1160
1161         send_els->status = -EINVAL;
1162
1163         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1164                 goto skip_fsfstatus;
1165
1166         switch (header->fsf_status) {
1167         case FSF_GOOD:
1168                 zfcp_san_dbf_event_els_response(req);
1169                 send_els->status = 0;
1170                 break;
1171         case FSF_SERVICE_CLASS_NOT_SUPPORTED:
1172                 zfcp_fsf_class_not_supp(req);
1173                 break;
1174         case FSF_ADAPTER_STATUS_AVAILABLE:
1175                 switch (header->fsf_status_qual.word[0]){
1176                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1177                         if (port && (send_els->ls_code != ZFCP_LS_ADISC))
1178                                 zfcp_test_link(port);
1179                         /*fall through */
1180                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1181                 case FSF_SQ_RETRY_IF_POSSIBLE:
1182                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1183                         break;
1184                 }
1185                 break;
1186         case FSF_ELS_COMMAND_REJECTED:
1187         case FSF_PAYLOAD_SIZE_MISMATCH:
1188         case FSF_REQUEST_SIZE_TOO_LARGE:
1189         case FSF_RESPONSE_SIZE_TOO_LARGE:
1190                 break;
1191         case FSF_ACCESS_DENIED:
1192                 zfcp_fsf_access_denied_port(req, port);
1193                 break;
1194         case FSF_SBAL_MISMATCH:
1195                 /* should never occure, avoided in zfcp_fsf_send_els */
1196                 /* fall through */
1197         default:
1198                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1199                 break;
1200         }
1201 skip_fsfstatus:
1202         if (send_els->handler)
1203                 send_els->handler(send_els->handler_data);
1204 }
1205
1206 /**
1207  * zfcp_fsf_send_els - initiate an ELS command (FC-FS)
1208  * @els: pointer to struct zfcp_send_els with data for the command
1209  */
1210 int zfcp_fsf_send_els(struct zfcp_send_els *els)
1211 {
1212         struct zfcp_fsf_req *req;
1213         struct zfcp_adapter *adapter = els->adapter;
1214         struct fsf_qtcb_bottom_support *bottom;
1215         int ret = -EIO;
1216
1217         if (unlikely(!(atomic_read(&els->port->status) &
1218                        ZFCP_STATUS_COMMON_UNBLOCKED)))
1219                 return -EBUSY;
1220
1221         spin_lock(&adapter->req_q.lock);
1222         if (!atomic_read(&adapter->req_q.count))
1223                 goto out;
1224         req = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_ELS,
1225                                   ZFCP_REQ_AUTO_CLEANUP, NULL);
1226         if (unlikely(IS_ERR(req))) {
1227                 ret = PTR_ERR(req);
1228                 goto out;
1229         }
1230
1231         ret = zfcp_fsf_setup_sbals(req, els->req, els->resp,
1232                                    FSF_MAX_SBALS_PER_ELS_REQ);
1233         if (ret)
1234                 goto failed_send;
1235
1236         bottom = &req->qtcb->bottom.support;
1237         req->handler = zfcp_fsf_send_els_handler;
1238         bottom->d_id = els->d_id;
1239         bottom->service_class = FSF_CLASS_3;
1240         bottom->timeout = 2 * R_A_TOV;
1241         req->data = els;
1242
1243         zfcp_san_dbf_event_els_request(req);
1244
1245         zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1246         ret = zfcp_fsf_req_send(req);
1247         if (ret)
1248                 goto failed_send;
1249
1250         goto out;
1251
1252 failed_send:
1253         zfcp_fsf_req_free(req);
1254 out:
1255         spin_unlock(&adapter->req_q.lock);
1256         return ret;
1257 }
1258
1259 int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
1260 {
1261         volatile struct qdio_buffer_element *sbale;
1262         struct zfcp_fsf_req *req;
1263         struct zfcp_adapter *adapter = erp_action->adapter;
1264         int retval = -EIO;
1265
1266         spin_lock(&adapter->req_q.lock);
1267         if (!atomic_read(&adapter->req_q.count))
1268                 goto out;
1269         req = zfcp_fsf_req_create(adapter,
1270                                   FSF_QTCB_EXCHANGE_CONFIG_DATA,
1271                                   ZFCP_REQ_AUTO_CLEANUP,
1272                                   adapter->pool.fsf_req_erp);
1273         if (unlikely(IS_ERR(req))) {
1274                 retval = PTR_ERR(req);
1275                 goto out;
1276         }
1277
1278         sbale = zfcp_qdio_sbale_req(req);
1279         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1280         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1281
1282         req->qtcb->bottom.config.feature_selection =
1283                         FSF_FEATURE_CFDC |
1284                         FSF_FEATURE_LUN_SHARING |
1285                         FSF_FEATURE_NOTIFICATION_LOST |
1286                         FSF_FEATURE_UPDATE_ALERT;
1287         req->erp_action = erp_action;
1288         req->handler = zfcp_fsf_exchange_config_data_handler;
1289         erp_action->fsf_req = req;
1290
1291         zfcp_fsf_start_erp_timer(req);
1292         retval = zfcp_fsf_req_send(req);
1293         if (retval) {
1294                 zfcp_fsf_req_free(req);
1295                 erp_action->fsf_req = NULL;
1296         }
1297 out:
1298         spin_unlock(&adapter->req_q.lock);
1299         return retval;
1300 }
1301
1302 int zfcp_fsf_exchange_config_data_sync(struct zfcp_adapter *adapter,
1303                                        struct fsf_qtcb_bottom_config *data)
1304 {
1305         volatile struct qdio_buffer_element *sbale;
1306         struct zfcp_fsf_req *req = NULL;
1307         int retval = -EIO;
1308
1309         spin_lock(&adapter->req_q.lock);
1310         if (zfcp_fsf_req_sbal_get(adapter))
1311                 goto out;
1312
1313         req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_CONFIG_DATA,
1314                                   0, NULL);
1315         if (unlikely(IS_ERR(req))) {
1316                 retval = PTR_ERR(req);
1317                 goto out;
1318         }
1319
1320         sbale = zfcp_qdio_sbale_req(req);
1321         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1322         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1323         req->handler = zfcp_fsf_exchange_config_data_handler;
1324
1325         req->qtcb->bottom.config.feature_selection =
1326                         FSF_FEATURE_CFDC |
1327                         FSF_FEATURE_LUN_SHARING |
1328                         FSF_FEATURE_NOTIFICATION_LOST |
1329                         FSF_FEATURE_UPDATE_ALERT;
1330
1331         if (data)
1332                 req->data = data;
1333
1334         zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1335         retval = zfcp_fsf_req_send(req);
1336 out:
1337         spin_unlock(&adapter->req_q.lock);
1338         if (!retval)
1339                 wait_event(req->completion_wq,
1340                            req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
1341
1342         zfcp_fsf_req_free(req);
1343
1344         return retval;
1345 }
1346
1347 /**
1348  * zfcp_fsf_exchange_port_data - request information about local port
1349  * @erp_action: ERP action for the adapter for which port data is requested
1350  * Returns: 0 on success, error otherwise
1351  */
1352 int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action)
1353 {
1354         volatile struct qdio_buffer_element *sbale;
1355         struct zfcp_fsf_req *req;
1356         struct zfcp_adapter *adapter = erp_action->adapter;
1357         int retval = -EIO;
1358
1359         if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
1360                 return -EOPNOTSUPP;
1361
1362         spin_lock(&adapter->req_q.lock);
1363         if (!atomic_read(&adapter->req_q.count))
1364                 goto out;
1365         req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA,
1366                                   ZFCP_REQ_AUTO_CLEANUP,
1367                                   adapter->pool.fsf_req_erp);
1368         if (unlikely(IS_ERR(req))) {
1369                 retval = PTR_ERR(req);
1370                 goto out;
1371         }
1372
1373         sbale = zfcp_qdio_sbale_req(req);
1374         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1375         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1376
1377         req->handler = zfcp_fsf_exchange_port_data_handler;
1378         req->erp_action = erp_action;
1379         erp_action->fsf_req = req;
1380
1381         zfcp_fsf_start_erp_timer(req);
1382         retval = zfcp_fsf_req_send(req);
1383         if (retval) {
1384                 zfcp_fsf_req_free(req);
1385                 erp_action->fsf_req = NULL;
1386         }
1387 out:
1388         spin_unlock(&adapter->req_q.lock);
1389         return retval;
1390 }
1391
1392 /**
1393  * zfcp_fsf_exchange_port_data_sync - request information about local port
1394  * @adapter: pointer to struct zfcp_adapter
1395  * @data: pointer to struct fsf_qtcb_bottom_port
1396  * Returns: 0 on success, error otherwise
1397  */
1398 int zfcp_fsf_exchange_port_data_sync(struct zfcp_adapter *adapter,
1399                                      struct fsf_qtcb_bottom_port *data)
1400 {
1401         volatile struct qdio_buffer_element *sbale;
1402         struct zfcp_fsf_req *req = NULL;
1403         int retval = -EIO;
1404
1405         if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
1406                 return -EOPNOTSUPP;
1407
1408         spin_lock(&adapter->req_q.lock);
1409         if (!atomic_read(&adapter->req_q.count))
1410                 goto out;
1411
1412         req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA, 0,
1413                                   NULL);
1414         if (unlikely(IS_ERR(req))) {
1415                 retval = PTR_ERR(req);
1416                 goto out;
1417         }
1418
1419         if (data)
1420                 req->data = data;
1421
1422         sbale = zfcp_qdio_sbale_req(req);
1423         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1424         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1425
1426         req->handler = zfcp_fsf_exchange_port_data_handler;
1427         zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1428         retval = zfcp_fsf_req_send(req);
1429 out:
1430         spin_unlock(&adapter->req_q.lock);
1431         if (!retval)
1432                 wait_event(req->completion_wq,
1433                            req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
1434         zfcp_fsf_req_free(req);
1435
1436         return retval;
1437 }
1438
1439 static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req)
1440 {
1441         struct zfcp_port *port = req->data;
1442         struct fsf_qtcb_header *header = &req->qtcb->header;
1443         struct fsf_plogi *plogi;
1444
1445         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1446                 goto skip_fsfstatus;
1447
1448         switch (header->fsf_status) {
1449         case FSF_PORT_ALREADY_OPEN:
1450                 break;
1451         case FSF_ACCESS_DENIED:
1452                 zfcp_fsf_access_denied_port(req, port);
1453                 break;
1454         case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
1455                 dev_warn(&req->adapter->ccw_device->dev,
1456                          "The adapter is out of resources. The remote port "
1457                          "0x%016Lx could not be opened, disabling it.\n",
1458                          port->wwpn);
1459                 zfcp_erp_port_failed(port, 31, req);
1460                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1461                 break;
1462         case FSF_ADAPTER_STATUS_AVAILABLE:
1463                 switch (header->fsf_status_qual.word[0]) {
1464                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1465                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1466                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1467                         break;
1468                 case FSF_SQ_NO_RETRY_POSSIBLE:
1469                         dev_warn(&req->adapter->ccw_device->dev,
1470                                  "The remote port 0x%016Lx could not be "
1471                                  "opened. Disabling it.\n", port->wwpn);
1472                         zfcp_erp_port_failed(port, 32, req);
1473                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1474                         break;
1475                 }
1476                 break;
1477         case FSF_GOOD:
1478                 port->handle = header->port_handle;
1479                 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN |
1480                                 ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
1481                 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
1482                                   ZFCP_STATUS_COMMON_ACCESS_BOXED,
1483                                   &port->status);
1484                 /* check whether D_ID has changed during open */
1485                 /*
1486                  * FIXME: This check is not airtight, as the FCP channel does
1487                  * not monitor closures of target port connections caused on
1488                  * the remote side. Thus, they might miss out on invalidating
1489                  * locally cached WWPNs (and other N_Port parameters) of gone
1490                  * target ports. So, our heroic attempt to make things safe
1491                  * could be undermined by 'open port' response data tagged with
1492                  * obsolete WWPNs. Another reason to monitor potential
1493                  * connection closures ourself at least (by interpreting
1494                  * incoming ELS' and unsolicited status). It just crosses my
1495                  * mind that one should be able to cross-check by means of
1496                  * another GID_PN straight after a port has been opened.
1497                  * Alternately, an ADISC/PDISC ELS should suffice, as well.
1498                  */
1499                 if (atomic_read(&port->status) & ZFCP_STATUS_PORT_NO_WWPN)
1500                         break;
1501
1502                 plogi = (struct fsf_plogi *) req->qtcb->bottom.support.els;
1503                 if (req->qtcb->bottom.support.els1_length >= sizeof(*plogi)) {
1504                         if (plogi->serv_param.wwpn != port->wwpn)
1505                                 atomic_clear_mask(ZFCP_STATUS_PORT_DID_DID,
1506                                                   &port->status);
1507                         else {
1508                                 port->wwnn = plogi->serv_param.wwnn;
1509                                 zfcp_fc_plogi_evaluate(port, plogi);
1510                         }
1511                 }
1512                 break;
1513         case FSF_UNKNOWN_OP_SUBTYPE:
1514                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1515                 break;
1516         }
1517
1518 skip_fsfstatus:
1519         atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, &port->status);
1520 }
1521
1522 /**
1523  * zfcp_fsf_open_port - create and send open port request
1524  * @erp_action: pointer to struct zfcp_erp_action
1525  * Returns: 0 on success, error otherwise
1526  */
1527 int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
1528 {
1529         volatile struct qdio_buffer_element *sbale;
1530         struct zfcp_adapter *adapter = erp_action->adapter;
1531         struct zfcp_fsf_req *req;
1532         int retval = -EIO;
1533
1534         spin_lock(&adapter->req_q.lock);
1535         if (zfcp_fsf_req_sbal_get(adapter))
1536                 goto out;
1537
1538         req = zfcp_fsf_req_create(adapter,
1539                                   FSF_QTCB_OPEN_PORT_WITH_DID,
1540                                   ZFCP_REQ_AUTO_CLEANUP,
1541                                   adapter->pool.fsf_req_erp);
1542         if (unlikely(IS_ERR(req))) {
1543                 retval = PTR_ERR(req);
1544                 goto out;
1545         }
1546
1547         sbale = zfcp_qdio_sbale_req(req);
1548         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1549         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1550
1551         req->handler = zfcp_fsf_open_port_handler;
1552         req->qtcb->bottom.support.d_id = erp_action->port->d_id;
1553         req->data = erp_action->port;
1554         req->erp_action = erp_action;
1555         erp_action->fsf_req = req;
1556         atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->port->status);
1557
1558         zfcp_fsf_start_erp_timer(req);
1559         retval = zfcp_fsf_req_send(req);
1560         if (retval) {
1561                 zfcp_fsf_req_free(req);
1562                 erp_action->fsf_req = NULL;
1563         }
1564 out:
1565         spin_unlock(&adapter->req_q.lock);
1566         return retval;
1567 }
1568
1569 static void zfcp_fsf_close_port_handler(struct zfcp_fsf_req *req)
1570 {
1571         struct zfcp_port *port = req->data;
1572
1573         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1574                 goto skip_fsfstatus;
1575
1576         switch (req->qtcb->header.fsf_status) {
1577         case FSF_PORT_HANDLE_NOT_VALID:
1578                 zfcp_erp_adapter_reopen(port->adapter, 0, 107, req);
1579                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1580                 break;
1581         case FSF_ADAPTER_STATUS_AVAILABLE:
1582                 break;
1583         case FSF_GOOD:
1584                 zfcp_erp_modify_port_status(port, 33, req,
1585                                             ZFCP_STATUS_COMMON_OPEN,
1586                                             ZFCP_CLEAR);
1587                 break;
1588         }
1589
1590 skip_fsfstatus:
1591         atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, &port->status);
1592 }
1593
1594 /**
1595  * zfcp_fsf_close_port - create and send close port request
1596  * @erp_action: pointer to struct zfcp_erp_action
1597  * Returns: 0 on success, error otherwise
1598  */
1599 int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
1600 {
1601         volatile struct qdio_buffer_element *sbale;
1602         struct zfcp_adapter *adapter = erp_action->adapter;
1603         struct zfcp_fsf_req *req;
1604         int retval = -EIO;
1605
1606         spin_lock(&adapter->req_q.lock);
1607         if (zfcp_fsf_req_sbal_get(adapter))
1608                 goto out;
1609
1610         req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_PORT,
1611                                   ZFCP_REQ_AUTO_CLEANUP,
1612                                   adapter->pool.fsf_req_erp);
1613         if (unlikely(IS_ERR(req))) {
1614                 retval = PTR_ERR(req);
1615                 goto out;
1616         }
1617
1618         sbale = zfcp_qdio_sbale_req(req);
1619         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1620         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1621
1622         req->handler = zfcp_fsf_close_port_handler;
1623         req->data = erp_action->port;
1624         req->erp_action = erp_action;
1625         req->qtcb->header.port_handle = erp_action->port->handle;
1626         erp_action->fsf_req = req;
1627         atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->port->status);
1628
1629         zfcp_fsf_start_erp_timer(req);
1630         retval = zfcp_fsf_req_send(req);
1631         if (retval) {
1632                 zfcp_fsf_req_free(req);
1633                 erp_action->fsf_req = NULL;
1634         }
1635 out:
1636         spin_unlock(&adapter->req_q.lock);
1637         return retval;
1638 }
1639
1640 static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
1641 {
1642         struct zfcp_port *port = req->data;
1643         struct fsf_qtcb_header *header = &req->qtcb->header;
1644         struct zfcp_unit *unit;
1645
1646         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1647                 goto skip_fsfstatus;
1648
1649         switch (header->fsf_status) {
1650         case FSF_PORT_HANDLE_NOT_VALID:
1651                 zfcp_erp_adapter_reopen(port->adapter, 0, 108, req);
1652                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1653                 break;
1654         case FSF_ACCESS_DENIED:
1655                 zfcp_fsf_access_denied_port(req, port);
1656                 break;
1657         case FSF_PORT_BOXED:
1658                 zfcp_erp_port_boxed(port, 50, req);
1659                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
1660                                ZFCP_STATUS_FSFREQ_RETRY;
1661                 /* can't use generic zfcp_erp_modify_port_status because
1662                  * ZFCP_STATUS_COMMON_OPEN must not be reset for the port */
1663                 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
1664                 list_for_each_entry(unit, &port->unit_list_head, list)
1665                         atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
1666                                           &unit->status);
1667                 break;
1668         case FSF_ADAPTER_STATUS_AVAILABLE:
1669                 switch (header->fsf_status_qual.word[0]) {
1670                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1671                         /* fall through */
1672                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1673                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1674                         break;
1675                 }
1676                 break;
1677         case FSF_GOOD:
1678                 /* can't use generic zfcp_erp_modify_port_status because
1679                  * ZFCP_STATUS_COMMON_OPEN must not be reset for the port
1680                  */
1681                 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
1682                 list_for_each_entry(unit, &port->unit_list_head, list)
1683                         atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
1684                                           &unit->status);
1685                 break;
1686         }
1687 skip_fsfstatus:
1688         atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_CLOSING, &port->status);
1689 }
1690
1691 /**
1692  * zfcp_fsf_close_physical_port - close physical port
1693  * @erp_action: pointer to struct zfcp_erp_action
1694  * Returns: 0 on success
1695  */
1696 int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
1697 {
1698         volatile struct qdio_buffer_element *sbale;
1699         struct zfcp_adapter *adapter = erp_action->adapter;
1700         struct zfcp_fsf_req *req;
1701         int retval = -EIO;
1702
1703         spin_lock(&adapter->req_q.lock);
1704         if (zfcp_fsf_req_sbal_get(adapter))
1705                 goto out;
1706
1707         req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_PHYSICAL_PORT,
1708                                   ZFCP_REQ_AUTO_CLEANUP,
1709                                   adapter->pool.fsf_req_erp);
1710         if (unlikely(IS_ERR(req))) {
1711                 retval = PTR_ERR(req);
1712                 goto out;
1713         }
1714
1715         sbale = zfcp_qdio_sbale_req(req);
1716         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1717         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1718
1719         req->data = erp_action->port;
1720         req->qtcb->header.port_handle = erp_action->port->handle;
1721         req->erp_action = erp_action;
1722         req->handler = zfcp_fsf_close_physical_port_handler;
1723         erp_action->fsf_req = req;
1724         atomic_set_mask(ZFCP_STATUS_PORT_PHYS_CLOSING,
1725                         &erp_action->port->status);
1726
1727         zfcp_fsf_start_erp_timer(req);
1728         retval = zfcp_fsf_req_send(req);
1729         if (retval) {
1730                 zfcp_fsf_req_free(req);
1731                 erp_action->fsf_req = NULL;
1732         }
1733 out:
1734         spin_unlock(&adapter->req_q.lock);
1735         return retval;
1736 }
1737
1738 static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
1739 {
1740         struct zfcp_adapter *adapter = req->adapter;
1741         struct zfcp_unit *unit = req->data;
1742         struct fsf_qtcb_header *header = &req->qtcb->header;
1743         struct fsf_qtcb_bottom_support *bottom = &req->qtcb->bottom.support;
1744         struct fsf_queue_designator *queue_designator =
1745                                 &header->fsf_status_qual.fsf_queue_designator;
1746         int exclusive, readwrite;
1747
1748         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1749                 goto skip_fsfstatus;
1750
1751         atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
1752                           ZFCP_STATUS_COMMON_ACCESS_BOXED |
1753                           ZFCP_STATUS_UNIT_SHARED |
1754                           ZFCP_STATUS_UNIT_READONLY,
1755                           &unit->status);
1756
1757         switch (header->fsf_status) {
1758
1759         case FSF_PORT_HANDLE_NOT_VALID:
1760                 zfcp_erp_adapter_reopen(unit->port->adapter, 0, 109, req);
1761                 /* fall through */
1762         case FSF_LUN_ALREADY_OPEN:
1763                 break;
1764         case FSF_ACCESS_DENIED:
1765                 zfcp_fsf_access_denied_unit(req, unit);
1766                 atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
1767                 atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
1768                 break;
1769         case FSF_PORT_BOXED:
1770                 zfcp_erp_port_boxed(unit->port, 51, req);
1771                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
1772                                ZFCP_STATUS_FSFREQ_RETRY;
1773                 break;
1774         case FSF_LUN_SHARING_VIOLATION:
1775                 if (header->fsf_status_qual.word[0])
1776                         dev_warn(&adapter->ccw_device->dev,
1777                                  "FCP-LUN 0x%Lx at the remote port "
1778                                  "with WWPN 0x%Lx "
1779                                  "connected to the adapter "
1780                                  "is already in use in LPAR%d, CSS%d.\n",
1781                                  unit->fcp_lun,
1782                                  unit->port->wwpn,
1783                                  queue_designator->hla,
1784                                  queue_designator->cssid);
1785                 else
1786                         zfcp_act_eval_err(adapter,
1787                                           header->fsf_status_qual.word[2]);
1788                 zfcp_erp_unit_access_denied(unit, 60, req);
1789                 atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
1790                 atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
1791                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1792                 break;
1793         case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED:
1794                 dev_warn(&adapter->ccw_device->dev,
1795                          "The adapter ran out of resources. There is no "
1796                          "handle available for unit 0x%016Lx on port 0x%016Lx.",
1797                          unit->fcp_lun, unit->port->wwpn);
1798                 zfcp_erp_unit_failed(unit, 34, req);
1799                 /* fall through */
1800         case FSF_INVALID_COMMAND_OPTION:
1801                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1802                 break;
1803         case FSF_ADAPTER_STATUS_AVAILABLE:
1804                 switch (header->fsf_status_qual.word[0]) {
1805                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1806                         zfcp_test_link(unit->port);
1807                         /* fall through */
1808                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1809                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1810                         break;
1811                 }
1812                 break;
1813
1814         case FSF_GOOD:
1815                 unit->handle = header->lun_handle;
1816                 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
1817
1818                 if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE) &&
1819                     (adapter->adapter_features & FSF_FEATURE_LUN_SHARING) &&
1820                     (adapter->ccw_device->id.dev_model != ZFCP_DEVICE_MODEL_PRIV)) {
1821                         exclusive = (bottom->lun_access_info &
1822                                         FSF_UNIT_ACCESS_EXCLUSIVE);
1823                         readwrite = (bottom->lun_access_info &
1824                                         FSF_UNIT_ACCESS_OUTBOUND_TRANSFER);
1825
1826                         if (!exclusive)
1827                                 atomic_set_mask(ZFCP_STATUS_UNIT_SHARED,
1828                                                 &unit->status);
1829
1830                         if (!readwrite) {
1831                                 atomic_set_mask(ZFCP_STATUS_UNIT_READONLY,
1832                                                 &unit->status);
1833                                 dev_info(&adapter->ccw_device->dev,
1834                                          "Read-only access for unit 0x%016Lx "
1835                                          "on port 0x%016Lx.\n",
1836                                          unit->fcp_lun, unit->port->wwpn);
1837                         }
1838
1839                         if (exclusive && !readwrite) {
1840                                 dev_err(&adapter->ccw_device->dev,
1841                                         "Exclusive access of read-only unit "
1842                                         "0x%016Lx on port 0x%016Lx not "
1843                                         "supported, disabling unit.\n",
1844                                         unit->fcp_lun, unit->port->wwpn);
1845                                 zfcp_erp_unit_failed(unit, 35, req);
1846                                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1847                                 zfcp_erp_unit_shutdown(unit, 0, 80, req);
1848                         } else if (!exclusive && readwrite) {
1849                                 dev_err(&adapter->ccw_device->dev,
1850                                         "Shared access of read-write unit "
1851                                         "0x%016Lx on port 0x%016Lx not "
1852                                         "supported, disabling unit.\n",
1853                                         unit->fcp_lun, unit->port->wwpn);
1854                                 zfcp_erp_unit_failed(unit, 36, req);
1855                                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1856                                 zfcp_erp_unit_shutdown(unit, 0, 81, req);
1857                         }
1858                 }
1859                 break;
1860         }
1861
1862 skip_fsfstatus:
1863         atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, &unit->status);
1864 }
1865
1866 /**
1867  * zfcp_fsf_open_unit - open unit
1868  * @erp_action: pointer to struct zfcp_erp_action
1869  * Returns: 0 on success, error otherwise
1870  */
1871 int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
1872 {
1873         volatile struct qdio_buffer_element *sbale;
1874         struct zfcp_adapter *adapter = erp_action->adapter;
1875         struct zfcp_fsf_req *req;
1876         int retval = -EIO;
1877
1878         spin_lock(&adapter->req_q.lock);
1879         if (zfcp_fsf_req_sbal_get(adapter))
1880                 goto out;
1881
1882         req = zfcp_fsf_req_create(adapter, FSF_QTCB_OPEN_LUN,
1883                                   ZFCP_REQ_AUTO_CLEANUP,
1884                                   adapter->pool.fsf_req_erp);
1885         if (unlikely(IS_ERR(req))) {
1886                 retval = PTR_ERR(req);
1887                 goto out;
1888         }
1889
1890         sbale = zfcp_qdio_sbale_req(req);
1891         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1892         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1893
1894         req->qtcb->header.port_handle = erp_action->port->handle;
1895         req->qtcb->bottom.support.fcp_lun = erp_action->unit->fcp_lun;
1896         req->handler = zfcp_fsf_open_unit_handler;
1897         req->data = erp_action->unit;
1898         req->erp_action = erp_action;
1899         erp_action->fsf_req = req;
1900
1901         if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE))
1902                 req->qtcb->bottom.support.option = FSF_OPEN_LUN_SUPPRESS_BOXING;
1903
1904         atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->unit->status);
1905
1906         zfcp_fsf_start_erp_timer(req);
1907         retval = zfcp_fsf_req_send(req);
1908         if (retval) {
1909                 zfcp_fsf_req_free(req);
1910                 erp_action->fsf_req = NULL;
1911         }
1912 out:
1913         spin_unlock(&adapter->req_q.lock);
1914         return retval;
1915 }
1916
1917 static void zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *req)
1918 {
1919         struct zfcp_unit *unit = req->data;
1920
1921         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1922                 goto skip_fsfstatus;
1923
1924         switch (req->qtcb->header.fsf_status) {
1925         case FSF_PORT_HANDLE_NOT_VALID:
1926                 zfcp_erp_adapter_reopen(unit->port->adapter, 0, 110, req);
1927                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1928                 break;
1929         case FSF_LUN_HANDLE_NOT_VALID:
1930                 zfcp_erp_port_reopen(unit->port, 0, 111, req);
1931                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1932                 break;
1933         case FSF_PORT_BOXED:
1934                 zfcp_erp_port_boxed(unit->port, 52, req);
1935                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
1936                                ZFCP_STATUS_FSFREQ_RETRY;
1937                 break;
1938         case FSF_ADAPTER_STATUS_AVAILABLE:
1939                 switch (req->qtcb->header.fsf_status_qual.word[0]) {
1940                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1941                         zfcp_test_link(unit->port);
1942                         /* fall through */
1943                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1944                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1945                         break;
1946                 }
1947                 break;
1948         case FSF_GOOD:
1949                 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
1950                 break;
1951         }
1952 skip_fsfstatus:
1953         atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, &unit->status);
1954 }
1955
1956 /**
1957  * zfcp_fsf_close_unit - close zfcp unit
1958  * @erp_action: pointer to struct zfcp_unit
1959  * Returns: 0 on success, error otherwise
1960  */
1961 int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
1962 {
1963         volatile struct qdio_buffer_element *sbale;
1964         struct zfcp_adapter *adapter = erp_action->adapter;
1965         struct zfcp_fsf_req *req;
1966         int retval = -EIO;
1967
1968         spin_lock(&adapter->req_q.lock);
1969         if (zfcp_fsf_req_sbal_get(adapter))
1970                 goto out;
1971         req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_LUN,
1972                                   ZFCP_REQ_AUTO_CLEANUP,
1973                                   adapter->pool.fsf_req_erp);
1974         if (unlikely(IS_ERR(req))) {
1975                 retval = PTR_ERR(req);
1976                 goto out;
1977         }
1978
1979         sbale = zfcp_qdio_sbale_req(req);
1980         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1981         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1982
1983         req->qtcb->header.port_handle = erp_action->port->handle;
1984         req->qtcb->header.lun_handle = erp_action->unit->handle;
1985         req->handler = zfcp_fsf_close_unit_handler;
1986         req->data = erp_action->unit;
1987         req->erp_action = erp_action;
1988         erp_action->fsf_req = req;
1989         atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->unit->status);
1990
1991         zfcp_fsf_start_erp_timer(req);
1992         retval = zfcp_fsf_req_send(req);
1993         if (retval) {
1994                 zfcp_fsf_req_free(req);
1995                 erp_action->fsf_req = NULL;
1996         }
1997 out:
1998         spin_unlock(&adapter->req_q.lock);
1999         return retval;
2000 }
2001
2002 static void zfcp_fsf_update_lat(struct fsf_latency_record *lat_rec, u32 lat)
2003 {
2004         lat_rec->sum += lat;
2005         lat_rec->min = min(lat_rec->min, lat);
2006         lat_rec->max = max(lat_rec->max, lat);
2007 }
2008
2009 static void zfcp_fsf_req_latency(struct zfcp_fsf_req *req)
2010 {
2011         struct fsf_qual_latency_info *lat_inf;
2012         struct latency_cont *lat;
2013         struct zfcp_unit *unit = req->unit;
2014         unsigned long flags;
2015
2016         lat_inf = &req->qtcb->prefix.prot_status_qual.latency_info;
2017
2018         switch (req->qtcb->bottom.io.data_direction) {
2019         case FSF_DATADIR_READ:
2020                 lat = &unit->latencies.read;
2021                 break;
2022         case FSF_DATADIR_WRITE:
2023                 lat = &unit->latencies.write;
2024                 break;
2025         case FSF_DATADIR_CMND:
2026                 lat = &unit->latencies.cmd;
2027                 break;
2028         default:
2029                 return;
2030         }
2031
2032         spin_lock_irqsave(&unit->latencies.lock, flags);
2033         zfcp_fsf_update_lat(&lat->channel, lat_inf->channel_lat);
2034         zfcp_fsf_update_lat(&lat->fabric, lat_inf->fabric_lat);
2035         lat->counter++;
2036         spin_unlock_irqrestore(&unit->latencies.lock, flags);
2037 }
2038
2039 static void zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *req)
2040 {
2041         struct scsi_cmnd *scpnt = req->data;
2042         struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *)
2043             &(req->qtcb->bottom.io.fcp_rsp);
2044         u32 sns_len;
2045         char *fcp_rsp_info = (unsigned char *) &fcp_rsp_iu[1];
2046         unsigned long flags;
2047
2048         if (unlikely(!scpnt))
2049                 return;
2050
2051         read_lock_irqsave(&req->adapter->abort_lock, flags);
2052
2053         if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ABORTED)) {
2054                 set_host_byte(scpnt, DID_SOFT_ERROR);
2055                 set_driver_byte(scpnt, SUGGEST_RETRY);
2056                 goto skip_fsfstatus;
2057         }
2058
2059         if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
2060                 set_host_byte(scpnt, DID_ERROR);
2061                 goto skip_fsfstatus;
2062         }
2063
2064         set_msg_byte(scpnt, COMMAND_COMPLETE);
2065
2066         scpnt->result |= fcp_rsp_iu->scsi_status;
2067
2068         if (req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA)
2069                 zfcp_fsf_req_latency(req);
2070
2071         if (unlikely(fcp_rsp_iu->validity.bits.fcp_rsp_len_valid)) {
2072                 if (fcp_rsp_info[3] == RSP_CODE_GOOD)
2073                         set_host_byte(scpnt, DID_OK);
2074                 else {
2075                         set_host_byte(scpnt, DID_ERROR);
2076                         goto skip_fsfstatus;
2077                 }
2078         }
2079
2080         if (unlikely(fcp_rsp_iu->validity.bits.fcp_sns_len_valid)) {
2081                 sns_len = FSF_FCP_RSP_SIZE - sizeof(struct fcp_rsp_iu) +
2082                           fcp_rsp_iu->fcp_rsp_len;
2083                 sns_len = min(sns_len, (u32) SCSI_SENSE_BUFFERSIZE);
2084                 sns_len = min(sns_len, fcp_rsp_iu->fcp_sns_len);
2085
2086                 memcpy(scpnt->sense_buffer,
2087                        zfcp_get_fcp_sns_info_ptr(fcp_rsp_iu), sns_len);
2088         }
2089
2090         if (unlikely(fcp_rsp_iu->validity.bits.fcp_resid_under)) {
2091                 scsi_set_resid(scpnt, fcp_rsp_iu->fcp_resid);
2092                 if (scsi_bufflen(scpnt) - scsi_get_resid(scpnt) <
2093                     scpnt->underflow)
2094                         set_host_byte(scpnt, DID_ERROR);
2095         }
2096 skip_fsfstatus:
2097         if (scpnt->result != 0)
2098                 zfcp_scsi_dbf_event_result("erro", 3, req->adapter, scpnt, req);
2099         else if (scpnt->retries > 0)
2100                 zfcp_scsi_dbf_event_result("retr", 4, req->adapter, scpnt, req);
2101         else
2102                 zfcp_scsi_dbf_event_result("norm", 6, req->adapter, scpnt, req);
2103
2104         scpnt->host_scribble = NULL;
2105         (scpnt->scsi_done) (scpnt);
2106         /*
2107          * We must hold this lock until scsi_done has been called.
2108          * Otherwise we may call scsi_done after abort regarding this
2109          * command has completed.
2110          * Note: scsi_done must not block!
2111          */
2112         read_unlock_irqrestore(&req->adapter->abort_lock, flags);
2113 }
2114
2115 static void zfcp_fsf_send_fcp_ctm_handler(struct zfcp_fsf_req *req)
2116 {
2117         struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *)
2118             &(req->qtcb->bottom.io.fcp_rsp);
2119         char *fcp_rsp_info = (unsigned char *) &fcp_rsp_iu[1];
2120
2121         if ((fcp_rsp_info[3] != RSP_CODE_GOOD) ||
2122              (req->status & ZFCP_STATUS_FSFREQ_ERROR))
2123                 req->status |= ZFCP_STATUS_FSFREQ_TMFUNCFAILED;
2124 }
2125
2126
2127 static void zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *req)
2128 {
2129         struct zfcp_unit *unit;
2130         struct fsf_qtcb_header *header = &req->qtcb->header;
2131
2132         if (unlikely(req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT))
2133                 unit = req->data;
2134         else
2135                 unit = req->unit;
2136
2137         if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
2138                 goto skip_fsfstatus;
2139
2140         switch (header->fsf_status) {
2141         case FSF_HANDLE_MISMATCH:
2142         case FSF_PORT_HANDLE_NOT_VALID:
2143                 zfcp_erp_adapter_reopen(unit->port->adapter, 0, 112, req);
2144                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2145                 break;
2146         case FSF_FCPLUN_NOT_VALID:
2147         case FSF_LUN_HANDLE_NOT_VALID:
2148                 zfcp_erp_port_reopen(unit->port, 0, 113, req);
2149                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2150                 break;
2151         case FSF_SERVICE_CLASS_NOT_SUPPORTED:
2152                 zfcp_fsf_class_not_supp(req);
2153                 break;
2154         case FSF_ACCESS_DENIED:
2155                 zfcp_fsf_access_denied_unit(req, unit);
2156                 break;
2157         case FSF_DIRECTION_INDICATOR_NOT_VALID:
2158                 dev_err(&req->adapter->ccw_device->dev,
2159                         "Invalid data direction (%d) given for unit "
2160                         "0x%016Lx on port 0x%016Lx, shutting down "
2161                         "adapter.\n",
2162                         req->qtcb->bottom.io.data_direction,
2163                         unit->fcp_lun, unit->port->wwpn);
2164                 zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 133, req);
2165                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2166                 break;
2167         case FSF_CMND_LENGTH_NOT_VALID:
2168                 dev_err(&req->adapter->ccw_device->dev,
2169                         "An invalid control-data-block length field (%d) "
2170                         "was found in a command for unit 0x%016Lx on port "
2171                         "0x%016Lx. Shutting down adapter.\n",
2172                         req->qtcb->bottom.io.fcp_cmnd_length,
2173                         unit->fcp_lun, unit->port->wwpn);
2174                 zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 134, req);
2175                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2176                 break;
2177         case FSF_PORT_BOXED:
2178                 zfcp_erp_port_boxed(unit->port, 53, req);
2179                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
2180                                ZFCP_STATUS_FSFREQ_RETRY;
2181                 break;
2182         case FSF_LUN_BOXED:
2183                 zfcp_erp_unit_boxed(unit, 54, req);
2184                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
2185                                ZFCP_STATUS_FSFREQ_RETRY;
2186                 break;
2187         case FSF_ADAPTER_STATUS_AVAILABLE:
2188                 if (header->fsf_status_qual.word[0] ==
2189                     FSF_SQ_INVOKE_LINK_TEST_PROCEDURE)
2190                         zfcp_test_link(unit->port);
2191                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2192                 break;
2193         }
2194 skip_fsfstatus:
2195         if (req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)
2196                 zfcp_fsf_send_fcp_ctm_handler(req);
2197         else {
2198                 zfcp_fsf_send_fcp_command_task_handler(req);
2199                 req->unit = NULL;
2200                 zfcp_unit_put(unit);
2201         }
2202 }
2203
2204 /**
2205  * zfcp_fsf_send_fcp_command_task - initiate an FCP command (for a SCSI command)
2206  * @adapter: adapter where scsi command is issued
2207  * @unit: unit where command is sent to
2208  * @scsi_cmnd: scsi command to be sent
2209  * @timer: timer to be started when request is initiated
2210  * @req_flags: flags for fsf_request
2211  */
2212 int zfcp_fsf_send_fcp_command_task(struct zfcp_adapter *adapter,
2213                                    struct zfcp_unit *unit,
2214                                    struct scsi_cmnd *scsi_cmnd,
2215                                    int use_timer, int req_flags)
2216 {
2217         struct zfcp_fsf_req *req;
2218         struct fcp_cmnd_iu *fcp_cmnd_iu;
2219         unsigned int sbtype;
2220         int real_bytes, retval = -EIO;
2221
2222         if (unlikely(!(atomic_read(&unit->status) &
2223                        ZFCP_STATUS_COMMON_UNBLOCKED)))
2224                 return -EBUSY;
2225
2226         spin_lock(&adapter->req_q.lock);
2227         if (!atomic_read(&adapter->req_q.count))
2228                 goto out;
2229         req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, req_flags,
2230                                   adapter->pool.fsf_req_scsi);
2231         if (unlikely(IS_ERR(req))) {
2232                 retval = PTR_ERR(req);
2233                 goto out;
2234         }
2235
2236         zfcp_unit_get(unit);
2237         req->unit = unit;
2238         req->data = scsi_cmnd;
2239         req->handler = zfcp_fsf_send_fcp_command_handler;
2240         req->qtcb->header.lun_handle = unit->handle;
2241         req->qtcb->header.port_handle = unit->port->handle;
2242         req->qtcb->bottom.io.service_class = FSF_CLASS_3;
2243
2244         scsi_cmnd->host_scribble = (unsigned char *) req->req_id;
2245
2246         fcp_cmnd_iu = (struct fcp_cmnd_iu *) &(req->qtcb->bottom.io.fcp_cmnd);
2247         fcp_cmnd_iu->fcp_lun = unit->fcp_lun;
2248         /*
2249          * set depending on data direction:
2250          *      data direction bits in SBALE (SB Type)
2251          *      data direction bits in QTCB
2252          *      data direction bits in FCP_CMND IU
2253          */
2254         switch (scsi_cmnd->sc_data_direction) {
2255         case DMA_NONE:
2256                 req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
2257                 sbtype = SBAL_FLAGS0_TYPE_READ;
2258                 break;
2259         case DMA_FROM_DEVICE:
2260                 req->qtcb->bottom.io.data_direction = FSF_DATADIR_READ;
2261                 sbtype = SBAL_FLAGS0_TYPE_READ;
2262                 fcp_cmnd_iu->rddata = 1;
2263                 break;
2264         case DMA_TO_DEVICE:
2265                 req->qtcb->bottom.io.data_direction = FSF_DATADIR_WRITE;
2266                 sbtype = SBAL_FLAGS0_TYPE_WRITE;
2267                 fcp_cmnd_iu->wddata = 1;
2268                 break;
2269         case DMA_BIDIRECTIONAL:
2270         default:
2271                 retval = -EIO;
2272                 goto failed_scsi_cmnd;
2273         }
2274
2275         if (likely((scsi_cmnd->device->simple_tags) ||
2276                    ((atomic_read(&unit->status) & ZFCP_STATUS_UNIT_READONLY) &&
2277                     (atomic_read(&unit->status) & ZFCP_STATUS_UNIT_SHARED))))
2278                 fcp_cmnd_iu->task_attribute = SIMPLE_Q;
2279         else
2280                 fcp_cmnd_iu->task_attribute = UNTAGGED;
2281
2282         if (unlikely(scsi_cmnd->cmd_len > FCP_CDB_LENGTH))
2283                 fcp_cmnd_iu->add_fcp_cdb_length =
2284                         (scsi_cmnd->cmd_len - FCP_CDB_LENGTH) >> 2;
2285
2286         memcpy(fcp_cmnd_iu->fcp_cdb, scsi_cmnd->cmnd, scsi_cmnd->cmd_len);
2287
2288         req->qtcb->bottom.io.fcp_cmnd_length = sizeof(struct fcp_cmnd_iu) +
2289                 fcp_cmnd_iu->add_fcp_cdb_length + sizeof(fcp_dl_t);
2290
2291         real_bytes = zfcp_qdio_sbals_from_sg(req, sbtype,
2292                                              scsi_sglist(scsi_cmnd),
2293                                              FSF_MAX_SBALS_PER_REQ);
2294         if (unlikely(real_bytes < 0)) {
2295                 if (req->sbal_number < FSF_MAX_SBALS_PER_REQ)
2296                         retval = -EIO;
2297                 else {
2298                         dev_err(&adapter->ccw_device->dev,
2299                                 "SCSI request too large. "
2300                                 "Shutting down unit 0x%016Lx on port "
2301                                 "0x%016Lx.\n", unit->fcp_lun,
2302                                 unit->port->wwpn);
2303                         zfcp_erp_unit_shutdown(unit, 0, 131, req);
2304                         retval = -EINVAL;
2305                 }
2306                 goto failed_scsi_cmnd;
2307         }
2308
2309         zfcp_set_fcp_dl(fcp_cmnd_iu, real_bytes);
2310
2311         if (use_timer)
2312                 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
2313
2314         retval = zfcp_fsf_req_send(req);
2315         if (unlikely(retval))
2316                 goto failed_scsi_cmnd;
2317
2318         goto out;
2319
2320 failed_scsi_cmnd:
2321         zfcp_unit_put(unit);
2322         zfcp_fsf_req_free(req);
2323         scsi_cmnd->host_scribble = NULL;
2324 out:
2325         spin_unlock(&adapter->req_q.lock);
2326         return retval;
2327 }
2328
2329 /**
2330  * zfcp_fsf_send_fcp_ctm - send SCSI task management command
2331  * @adapter: pointer to struct zfcp-adapter
2332  * @unit: pointer to struct zfcp_unit
2333  * @tm_flags: unsigned byte for task management flags
2334  * @req_flags: int request flags
2335  * Returns: on success pointer to struct fsf_req, NULL otherwise
2336  */
2337 struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_adapter *adapter,
2338                                            struct zfcp_unit *unit,
2339                                            u8 tm_flags, int req_flags)
2340 {
2341         volatile struct qdio_buffer_element *sbale;
2342         struct zfcp_fsf_req *req = NULL;
2343         struct fcp_cmnd_iu *fcp_cmnd_iu;
2344
2345         if (unlikely(!(atomic_read(&unit->status) &
2346                        ZFCP_STATUS_COMMON_UNBLOCKED)))
2347                 return NULL;
2348
2349         spin_lock(&adapter->req_q.lock);
2350         if (!atomic_read(&adapter->req_q.count))
2351                 goto out;
2352         req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, req_flags,
2353                                   adapter->pool.fsf_req_scsi);
2354         if (unlikely(IS_ERR(req)))
2355                 goto out;
2356
2357         req->status |= ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT;
2358         req->data = unit;
2359         req->handler = zfcp_fsf_send_fcp_command_handler;
2360         req->qtcb->header.lun_handle = unit->handle;
2361         req->qtcb->header.port_handle = unit->port->handle;
2362         req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
2363         req->qtcb->bottom.io.service_class = FSF_CLASS_3;
2364         req->qtcb->bottom.io.fcp_cmnd_length =  sizeof(struct fcp_cmnd_iu) +
2365                                                 sizeof(fcp_dl_t);
2366
2367         sbale = zfcp_qdio_sbale_req(req);
2368         sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE;
2369         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
2370
2371         fcp_cmnd_iu = (struct fcp_cmnd_iu *) &req->qtcb->bottom.io.fcp_cmnd;
2372         fcp_cmnd_iu->fcp_lun = unit->fcp_lun;
2373         fcp_cmnd_iu->task_management_flags = tm_flags;
2374
2375         zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT);
2376         if (!zfcp_fsf_req_send(req))
2377                 goto out;
2378
2379         zfcp_fsf_req_free(req);
2380         req = NULL;
2381 out:
2382         spin_unlock(&adapter->req_q.lock);
2383         return req;
2384 }
2385
2386 static void zfcp_fsf_control_file_handler(struct zfcp_fsf_req *req)
2387 {
2388         if (req->qtcb->header.fsf_status != FSF_GOOD)
2389                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2390 }
2391
2392 /**
2393  * zfcp_fsf_control_file - control file upload/download
2394  * @adapter: pointer to struct zfcp_adapter
2395  * @fsf_cfdc: pointer to struct zfcp_fsf_cfdc
2396  * Returns: on success pointer to struct zfcp_fsf_req, NULL otherwise
2397  */
2398 struct zfcp_fsf_req *zfcp_fsf_control_file(struct zfcp_adapter *adapter,
2399                                            struct zfcp_fsf_cfdc *fsf_cfdc)
2400 {
2401         volatile struct qdio_buffer_element *sbale;
2402         struct zfcp_fsf_req *req = NULL;
2403         struct fsf_qtcb_bottom_support *bottom;
2404         int direction, retval = -EIO, bytes;
2405
2406         if (!(adapter->adapter_features & FSF_FEATURE_CFDC))
2407                 return ERR_PTR(-EOPNOTSUPP);
2408
2409         switch (fsf_cfdc->command) {
2410         case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
2411                 direction = SBAL_FLAGS0_TYPE_WRITE;
2412                 break;
2413         case FSF_QTCB_UPLOAD_CONTROL_FILE:
2414                 direction = SBAL_FLAGS0_TYPE_READ;
2415                 break;
2416         default:
2417                 return ERR_PTR(-EINVAL);
2418         }
2419
2420         spin_lock(&adapter->req_q.lock);
2421         if (zfcp_fsf_req_sbal_get(adapter))
2422                 goto out;
2423
2424         req = zfcp_fsf_req_create(adapter, fsf_cfdc->command, 0, NULL);
2425         if (unlikely(IS_ERR(req))) {
2426                 retval = -EPERM;
2427                 goto out;
2428         }
2429
2430         req->handler = zfcp_fsf_control_file_handler;
2431
2432         sbale = zfcp_qdio_sbale_req(req);
2433         sbale[0].flags |= direction;
2434
2435         bottom = &req->qtcb->bottom.support;
2436         bottom->operation_subtype = FSF_CFDC_OPERATION_SUBTYPE;
2437         bottom->option = fsf_cfdc->option;
2438
2439         bytes = zfcp_qdio_sbals_from_sg(req, direction, fsf_cfdc->sg,
2440                                         FSF_MAX_SBALS_PER_REQ);
2441         if (bytes != ZFCP_CFDC_MAX_SIZE) {
2442                 retval = -ENOMEM;
2443                 zfcp_fsf_req_free(req);
2444                 goto out;
2445         }
2446
2447         zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
2448         retval = zfcp_fsf_req_send(req);
2449 out:
2450         spin_unlock(&adapter->req_q.lock);
2451
2452         if (!retval) {
2453                 wait_event(req->completion_wq,
2454                            req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
2455                 return req;
2456         }
2457         return ERR_PTR(retval);
2458 }