3 int ql_unpause_mpi_risc(struct ql_adapter *qdev)
7 /* Un-pause the RISC */
8 tmp = ql_read32(qdev, CSR);
12 ql_write32(qdev, CSR, CSR_CMD_CLR_PAUSE);
16 int ql_pause_mpi_risc(struct ql_adapter *qdev)
19 int count = UDELAY_COUNT;
22 ql_write32(qdev, CSR, CSR_CMD_SET_PAUSE);
24 tmp = ql_read32(qdev, CSR);
30 return (count == 0) ? -ETIMEDOUT : 0;
33 int ql_hard_reset_mpi_risc(struct ql_adapter *qdev)
36 int count = UDELAY_COUNT;
39 ql_write32(qdev, CSR, CSR_CMD_SET_RST);
41 tmp = ql_read32(qdev, CSR);
43 ql_write32(qdev, CSR, CSR_CMD_CLR_RST);
49 return (count == 0) ? -ETIMEDOUT : 0;
52 int ql_read_mpi_reg(struct ql_adapter *qdev, u32 reg, u32 *data)
55 /* wait for reg to come ready */
56 status = ql_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
59 /* set up for reg read */
60 ql_write32(qdev, PROC_ADDR, reg | PROC_ADDR_R);
61 /* wait for reg to come ready */
62 status = ql_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
66 *data = ql_read32(qdev, PROC_DATA);
71 int ql_write_mpi_reg(struct ql_adapter *qdev, u32 reg, u32 data)
74 /* wait for reg to come ready */
75 status = ql_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
78 /* write the data to the data reg */
79 ql_write32(qdev, PROC_DATA, data);
80 /* trigger the write */
81 ql_write32(qdev, PROC_ADDR, reg);
82 /* wait for reg to come ready */
83 status = ql_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
90 int ql_soft_reset_mpi_risc(struct ql_adapter *qdev)
93 status = ql_write_mpi_reg(qdev, 0x00001010, 1);
97 /* Determine if we are in charge of the firwmare. If
98 * we are the lower of the 2 NIC pcie functions, or if
99 * we are the higher function and the lower function
102 int ql_own_firmware(struct ql_adapter *qdev)
106 /* If we are the lower of the 2 NIC functions
107 * on the chip the we are responsible for
108 * core dump and firmware reset after an error.
110 if (qdev->func < qdev->alt_func)
113 /* If we are the higher of the 2 NIC functions
114 * on the chip and the lower function is not
115 * enabled, then we are responsible for
116 * core dump and firmware reset after an error.
118 temp = ql_read32(qdev, STS);
119 if (!(temp & (1 << (8 + qdev->alt_func))))
126 static int ql_get_mb_sts(struct ql_adapter *qdev, struct mbox_params *mbcp)
130 status = ql_sem_spinlock(qdev, SEM_PROC_REG_MASK);
133 for (i = 0; i < mbcp->out_count; i++) {
135 ql_read_mpi_reg(qdev, qdev->mailbox_out + i,
138 netif_err(qdev, drv, qdev->ndev, "Failed mailbox read.\n");
142 ql_sem_unlock(qdev, SEM_PROC_REG_MASK); /* does flush too */
146 /* Wait for a single mailbox command to complete.
147 * Returns zero on success.
149 static int ql_wait_mbx_cmd_cmplt(struct ql_adapter *qdev)
155 value = ql_read32(qdev, STS);
158 mdelay(UDELAY_DELAY); /* 100ms */
163 /* Execute a single mailbox command.
164 * Caller must hold PROC_ADDR semaphore.
166 static int ql_exec_mb_cmd(struct ql_adapter *qdev, struct mbox_params *mbcp)
171 * Make sure there's nothing pending.
172 * This shouldn't happen.
174 if (ql_read32(qdev, CSR) & CSR_HRI)
177 status = ql_sem_spinlock(qdev, SEM_PROC_REG_MASK);
182 * Fill the outbound mailboxes.
184 for (i = 0; i < mbcp->in_count; i++) {
185 status = ql_write_mpi_reg(qdev, qdev->mailbox_in + i,
191 * Wake up the MPI firmware.
193 ql_write32(qdev, CSR, CSR_CMD_SET_H2R_INT);
195 ql_sem_unlock(qdev, SEM_PROC_REG_MASK);
199 /* We are being asked by firmware to accept
200 * a change to the port. This is only
201 * a change to max frame sizes (Tx/Rx), pause
202 * parameters, or loopback mode. We wake up a worker
203 * to handler processing this since a mailbox command
204 * will need to be sent to ACK the request.
206 static int ql_idc_req_aen(struct ql_adapter *qdev)
209 struct mbox_params *mbcp = &qdev->idc_mbc;
211 netif_err(qdev, drv, qdev->ndev, "Enter!\n");
212 /* Get the status data and start up a thread to
213 * handle the request.
215 mbcp = &qdev->idc_mbc;
217 status = ql_get_mb_sts(qdev, mbcp);
219 netif_err(qdev, drv, qdev->ndev,
220 "Could not read MPI, resetting ASIC!\n");
221 ql_queue_asic_error(qdev);
223 /* Begin polled mode early so
224 * we don't get another interrupt
225 * when we leave mpi_worker.
227 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
228 queue_delayed_work(qdev->workqueue, &qdev->mpi_idc_work, 0);
233 /* Process an inter-device event completion.
234 * If good, signal the caller's completion.
236 static int ql_idc_cmplt_aen(struct ql_adapter *qdev)
239 struct mbox_params *mbcp = &qdev->idc_mbc;
241 status = ql_get_mb_sts(qdev, mbcp);
243 netif_err(qdev, drv, qdev->ndev,
244 "Could not read MPI, resetting RISC!\n");
245 ql_queue_fw_error(qdev);
247 /* Wake up the sleeping mpi_idc_work thread that is
248 * waiting for this event.
250 complete(&qdev->ide_completion);
255 static void ql_link_up(struct ql_adapter *qdev, struct mbox_params *mbcp)
260 status = ql_get_mb_sts(qdev, mbcp);
262 netif_err(qdev, drv, qdev->ndev,
263 "%s: Could not get mailbox status.\n", __func__);
267 qdev->link_status = mbcp->mbox_out[1];
268 netif_err(qdev, drv, qdev->ndev, "Link Up.\n");
270 /* If we're coming back from an IDC event
271 * then set up the CAM and frame routing.
273 if (test_bit(QL_CAM_RT_SET, &qdev->flags)) {
274 status = ql_cam_route_initialize(qdev);
276 netif_err(qdev, ifup, qdev->ndev,
277 "Failed to init CAM/Routing tables.\n");
280 clear_bit(QL_CAM_RT_SET, &qdev->flags);
283 /* Queue up a worker to check the frame
284 * size information, and fix it if it's not
287 if (!test_bit(QL_PORT_CFG, &qdev->flags)) {
288 netif_err(qdev, drv, qdev->ndev, "Queue Port Config Worker!\n");
289 set_bit(QL_PORT_CFG, &qdev->flags);
290 /* Begin polled mode early so
291 * we don't get another interrupt
292 * when we leave mpi_worker dpc.
294 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
295 queue_delayed_work(qdev->workqueue,
296 &qdev->mpi_port_cfg_work, 0);
302 static void ql_link_down(struct ql_adapter *qdev, struct mbox_params *mbcp)
308 status = ql_get_mb_sts(qdev, mbcp);
310 netif_err(qdev, drv, qdev->ndev, "Link down AEN broken!\n");
315 static int ql_sfp_in(struct ql_adapter *qdev, struct mbox_params *mbcp)
321 status = ql_get_mb_sts(qdev, mbcp);
323 netif_err(qdev, drv, qdev->ndev, "SFP in AEN broken!\n");
325 netif_err(qdev, drv, qdev->ndev, "SFP insertion detected.\n");
330 static int ql_sfp_out(struct ql_adapter *qdev, struct mbox_params *mbcp)
336 status = ql_get_mb_sts(qdev, mbcp);
338 netif_err(qdev, drv, qdev->ndev, "SFP out AEN broken!\n");
340 netif_err(qdev, drv, qdev->ndev, "SFP removal detected.\n");
345 static int ql_aen_lost(struct ql_adapter *qdev, struct mbox_params *mbcp)
351 status = ql_get_mb_sts(qdev, mbcp);
353 netif_err(qdev, drv, qdev->ndev, "Lost AEN broken!\n");
356 netif_err(qdev, drv, qdev->ndev, "Lost AEN detected.\n");
357 for (i = 0; i < mbcp->out_count; i++)
358 netif_err(qdev, drv, qdev->ndev, "mbox_out[%d] = 0x%.08x.\n",
359 i, mbcp->mbox_out[i]);
366 static void ql_init_fw_done(struct ql_adapter *qdev, struct mbox_params *mbcp)
372 status = ql_get_mb_sts(qdev, mbcp);
374 netif_err(qdev, drv, qdev->ndev, "Firmware did not initialize!\n");
376 netif_err(qdev, drv, qdev->ndev, "Firmware Revision = 0x%.08x.\n",
378 qdev->fw_rev_id = mbcp->mbox_out[1];
379 status = ql_cam_route_initialize(qdev);
381 netif_err(qdev, ifup, qdev->ndev,
382 "Failed to init CAM/Routing tables.\n");
386 /* Process an async event and clear it unless it's an
388 * This can get called iteratively from the mpi_work thread
389 * when events arrive via an interrupt.
390 * It also gets called when a mailbox command is polling for
391 * it's completion. */
392 static int ql_mpi_handler(struct ql_adapter *qdev, struct mbox_params *mbcp)
395 int orig_count = mbcp->out_count;
397 /* Just get mailbox zero for now. */
399 status = ql_get_mb_sts(qdev, mbcp);
401 netif_err(qdev, drv, qdev->ndev,
402 "Could not read MPI, resetting ASIC!\n");
403 ql_queue_asic_error(qdev);
407 switch (mbcp->mbox_out[0]) {
409 /* This case is only active when we arrive here
410 * as a result of issuing a mailbox command to
413 case MB_CMD_STS_INTRMDT:
414 case MB_CMD_STS_GOOD:
415 case MB_CMD_STS_INVLD_CMD:
416 case MB_CMD_STS_XFC_ERR:
417 case MB_CMD_STS_CSUM_ERR:
419 case MB_CMD_STS_PARAM_ERR:
420 /* We can only get mailbox status if we're polling from an
421 * unfinished command. Get the rest of the status data and
422 * return back to the caller.
423 * We only end up here when we're polling for a mailbox
424 * command completion.
426 mbcp->out_count = orig_count;
427 status = ql_get_mb_sts(qdev, mbcp);
430 /* We are being asked by firmware to accept
431 * a change to the port. This is only
432 * a change to max frame sizes (Tx/Rx), pause
433 * parameters, or loopback mode.
436 status = ql_idc_req_aen(qdev);
439 /* Process and inbound IDC event.
440 * This will happen when we're trying to
441 * change tx/rx max frame size, change pause
442 * parameters or loopback mode.
446 status = ql_idc_cmplt_aen(qdev);
450 ql_link_up(qdev, mbcp);
454 ql_link_down(qdev, mbcp);
457 case AEN_FW_INIT_DONE:
458 /* If we're in process on executing the firmware,
459 * then convert the status to normal mailbox status.
461 if (mbcp->mbox_in[0] == MB_CMD_EX_FW) {
462 mbcp->out_count = orig_count;
463 status = ql_get_mb_sts(qdev, mbcp);
464 mbcp->mbox_out[0] = MB_CMD_STS_GOOD;
467 ql_init_fw_done(qdev, mbcp);
471 ql_sfp_in(qdev, mbcp);
474 case AEN_AEN_SFP_OUT:
475 ql_sfp_out(qdev, mbcp);
478 /* This event can arrive at boot time or after an
479 * MPI reset if the firmware failed to initialize.
481 case AEN_FW_INIT_FAIL:
482 /* If we're in process on executing the firmware,
483 * then convert the status to normal mailbox status.
485 if (mbcp->mbox_in[0] == MB_CMD_EX_FW) {
486 mbcp->out_count = orig_count;
487 status = ql_get_mb_sts(qdev, mbcp);
488 mbcp->mbox_out[0] = MB_CMD_STS_ERR;
491 netif_err(qdev, drv, qdev->ndev,
492 "Firmware initialization failed.\n");
494 ql_queue_fw_error(qdev);
498 netif_err(qdev, drv, qdev->ndev, "System Error.\n");
499 ql_queue_fw_error(qdev);
504 ql_aen_lost(qdev, mbcp);
508 /* Need to support AEN 8110 */
511 netif_err(qdev, drv, qdev->ndev,
512 "Unsupported AE %.08x.\n", mbcp->mbox_out[0]);
513 /* Clear the MPI firmware status. */
516 ql_write32(qdev, CSR, CSR_CMD_CLR_R2PCI_INT);
517 /* Restore the original mailbox count to
518 * what the caller asked for. This can get
519 * changed when a mailbox command is waiting
520 * for a response and an AEN arrives and
523 mbcp->out_count = orig_count;
527 /* Execute a single mailbox command.
528 * mbcp is a pointer to an array of u32. Each
529 * element in the array contains the value for it's
530 * respective mailbox register.
532 static int ql_mailbox_command(struct ql_adapter *qdev, struct mbox_params *mbcp)
538 /* Begin polled mode for MPI */
539 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
541 /* Load the mailbox registers and wake up MPI RISC. */
542 status = ql_exec_mb_cmd(qdev, mbcp);
547 /* If we're generating a system error, then there's nothing
550 if (mbcp->mbox_in[0] == MB_CMD_MAKE_SYS_ERR)
553 /* Wait for the command to complete. We loop
554 * here because some AEN might arrive while
555 * we're waiting for the mailbox command to
556 * complete. If more than 5 seconds expire we can
557 * assume something is wrong. */
558 count = jiffies + HZ * MAILBOX_TIMEOUT;
560 /* Wait for the interrupt to come in. */
561 status = ql_wait_mbx_cmd_cmplt(qdev);
565 /* Process the event. If it's an AEN, it
566 * will be handled in-line or a worker
567 * will be spawned. If it's our completion
568 * we will catch it below.
570 status = ql_mpi_handler(qdev, mbcp);
574 /* It's either the completion for our mailbox
575 * command complete or an AEN. If it's our
576 * completion then get out.
578 if (((mbcp->mbox_out[0] & 0x0000f000) ==
580 ((mbcp->mbox_out[0] & 0x0000f000) ==
583 } while (time_before(jiffies, count));
585 netif_err(qdev, drv, qdev->ndev,
586 "Timed out waiting for mailbox complete.\n");
592 /* Now we can clear the interrupt condition
593 * and look at our status.
595 ql_write32(qdev, CSR, CSR_CMD_CLR_R2PCI_INT);
597 if (((mbcp->mbox_out[0] & 0x0000f000) !=
599 ((mbcp->mbox_out[0] & 0x0000f000) !=
600 MB_CMD_STS_INTRMDT)) {
604 /* End polled mode for MPI */
605 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16) | INTR_MASK_PI);
609 int ql_mb_sys_err(struct ql_adapter *qdev)
611 struct mbox_params mbc;
612 struct mbox_params *mbcp = &mbc;
615 memset(mbcp, 0, sizeof(struct mbox_params));
620 mbcp->mbox_in[0] = MB_CMD_MAKE_SYS_ERR;
622 status = ql_mailbox_command(qdev, mbcp);
626 /* Get MPI firmware version. This will be used for
627 * driver banner and for ethtool info.
628 * Returns zero on success.
630 int ql_mb_about_fw(struct ql_adapter *qdev)
632 struct mbox_params mbc;
633 struct mbox_params *mbcp = &mbc;
636 memset(mbcp, 0, sizeof(struct mbox_params));
641 mbcp->mbox_in[0] = MB_CMD_ABOUT_FW;
643 status = ql_mailbox_command(qdev, mbcp);
647 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
648 netif_err(qdev, drv, qdev->ndev,
649 "Failed about firmware command\n");
653 /* Store the firmware version */
654 qdev->fw_rev_id = mbcp->mbox_out[1];
659 /* Get functional state for MPI firmware.
660 * Returns zero on success.
662 int ql_mb_get_fw_state(struct ql_adapter *qdev)
664 struct mbox_params mbc;
665 struct mbox_params *mbcp = &mbc;
668 memset(mbcp, 0, sizeof(struct mbox_params));
673 mbcp->mbox_in[0] = MB_CMD_GET_FW_STATE;
675 status = ql_mailbox_command(qdev, mbcp);
679 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
680 netif_err(qdev, drv, qdev->ndev,
681 "Failed Get Firmware State.\n");
685 /* If bit zero is set in mbx 1 then the firmware is
686 * running, but not initialized. This should never
689 if (mbcp->mbox_out[1] & 1) {
690 netif_err(qdev, drv, qdev->ndev,
691 "Firmware waiting for initialization.\n");
698 /* Send and ACK mailbox command to the firmware to
699 * let it continue with the change.
701 int ql_mb_idc_ack(struct ql_adapter *qdev)
703 struct mbox_params mbc;
704 struct mbox_params *mbcp = &mbc;
707 memset(mbcp, 0, sizeof(struct mbox_params));
712 mbcp->mbox_in[0] = MB_CMD_IDC_ACK;
713 mbcp->mbox_in[1] = qdev->idc_mbc.mbox_out[1];
714 mbcp->mbox_in[2] = qdev->idc_mbc.mbox_out[2];
715 mbcp->mbox_in[3] = qdev->idc_mbc.mbox_out[3];
716 mbcp->mbox_in[4] = qdev->idc_mbc.mbox_out[4];
718 status = ql_mailbox_command(qdev, mbcp);
722 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
723 netif_err(qdev, drv, qdev->ndev, "Failed IDC ACK send.\n");
729 /* Get link settings and maximum frame size settings
730 * for the current port.
731 * Most likely will block.
733 int ql_mb_set_port_cfg(struct ql_adapter *qdev)
735 struct mbox_params mbc;
736 struct mbox_params *mbcp = &mbc;
739 memset(mbcp, 0, sizeof(struct mbox_params));
744 mbcp->mbox_in[0] = MB_CMD_SET_PORT_CFG;
745 mbcp->mbox_in[1] = qdev->link_config;
746 mbcp->mbox_in[2] = qdev->max_frame_size;
749 status = ql_mailbox_command(qdev, mbcp);
753 if (mbcp->mbox_out[0] == MB_CMD_STS_INTRMDT) {
754 netif_err(qdev, drv, qdev->ndev,
755 "Port Config sent, wait for IDC.\n");
756 } else if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
757 netif_err(qdev, drv, qdev->ndev,
758 "Failed Set Port Configuration.\n");
764 int ql_mb_dump_ram(struct ql_adapter *qdev, u64 req_dma, u32 addr,
768 struct mbox_params mbc;
769 struct mbox_params *mbcp = &mbc;
771 memset(mbcp, 0, sizeof(struct mbox_params));
776 mbcp->mbox_in[0] = MB_CMD_DUMP_RISC_RAM;
777 mbcp->mbox_in[1] = LSW(addr);
778 mbcp->mbox_in[2] = MSW(req_dma);
779 mbcp->mbox_in[3] = LSW(req_dma);
780 mbcp->mbox_in[4] = MSW(size);
781 mbcp->mbox_in[5] = LSW(size);
782 mbcp->mbox_in[6] = MSW(MSD(req_dma));
783 mbcp->mbox_in[7] = LSW(MSD(req_dma));
784 mbcp->mbox_in[8] = MSW(addr);
787 status = ql_mailbox_command(qdev, mbcp);
791 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
792 netif_err(qdev, drv, qdev->ndev, "Failed to dump risc RAM.\n");
798 /* Issue a mailbox command to dump RISC RAM. */
799 int ql_dump_risc_ram_area(struct ql_adapter *qdev, void *buf,
800 u32 ram_addr, int word_count)
806 my_buf = pci_alloc_consistent(qdev->pdev, word_count * sizeof(u32),
811 status = ql_mb_dump_ram(qdev, buf_dma, ram_addr, word_count);
813 memcpy(buf, my_buf, word_count * sizeof(u32));
815 pci_free_consistent(qdev->pdev, word_count * sizeof(u32), my_buf,
820 /* Get link settings and maximum frame size settings
821 * for the current port.
822 * Most likely will block.
824 int ql_mb_get_port_cfg(struct ql_adapter *qdev)
826 struct mbox_params mbc;
827 struct mbox_params *mbcp = &mbc;
830 memset(mbcp, 0, sizeof(struct mbox_params));
835 mbcp->mbox_in[0] = MB_CMD_GET_PORT_CFG;
837 status = ql_mailbox_command(qdev, mbcp);
841 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
842 netif_err(qdev, drv, qdev->ndev,
843 "Failed Get Port Configuration.\n");
846 netif_printk(qdev, drv, KERN_DEBUG, qdev->ndev,
847 "Passed Get Port Configuration.\n");
848 qdev->link_config = mbcp->mbox_out[1];
849 qdev->max_frame_size = mbcp->mbox_out[2];
854 int ql_mb_wol_mode(struct ql_adapter *qdev, u32 wol)
856 struct mbox_params mbc;
857 struct mbox_params *mbcp = &mbc;
860 memset(mbcp, 0, sizeof(struct mbox_params));
865 mbcp->mbox_in[0] = MB_CMD_SET_WOL_MODE;
866 mbcp->mbox_in[1] = wol;
869 status = ql_mailbox_command(qdev, mbcp);
873 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
874 netif_err(qdev, drv, qdev->ndev, "Failed to set WOL mode.\n");
880 int ql_mb_wol_set_magic(struct ql_adapter *qdev, u32 enable_wol)
882 struct mbox_params mbc;
883 struct mbox_params *mbcp = &mbc;
885 u8 *addr = qdev->ndev->dev_addr;
887 memset(mbcp, 0, sizeof(struct mbox_params));
892 mbcp->mbox_in[0] = MB_CMD_SET_WOL_MAGIC;
894 mbcp->mbox_in[1] = (u32)addr[0];
895 mbcp->mbox_in[2] = (u32)addr[1];
896 mbcp->mbox_in[3] = (u32)addr[2];
897 mbcp->mbox_in[4] = (u32)addr[3];
898 mbcp->mbox_in[5] = (u32)addr[4];
899 mbcp->mbox_in[6] = (u32)addr[5];
900 mbcp->mbox_in[7] = 0;
902 mbcp->mbox_in[1] = 0;
903 mbcp->mbox_in[2] = 1;
904 mbcp->mbox_in[3] = 1;
905 mbcp->mbox_in[4] = 1;
906 mbcp->mbox_in[5] = 1;
907 mbcp->mbox_in[6] = 1;
908 mbcp->mbox_in[7] = 0;
911 status = ql_mailbox_command(qdev, mbcp);
915 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
916 netif_err(qdev, drv, qdev->ndev, "Failed to set WOL mode.\n");
922 /* IDC - Inter Device Communication...
923 * Some firmware commands require consent of adjacent FCOE
924 * function. This function waits for the OK, or a
925 * counter-request for a little more time.i
926 * The firmware will complete the request if the other
927 * function doesn't respond.
929 static int ql_idc_wait(struct ql_adapter *qdev)
931 int status = -ETIMEDOUT;
932 long wait_time = 1 * HZ;
933 struct mbox_params *mbcp = &qdev->idc_mbc;
935 /* Wait here for the command to complete
936 * via the IDC process.
939 wait_for_completion_timeout(&qdev->ide_completion,
942 netif_err(qdev, drv, qdev->ndev, "IDC Timeout.\n");
945 /* Now examine the response from the IDC process.
946 * We might have a good completion or a request for
949 if (mbcp->mbox_out[0] == AEN_IDC_EXT) {
950 netif_err(qdev, drv, qdev->ndev,
951 "IDC Time Extension from function.\n");
952 wait_time += (mbcp->mbox_out[1] >> 8) & 0x0000000f;
953 } else if (mbcp->mbox_out[0] == AEN_IDC_CMPLT) {
954 netif_err(qdev, drv, qdev->ndev, "IDC Success.\n");
958 netif_err(qdev, drv, qdev->ndev,
959 "IDC: Invalid State 0x%.04x.\n",
969 int ql_mb_set_led_cfg(struct ql_adapter *qdev, u32 led_config)
971 struct mbox_params mbc;
972 struct mbox_params *mbcp = &mbc;
975 memset(mbcp, 0, sizeof(struct mbox_params));
980 mbcp->mbox_in[0] = MB_CMD_SET_LED_CFG;
981 mbcp->mbox_in[1] = led_config;
984 status = ql_mailbox_command(qdev, mbcp);
988 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
989 netif_err(qdev, drv, qdev->ndev,
990 "Failed to set LED Configuration.\n");
997 int ql_mb_get_led_cfg(struct ql_adapter *qdev)
999 struct mbox_params mbc;
1000 struct mbox_params *mbcp = &mbc;
1003 memset(mbcp, 0, sizeof(struct mbox_params));
1006 mbcp->out_count = 2;
1008 mbcp->mbox_in[0] = MB_CMD_GET_LED_CFG;
1010 status = ql_mailbox_command(qdev, mbcp);
1014 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
1015 netif_err(qdev, drv, qdev->ndev,
1016 "Failed to get LED Configuration.\n");
1019 qdev->led_config = mbcp->mbox_out[1];
1024 int ql_mb_set_mgmnt_traffic_ctl(struct ql_adapter *qdev, u32 control)
1026 struct mbox_params mbc;
1027 struct mbox_params *mbcp = &mbc;
1030 memset(mbcp, 0, sizeof(struct mbox_params));
1033 mbcp->out_count = 2;
1035 mbcp->mbox_in[0] = MB_CMD_SET_MGMNT_TFK_CTL;
1036 mbcp->mbox_in[1] = control;
1038 status = ql_mailbox_command(qdev, mbcp);
1042 if (mbcp->mbox_out[0] == MB_CMD_STS_GOOD)
1045 if (mbcp->mbox_out[0] == MB_CMD_STS_INVLD_CMD) {
1046 netif_err(qdev, drv, qdev->ndev,
1047 "Command not supported by firmware.\n");
1049 } else if (mbcp->mbox_out[0] == MB_CMD_STS_ERR) {
1050 /* This indicates that the firmware is
1051 * already in the state we are trying to
1054 netif_err(qdev, drv, qdev->ndev,
1055 "Command parameters make no change.\n");
1060 /* Returns a negative error code or the mailbox command status. */
1061 static int ql_mb_get_mgmnt_traffic_ctl(struct ql_adapter *qdev, u32 *control)
1063 struct mbox_params mbc;
1064 struct mbox_params *mbcp = &mbc;
1067 memset(mbcp, 0, sizeof(struct mbox_params));
1071 mbcp->out_count = 1;
1073 mbcp->mbox_in[0] = MB_CMD_GET_MGMNT_TFK_CTL;
1075 status = ql_mailbox_command(qdev, mbcp);
1079 if (mbcp->mbox_out[0] == MB_CMD_STS_GOOD) {
1080 *control = mbcp->mbox_in[1];
1084 if (mbcp->mbox_out[0] == MB_CMD_STS_INVLD_CMD) {
1085 netif_err(qdev, drv, qdev->ndev,
1086 "Command not supported by firmware.\n");
1088 } else if (mbcp->mbox_out[0] == MB_CMD_STS_ERR) {
1089 netif_err(qdev, drv, qdev->ndev,
1090 "Failed to get MPI traffic control.\n");
1096 int ql_wait_fifo_empty(struct ql_adapter *qdev)
1099 u32 mgmnt_fifo_empty;
1103 nic_fifo_empty = ql_read32(qdev, STS) & STS_NFE;
1104 ql_mb_get_mgmnt_traffic_ctl(qdev, &mgmnt_fifo_empty);
1105 mgmnt_fifo_empty &= MB_GET_MPI_TFK_FIFO_EMPTY;
1106 if (nic_fifo_empty && mgmnt_fifo_empty)
1109 } while (count-- > 0);
1113 /* API called in work thread context to set new TX/RX
1114 * maximum frame size values to match MTU.
1116 static int ql_set_port_cfg(struct ql_adapter *qdev)
1120 status = ql_mb_set_port_cfg(qdev);
1124 status = ql_idc_wait(qdev);
1128 /* The following routines are worker threads that process
1129 * events that may sleep waiting for completion.
1132 /* This thread gets the maximum TX and RX frame size values
1133 * from the firmware and, if necessary, changes them to match
1136 void ql_mpi_port_cfg_work(struct work_struct *work)
1138 struct ql_adapter *qdev =
1139 container_of(work, struct ql_adapter, mpi_port_cfg_work.work);
1143 status = ql_mb_get_port_cfg(qdev);
1146 netif_err(qdev, drv, qdev->ndev,
1147 "Bug: Failed to get port config data.\n");
1151 if (qdev->link_config & CFG_JUMBO_FRAME_SIZE &&
1152 qdev->max_frame_size ==
1153 CFG_DEFAULT_MAX_FRAME_SIZE)
1156 qdev->link_config |= CFG_JUMBO_FRAME_SIZE;
1157 qdev->max_frame_size = CFG_DEFAULT_MAX_FRAME_SIZE;
1158 status = ql_set_port_cfg(qdev);
1160 netif_err(qdev, drv, qdev->ndev,
1161 "Bug: Failed to set port config data.\n");
1165 clear_bit(QL_PORT_CFG, &qdev->flags);
1168 ql_queue_fw_error(qdev);
1172 /* Process an inter-device request. This is issues by
1173 * the firmware in response to another function requesting
1174 * a change to the port. We set a flag to indicate a change
1175 * has been made and then send a mailbox command ACKing
1176 * the change request.
1178 void ql_mpi_idc_work(struct work_struct *work)
1180 struct ql_adapter *qdev =
1181 container_of(work, struct ql_adapter, mpi_idc_work.work);
1183 struct mbox_params *mbcp = &qdev->idc_mbc;
1188 aen = mbcp->mbox_out[1] >> 16;
1189 timeout = (mbcp->mbox_out[1] >> 8) & 0xf;
1193 netif_err(qdev, drv, qdev->ndev,
1194 "Bug: Unhandled IDC action.\n");
1196 case MB_CMD_PORT_RESET:
1197 case MB_CMD_STOP_FW:
1199 case MB_CMD_SET_PORT_CFG:
1200 /* Signal the resulting link up AEN
1201 * that the frame routing and mac addr
1204 set_bit(QL_CAM_RT_SET, &qdev->flags);
1205 /* Do ACK if required */
1207 status = ql_mb_idc_ack(qdev);
1209 netif_err(qdev, drv, qdev->ndev,
1210 "Bug: No pending IDC!\n");
1212 netif_printk(qdev, drv, KERN_DEBUG, qdev->ndev,
1213 "IDC ACK not required\n");
1214 status = 0; /* success */
1218 /* These sub-commands issued by another (FCoE)
1219 * function are requesting to do an operation
1220 * on the shared resource (MPI environment).
1221 * We currently don't issue these so we just
1224 case MB_CMD_IOP_RESTART_MPI:
1225 case MB_CMD_IOP_PREP_LINK_DOWN:
1226 /* Drop the link, reload the routing
1227 * table when link comes up.
1230 set_bit(QL_CAM_RT_SET, &qdev->flags);
1232 case MB_CMD_IOP_DVR_START:
1233 case MB_CMD_IOP_FLASH_ACC:
1234 case MB_CMD_IOP_CORE_DUMP_MPI:
1235 case MB_CMD_IOP_PREP_UPDATE_MPI:
1236 case MB_CMD_IOP_COMP_UPDATE_MPI:
1237 case MB_CMD_IOP_NONE: /* an IDC without params */
1238 /* Do ACK if required */
1240 status = ql_mb_idc_ack(qdev);
1242 netif_err(qdev, drv, qdev->ndev,
1243 "Bug: No pending IDC!\n");
1245 netif_printk(qdev, drv, KERN_DEBUG, qdev->ndev,
1246 "IDC ACK not required\n");
1247 status = 0; /* success */
1254 void ql_mpi_work(struct work_struct *work)
1256 struct ql_adapter *qdev =
1257 container_of(work, struct ql_adapter, mpi_work.work);
1258 struct mbox_params mbc;
1259 struct mbox_params *mbcp = &mbc;
1263 /* Begin polled mode for MPI */
1264 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
1266 while (ql_read32(qdev, STS) & STS_PI) {
1267 memset(mbcp, 0, sizeof(struct mbox_params));
1268 mbcp->out_count = 1;
1269 /* Don't continue if an async event
1270 * did not complete properly.
1272 err = ql_mpi_handler(qdev, mbcp);
1277 /* End polled mode for MPI */
1278 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16) | INTR_MASK_PI);
1280 ql_enable_completion_interrupt(qdev, 0);
1283 void ql_mpi_reset_work(struct work_struct *work)
1285 struct ql_adapter *qdev =
1286 container_of(work, struct ql_adapter, mpi_reset_work.work);
1287 cancel_delayed_work_sync(&qdev->mpi_work);
1288 cancel_delayed_work_sync(&qdev->mpi_port_cfg_work);
1289 cancel_delayed_work_sync(&qdev->mpi_idc_work);
1290 /* If we're not the dominant NIC function,
1291 * then there is nothing to do.
1293 if (!ql_own_firmware(qdev)) {
1294 netif_err(qdev, drv, qdev->ndev, "Don't own firmware!\n");
1298 if (!ql_core_dump(qdev, qdev->mpi_coredump)) {
1299 netif_err(qdev, drv, qdev->ndev, "Core is dumped!\n");
1300 qdev->core_is_dumped = 1;
1301 queue_delayed_work(qdev->workqueue,
1302 &qdev->mpi_core_to_log, 5 * HZ);
1304 ql_soft_reset_mpi_risc(qdev);