qlge: Fix timeout on firmware mailbox commands.
[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  * paramters, 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         netif_carrier_on(qdev->ndev);
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         netif_carrier_off(qdev->ndev);
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          * paramters, 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          * paramters 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         mutex_lock(&qdev->mpi_mutex);
476
477         /* Begin polled mode for MPI */
478         ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
479
480         /* Load the mailbox registers and wake up MPI RISC. */
481         status = ql_exec_mb_cmd(qdev, mbcp);
482         if (status)
483                 goto end;
484
485
486         /* If we're generating a system error, then there's nothing
487          * to wait for.
488          */
489         if (mbcp->mbox_in[0] == MB_CMD_MAKE_SYS_ERR)
490                 goto end;
491
492         /* Wait for the command to complete. We loop
493          * here because some AEN might arrive while
494          * we're waiting for the mailbox command to
495          * complete. If more than 5 arrive then we can
496          * assume something is wrong. */
497         count = 5;
498         do {
499                 /* Wait for the interrupt to come in. */
500                 status = ql_wait_mbx_cmd_cmplt(qdev);
501                 if (status)
502                         goto end;
503
504                 /* Process the event.  If it's an AEN, it
505                  * will be handled in-line or a worker
506                  * will be spawned. If it's our completion
507                  * we will catch it below.
508                  */
509                 status = ql_mpi_handler(qdev, mbcp);
510                 if (status)
511                         goto end;
512
513                 /* It's either the completion for our mailbox
514                  * command complete or an AEN.  If it's our
515                  * completion then get out.
516                  */
517                 if (((mbcp->mbox_out[0] & 0x0000f000) ==
518                                         MB_CMD_STS_GOOD) ||
519                         ((mbcp->mbox_out[0] & 0x0000f000) ==
520                                         MB_CMD_STS_INTRMDT))
521                         break;
522         } while (--count);
523
524         if (!count) {
525                 QPRINTK(qdev, DRV, ERR,
526                         "Timed out waiting for mailbox complete.\n");
527                 status = -ETIMEDOUT;
528                 goto end;
529         }
530
531         /* Now we can clear the interrupt condition
532          * and look at our status.
533          */
534         ql_write32(qdev, CSR, CSR_CMD_CLR_R2PCI_INT);
535
536         if (((mbcp->mbox_out[0] & 0x0000f000) !=
537                                         MB_CMD_STS_GOOD) &&
538                 ((mbcp->mbox_out[0] & 0x0000f000) !=
539                                         MB_CMD_STS_INTRMDT)) {
540                 ql_display_mb_sts(qdev, mbcp);
541                 status = -EIO;
542         }
543 end:
544         mutex_unlock(&qdev->mpi_mutex);
545         /* End polled mode for MPI */
546         ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16) | INTR_MASK_PI);
547         return status;
548 }
549
550 /* Get functional state for MPI firmware.
551  * Returns zero on success.
552  */
553 int ql_mb_get_fw_state(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 = 2;
563
564         mbcp->mbox_in[0] = MB_CMD_GET_FW_STATE;
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 Get Firmware State.\n");
573                 status = -EIO;
574         }
575
576         /* If bit zero is set in mbx 1 then the firmware is
577          * running, but not initialized.  This should never
578          * happen.
579          */
580         if (mbcp->mbox_out[1] & 1) {
581                 QPRINTK(qdev, DRV, ERR,
582                         "Firmware waiting for initialization.\n");
583                 status = -EIO;
584         }
585
586         return status;
587 }
588
589 /* Send and ACK mailbox command to the firmware to
590  * let it continue with the change.
591  */
592 int ql_mb_idc_ack(struct ql_adapter *qdev)
593 {
594         struct mbox_params mbc;
595         struct mbox_params *mbcp = &mbc;
596         int status = 0;
597
598         memset(mbcp, 0, sizeof(struct mbox_params));
599
600         mbcp->in_count = 5;
601         mbcp->out_count = 1;
602
603         mbcp->mbox_in[0] = MB_CMD_IDC_ACK;
604         mbcp->mbox_in[1] = qdev->idc_mbc.mbox_out[1];
605         mbcp->mbox_in[2] = qdev->idc_mbc.mbox_out[2];
606         mbcp->mbox_in[3] = qdev->idc_mbc.mbox_out[3];
607         mbcp->mbox_in[4] = qdev->idc_mbc.mbox_out[4];
608
609         status = ql_mailbox_command(qdev, mbcp);
610         if (status)
611                 return status;
612
613         if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
614                 QPRINTK(qdev, DRV, ERR,
615                         "Failed IDC ACK send.\n");
616                 status = -EIO;
617         }
618         return status;
619 }
620
621 /* Get link settings and maximum frame size settings
622  * for the current port.
623  * Most likely will block.
624  */
625 static int ql_mb_set_port_cfg(struct ql_adapter *qdev)
626 {
627         struct mbox_params mbc;
628         struct mbox_params *mbcp = &mbc;
629         int status = 0;
630
631         memset(mbcp, 0, sizeof(struct mbox_params));
632
633         mbcp->in_count = 3;
634         mbcp->out_count = 1;
635
636         mbcp->mbox_in[0] = MB_CMD_SET_PORT_CFG;
637         mbcp->mbox_in[1] = qdev->link_config;
638         mbcp->mbox_in[2] = qdev->max_frame_size;
639
640
641         status = ql_mailbox_command(qdev, mbcp);
642         if (status)
643                 return status;
644
645         if (mbcp->mbox_out[0] == MB_CMD_STS_INTRMDT) {
646                 QPRINTK(qdev, DRV, ERR,
647                         "Port Config sent, wait for IDC.\n");
648         } else  if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
649                 QPRINTK(qdev, DRV, ERR,
650                         "Failed Set Port Configuration.\n");
651                 status = -EIO;
652         }
653         return status;
654 }
655
656 /* Get link settings and maximum frame size settings
657  * for the current port.
658  * Most likely will block.
659  */
660 static int ql_mb_get_port_cfg(struct ql_adapter *qdev)
661 {
662         struct mbox_params mbc;
663         struct mbox_params *mbcp = &mbc;
664         int status = 0;
665
666         memset(mbcp, 0, sizeof(struct mbox_params));
667
668         mbcp->in_count = 1;
669         mbcp->out_count = 3;
670
671         mbcp->mbox_in[0] = MB_CMD_GET_PORT_CFG;
672
673         status = ql_mailbox_command(qdev, mbcp);
674         if (status)
675                 return status;
676
677         if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
678                 QPRINTK(qdev, DRV, ERR,
679                         "Failed Get Port Configuration.\n");
680                 status = -EIO;
681         } else  {
682                 QPRINTK(qdev, DRV, DEBUG,
683                         "Passed Get Port Configuration.\n");
684                 qdev->link_config = mbcp->mbox_out[1];
685                 qdev->max_frame_size = mbcp->mbox_out[2];
686         }
687         return status;
688 }
689
690 /* IDC - Inter Device Communication...
691  * Some firmware commands require consent of adjacent FCOE
692  * function.  This function waits for the OK, or a
693  * counter-request for a little more time.i
694  * The firmware will complete the request if the other
695  * function doesn't respond.
696  */
697 static int ql_idc_wait(struct ql_adapter *qdev)
698 {
699         int status = -ETIMEDOUT;
700         long wait_time = 1 * HZ;
701         struct mbox_params *mbcp = &qdev->idc_mbc;
702         do {
703                 /* Wait here for the command to complete
704                  * via the IDC process.
705                  */
706                 wait_time =
707                         wait_for_completion_timeout(&qdev->ide_completion,
708                                                         wait_time);
709                 if (!wait_time) {
710                         QPRINTK(qdev, DRV, ERR,
711                                 "IDC Timeout.\n");
712                         break;
713                 }
714                 /* Now examine the response from the IDC process.
715                  * We might have a good completion or a request for
716                  * more wait time.
717                  */
718                 if (mbcp->mbox_out[0] == AEN_IDC_EXT) {
719                         QPRINTK(qdev, DRV, ERR,
720                                 "IDC Time Extension from function.\n");
721                         wait_time += (mbcp->mbox_out[1] >> 8) & 0x0000000f;
722                 } else if (mbcp->mbox_out[0] == AEN_IDC_CMPLT) {
723                         QPRINTK(qdev, DRV, ERR,
724                                 "IDC Success.\n");
725                         status = 0;
726                         break;
727                 } else {
728                         QPRINTK(qdev, DRV, ERR,
729                                 "IDC: Invalid State 0x%.04x.\n",
730                                 mbcp->mbox_out[0]);
731                         status = -EIO;
732                         break;
733                 }
734         } while (wait_time);
735
736         return status;
737 }
738
739 /* API called in work thread context to set new TX/RX
740  * maximum frame size values to match MTU.
741  */
742 static int ql_set_port_cfg(struct ql_adapter *qdev)
743 {
744         int status;
745         status = ql_mb_set_port_cfg(qdev);
746         if (status)
747                 return status;
748         status = ql_idc_wait(qdev);
749         return status;
750 }
751
752 /* The following routines are worker threads that process
753  * events that may sleep waiting for completion.
754  */
755
756 /* This thread gets the maximum TX and RX frame size values
757  * from the firmware and, if necessary, changes them to match
758  * the MTU setting.
759  */
760 void ql_mpi_port_cfg_work(struct work_struct *work)
761 {
762         struct ql_adapter *qdev =
763             container_of(work, struct ql_adapter, mpi_port_cfg_work.work);
764         int status;
765
766         status = ql_mb_get_port_cfg(qdev);
767         if (status) {
768                 QPRINTK(qdev, DRV, ERR,
769                         "Bug: Failed to get port config data.\n");
770                 goto err;
771         }
772
773         if (qdev->link_config & CFG_JUMBO_FRAME_SIZE &&
774                         qdev->max_frame_size ==
775                         CFG_DEFAULT_MAX_FRAME_SIZE)
776                 goto end;
777
778         qdev->link_config |=    CFG_JUMBO_FRAME_SIZE;
779         qdev->max_frame_size = CFG_DEFAULT_MAX_FRAME_SIZE;
780         status = ql_set_port_cfg(qdev);
781         if (status) {
782                 QPRINTK(qdev, DRV, ERR,
783                         "Bug: Failed to set port config data.\n");
784                 goto err;
785         }
786 end:
787         clear_bit(QL_PORT_CFG, &qdev->flags);
788         return;
789 err:
790         ql_queue_fw_error(qdev);
791         goto end;
792 }
793
794 /* Process an inter-device request.  This is issues by
795  * the firmware in response to another function requesting
796  * a change to the port. We set a flag to indicate a change
797  * has been made and then send a mailbox command ACKing
798  * the change request.
799  */
800 void ql_mpi_idc_work(struct work_struct *work)
801 {
802         struct ql_adapter *qdev =
803             container_of(work, struct ql_adapter, mpi_idc_work.work);
804         int status;
805         struct mbox_params *mbcp = &qdev->idc_mbc;
806         u32 aen;
807
808         aen = mbcp->mbox_out[1] >> 16;
809
810         switch (aen) {
811         default:
812                 QPRINTK(qdev, DRV, ERR,
813                         "Bug: Unhandled IDC action.\n");
814                 break;
815         case MB_CMD_PORT_RESET:
816         case MB_CMD_SET_PORT_CFG:
817         case MB_CMD_STOP_FW:
818                 netif_carrier_off(qdev->ndev);
819                 /* Signal the resulting link up AEN
820                  * that the frame routing and mac addr
821                  * needs to be set.
822                  * */
823                 set_bit(QL_CAM_RT_SET, &qdev->flags);
824                 status = ql_mb_idc_ack(qdev);
825                 if (status) {
826                         QPRINTK(qdev, DRV, ERR,
827                         "Bug: No pending IDC!\n");
828                 }
829         }
830 }
831
832 void ql_mpi_work(struct work_struct *work)
833 {
834         struct ql_adapter *qdev =
835             container_of(work, struct ql_adapter, mpi_work.work);
836         struct mbox_params mbc;
837         struct mbox_params *mbcp = &mbc;
838         int err = 0;
839
840         mutex_lock(&qdev->mpi_mutex);
841
842         while (ql_read32(qdev, STS) & STS_PI) {
843                 memset(mbcp, 0, sizeof(struct mbox_params));
844                 mbcp->out_count = 1;
845                 /* Don't continue if an async event
846                  * did not complete properly.
847                  */
848                 err = ql_mpi_handler(qdev, mbcp);
849                 if (err)
850                         break;
851         }
852
853         mutex_unlock(&qdev->mpi_mutex);
854         ql_enable_completion_interrupt(qdev, 0);
855 }
856
857 void ql_mpi_reset_work(struct work_struct *work)
858 {
859         struct ql_adapter *qdev =
860             container_of(work, struct ql_adapter, mpi_reset_work.work);
861         cancel_delayed_work_sync(&qdev->mpi_work);
862         cancel_delayed_work_sync(&qdev->mpi_port_cfg_work);
863         cancel_delayed_work_sync(&qdev->mpi_idc_work);
864         ql_soft_reset_mpi_risc(qdev);
865 }