c2e43073047eabfa58b40945de95e7d5c7c944cb
[linux-2.6.git] / drivers / net / qlge / qlge_mpi.c
1 #include "qlge.h"
2
3 static void ql_display_mb_sts(struct ql_adapter *qdev,
4                                                 struct mbox_params *mbcp)
5 {
6         int i;
7         static char *err_sts[] = {
8                 "Command Complete",
9                 "Command Not Supported",
10                 "Host Interface Error",
11                 "Checksum Error",
12                 "Unused Completion Status",
13                 "Test Failed",
14                 "Command Parameter Error"};
15
16         QPRINTK(qdev, DRV, DEBUG, "%s.\n",
17                 err_sts[mbcp->mbox_out[0] & 0x0000000f]);
18         for (i = 0; i < mbcp->out_count; i++)
19                 QPRINTK(qdev, DRV, DEBUG, "mbox_out[%d] = 0x%.08x.\n",
20                                 i, mbcp->mbox_out[i]);
21 }
22
23 int ql_read_mpi_reg(struct ql_adapter *qdev, u32 reg, u32 *data)
24 {
25         int status;
26         /* wait for reg to come ready */
27         status = ql_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
28         if (status)
29                 goto exit;
30         /* set up for reg read */
31         ql_write32(qdev, PROC_ADDR, reg | PROC_ADDR_R);
32         /* wait for reg to come ready */
33         status = ql_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
34         if (status)
35                 goto exit;
36         /* get the data */
37         *data = ql_read32(qdev, PROC_DATA);
38 exit:
39         return status;
40 }
41
42 int ql_write_mpi_reg(struct ql_adapter *qdev, u32 reg, u32 data)
43 {
44         int status = 0;
45         /* wait for reg to come ready */
46         status = ql_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
47         if (status)
48                 goto exit;
49         /* write the data to the data reg */
50         ql_write32(qdev, PROC_DATA, data);
51         /* trigger the write */
52         ql_write32(qdev, PROC_ADDR, reg);
53         /* wait for reg to come ready */
54         status = ql_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
55         if (status)
56                 goto exit;
57 exit:
58         return status;
59 }
60
61 int ql_soft_reset_mpi_risc(struct ql_adapter *qdev)
62 {
63         int status;
64         status = ql_write_mpi_reg(qdev, 0x00001010, 1);
65         return status;
66 }
67
68 static int ql_get_mb_sts(struct ql_adapter *qdev, struct mbox_params *mbcp)
69 {
70         int i, status;
71
72         status = ql_sem_spinlock(qdev, SEM_PROC_REG_MASK);
73         if (status)
74                 return -EBUSY;
75         for (i = 0; i < mbcp->out_count; i++) {
76                 status =
77                     ql_read_mpi_reg(qdev, qdev->mailbox_out + i,
78                                      &mbcp->mbox_out[i]);
79                 if (status) {
80                         QPRINTK(qdev, DRV, ERR, "Failed mailbox read.\n");
81                         break;
82                 }
83         }
84         ql_sem_unlock(qdev, SEM_PROC_REG_MASK); /* does flush too */
85         return status;
86 }
87
88 /* Wait for a single mailbox command to complete.
89  * Returns zero on success.
90  */
91 static int ql_wait_mbx_cmd_cmplt(struct ql_adapter *qdev)
92 {
93         int count = 100;
94         u32 value;
95
96         do {
97                 value = ql_read32(qdev, STS);
98                 if (value & STS_PI)
99                         return 0;
100                 mdelay(UDELAY_DELAY); /* 100ms */
101         } while (--count);
102         return -ETIMEDOUT;
103 }
104
105 /* Execute a single mailbox command.
106  * Caller must hold PROC_ADDR semaphore.
107  */
108 static int ql_exec_mb_cmd(struct ql_adapter *qdev, struct mbox_params *mbcp)
109 {
110         int i, status;
111
112         /*
113          * Make sure there's nothing pending.
114          * This shouldn't happen.
115          */
116         if (ql_read32(qdev, CSR) & CSR_HRI)
117                 return -EIO;
118
119         status = ql_sem_spinlock(qdev, SEM_PROC_REG_MASK);
120         if (status)
121                 return status;
122
123         /*
124          * Fill the outbound mailboxes.
125          */
126         for (i = 0; i < mbcp->in_count; i++) {
127                 status = ql_write_mpi_reg(qdev, qdev->mailbox_in + i,
128                                                 mbcp->mbox_in[i]);
129                 if (status)
130                         goto end;
131         }
132         /*
133          * Wake up the MPI firmware.
134          */
135         ql_write32(qdev, CSR, CSR_CMD_SET_H2R_INT);
136 end:
137         ql_sem_unlock(qdev, SEM_PROC_REG_MASK);
138         return status;
139 }
140
141 /* We are being asked by firmware to accept
142  * a change to the port.  This is only
143  * a change to max frame sizes (Tx/Rx), pause
144  * parameters, or loopback mode. We wake up a worker
145  * to handler processing this since a mailbox command
146  * will need to be sent to ACK the request.
147  */
148 static int ql_idc_req_aen(struct ql_adapter *qdev)
149 {
150         int status;
151         struct mbox_params *mbcp = &qdev->idc_mbc;
152
153         QPRINTK(qdev, DRV, ERR, "Enter!\n");
154         /* Get the status data and start up a thread to
155          * handle the request.
156          */
157         mbcp = &qdev->idc_mbc;
158         mbcp->out_count = 4;
159         status = ql_get_mb_sts(qdev, mbcp);
160         if (status) {
161                 QPRINTK(qdev, DRV, ERR,
162                         "Could not read MPI, resetting ASIC!\n");
163                 ql_queue_asic_error(qdev);
164         } else  {
165                 /* Begin polled mode early so
166                  * we don't get another interrupt
167                  * when we leave mpi_worker.
168                  */
169                 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
170                 queue_delayed_work(qdev->workqueue, &qdev->mpi_idc_work, 0);
171         }
172         return status;
173 }
174
175 /* Process an inter-device event completion.
176  * If good, signal the caller's completion.
177  */
178 static int ql_idc_cmplt_aen(struct ql_adapter *qdev)
179 {
180         int status;
181         struct mbox_params *mbcp = &qdev->idc_mbc;
182         mbcp->out_count = 4;
183         status = ql_get_mb_sts(qdev, mbcp);
184         if (status) {
185                 QPRINTK(qdev, DRV, ERR,
186                         "Could not read MPI, resetting RISC!\n");
187                 ql_queue_fw_error(qdev);
188         } else
189                 /* Wake up the sleeping mpi_idc_work thread that is
190                  * waiting for this event.
191                  */
192                 complete(&qdev->ide_completion);
193
194         return status;
195 }
196
197 static void ql_link_up(struct ql_adapter *qdev, struct mbox_params *mbcp)
198 {
199         int status;
200         mbcp->out_count = 2;
201
202         status = ql_get_mb_sts(qdev, mbcp);
203         if (status) {
204                 QPRINTK(qdev, DRV, ERR,
205                         "%s: Could not get mailbox status.\n", __func__);
206                 return;
207         }
208
209         qdev->link_status = mbcp->mbox_out[1];
210         QPRINTK(qdev, DRV, ERR, "Link Up.\n");
211
212         /* If we're coming back from an IDC event
213          * then set up the CAM and frame routing.
214          */
215         if (test_bit(QL_CAM_RT_SET, &qdev->flags)) {
216                 status = ql_cam_route_initialize(qdev);
217                 if (status) {
218                         QPRINTK(qdev, IFUP, ERR,
219                         "Failed to init CAM/Routing tables.\n");
220                         return;
221                 } else
222                         clear_bit(QL_CAM_RT_SET, &qdev->flags);
223         }
224
225         /* Queue up a worker to check the frame
226          * size information, and fix it if it's not
227          * to our liking.
228          */
229         if (!test_bit(QL_PORT_CFG, &qdev->flags)) {
230                 QPRINTK(qdev, DRV, ERR, "Queue Port Config Worker!\n");
231                 set_bit(QL_PORT_CFG, &qdev->flags);
232                 /* Begin polled mode early so
233                  * we don't get another interrupt
234                  * when we leave mpi_worker dpc.
235                  */
236                 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
237                 queue_delayed_work(qdev->workqueue,
238                                 &qdev->mpi_port_cfg_work, 0);
239         }
240
241         ql_link_on(qdev);
242 }
243
244 static void ql_link_down(struct ql_adapter *qdev, struct mbox_params *mbcp)
245 {
246         int status;
247
248         mbcp->out_count = 3;
249
250         status = ql_get_mb_sts(qdev, mbcp);
251         if (status)
252                 QPRINTK(qdev, DRV, ERR, "Link down AEN broken!\n");
253
254         ql_link_off(qdev);
255 }
256
257 static int ql_sfp_in(struct ql_adapter *qdev, struct mbox_params *mbcp)
258 {
259         int status;
260
261         mbcp->out_count = 5;
262
263         status = ql_get_mb_sts(qdev, mbcp);
264         if (status)
265                 QPRINTK(qdev, DRV, ERR, "SFP in AEN broken!\n");
266         else
267                 QPRINTK(qdev, DRV, ERR, "SFP insertion detected.\n");
268
269         return status;
270 }
271
272 static int ql_sfp_out(struct ql_adapter *qdev, struct mbox_params *mbcp)
273 {
274         int status;
275
276         mbcp->out_count = 1;
277
278         status = ql_get_mb_sts(qdev, mbcp);
279         if (status)
280                 QPRINTK(qdev, DRV, ERR, "SFP out AEN broken!\n");
281         else
282                 QPRINTK(qdev, DRV, ERR, "SFP removal detected.\n");
283
284         return status;
285 }
286
287 static int ql_aen_lost(struct ql_adapter *qdev, struct mbox_params *mbcp)
288 {
289         int status;
290
291         mbcp->out_count = 6;
292
293         status = ql_get_mb_sts(qdev, mbcp);
294         if (status)
295                 QPRINTK(qdev, DRV, ERR, "Lost AEN broken!\n");
296         else {
297                 int i;
298                 QPRINTK(qdev, DRV, ERR, "Lost AEN detected.\n");
299                 for (i = 0; i < mbcp->out_count; i++)
300                         QPRINTK(qdev, DRV, ERR, "mbox_out[%d] = 0x%.08x.\n",
301                                         i, mbcp->mbox_out[i]);
302
303         }
304
305         return status;
306 }
307
308 static void ql_init_fw_done(struct ql_adapter *qdev, struct mbox_params *mbcp)
309 {
310         int status;
311
312         mbcp->out_count = 2;
313
314         status = ql_get_mb_sts(qdev, mbcp);
315         if (status) {
316                 QPRINTK(qdev, DRV, ERR, "Firmware did not initialize!\n");
317         } else {
318                 QPRINTK(qdev, DRV, ERR, "Firmware Revision  = 0x%.08x.\n",
319                         mbcp->mbox_out[1]);
320                 status = ql_cam_route_initialize(qdev);
321                 if (status)
322                         QPRINTK(qdev, IFUP, ERR,
323                                 "Failed to init CAM/Routing tables.\n");
324         }
325 }
326
327 /* Process an async event and clear it unless it's an
328  * error condition.
329  *  This can get called iteratively from the mpi_work thread
330  *  when events arrive via an interrupt.
331  *  It also gets called when a mailbox command is polling for
332  *  it's completion. */
333 static int ql_mpi_handler(struct ql_adapter *qdev, struct mbox_params *mbcp)
334 {
335         int status;
336         int orig_count = mbcp->out_count;
337
338         /* Just get mailbox zero for now. */
339         mbcp->out_count = 1;
340         status = ql_get_mb_sts(qdev, mbcp);
341         if (status) {
342                 QPRINTK(qdev, DRV, ERR,
343                         "Could not read MPI, resetting ASIC!\n");
344                 ql_queue_asic_error(qdev);
345                 goto end;
346         }
347
348         switch (mbcp->mbox_out[0]) {
349
350         /* This case is only active when we arrive here
351          * as a result of issuing a mailbox command to
352          * the firmware.
353          */
354         case MB_CMD_STS_INTRMDT:
355         case MB_CMD_STS_GOOD:
356         case MB_CMD_STS_INVLD_CMD:
357         case MB_CMD_STS_XFC_ERR:
358         case MB_CMD_STS_CSUM_ERR:
359         case MB_CMD_STS_ERR:
360         case MB_CMD_STS_PARAM_ERR:
361                 /* We can only get mailbox status if we're polling from an
362                  * unfinished command.  Get the rest of the status data and
363                  * return back to the caller.
364                  * We only end up here when we're polling for a mailbox
365                  * command completion.
366                  */
367                 mbcp->out_count = orig_count;
368                 status = ql_get_mb_sts(qdev, mbcp);
369                 return status;
370
371         /* We are being asked by firmware to accept
372          * a change to the port.  This is only
373          * a change to max frame sizes (Tx/Rx), pause
374          * parameters, or loopback mode.
375          */
376         case AEN_IDC_REQ:
377                 status = ql_idc_req_aen(qdev);
378                 break;
379
380         /* Process and inbound IDC event.
381          * This will happen when we're trying to
382          * change tx/rx max frame size, change pause
383          * parameters or loopback mode.
384          */
385         case AEN_IDC_CMPLT:
386         case AEN_IDC_EXT:
387                 status = ql_idc_cmplt_aen(qdev);
388                 break;
389
390         case AEN_LINK_UP:
391                 ql_link_up(qdev, mbcp);
392                 break;
393
394         case AEN_LINK_DOWN:
395                 ql_link_down(qdev, mbcp);
396                 break;
397
398         case AEN_FW_INIT_DONE:
399                 /* If we're in process on executing the firmware,
400                  * then convert the status to normal mailbox status.
401                  */
402                 if (mbcp->mbox_in[0] == MB_CMD_EX_FW) {
403                         mbcp->out_count = orig_count;
404                         status = ql_get_mb_sts(qdev, mbcp);
405                         mbcp->mbox_out[0] = MB_CMD_STS_GOOD;
406                         return status;
407                 }
408                 ql_init_fw_done(qdev, mbcp);
409                 break;
410
411         case AEN_AEN_SFP_IN:
412                 ql_sfp_in(qdev, mbcp);
413                 break;
414
415         case AEN_AEN_SFP_OUT:
416                 ql_sfp_out(qdev, mbcp);
417                 break;
418
419         /* This event can arrive at boot time or after an
420          * MPI reset if the firmware failed to initialize.
421          */
422         case AEN_FW_INIT_FAIL:
423                 /* If we're in process on executing the firmware,
424                  * then convert the status to normal mailbox status.
425                  */
426                 if (mbcp->mbox_in[0] == MB_CMD_EX_FW) {
427                         mbcp->out_count = orig_count;
428                         status = ql_get_mb_sts(qdev, mbcp);
429                         mbcp->mbox_out[0] = MB_CMD_STS_ERR;
430                         return status;
431                 }
432                 QPRINTK(qdev, DRV, ERR,
433                         "Firmware initialization failed.\n");
434                 status = -EIO;
435                 ql_queue_fw_error(qdev);
436                 break;
437
438         case AEN_SYS_ERR:
439                 QPRINTK(qdev, DRV, ERR,
440                         "System Error.\n");
441                 ql_queue_fw_error(qdev);
442                 status = -EIO;
443                 break;
444
445         case AEN_AEN_LOST:
446                 ql_aen_lost(qdev, mbcp);
447                 break;
448
449         default:
450                 QPRINTK(qdev, DRV, ERR,
451                         "Unsupported AE %.08x.\n", mbcp->mbox_out[0]);
452                 /* Clear the MPI firmware status. */
453         }
454 end:
455         ql_write32(qdev, CSR, CSR_CMD_CLR_R2PCI_INT);
456         /* Restore the original mailbox count to
457          * what the caller asked for.  This can get
458          * changed when a mailbox command is waiting
459          * for a response and an AEN arrives and
460          * is handled.
461          * */
462         mbcp->out_count = orig_count;
463         return status;
464 }
465
466 /* Execute a single mailbox command.
467  * mbcp is a pointer to an array of u32.  Each
468  * element in the array contains the value for it's
469  * respective mailbox register.
470  */
471 static int ql_mailbox_command(struct ql_adapter *qdev, struct mbox_params *mbcp)
472 {
473         int status, count;
474
475
476         /* Begin polled mode for MPI */
477         ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
478
479         /* Load the mailbox registers and wake up MPI RISC. */
480         status = ql_exec_mb_cmd(qdev, mbcp);
481         if (status)
482                 goto end;
483
484
485         /* If we're generating a system error, then there's nothing
486          * to wait for.
487          */
488         if (mbcp->mbox_in[0] == MB_CMD_MAKE_SYS_ERR)
489                 goto end;
490
491         /* Wait for the command to complete. We loop
492          * here because some AEN might arrive while
493          * we're waiting for the mailbox command to
494          * complete. If more than 5 arrive then we can
495          * assume something is wrong. */
496         count = 5;
497         do {
498                 /* Wait for the interrupt to come in. */
499                 status = ql_wait_mbx_cmd_cmplt(qdev);
500                 if (status)
501                         goto end;
502
503                 /* Process the event.  If it's an AEN, it
504                  * will be handled in-line or a worker
505                  * will be spawned. If it's our completion
506                  * we will catch it below.
507                  */
508                 status = ql_mpi_handler(qdev, mbcp);
509                 if (status)
510                         goto end;
511
512                 /* It's either the completion for our mailbox
513                  * command complete or an AEN.  If it's our
514                  * completion then get out.
515                  */
516                 if (((mbcp->mbox_out[0] & 0x0000f000) ==
517                                         MB_CMD_STS_GOOD) ||
518                         ((mbcp->mbox_out[0] & 0x0000f000) ==
519                                         MB_CMD_STS_INTRMDT))
520                         break;
521         } while (--count);
522
523         if (!count) {
524                 QPRINTK(qdev, DRV, ERR,
525                         "Timed out waiting for mailbox complete.\n");
526                 status = -ETIMEDOUT;
527                 goto end;
528         }
529
530         /* Now we can clear the interrupt condition
531          * and look at our status.
532          */
533         ql_write32(qdev, CSR, CSR_CMD_CLR_R2PCI_INT);
534
535         if (((mbcp->mbox_out[0] & 0x0000f000) !=
536                                         MB_CMD_STS_GOOD) &&
537                 ((mbcp->mbox_out[0] & 0x0000f000) !=
538                                         MB_CMD_STS_INTRMDT)) {
539                 ql_display_mb_sts(qdev, mbcp);
540                 status = -EIO;
541         }
542 end:
543         /* End polled mode for MPI */
544         ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16) | INTR_MASK_PI);
545         return status;
546 }
547
548
549 /* Get MPI firmware version. This will be used for
550  * driver banner and for ethtool info.
551  * Returns zero on success.
552  */
553 int ql_mb_about_fw(struct ql_adapter *qdev)
554 {
555         struct mbox_params mbc;
556         struct mbox_params *mbcp = &mbc;
557         int status = 0;
558
559         memset(mbcp, 0, sizeof(struct mbox_params));
560
561         mbcp->in_count = 1;
562         mbcp->out_count = 3;
563
564         mbcp->mbox_in[0] = MB_CMD_ABOUT_FW;
565
566         status = ql_mailbox_command(qdev, mbcp);
567         if (status)
568                 return status;
569
570         if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
571                 QPRINTK(qdev, DRV, ERR,
572                         "Failed about firmware command\n");
573                 status = -EIO;
574         }
575
576         /* Store the firmware version */
577         qdev->fw_rev_id = mbcp->mbox_out[1];
578
579         return status;
580 }
581
582 /* Get functional state for MPI firmware.
583  * Returns zero on success.
584  */
585 int ql_mb_get_fw_state(struct ql_adapter *qdev)
586 {
587         struct mbox_params mbc;
588         struct mbox_params *mbcp = &mbc;
589         int status = 0;
590
591         memset(mbcp, 0, sizeof(struct mbox_params));
592
593         mbcp->in_count = 1;
594         mbcp->out_count = 2;
595
596         mbcp->mbox_in[0] = MB_CMD_GET_FW_STATE;
597
598         status = ql_mailbox_command(qdev, mbcp);
599         if (status)
600                 return status;
601
602         if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
603                 QPRINTK(qdev, DRV, ERR,
604                         "Failed Get Firmware State.\n");
605                 status = -EIO;
606         }
607
608         /* If bit zero is set in mbx 1 then the firmware is
609          * running, but not initialized.  This should never
610          * happen.
611          */
612         if (mbcp->mbox_out[1] & 1) {
613                 QPRINTK(qdev, DRV, ERR,
614                         "Firmware waiting for initialization.\n");
615                 status = -EIO;
616         }
617
618         return status;
619 }
620
621 /* Send and ACK mailbox command to the firmware to
622  * let it continue with the change.
623  */
624 int ql_mb_idc_ack(struct ql_adapter *qdev)
625 {
626         struct mbox_params mbc;
627         struct mbox_params *mbcp = &mbc;
628         int status = 0;
629
630         memset(mbcp, 0, sizeof(struct mbox_params));
631
632         mbcp->in_count = 5;
633         mbcp->out_count = 1;
634
635         mbcp->mbox_in[0] = MB_CMD_IDC_ACK;
636         mbcp->mbox_in[1] = qdev->idc_mbc.mbox_out[1];
637         mbcp->mbox_in[2] = qdev->idc_mbc.mbox_out[2];
638         mbcp->mbox_in[3] = qdev->idc_mbc.mbox_out[3];
639         mbcp->mbox_in[4] = qdev->idc_mbc.mbox_out[4];
640
641         status = ql_mailbox_command(qdev, mbcp);
642         if (status)
643                 return status;
644
645         if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
646                 QPRINTK(qdev, DRV, ERR,
647                         "Failed IDC ACK send.\n");
648                 status = -EIO;
649         }
650         return status;
651 }
652
653 /* Get link settings and maximum frame size settings
654  * for the current port.
655  * Most likely will block.
656  */
657 static int ql_mb_set_port_cfg(struct ql_adapter *qdev)
658 {
659         struct mbox_params mbc;
660         struct mbox_params *mbcp = &mbc;
661         int status = 0;
662
663         memset(mbcp, 0, sizeof(struct mbox_params));
664
665         mbcp->in_count = 3;
666         mbcp->out_count = 1;
667
668         mbcp->mbox_in[0] = MB_CMD_SET_PORT_CFG;
669         mbcp->mbox_in[1] = qdev->link_config;
670         mbcp->mbox_in[2] = qdev->max_frame_size;
671
672
673         status = ql_mailbox_command(qdev, mbcp);
674         if (status)
675                 return status;
676
677         if (mbcp->mbox_out[0] == MB_CMD_STS_INTRMDT) {
678                 QPRINTK(qdev, DRV, ERR,
679                         "Port Config sent, wait for IDC.\n");
680         } else  if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
681                 QPRINTK(qdev, DRV, ERR,
682                         "Failed Set Port Configuration.\n");
683                 status = -EIO;
684         }
685         return status;
686 }
687
688 /* Get link settings and maximum frame size settings
689  * for the current port.
690  * Most likely will block.
691  */
692 static int ql_mb_get_port_cfg(struct ql_adapter *qdev)
693 {
694         struct mbox_params mbc;
695         struct mbox_params *mbcp = &mbc;
696         int status = 0;
697
698         memset(mbcp, 0, sizeof(struct mbox_params));
699
700         mbcp->in_count = 1;
701         mbcp->out_count = 3;
702
703         mbcp->mbox_in[0] = MB_CMD_GET_PORT_CFG;
704
705         status = ql_mailbox_command(qdev, mbcp);
706         if (status)
707                 return status;
708
709         if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
710                 QPRINTK(qdev, DRV, ERR,
711                         "Failed Get Port Configuration.\n");
712                 status = -EIO;
713         } else  {
714                 QPRINTK(qdev, DRV, DEBUG,
715                         "Passed Get Port Configuration.\n");
716                 qdev->link_config = mbcp->mbox_out[1];
717                 qdev->max_frame_size = mbcp->mbox_out[2];
718         }
719         return status;
720 }
721
722 /* IDC - Inter Device Communication...
723  * Some firmware commands require consent of adjacent FCOE
724  * function.  This function waits for the OK, or a
725  * counter-request for a little more time.i
726  * The firmware will complete the request if the other
727  * function doesn't respond.
728  */
729 static int ql_idc_wait(struct ql_adapter *qdev)
730 {
731         int status = -ETIMEDOUT;
732         long wait_time = 1 * HZ;
733         struct mbox_params *mbcp = &qdev->idc_mbc;
734         do {
735                 /* Wait here for the command to complete
736                  * via the IDC process.
737                  */
738                 wait_time =
739                         wait_for_completion_timeout(&qdev->ide_completion,
740                                                         wait_time);
741                 if (!wait_time) {
742                         QPRINTK(qdev, DRV, ERR,
743                                 "IDC Timeout.\n");
744                         break;
745                 }
746                 /* Now examine the response from the IDC process.
747                  * We might have a good completion or a request for
748                  * more wait time.
749                  */
750                 if (mbcp->mbox_out[0] == AEN_IDC_EXT) {
751                         QPRINTK(qdev, DRV, ERR,
752                                 "IDC Time Extension from function.\n");
753                         wait_time += (mbcp->mbox_out[1] >> 8) & 0x0000000f;
754                 } else if (mbcp->mbox_out[0] == AEN_IDC_CMPLT) {
755                         QPRINTK(qdev, DRV, ERR,
756                                 "IDC Success.\n");
757                         status = 0;
758                         break;
759                 } else {
760                         QPRINTK(qdev, DRV, ERR,
761                                 "IDC: Invalid State 0x%.04x.\n",
762                                 mbcp->mbox_out[0]);
763                         status = -EIO;
764                         break;
765                 }
766         } while (wait_time);
767
768         return status;
769 }
770
771 /* API called in work thread context to set new TX/RX
772  * maximum frame size values to match MTU.
773  */
774 static int ql_set_port_cfg(struct ql_adapter *qdev)
775 {
776         int status;
777         rtnl_lock();
778         status = ql_mb_set_port_cfg(qdev);
779         rtnl_unlock();
780         if (status)
781                 return status;
782         status = ql_idc_wait(qdev);
783         return status;
784 }
785
786 /* The following routines are worker threads that process
787  * events that may sleep waiting for completion.
788  */
789
790 /* This thread gets the maximum TX and RX frame size values
791  * from the firmware and, if necessary, changes them to match
792  * the MTU setting.
793  */
794 void ql_mpi_port_cfg_work(struct work_struct *work)
795 {
796         struct ql_adapter *qdev =
797             container_of(work, struct ql_adapter, mpi_port_cfg_work.work);
798         int status;
799
800         rtnl_lock();
801         status = ql_mb_get_port_cfg(qdev);
802         rtnl_unlock();
803         if (status) {
804                 QPRINTK(qdev, DRV, ERR,
805                         "Bug: Failed to get port config data.\n");
806                 goto err;
807         }
808
809         if (qdev->link_config & CFG_JUMBO_FRAME_SIZE &&
810                         qdev->max_frame_size ==
811                         CFG_DEFAULT_MAX_FRAME_SIZE)
812                 goto end;
813
814         qdev->link_config |=    CFG_JUMBO_FRAME_SIZE;
815         qdev->max_frame_size = CFG_DEFAULT_MAX_FRAME_SIZE;
816         status = ql_set_port_cfg(qdev);
817         if (status) {
818                 QPRINTK(qdev, DRV, ERR,
819                         "Bug: Failed to set port config data.\n");
820                 goto err;
821         }
822 end:
823         clear_bit(QL_PORT_CFG, &qdev->flags);
824         return;
825 err:
826         ql_queue_fw_error(qdev);
827         goto end;
828 }
829
830 /* Process an inter-device request.  This is issues by
831  * the firmware in response to another function requesting
832  * a change to the port. We set a flag to indicate a change
833  * has been made and then send a mailbox command ACKing
834  * the change request.
835  */
836 void ql_mpi_idc_work(struct work_struct *work)
837 {
838         struct ql_adapter *qdev =
839             container_of(work, struct ql_adapter, mpi_idc_work.work);
840         int status;
841         struct mbox_params *mbcp = &qdev->idc_mbc;
842         u32 aen;
843
844         aen = mbcp->mbox_out[1] >> 16;
845
846         switch (aen) {
847         default:
848                 QPRINTK(qdev, DRV, ERR,
849                         "Bug: Unhandled IDC action.\n");
850                 break;
851         case MB_CMD_PORT_RESET:
852         case MB_CMD_SET_PORT_CFG:
853         case MB_CMD_STOP_FW:
854                 ql_link_off(qdev);
855                 /* Signal the resulting link up AEN
856                  * that the frame routing and mac addr
857                  * needs to be set.
858                  * */
859                 set_bit(QL_CAM_RT_SET, &qdev->flags);
860                 rtnl_lock();
861                 status = ql_mb_idc_ack(qdev);
862                 rtnl_unlock();
863                 if (status) {
864                         QPRINTK(qdev, DRV, ERR,
865                         "Bug: No pending IDC!\n");
866                 }
867         }
868 }
869
870 void ql_mpi_work(struct work_struct *work)
871 {
872         struct ql_adapter *qdev =
873             container_of(work, struct ql_adapter, mpi_work.work);
874         struct mbox_params mbc;
875         struct mbox_params *mbcp = &mbc;
876         int err = 0;
877
878         rtnl_lock();
879
880         while (ql_read32(qdev, STS) & STS_PI) {
881                 memset(mbcp, 0, sizeof(struct mbox_params));
882                 mbcp->out_count = 1;
883                 /* Don't continue if an async event
884                  * did not complete properly.
885                  */
886                 err = ql_mpi_handler(qdev, mbcp);
887                 if (err)
888                         break;
889         }
890
891         rtnl_unlock();
892         ql_enable_completion_interrupt(qdev, 0);
893 }
894
895 void ql_mpi_reset_work(struct work_struct *work)
896 {
897         struct ql_adapter *qdev =
898             container_of(work, struct ql_adapter, mpi_reset_work.work);
899         cancel_delayed_work_sync(&qdev->mpi_work);
900         cancel_delayed_work_sync(&qdev->mpi_port_cfg_work);
901         cancel_delayed_work_sync(&qdev->mpi_idc_work);
902         ql_soft_reset_mpi_risc(qdev);
903 }