1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * QLogic iSCSI HBA Driver
4 * Copyright (c) 2011-2013 QLogic Corporation
5 */
6
7 #include "ql4_def.h"
8 #include "ql4_glbl.h"
9 #include "ql4_bsg.h"
10
11 static int
qla4xxx_read_flash(struct bsg_job * bsg_job)12 qla4xxx_read_flash(struct bsg_job *bsg_job)
13 {
14 struct Scsi_Host *host = iscsi_job_to_shost(bsg_job);
15 struct scsi_qla_host *ha = to_qla_host(host);
16 struct iscsi_bsg_reply *bsg_reply = bsg_job->reply;
17 struct iscsi_bsg_request *bsg_req = bsg_job->request;
18 uint32_t offset = 0;
19 uint32_t length = 0;
20 dma_addr_t flash_dma;
21 uint8_t *flash = NULL;
22 int rval = -EINVAL;
23
24 bsg_reply->reply_payload_rcv_len = 0;
25
26 if (unlikely(pci_channel_offline(ha->pdev)))
27 goto leave;
28
29 if (ql4xxx_reset_active(ha)) {
30 ql4_printk(KERN_ERR, ha, "%s: reset active\n", __func__);
31 rval = -EBUSY;
32 goto leave;
33 }
34
35 if (ha->flash_state != QLFLASH_WAITING) {
36 ql4_printk(KERN_ERR, ha, "%s: another flash operation "
37 "active\n", __func__);
38 rval = -EBUSY;
39 goto leave;
40 }
41
42 ha->flash_state = QLFLASH_READING;
43 offset = bsg_req->rqst_data.h_vendor.vendor_cmd[1];
44 length = bsg_job->reply_payload.payload_len;
45
46 flash = dma_alloc_coherent(&ha->pdev->dev, length, &flash_dma,
47 GFP_KERNEL);
48 if (!flash) {
49 ql4_printk(KERN_ERR, ha, "%s: dma alloc failed for flash "
50 "data\n", __func__);
51 rval = -ENOMEM;
52 goto leave;
53 }
54
55 rval = qla4xxx_get_flash(ha, flash_dma, offset, length);
56 if (rval) {
57 ql4_printk(KERN_ERR, ha, "%s: get flash failed\n", __func__);
58 bsg_reply->result = DID_ERROR << 16;
59 rval = -EIO;
60 } else {
61 bsg_reply->reply_payload_rcv_len =
62 sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
63 bsg_job->reply_payload.sg_cnt,
64 flash, length);
65 bsg_reply->result = DID_OK << 16;
66 }
67
68 bsg_job_done(bsg_job, bsg_reply->result,
69 bsg_reply->reply_payload_rcv_len);
70 dma_free_coherent(&ha->pdev->dev, length, flash, flash_dma);
71 leave:
72 ha->flash_state = QLFLASH_WAITING;
73 return rval;
74 }
75
76 static int
qla4xxx_update_flash(struct bsg_job * bsg_job)77 qla4xxx_update_flash(struct bsg_job *bsg_job)
78 {
79 struct Scsi_Host *host = iscsi_job_to_shost(bsg_job);
80 struct scsi_qla_host *ha = to_qla_host(host);
81 struct iscsi_bsg_reply *bsg_reply = bsg_job->reply;
82 struct iscsi_bsg_request *bsg_req = bsg_job->request;
83 uint32_t length = 0;
84 uint32_t offset = 0;
85 uint32_t options = 0;
86 dma_addr_t flash_dma;
87 uint8_t *flash = NULL;
88 int rval = -EINVAL;
89
90 bsg_reply->reply_payload_rcv_len = 0;
91
92 if (unlikely(pci_channel_offline(ha->pdev)))
93 goto leave;
94
95 if (ql4xxx_reset_active(ha)) {
96 ql4_printk(KERN_ERR, ha, "%s: reset active\n", __func__);
97 rval = -EBUSY;
98 goto leave;
99 }
100
101 if (ha->flash_state != QLFLASH_WAITING) {
102 ql4_printk(KERN_ERR, ha, "%s: another flash operation "
103 "active\n", __func__);
104 rval = -EBUSY;
105 goto leave;
106 }
107
108 ha->flash_state = QLFLASH_WRITING;
109 length = bsg_job->request_payload.payload_len;
110 offset = bsg_req->rqst_data.h_vendor.vendor_cmd[1];
111 options = bsg_req->rqst_data.h_vendor.vendor_cmd[2];
112
113 flash = dma_alloc_coherent(&ha->pdev->dev, length, &flash_dma,
114 GFP_KERNEL);
115 if (!flash) {
116 ql4_printk(KERN_ERR, ha, "%s: dma alloc failed for flash "
117 "data\n", __func__);
118 rval = -ENOMEM;
119 goto leave;
120 }
121
122 sg_copy_to_buffer(bsg_job->request_payload.sg_list,
123 bsg_job->request_payload.sg_cnt, flash, length);
124
125 rval = qla4xxx_set_flash(ha, flash_dma, offset, length, options);
126 if (rval) {
127 ql4_printk(KERN_ERR, ha, "%s: set flash failed\n", __func__);
128 bsg_reply->result = DID_ERROR << 16;
129 rval = -EIO;
130 } else
131 bsg_reply->result = DID_OK << 16;
132
133 bsg_job_done(bsg_job, bsg_reply->result,
134 bsg_reply->reply_payload_rcv_len);
135 dma_free_coherent(&ha->pdev->dev, length, flash, flash_dma);
136 leave:
137 ha->flash_state = QLFLASH_WAITING;
138 return rval;
139 }
140
141 static int
qla4xxx_get_acb_state(struct bsg_job * bsg_job)142 qla4xxx_get_acb_state(struct bsg_job *bsg_job)
143 {
144 struct Scsi_Host *host = iscsi_job_to_shost(bsg_job);
145 struct scsi_qla_host *ha = to_qla_host(host);
146 struct iscsi_bsg_request *bsg_req = bsg_job->request;
147 struct iscsi_bsg_reply *bsg_reply = bsg_job->reply;
148 uint32_t status[MBOX_REG_COUNT];
149 uint32_t acb_idx;
150 uint32_t ip_idx;
151 int rval = -EINVAL;
152
153 bsg_reply->reply_payload_rcv_len = 0;
154
155 if (unlikely(pci_channel_offline(ha->pdev)))
156 goto leave;
157
158 /* Only 4022 and above adapters are supported */
159 if (is_qla4010(ha))
160 goto leave;
161
162 if (ql4xxx_reset_active(ha)) {
163 ql4_printk(KERN_ERR, ha, "%s: reset active\n", __func__);
164 rval = -EBUSY;
165 goto leave;
166 }
167
168 if (bsg_job->reply_payload.payload_len < sizeof(status)) {
169 ql4_printk(KERN_ERR, ha, "%s: invalid payload len %d\n",
170 __func__, bsg_job->reply_payload.payload_len);
171 rval = -EINVAL;
172 goto leave;
173 }
174
175 acb_idx = bsg_req->rqst_data.h_vendor.vendor_cmd[1];
176 ip_idx = bsg_req->rqst_data.h_vendor.vendor_cmd[2];
177
178 rval = qla4xxx_get_ip_state(ha, acb_idx, ip_idx, status);
179 if (rval) {
180 ql4_printk(KERN_ERR, ha, "%s: get ip state failed\n",
181 __func__);
182 bsg_reply->result = DID_ERROR << 16;
183 rval = -EIO;
184 } else {
185 bsg_reply->reply_payload_rcv_len =
186 sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
187 bsg_job->reply_payload.sg_cnt,
188 status, sizeof(status));
189 bsg_reply->result = DID_OK << 16;
190 }
191
192 bsg_job_done(bsg_job, bsg_reply->result,
193 bsg_reply->reply_payload_rcv_len);
194 leave:
195 return rval;
196 }
197
198 static int
qla4xxx_read_nvram(struct bsg_job * bsg_job)199 qla4xxx_read_nvram(struct bsg_job *bsg_job)
200 {
201 struct Scsi_Host *host = iscsi_job_to_shost(bsg_job);
202 struct scsi_qla_host *ha = to_qla_host(host);
203 struct iscsi_bsg_request *bsg_req = bsg_job->request;
204 struct iscsi_bsg_reply *bsg_reply = bsg_job->reply;
205 uint32_t offset = 0;
206 uint32_t len = 0;
207 uint32_t total_len = 0;
208 dma_addr_t nvram_dma;
209 uint8_t *nvram = NULL;
210 int rval = -EINVAL;
211
212 bsg_reply->reply_payload_rcv_len = 0;
213
214 if (unlikely(pci_channel_offline(ha->pdev)))
215 goto leave;
216
217 /* Only 40xx adapters are supported */
218 if (!(is_qla4010(ha) || is_qla4022(ha) || is_qla4032(ha)))
219 goto leave;
220
221 if (ql4xxx_reset_active(ha)) {
222 ql4_printk(KERN_ERR, ha, "%s: reset active\n", __func__);
223 rval = -EBUSY;
224 goto leave;
225 }
226
227 offset = bsg_req->rqst_data.h_vendor.vendor_cmd[1];
228 len = bsg_job->reply_payload.payload_len;
229 total_len = offset + len;
230
231 /* total len should not be greater than max NVRAM size */
232 if ((is_qla4010(ha) && total_len > QL4010_NVRAM_SIZE) ||
233 ((is_qla4022(ha) || is_qla4032(ha)) &&
234 total_len > QL40X2_NVRAM_SIZE)) {
235 ql4_printk(KERN_ERR, ha, "%s: offset+len greater than max"
236 " nvram size, offset=%d len=%d\n",
237 __func__, offset, len);
238 goto leave;
239 }
240
241 nvram = dma_alloc_coherent(&ha->pdev->dev, len, &nvram_dma,
242 GFP_KERNEL);
243 if (!nvram) {
244 ql4_printk(KERN_ERR, ha, "%s: dma alloc failed for nvram "
245 "data\n", __func__);
246 rval = -ENOMEM;
247 goto leave;
248 }
249
250 rval = qla4xxx_get_nvram(ha, nvram_dma, offset, len);
251 if (rval) {
252 ql4_printk(KERN_ERR, ha, "%s: get nvram failed\n", __func__);
253 bsg_reply->result = DID_ERROR << 16;
254 rval = -EIO;
255 } else {
256 bsg_reply->reply_payload_rcv_len =
257 sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
258 bsg_job->reply_payload.sg_cnt,
259 nvram, len);
260 bsg_reply->result = DID_OK << 16;
261 }
262
263 bsg_job_done(bsg_job, bsg_reply->result,
264 bsg_reply->reply_payload_rcv_len);
265 dma_free_coherent(&ha->pdev->dev, len, nvram, nvram_dma);
266 leave:
267 return rval;
268 }
269
270 static int
qla4xxx_update_nvram(struct bsg_job * bsg_job)271 qla4xxx_update_nvram(struct bsg_job *bsg_job)
272 {
273 struct Scsi_Host *host = iscsi_job_to_shost(bsg_job);
274 struct scsi_qla_host *ha = to_qla_host(host);
275 struct iscsi_bsg_request *bsg_req = bsg_job->request;
276 struct iscsi_bsg_reply *bsg_reply = bsg_job->reply;
277 uint32_t offset = 0;
278 uint32_t len = 0;
279 uint32_t total_len = 0;
280 dma_addr_t nvram_dma;
281 uint8_t *nvram = NULL;
282 int rval = -EINVAL;
283
284 bsg_reply->reply_payload_rcv_len = 0;
285
286 if (unlikely(pci_channel_offline(ha->pdev)))
287 goto leave;
288
289 if (!(is_qla4010(ha) || is_qla4022(ha) || is_qla4032(ha)))
290 goto leave;
291
292 if (ql4xxx_reset_active(ha)) {
293 ql4_printk(KERN_ERR, ha, "%s: reset active\n", __func__);
294 rval = -EBUSY;
295 goto leave;
296 }
297
298 offset = bsg_req->rqst_data.h_vendor.vendor_cmd[1];
299 len = bsg_job->request_payload.payload_len;
300 total_len = offset + len;
301
302 /* total len should not be greater than max NVRAM size */
303 if ((is_qla4010(ha) && total_len > QL4010_NVRAM_SIZE) ||
304 ((is_qla4022(ha) || is_qla4032(ha)) &&
305 total_len > QL40X2_NVRAM_SIZE)) {
306 ql4_printk(KERN_ERR, ha, "%s: offset+len greater than max"
307 " nvram size, offset=%d len=%d\n",
308 __func__, offset, len);
309 goto leave;
310 }
311
312 nvram = dma_alloc_coherent(&ha->pdev->dev, len, &nvram_dma,
313 GFP_KERNEL);
314 if (!nvram) {
315 ql4_printk(KERN_ERR, ha, "%s: dma alloc failed for flash "
316 "data\n", __func__);
317 rval = -ENOMEM;
318 goto leave;
319 }
320
321 sg_copy_to_buffer(bsg_job->request_payload.sg_list,
322 bsg_job->request_payload.sg_cnt, nvram, len);
323
324 rval = qla4xxx_set_nvram(ha, nvram_dma, offset, len);
325 if (rval) {
326 ql4_printk(KERN_ERR, ha, "%s: set nvram failed\n", __func__);
327 bsg_reply->result = DID_ERROR << 16;
328 rval = -EIO;
329 } else
330 bsg_reply->result = DID_OK << 16;
331
332 bsg_job_done(bsg_job, bsg_reply->result,
333 bsg_reply->reply_payload_rcv_len);
334 dma_free_coherent(&ha->pdev->dev, len, nvram, nvram_dma);
335 leave:
336 return rval;
337 }
338
339 static int
qla4xxx_restore_defaults(struct bsg_job * bsg_job)340 qla4xxx_restore_defaults(struct bsg_job *bsg_job)
341 {
342 struct Scsi_Host *host = iscsi_job_to_shost(bsg_job);
343 struct scsi_qla_host *ha = to_qla_host(host);
344 struct iscsi_bsg_request *bsg_req = bsg_job->request;
345 struct iscsi_bsg_reply *bsg_reply = bsg_job->reply;
346 uint32_t region = 0;
347 uint32_t field0 = 0;
348 uint32_t field1 = 0;
349 int rval = -EINVAL;
350
351 bsg_reply->reply_payload_rcv_len = 0;
352
353 if (unlikely(pci_channel_offline(ha->pdev)))
354 goto leave;
355
356 if (is_qla4010(ha))
357 goto leave;
358
359 if (ql4xxx_reset_active(ha)) {
360 ql4_printk(KERN_ERR, ha, "%s: reset active\n", __func__);
361 rval = -EBUSY;
362 goto leave;
363 }
364
365 region = bsg_req->rqst_data.h_vendor.vendor_cmd[1];
366 field0 = bsg_req->rqst_data.h_vendor.vendor_cmd[2];
367 field1 = bsg_req->rqst_data.h_vendor.vendor_cmd[3];
368
369 rval = qla4xxx_restore_factory_defaults(ha, region, field0, field1);
370 if (rval) {
371 ql4_printk(KERN_ERR, ha, "%s: set nvram failed\n", __func__);
372 bsg_reply->result = DID_ERROR << 16;
373 rval = -EIO;
374 } else
375 bsg_reply->result = DID_OK << 16;
376
377 bsg_job_done(bsg_job, bsg_reply->result,
378 bsg_reply->reply_payload_rcv_len);
379 leave:
380 return rval;
381 }
382
383 static int
qla4xxx_bsg_get_acb(struct bsg_job * bsg_job)384 qla4xxx_bsg_get_acb(struct bsg_job *bsg_job)
385 {
386 struct Scsi_Host *host = iscsi_job_to_shost(bsg_job);
387 struct scsi_qla_host *ha = to_qla_host(host);
388 struct iscsi_bsg_request *bsg_req = bsg_job->request;
389 struct iscsi_bsg_reply *bsg_reply = bsg_job->reply;
390 uint32_t acb_type = 0;
391 uint32_t len = 0;
392 dma_addr_t acb_dma;
393 uint8_t *acb = NULL;
394 int rval = -EINVAL;
395
396 bsg_reply->reply_payload_rcv_len = 0;
397
398 if (unlikely(pci_channel_offline(ha->pdev)))
399 goto leave;
400
401 /* Only 4022 and above adapters are supported */
402 if (is_qla4010(ha))
403 goto leave;
404
405 if (ql4xxx_reset_active(ha)) {
406 ql4_printk(KERN_ERR, ha, "%s: reset active\n", __func__);
407 rval = -EBUSY;
408 goto leave;
409 }
410
411 acb_type = bsg_req->rqst_data.h_vendor.vendor_cmd[1];
412 len = bsg_job->reply_payload.payload_len;
413 if (len < sizeof(struct addr_ctrl_blk)) {
414 ql4_printk(KERN_ERR, ha, "%s: invalid acb len %d\n",
415 __func__, len);
416 rval = -EINVAL;
417 goto leave;
418 }
419
420 acb = dma_alloc_coherent(&ha->pdev->dev, len, &acb_dma, GFP_KERNEL);
421 if (!acb) {
422 ql4_printk(KERN_ERR, ha, "%s: dma alloc failed for acb "
423 "data\n", __func__);
424 rval = -ENOMEM;
425 goto leave;
426 }
427
428 rval = qla4xxx_get_acb(ha, acb_dma, acb_type, len);
429 if (rval) {
430 ql4_printk(KERN_ERR, ha, "%s: get acb failed\n", __func__);
431 bsg_reply->result = DID_ERROR << 16;
432 rval = -EIO;
433 } else {
434 bsg_reply->reply_payload_rcv_len =
435 sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
436 bsg_job->reply_payload.sg_cnt,
437 acb, len);
438 bsg_reply->result = DID_OK << 16;
439 }
440
441 bsg_job_done(bsg_job, bsg_reply->result,
442 bsg_reply->reply_payload_rcv_len);
443 dma_free_coherent(&ha->pdev->dev, len, acb, acb_dma);
444 leave:
445 return rval;
446 }
447
ql4xxx_execute_diag_cmd(struct bsg_job * bsg_job)448 static void ql4xxx_execute_diag_cmd(struct bsg_job *bsg_job)
449 {
450 struct Scsi_Host *host = iscsi_job_to_shost(bsg_job);
451 struct scsi_qla_host *ha = to_qla_host(host);
452 struct iscsi_bsg_request *bsg_req = bsg_job->request;
453 struct iscsi_bsg_reply *bsg_reply = bsg_job->reply;
454 uint8_t *rsp_ptr = NULL;
455 uint32_t mbox_cmd[MBOX_REG_COUNT];
456 uint32_t mbox_sts[MBOX_REG_COUNT];
457 int status = QLA_ERROR;
458
459 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: in\n", __func__));
460
461 if (test_bit(DPC_RESET_HA, &ha->dpc_flags)) {
462 ql4_printk(KERN_INFO, ha, "%s: Adapter reset in progress. Invalid Request\n",
463 __func__);
464 bsg_reply->result = DID_ERROR << 16;
465 goto exit_diag_mem_test;
466 }
467
468 bsg_reply->reply_payload_rcv_len = 0;
469 memcpy(mbox_cmd, &bsg_req->rqst_data.h_vendor.vendor_cmd[1],
470 sizeof(uint32_t) * MBOX_REG_COUNT);
471
472 DEBUG2(ql4_printk(KERN_INFO, ha,
473 "%s: mbox_cmd: %08X %08X %08X %08X %08X %08X %08X %08X\n",
474 __func__, mbox_cmd[0], mbox_cmd[1], mbox_cmd[2],
475 mbox_cmd[3], mbox_cmd[4], mbox_cmd[5], mbox_cmd[6],
476 mbox_cmd[7]));
477
478 status = qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 8, &mbox_cmd[0],
479 &mbox_sts[0]);
480
481 DEBUG2(ql4_printk(KERN_INFO, ha,
482 "%s: mbox_sts: %08X %08X %08X %08X %08X %08X %08X %08X\n",
483 __func__, mbox_sts[0], mbox_sts[1], mbox_sts[2],
484 mbox_sts[3], mbox_sts[4], mbox_sts[5], mbox_sts[6],
485 mbox_sts[7]));
486
487 if (status == QLA_SUCCESS)
488 bsg_reply->result = DID_OK << 16;
489 else
490 bsg_reply->result = DID_ERROR << 16;
491
492 /* Send mbox_sts to application */
493 bsg_job->reply_len = sizeof(struct iscsi_bsg_reply) + sizeof(mbox_sts);
494 rsp_ptr = ((uint8_t *)bsg_reply) + sizeof(struct iscsi_bsg_reply);
495 memcpy(rsp_ptr, mbox_sts, sizeof(mbox_sts));
496
497 exit_diag_mem_test:
498 DEBUG2(ql4_printk(KERN_INFO, ha,
499 "%s: bsg_reply->result = x%x, status = %s\n",
500 __func__, bsg_reply->result, STATUS(status)));
501
502 bsg_job_done(bsg_job, bsg_reply->result,
503 bsg_reply->reply_payload_rcv_len);
504 }
505
qla4_83xx_wait_for_loopback_config_comp(struct scsi_qla_host * ha,int wait_for_link)506 static int qla4_83xx_wait_for_loopback_config_comp(struct scsi_qla_host *ha,
507 int wait_for_link)
508 {
509 int status = QLA_SUCCESS;
510
511 if (!wait_for_completion_timeout(&ha->idc_comp, (IDC_COMP_TOV * HZ))) {
512 ql4_printk(KERN_INFO, ha, "%s: IDC Complete notification not received, Waiting for another %d timeout",
513 __func__, ha->idc_extend_tmo);
514 if (ha->idc_extend_tmo) {
515 if (!wait_for_completion_timeout(&ha->idc_comp,
516 (ha->idc_extend_tmo * HZ))) {
517 ha->notify_idc_comp = 0;
518 ha->notify_link_up_comp = 0;
519 ql4_printk(KERN_WARNING, ha, "%s: Aborting: IDC Complete notification not received",
520 __func__);
521 status = QLA_ERROR;
522 goto exit_wait;
523 } else {
524 DEBUG2(ql4_printk(KERN_INFO, ha,
525 "%s: IDC Complete notification received\n",
526 __func__));
527 }
528 }
529 } else {
530 DEBUG2(ql4_printk(KERN_INFO, ha,
531 "%s: IDC Complete notification received\n",
532 __func__));
533 }
534 ha->notify_idc_comp = 0;
535
536 if (wait_for_link) {
537 if (!wait_for_completion_timeout(&ha->link_up_comp,
538 (IDC_COMP_TOV * HZ))) {
539 ha->notify_link_up_comp = 0;
540 ql4_printk(KERN_WARNING, ha, "%s: Aborting: LINK UP notification not received",
541 __func__);
542 status = QLA_ERROR;
543 goto exit_wait;
544 } else {
545 DEBUG2(ql4_printk(KERN_INFO, ha,
546 "%s: LINK UP notification received\n",
547 __func__));
548 }
549 ha->notify_link_up_comp = 0;
550 }
551
552 exit_wait:
553 return status;
554 }
555
qla4_83xx_pre_loopback_config(struct scsi_qla_host * ha,uint32_t * mbox_cmd)556 static int qla4_83xx_pre_loopback_config(struct scsi_qla_host *ha,
557 uint32_t *mbox_cmd)
558 {
559 uint32_t config = 0;
560 int status = QLA_SUCCESS;
561
562 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: in\n", __func__));
563
564 status = qla4_83xx_get_port_config(ha, &config);
565 if (status != QLA_SUCCESS)
566 goto exit_pre_loopback_config;
567
568 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Default port config=%08X\n",
569 __func__, config));
570
571 if ((config & ENABLE_INTERNAL_LOOPBACK) ||
572 (config & ENABLE_EXTERNAL_LOOPBACK)) {
573 ql4_printk(KERN_INFO, ha, "%s: Loopback diagnostics already in progress. Invalid request\n",
574 __func__);
575 goto exit_pre_loopback_config;
576 }
577
578 if (mbox_cmd[1] == QL_DIAG_CMD_TEST_INT_LOOPBACK)
579 config |= ENABLE_INTERNAL_LOOPBACK;
580
581 if (mbox_cmd[1] == QL_DIAG_CMD_TEST_EXT_LOOPBACK)
582 config |= ENABLE_EXTERNAL_LOOPBACK;
583
584 config &= ~ENABLE_DCBX;
585
586 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: New port config=%08X\n",
587 __func__, config));
588
589 ha->notify_idc_comp = 1;
590 ha->notify_link_up_comp = 1;
591
592 /* get the link state */
593 qla4xxx_get_firmware_state(ha);
594
595 status = qla4_83xx_set_port_config(ha, &config);
596 if (status != QLA_SUCCESS) {
597 ha->notify_idc_comp = 0;
598 ha->notify_link_up_comp = 0;
599 goto exit_pre_loopback_config;
600 }
601 exit_pre_loopback_config:
602 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: status = %s\n", __func__,
603 STATUS(status)));
604 return status;
605 }
606
qla4_83xx_post_loopback_config(struct scsi_qla_host * ha,uint32_t * mbox_cmd)607 static int qla4_83xx_post_loopback_config(struct scsi_qla_host *ha,
608 uint32_t *mbox_cmd)
609 {
610 int status = QLA_SUCCESS;
611 uint32_t config = 0;
612
613 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: in\n", __func__));
614
615 status = qla4_83xx_get_port_config(ha, &config);
616 if (status != QLA_SUCCESS)
617 goto exit_post_loopback_config;
618
619 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: port config=%08X\n", __func__,
620 config));
621
622 if (mbox_cmd[1] == QL_DIAG_CMD_TEST_INT_LOOPBACK)
623 config &= ~ENABLE_INTERNAL_LOOPBACK;
624 else if (mbox_cmd[1] == QL_DIAG_CMD_TEST_EXT_LOOPBACK)
625 config &= ~ENABLE_EXTERNAL_LOOPBACK;
626
627 config |= ENABLE_DCBX;
628
629 DEBUG2(ql4_printk(KERN_INFO, ha,
630 "%s: Restore default port config=%08X\n", __func__,
631 config));
632
633 ha->notify_idc_comp = 1;
634 if (ha->addl_fw_state & FW_ADDSTATE_LINK_UP)
635 ha->notify_link_up_comp = 1;
636
637 status = qla4_83xx_set_port_config(ha, &config);
638 if (status != QLA_SUCCESS) {
639 ql4_printk(KERN_INFO, ha, "%s: Scheduling adapter reset\n",
640 __func__);
641 set_bit(DPC_RESET_HA, &ha->dpc_flags);
642 clear_bit(AF_LOOPBACK, &ha->flags);
643 goto exit_post_loopback_config;
644 }
645
646 exit_post_loopback_config:
647 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: status = %s\n", __func__,
648 STATUS(status)));
649 return status;
650 }
651
qla4xxx_execute_diag_loopback_cmd(struct bsg_job * bsg_job)652 static void qla4xxx_execute_diag_loopback_cmd(struct bsg_job *bsg_job)
653 {
654 struct Scsi_Host *host = iscsi_job_to_shost(bsg_job);
655 struct scsi_qla_host *ha = to_qla_host(host);
656 struct iscsi_bsg_request *bsg_req = bsg_job->request;
657 struct iscsi_bsg_reply *bsg_reply = bsg_job->reply;
658 uint8_t *rsp_ptr = NULL;
659 uint32_t mbox_cmd[MBOX_REG_COUNT];
660 uint32_t mbox_sts[MBOX_REG_COUNT];
661 int wait_for_link = 1;
662 int status = QLA_ERROR;
663
664 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: in\n", __func__));
665
666 bsg_reply->reply_payload_rcv_len = 0;
667
668 if (test_bit(AF_LOOPBACK, &ha->flags)) {
669 ql4_printk(KERN_INFO, ha, "%s: Loopback Diagnostics already in progress. Invalid Request\n",
670 __func__);
671 bsg_reply->result = DID_ERROR << 16;
672 goto exit_loopback_cmd;
673 }
674
675 if (test_bit(DPC_RESET_HA, &ha->dpc_flags)) {
676 ql4_printk(KERN_INFO, ha, "%s: Adapter reset in progress. Invalid Request\n",
677 __func__);
678 bsg_reply->result = DID_ERROR << 16;
679 goto exit_loopback_cmd;
680 }
681
682 memcpy(mbox_cmd, &bsg_req->rqst_data.h_vendor.vendor_cmd[1],
683 sizeof(uint32_t) * MBOX_REG_COUNT);
684
685 if (is_qla8032(ha) || is_qla8042(ha)) {
686 status = qla4_83xx_pre_loopback_config(ha, mbox_cmd);
687 if (status != QLA_SUCCESS) {
688 bsg_reply->result = DID_ERROR << 16;
689 goto exit_loopback_cmd;
690 }
691
692 status = qla4_83xx_wait_for_loopback_config_comp(ha,
693 wait_for_link);
694 if (status != QLA_SUCCESS) {
695 bsg_reply->result = DID_TIME_OUT << 16;
696 goto restore;
697 }
698 }
699
700 DEBUG2(ql4_printk(KERN_INFO, ha,
701 "%s: mbox_cmd: %08X %08X %08X %08X %08X %08X %08X %08X\n",
702 __func__, mbox_cmd[0], mbox_cmd[1], mbox_cmd[2],
703 mbox_cmd[3], mbox_cmd[4], mbox_cmd[5], mbox_cmd[6],
704 mbox_cmd[7]));
705
706 status = qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 8, &mbox_cmd[0],
707 &mbox_sts[0]);
708
709 if (status == QLA_SUCCESS)
710 bsg_reply->result = DID_OK << 16;
711 else
712 bsg_reply->result = DID_ERROR << 16;
713
714 DEBUG2(ql4_printk(KERN_INFO, ha,
715 "%s: mbox_sts: %08X %08X %08X %08X %08X %08X %08X %08X\n",
716 __func__, mbox_sts[0], mbox_sts[1], mbox_sts[2],
717 mbox_sts[3], mbox_sts[4], mbox_sts[5], mbox_sts[6],
718 mbox_sts[7]));
719
720 /* Send mbox_sts to application */
721 bsg_job->reply_len = sizeof(struct iscsi_bsg_reply) + sizeof(mbox_sts);
722 rsp_ptr = ((uint8_t *)bsg_reply) + sizeof(struct iscsi_bsg_reply);
723 memcpy(rsp_ptr, mbox_sts, sizeof(mbox_sts));
724 restore:
725 if (is_qla8032(ha) || is_qla8042(ha)) {
726 status = qla4_83xx_post_loopback_config(ha, mbox_cmd);
727 if (status != QLA_SUCCESS) {
728 bsg_reply->result = DID_ERROR << 16;
729 goto exit_loopback_cmd;
730 }
731
732 /* for pre_loopback_config() wait for LINK UP only
733 * if PHY LINK is UP */
734 if (!(ha->addl_fw_state & FW_ADDSTATE_LINK_UP))
735 wait_for_link = 0;
736
737 status = qla4_83xx_wait_for_loopback_config_comp(ha,
738 wait_for_link);
739 if (status != QLA_SUCCESS) {
740 bsg_reply->result = DID_TIME_OUT << 16;
741 goto exit_loopback_cmd;
742 }
743 }
744 exit_loopback_cmd:
745 DEBUG2(ql4_printk(KERN_INFO, ha,
746 "%s: bsg_reply->result = x%x, status = %s\n",
747 __func__, bsg_reply->result, STATUS(status)));
748 bsg_job_done(bsg_job, bsg_reply->result,
749 bsg_reply->reply_payload_rcv_len);
750 }
751
qla4xxx_execute_diag_test(struct bsg_job * bsg_job)752 static int qla4xxx_execute_diag_test(struct bsg_job *bsg_job)
753 {
754 struct Scsi_Host *host = iscsi_job_to_shost(bsg_job);
755 struct scsi_qla_host *ha = to_qla_host(host);
756 struct iscsi_bsg_request *bsg_req = bsg_job->request;
757 uint32_t diag_cmd;
758 int rval = -EINVAL;
759
760 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: in\n", __func__));
761
762 diag_cmd = bsg_req->rqst_data.h_vendor.vendor_cmd[1];
763 if (diag_cmd == MBOX_CMD_DIAG_TEST) {
764 switch (bsg_req->rqst_data.h_vendor.vendor_cmd[2]) {
765 case QL_DIAG_CMD_TEST_DDR_SIZE:
766 case QL_DIAG_CMD_TEST_DDR_RW:
767 case QL_DIAG_CMD_TEST_ONCHIP_MEM_RW:
768 case QL_DIAG_CMD_TEST_NVRAM:
769 case QL_DIAG_CMD_TEST_FLASH_ROM:
770 case QL_DIAG_CMD_TEST_DMA_XFER:
771 case QL_DIAG_CMD_SELF_DDR_RW:
772 case QL_DIAG_CMD_SELF_ONCHIP_MEM_RW:
773 /* Execute diag test for adapter RAM/FLASH */
774 ql4xxx_execute_diag_cmd(bsg_job);
775 /* Always return success as we want to sent bsg_reply
776 * to Application */
777 rval = QLA_SUCCESS;
778 break;
779
780 case QL_DIAG_CMD_TEST_INT_LOOPBACK:
781 case QL_DIAG_CMD_TEST_EXT_LOOPBACK:
782 /* Execute diag test for Network */
783 qla4xxx_execute_diag_loopback_cmd(bsg_job);
784 /* Always return success as we want to sent bsg_reply
785 * to Application */
786 rval = QLA_SUCCESS;
787 break;
788 default:
789 ql4_printk(KERN_ERR, ha, "%s: Invalid diag test: 0x%x\n",
790 __func__,
791 bsg_req->rqst_data.h_vendor.vendor_cmd[2]);
792 }
793 } else if ((diag_cmd == MBOX_CMD_SET_LED_CONFIG) ||
794 (diag_cmd == MBOX_CMD_GET_LED_CONFIG)) {
795 ql4xxx_execute_diag_cmd(bsg_job);
796 rval = QLA_SUCCESS;
797 } else {
798 ql4_printk(KERN_ERR, ha, "%s: Invalid diag cmd: 0x%x\n",
799 __func__, diag_cmd);
800 }
801
802 return rval;
803 }
804
805 /**
806 * qla4xxx_process_vendor_specific - handle vendor specific bsg request
807 * @bsg_job: iscsi_bsg_job to handle
808 **/
qla4xxx_process_vendor_specific(struct bsg_job * bsg_job)809 int qla4xxx_process_vendor_specific(struct bsg_job *bsg_job)
810 {
811 struct iscsi_bsg_reply *bsg_reply = bsg_job->reply;
812 struct iscsi_bsg_request *bsg_req = bsg_job->request;
813 struct Scsi_Host *host = iscsi_job_to_shost(bsg_job);
814 struct scsi_qla_host *ha = to_qla_host(host);
815
816 switch (bsg_req->rqst_data.h_vendor.vendor_cmd[0]) {
817 case QLISCSI_VND_READ_FLASH:
818 return qla4xxx_read_flash(bsg_job);
819
820 case QLISCSI_VND_UPDATE_FLASH:
821 return qla4xxx_update_flash(bsg_job);
822
823 case QLISCSI_VND_GET_ACB_STATE:
824 return qla4xxx_get_acb_state(bsg_job);
825
826 case QLISCSI_VND_READ_NVRAM:
827 return qla4xxx_read_nvram(bsg_job);
828
829 case QLISCSI_VND_UPDATE_NVRAM:
830 return qla4xxx_update_nvram(bsg_job);
831
832 case QLISCSI_VND_RESTORE_DEFAULTS:
833 return qla4xxx_restore_defaults(bsg_job);
834
835 case QLISCSI_VND_GET_ACB:
836 return qla4xxx_bsg_get_acb(bsg_job);
837
838 case QLISCSI_VND_DIAG_TEST:
839 return qla4xxx_execute_diag_test(bsg_job);
840
841 default:
842 ql4_printk(KERN_ERR, ha, "%s: invalid BSG vendor command: "
843 "0x%x\n", __func__, bsg_req->msgcode);
844 bsg_reply->result = (DID_ERROR << 16);
845 bsg_reply->reply_payload_rcv_len = 0;
846 bsg_job_done(bsg_job, bsg_reply->result,
847 bsg_reply->reply_payload_rcv_len);
848 return -ENOSYS;
849 }
850 }
851
852 /**
853 * qla4xxx_bsg_request - handle bsg request from ISCSI transport
854 * @bsg_job: iscsi_bsg_job to handle
855 */
qla4xxx_bsg_request(struct bsg_job * bsg_job)856 int qla4xxx_bsg_request(struct bsg_job *bsg_job)
857 {
858 struct iscsi_bsg_request *bsg_req = bsg_job->request;
859 struct Scsi_Host *host = iscsi_job_to_shost(bsg_job);
860 struct scsi_qla_host *ha = to_qla_host(host);
861
862 switch (bsg_req->msgcode) {
863 case ISCSI_BSG_HST_VENDOR:
864 return qla4xxx_process_vendor_specific(bsg_job);
865
866 default:
867 ql4_printk(KERN_ERR, ha, "%s: invalid BSG command: 0x%x\n",
868 __func__, bsg_req->msgcode);
869 }
870
871 return -ENOSYS;
872 }
873