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