1 // SPDX-License-Identifier: GPL-2.0
4 int qlge_unpause_mpi_risc(struct qlge_adapter *qdev)
8 /* Un-pause the RISC */
9 tmp = qlge_read32(qdev, CSR);
13 qlge_write32(qdev, CSR, CSR_CMD_CLR_PAUSE);
17 int qlge_pause_mpi_risc(struct qlge_adapter *qdev)
23 qlge_write32(qdev, CSR, CSR_CMD_SET_PAUSE);
24 for (count = UDELAY_COUNT; count; count--) {
25 tmp = qlge_read32(qdev, CSR);
30 return (count == 0) ? -ETIMEDOUT : 0;
33 int qlge_hard_reset_mpi_risc(struct qlge_adapter *qdev)
39 qlge_write32(qdev, CSR, CSR_CMD_SET_RST);
40 for (count = UDELAY_COUNT; count; count--) {
41 tmp = qlge_read32(qdev, CSR);
43 qlge_write32(qdev, CSR, CSR_CMD_CLR_RST);
48 return (count == 0) ? -ETIMEDOUT : 0;
51 int qlge_read_mpi_reg(struct qlge_adapter *qdev, u32 reg, u32 *data)
54 /* wait for reg to come ready */
55 status = qlge_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
58 /* set up for reg read */
59 qlge_write32(qdev, PROC_ADDR, reg | PROC_ADDR_R);
60 /* wait for reg to come ready */
61 status = qlge_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
65 *data = qlge_read32(qdev, PROC_DATA);
70 int qlge_write_mpi_reg(struct qlge_adapter *qdev, u32 reg, u32 data)
73 /* wait for reg to come ready */
74 status = qlge_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
77 /* write the data to the data reg */
78 qlge_write32(qdev, PROC_DATA, data);
79 /* trigger the write */
80 qlge_write32(qdev, PROC_ADDR, reg);
81 /* wait for reg to come ready */
82 status = qlge_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
89 int qlge_soft_reset_mpi_risc(struct qlge_adapter *qdev)
91 return qlge_write_mpi_reg(qdev, 0x00001010, 1);
94 /* Determine if we are in charge of the firmware. If
95 * we are the lower of the 2 NIC pcie functions, or if
96 * we are the higher function and the lower function
99 int qlge_own_firmware(struct qlge_adapter *qdev)
103 /* If we are the lower of the 2 NIC functions
104 * on the chip the we are responsible for
105 * core dump and firmware reset after an error.
107 if (qdev->func < qdev->alt_func)
110 /* If we are the higher of the 2 NIC functions
111 * on the chip and the lower function is not
112 * enabled, then we are responsible for
113 * core dump and firmware reset after an error.
115 temp = qlge_read32(qdev, STS);
116 if (!(temp & (1 << (8 + qdev->alt_func))))
122 static int qlge_get_mb_sts(struct qlge_adapter *qdev, struct mbox_params *mbcp)
126 status = qlge_sem_spinlock(qdev, SEM_PROC_REG_MASK);
129 for (i = 0; i < mbcp->out_count; i++) {
131 qlge_read_mpi_reg(qdev, qdev->mailbox_out + i,
134 netif_err(qdev, drv, qdev->ndev, "Failed mailbox read.\n");
138 qlge_sem_unlock(qdev, SEM_PROC_REG_MASK); /* does flush too */
142 /* Wait for a single mailbox command to complete.
143 * Returns zero on success.
145 static int qlge_wait_mbx_cmd_cmplt(struct qlge_adapter *qdev)
150 for (count = 100; count; count--) {
151 value = qlge_read32(qdev, STS);
154 mdelay(UDELAY_DELAY); /* 100ms */
159 /* Execute a single mailbox command.
160 * Caller must hold PROC_ADDR semaphore.
162 static int qlge_exec_mb_cmd(struct qlge_adapter *qdev, struct mbox_params *mbcp)
167 * Make sure there's nothing pending.
168 * This shouldn't happen.
170 if (qlge_read32(qdev, CSR) & CSR_HRI)
173 status = qlge_sem_spinlock(qdev, SEM_PROC_REG_MASK);
178 * Fill the outbound mailboxes.
180 for (i = 0; i < mbcp->in_count; i++) {
181 status = qlge_write_mpi_reg(qdev, qdev->mailbox_in + i,
187 * Wake up the MPI firmware.
189 qlge_write32(qdev, CSR, CSR_CMD_SET_H2R_INT);
191 qlge_sem_unlock(qdev, SEM_PROC_REG_MASK);
195 /* We are being asked by firmware to accept
196 * a change to the port. This is only
197 * a change to max frame sizes (Tx/Rx), pause
198 * parameters, or loopback mode. We wake up a worker
199 * to handler processing this since a mailbox command
200 * will need to be sent to ACK the request.
202 static int qlge_idc_req_aen(struct qlge_adapter *qdev)
205 struct mbox_params *mbcp = &qdev->idc_mbc;
207 netif_err(qdev, drv, qdev->ndev, "Enter!\n");
208 /* Get the status data and start up a thread to
209 * handle the request.
212 status = qlge_get_mb_sts(qdev, mbcp);
214 netif_err(qdev, drv, qdev->ndev,
215 "Could not read MPI, resetting ASIC!\n");
216 qlge_queue_asic_error(qdev);
218 /* Begin polled mode early so
219 * we don't get another interrupt
220 * when we leave mpi_worker.
222 qlge_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
223 queue_delayed_work(qdev->workqueue, &qdev->mpi_idc_work, 0);
228 /* Process an inter-device event completion.
229 * If good, signal the caller's completion.
231 static int qlge_idc_cmplt_aen(struct qlge_adapter *qdev)
234 struct mbox_params *mbcp = &qdev->idc_mbc;
237 status = qlge_get_mb_sts(qdev, mbcp);
239 netif_err(qdev, drv, qdev->ndev,
240 "Could not read MPI, resetting RISC!\n");
241 qlge_queue_fw_error(qdev);
243 /* Wake up the sleeping mpi_idc_work thread that is
244 * waiting for this event.
246 complete(&qdev->ide_completion);
251 static void qlge_link_up(struct qlge_adapter *qdev, struct mbox_params *mbcp)
257 status = qlge_get_mb_sts(qdev, mbcp);
259 netif_err(qdev, drv, qdev->ndev,
260 "%s: Could not get mailbox status.\n", __func__);
264 qdev->link_status = mbcp->mbox_out[1];
265 netif_err(qdev, drv, qdev->ndev, "Link Up.\n");
267 /* If we're coming back from an IDC event
268 * then set up the CAM and frame routing.
270 if (test_bit(QL_CAM_RT_SET, &qdev->flags)) {
271 status = qlge_cam_route_initialize(qdev);
273 netif_err(qdev, ifup, qdev->ndev,
274 "Failed to init CAM/Routing tables.\n");
277 clear_bit(QL_CAM_RT_SET, &qdev->flags);
280 /* Queue up a worker to check the frame
281 * size information, and fix it if it's not
284 if (!test_bit(QL_PORT_CFG, &qdev->flags)) {
285 netif_err(qdev, drv, qdev->ndev, "Queue Port Config Worker!\n");
286 set_bit(QL_PORT_CFG, &qdev->flags);
287 /* Begin polled mode early so
288 * we don't get another interrupt
289 * when we leave mpi_worker dpc.
291 qlge_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
292 queue_delayed_work(qdev->workqueue,
293 &qdev->mpi_port_cfg_work, 0);
299 static void qlge_link_down(struct qlge_adapter *qdev, struct mbox_params *mbcp)
305 status = qlge_get_mb_sts(qdev, mbcp);
307 netif_err(qdev, drv, qdev->ndev, "Link down AEN broken!\n");
312 static int qlge_sfp_in(struct qlge_adapter *qdev, struct mbox_params *mbcp)
318 status = qlge_get_mb_sts(qdev, mbcp);
320 netif_err(qdev, drv, qdev->ndev, "SFP in AEN broken!\n");
322 netif_err(qdev, drv, qdev->ndev, "SFP insertion detected.\n");
327 static int qlge_sfp_out(struct qlge_adapter *qdev, struct mbox_params *mbcp)
333 status = qlge_get_mb_sts(qdev, mbcp);
335 netif_err(qdev, drv, qdev->ndev, "SFP out AEN broken!\n");
337 netif_err(qdev, drv, qdev->ndev, "SFP removal detected.\n");
342 static int qlge_aen_lost(struct qlge_adapter *qdev, struct mbox_params *mbcp)
348 status = qlge_get_mb_sts(qdev, mbcp);
350 netif_err(qdev, drv, qdev->ndev, "Lost AEN broken!\n");
354 netif_err(qdev, drv, qdev->ndev, "Lost AEN detected.\n");
355 for (i = 0; i < mbcp->out_count; i++)
356 netif_err(qdev, drv, qdev->ndev, "mbox_out[%d] = 0x%.08x.\n",
357 i, mbcp->mbox_out[i]);
363 static void qlge_init_fw_done(struct qlge_adapter *qdev, struct mbox_params *mbcp)
369 status = qlge_get_mb_sts(qdev, mbcp);
371 netif_err(qdev, drv, qdev->ndev, "Firmware did not initialize!\n");
373 netif_err(qdev, drv, qdev->ndev, "Firmware Revision = 0x%.08x.\n",
375 qdev->fw_rev_id = mbcp->mbox_out[1];
376 status = qlge_cam_route_initialize(qdev);
378 netif_err(qdev, ifup, qdev->ndev,
379 "Failed to init CAM/Routing tables.\n");
383 /* Process an async event and clear it unless it's an
385 * This can get called iteratively from the mpi_work thread
386 * when events arrive via an interrupt.
387 * It also gets called when a mailbox command is polling for
390 static int qlge_mpi_handler(struct qlge_adapter *qdev, struct mbox_params *mbcp)
393 int orig_count = mbcp->out_count;
395 /* Just get mailbox zero for now. */
397 status = qlge_get_mb_sts(qdev, mbcp);
399 netif_err(qdev, drv, qdev->ndev,
400 "Could not read MPI, resetting ASIC!\n");
401 qlge_queue_asic_error(qdev);
405 switch (mbcp->mbox_out[0]) {
406 /* This case is only active when we arrive here
407 * as a result of issuing a mailbox command to
410 case MB_CMD_STS_INTRMDT:
411 case MB_CMD_STS_GOOD:
412 case MB_CMD_STS_INVLD_CMD:
413 case MB_CMD_STS_XFC_ERR:
414 case MB_CMD_STS_CSUM_ERR:
416 case MB_CMD_STS_PARAM_ERR:
417 /* We can only get mailbox status if we're polling from an
418 * unfinished command. Get the rest of the status data and
419 * return back to the caller.
420 * We only end up here when we're polling for a mailbox
421 * command completion.
423 mbcp->out_count = orig_count;
424 status = qlge_get_mb_sts(qdev, mbcp);
427 /* We are being asked by firmware to accept
428 * a change to the port. This is only
429 * a change to max frame sizes (Tx/Rx), pause
430 * parameters, or loopback mode.
433 status = qlge_idc_req_aen(qdev);
436 /* Process and inbound IDC event.
437 * This will happen when we're trying to
438 * change tx/rx max frame size, change pause
439 * parameters or loopback mode.
443 status = qlge_idc_cmplt_aen(qdev);
447 qlge_link_up(qdev, mbcp);
451 qlge_link_down(qdev, mbcp);
454 case AEN_FW_INIT_DONE:
455 /* If we're in process on executing the firmware,
456 * then convert the status to normal mailbox status.
458 if (mbcp->mbox_in[0] == MB_CMD_EX_FW) {
459 mbcp->out_count = orig_count;
460 status = qlge_get_mb_sts(qdev, mbcp);
461 mbcp->mbox_out[0] = MB_CMD_STS_GOOD;
464 qlge_init_fw_done(qdev, mbcp);
468 qlge_sfp_in(qdev, mbcp);
471 case AEN_AEN_SFP_OUT:
472 qlge_sfp_out(qdev, mbcp);
475 /* This event can arrive at boot time or after an
476 * MPI reset if the firmware failed to initialize.
478 case AEN_FW_INIT_FAIL:
479 /* If we're in process on executing the firmware,
480 * then convert the status to normal mailbox status.
482 if (mbcp->mbox_in[0] == MB_CMD_EX_FW) {
483 mbcp->out_count = orig_count;
484 status = qlge_get_mb_sts(qdev, mbcp);
485 mbcp->mbox_out[0] = MB_CMD_STS_ERR;
488 netif_err(qdev, drv, qdev->ndev,
489 "Firmware initialization failed.\n");
491 qlge_queue_fw_error(qdev);
495 netif_err(qdev, drv, qdev->ndev, "System Error.\n");
496 qlge_queue_fw_error(qdev);
501 qlge_aen_lost(qdev, mbcp);
505 /* Need to support AEN 8110 */
508 netif_err(qdev, drv, qdev->ndev,
509 "Unsupported AE %.08x.\n", mbcp->mbox_out[0]);
510 /* Clear the MPI firmware status. */
513 qlge_write32(qdev, CSR, CSR_CMD_CLR_R2PCI_INT);
514 /* Restore the original mailbox count to
515 * what the caller asked for. This can get
516 * changed when a mailbox command is waiting
517 * for a response and an AEN arrives and
520 mbcp->out_count = orig_count;
524 /* Execute a single mailbox command.
525 * mbcp is a pointer to an array of u32. Each
526 * element in the array contains the value for it's
527 * respective mailbox register.
529 static int qlge_mailbox_command(struct qlge_adapter *qdev, struct mbox_params *mbcp)
534 mutex_lock(&qdev->mpi_mutex);
536 /* Begin polled mode for MPI */
537 qlge_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
539 /* Load the mailbox registers and wake up MPI RISC. */
540 status = qlge_exec_mb_cmd(qdev, mbcp);
544 /* If we're generating a system error, then there's nothing
547 if (mbcp->mbox_in[0] == MB_CMD_MAKE_SYS_ERR)
550 /* Wait for the command to complete. We loop
551 * here because some AEN might arrive while
552 * we're waiting for the mailbox command to
553 * complete. If more than 5 seconds expire we can
554 * assume something is wrong.
556 count = jiffies + HZ * MAILBOX_TIMEOUT;
558 /* Wait for the interrupt to come in. */
559 status = qlge_wait_mbx_cmd_cmplt(qdev);
563 /* Process the event. If it's an AEN, it
564 * will be handled in-line or a worker
565 * will be spawned. If it's our completion
566 * we will catch it below.
568 status = qlge_mpi_handler(qdev, mbcp);
572 /* It's either the completion for our mailbox
573 * command complete or an AEN. If it's our
574 * completion then get out.
576 if (((mbcp->mbox_out[0] & 0x0000f000) ==
578 ((mbcp->mbox_out[0] & 0x0000f000) ==
581 } while (time_before(jiffies, count));
583 netif_err(qdev, drv, qdev->ndev,
584 "Timed out waiting for mailbox complete.\n");
590 /* Now we can clear the interrupt condition
591 * and look at our status.
593 qlge_write32(qdev, CSR, CSR_CMD_CLR_R2PCI_INT);
595 if (((mbcp->mbox_out[0] & 0x0000f000) !=
597 ((mbcp->mbox_out[0] & 0x0000f000) !=
598 MB_CMD_STS_INTRMDT)) {
602 /* End polled mode for MPI */
603 qlge_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16) | INTR_MASK_PI);
604 mutex_unlock(&qdev->mpi_mutex);
608 /* Get MPI firmware version. This will be used for
609 * driver banner and for ethtool info.
610 * Returns zero on success.
612 int qlge_mb_about_fw(struct qlge_adapter *qdev)
614 struct mbox_params mbc;
615 struct mbox_params *mbcp = &mbc;
618 memset(mbcp, 0, sizeof(struct mbox_params));
623 mbcp->mbox_in[0] = MB_CMD_ABOUT_FW;
625 status = qlge_mailbox_command(qdev, mbcp);
629 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
630 netif_err(qdev, drv, qdev->ndev,
631 "Failed about firmware command\n");
635 /* Store the firmware version */
636 qdev->fw_rev_id = mbcp->mbox_out[1];
641 /* Get functional state for MPI firmware.
642 * Returns zero on success.
644 int qlge_mb_get_fw_state(struct qlge_adapter *qdev)
646 struct mbox_params mbc;
647 struct mbox_params *mbcp = &mbc;
650 memset(mbcp, 0, sizeof(struct mbox_params));
655 mbcp->mbox_in[0] = MB_CMD_GET_FW_STATE;
657 status = qlge_mailbox_command(qdev, mbcp);
661 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
662 netif_err(qdev, drv, qdev->ndev,
663 "Failed Get Firmware State.\n");
667 /* If bit zero is set in mbx 1 then the firmware is
668 * running, but not initialized. This should never
671 if (mbcp->mbox_out[1] & 1) {
672 netif_err(qdev, drv, qdev->ndev,
673 "Firmware waiting for initialization.\n");
680 /* Send and ACK mailbox command to the firmware to
681 * let it continue with the change.
683 static int qlge_mb_idc_ack(struct qlge_adapter *qdev)
685 struct mbox_params mbc;
686 struct mbox_params *mbcp = &mbc;
689 memset(mbcp, 0, sizeof(struct mbox_params));
694 mbcp->mbox_in[0] = MB_CMD_IDC_ACK;
695 mbcp->mbox_in[1] = qdev->idc_mbc.mbox_out[1];
696 mbcp->mbox_in[2] = qdev->idc_mbc.mbox_out[2];
697 mbcp->mbox_in[3] = qdev->idc_mbc.mbox_out[3];
698 mbcp->mbox_in[4] = qdev->idc_mbc.mbox_out[4];
700 status = qlge_mailbox_command(qdev, mbcp);
704 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
705 netif_err(qdev, drv, qdev->ndev, "Failed IDC ACK send.\n");
711 /* Get link settings and maximum frame size settings
712 * for the current port.
713 * Most likely will block.
715 int qlge_mb_set_port_cfg(struct qlge_adapter *qdev)
717 struct mbox_params mbc;
718 struct mbox_params *mbcp = &mbc;
721 memset(mbcp, 0, sizeof(struct mbox_params));
726 mbcp->mbox_in[0] = MB_CMD_SET_PORT_CFG;
727 mbcp->mbox_in[1] = qdev->link_config;
728 mbcp->mbox_in[2] = qdev->max_frame_size;
730 status = qlge_mailbox_command(qdev, mbcp);
734 if (mbcp->mbox_out[0] == MB_CMD_STS_INTRMDT) {
735 netif_err(qdev, drv, qdev->ndev,
736 "Port Config sent, wait for IDC.\n");
737 } else if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
738 netif_err(qdev, drv, qdev->ndev,
739 "Failed Set Port Configuration.\n");
745 static int qlge_mb_dump_ram(struct qlge_adapter *qdev, u64 req_dma, u32 addr,
749 struct mbox_params mbc;
750 struct mbox_params *mbcp = &mbc;
752 memset(mbcp, 0, sizeof(struct mbox_params));
757 mbcp->mbox_in[0] = MB_CMD_DUMP_RISC_RAM;
758 mbcp->mbox_in[1] = LSW(addr);
759 mbcp->mbox_in[2] = MSW(req_dma);
760 mbcp->mbox_in[3] = LSW(req_dma);
761 mbcp->mbox_in[4] = MSW(size);
762 mbcp->mbox_in[5] = LSW(size);
763 mbcp->mbox_in[6] = MSW(MSD(req_dma));
764 mbcp->mbox_in[7] = LSW(MSD(req_dma));
765 mbcp->mbox_in[8] = MSW(addr);
767 status = qlge_mailbox_command(qdev, mbcp);
771 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
772 netif_err(qdev, drv, qdev->ndev, "Failed to dump risc RAM.\n");
778 /* Issue a mailbox command to dump RISC RAM. */
779 int qlge_dump_risc_ram_area(struct qlge_adapter *qdev, void *buf,
780 u32 ram_addr, int word_count)
786 my_buf = dma_alloc_coherent(&qdev->pdev->dev,
787 word_count * sizeof(u32), &buf_dma,
792 status = qlge_mb_dump_ram(qdev, buf_dma, ram_addr, word_count);
794 memcpy(buf, my_buf, word_count * sizeof(u32));
796 dma_free_coherent(&qdev->pdev->dev, word_count * sizeof(u32), my_buf,
801 /* Get link settings and maximum frame size settings
802 * for the current port.
803 * Most likely will block.
805 int qlge_mb_get_port_cfg(struct qlge_adapter *qdev)
807 struct mbox_params mbc;
808 struct mbox_params *mbcp = &mbc;
811 memset(mbcp, 0, sizeof(struct mbox_params));
816 mbcp->mbox_in[0] = MB_CMD_GET_PORT_CFG;
818 status = qlge_mailbox_command(qdev, mbcp);
822 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
823 netif_err(qdev, drv, qdev->ndev,
824 "Failed Get Port Configuration.\n");
827 netif_printk(qdev, drv, KERN_DEBUG, qdev->ndev,
828 "Passed Get Port Configuration.\n");
829 qdev->link_config = mbcp->mbox_out[1];
830 qdev->max_frame_size = mbcp->mbox_out[2];
835 int qlge_mb_wol_mode(struct qlge_adapter *qdev, u32 wol)
837 struct mbox_params mbc;
838 struct mbox_params *mbcp = &mbc;
841 memset(mbcp, 0, sizeof(struct mbox_params));
846 mbcp->mbox_in[0] = MB_CMD_SET_WOL_MODE;
847 mbcp->mbox_in[1] = wol;
849 status = qlge_mailbox_command(qdev, mbcp);
853 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
854 netif_err(qdev, drv, qdev->ndev, "Failed to set WOL mode.\n");
860 int qlge_mb_wol_set_magic(struct qlge_adapter *qdev, u32 enable_wol)
862 struct mbox_params mbc;
863 struct mbox_params *mbcp = &mbc;
865 u8 *addr = qdev->ndev->dev_addr;
867 memset(mbcp, 0, sizeof(struct mbox_params));
872 mbcp->mbox_in[0] = MB_CMD_SET_WOL_MAGIC;
874 mbcp->mbox_in[1] = (u32)addr[0];
875 mbcp->mbox_in[2] = (u32)addr[1];
876 mbcp->mbox_in[3] = (u32)addr[2];
877 mbcp->mbox_in[4] = (u32)addr[3];
878 mbcp->mbox_in[5] = (u32)addr[4];
879 mbcp->mbox_in[6] = (u32)addr[5];
880 mbcp->mbox_in[7] = 0;
882 mbcp->mbox_in[1] = 0;
883 mbcp->mbox_in[2] = 1;
884 mbcp->mbox_in[3] = 1;
885 mbcp->mbox_in[4] = 1;
886 mbcp->mbox_in[5] = 1;
887 mbcp->mbox_in[6] = 1;
888 mbcp->mbox_in[7] = 0;
891 status = qlge_mailbox_command(qdev, mbcp);
895 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
896 netif_err(qdev, drv, qdev->ndev, "Failed to set WOL mode.\n");
902 /* IDC - Inter Device Communication...
903 * Some firmware commands require consent of adjacent FCOE
904 * function. This function waits for the OK, or a
905 * counter-request for a little more time.i
906 * The firmware will complete the request if the other
907 * function doesn't respond.
909 static int qlge_idc_wait(struct qlge_adapter *qdev)
911 int status = -ETIMEDOUT;
912 struct mbox_params *mbcp = &qdev->idc_mbc;
915 for (wait_time = 1 * HZ; wait_time;) {
916 /* Wait here for the command to complete
917 * via the IDC process.
920 wait_for_completion_timeout(&qdev->ide_completion,
923 netif_err(qdev, drv, qdev->ndev, "IDC Timeout.\n");
926 /* Now examine the response from the IDC process.
927 * We might have a good completion or a request for
930 if (mbcp->mbox_out[0] == AEN_IDC_EXT) {
931 netif_err(qdev, drv, qdev->ndev,
932 "IDC Time Extension from function.\n");
933 wait_time += (mbcp->mbox_out[1] >> 8) & 0x0000000f;
934 } else if (mbcp->mbox_out[0] == AEN_IDC_CMPLT) {
935 netif_err(qdev, drv, qdev->ndev, "IDC Success.\n");
939 netif_err(qdev, drv, qdev->ndev,
940 "IDC: Invalid State 0x%.04x.\n",
950 int qlge_mb_set_led_cfg(struct qlge_adapter *qdev, u32 led_config)
952 struct mbox_params mbc;
953 struct mbox_params *mbcp = &mbc;
956 memset(mbcp, 0, sizeof(struct mbox_params));
961 mbcp->mbox_in[0] = MB_CMD_SET_LED_CFG;
962 mbcp->mbox_in[1] = led_config;
964 status = qlge_mailbox_command(qdev, mbcp);
968 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
969 netif_err(qdev, drv, qdev->ndev,
970 "Failed to set LED Configuration.\n");
977 int qlge_mb_get_led_cfg(struct qlge_adapter *qdev)
979 struct mbox_params mbc;
980 struct mbox_params *mbcp = &mbc;
983 memset(mbcp, 0, sizeof(struct mbox_params));
988 mbcp->mbox_in[0] = MB_CMD_GET_LED_CFG;
990 status = qlge_mailbox_command(qdev, mbcp);
994 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
995 netif_err(qdev, drv, qdev->ndev,
996 "Failed to get LED Configuration.\n");
999 qdev->led_config = mbcp->mbox_out[1];
1004 int qlge_mb_set_mgmnt_traffic_ctl(struct qlge_adapter *qdev, u32 control)
1006 struct mbox_params mbc;
1007 struct mbox_params *mbcp = &mbc;
1010 memset(mbcp, 0, sizeof(struct mbox_params));
1013 mbcp->out_count = 2;
1015 mbcp->mbox_in[0] = MB_CMD_SET_MGMNT_TFK_CTL;
1016 mbcp->mbox_in[1] = control;
1018 status = qlge_mailbox_command(qdev, mbcp);
1022 if (mbcp->mbox_out[0] == MB_CMD_STS_GOOD)
1025 if (mbcp->mbox_out[0] == MB_CMD_STS_INVLD_CMD) {
1026 netif_err(qdev, drv, qdev->ndev,
1027 "Command not supported by firmware.\n");
1029 } else if (mbcp->mbox_out[0] == MB_CMD_STS_ERR) {
1030 /* This indicates that the firmware is
1031 * already in the state we are trying to
1034 netif_err(qdev, drv, qdev->ndev,
1035 "Command parameters make no change.\n");
1040 /* Returns a negative error code or the mailbox command status. */
1041 static int qlge_mb_get_mgmnt_traffic_ctl(struct qlge_adapter *qdev, u32 *control)
1043 struct mbox_params mbc;
1044 struct mbox_params *mbcp = &mbc;
1047 memset(mbcp, 0, sizeof(struct mbox_params));
1051 mbcp->out_count = 1;
1053 mbcp->mbox_in[0] = MB_CMD_GET_MGMNT_TFK_CTL;
1055 status = qlge_mailbox_command(qdev, mbcp);
1059 if (mbcp->mbox_out[0] == MB_CMD_STS_GOOD) {
1060 *control = mbcp->mbox_in[1];
1064 if (mbcp->mbox_out[0] == MB_CMD_STS_INVLD_CMD) {
1065 netif_err(qdev, drv, qdev->ndev,
1066 "Command not supported by firmware.\n");
1068 } else if (mbcp->mbox_out[0] == MB_CMD_STS_ERR) {
1069 netif_err(qdev, drv, qdev->ndev,
1070 "Failed to get MPI traffic control.\n");
1076 int qlge_wait_fifo_empty(struct qlge_adapter *qdev)
1079 u32 mgmnt_fifo_empty;
1082 for (count = 6; count; count--) {
1083 nic_fifo_empty = qlge_read32(qdev, STS) & STS_NFE;
1084 qlge_mb_get_mgmnt_traffic_ctl(qdev, &mgmnt_fifo_empty);
1085 mgmnt_fifo_empty &= MB_GET_MPI_TFK_FIFO_EMPTY;
1086 if (nic_fifo_empty && mgmnt_fifo_empty)
1093 /* API called in work thread context to set new TX/RX
1094 * maximum frame size values to match MTU.
1096 static int qlge_set_port_cfg(struct qlge_adapter *qdev)
1100 status = qlge_mb_set_port_cfg(qdev);
1103 status = qlge_idc_wait(qdev);
1107 /* The following routines are worker threads that process
1108 * events that may sleep waiting for completion.
1111 /* This thread gets the maximum TX and RX frame size values
1112 * from the firmware and, if necessary, changes them to match
1115 void qlge_mpi_port_cfg_work(struct work_struct *work)
1117 struct qlge_adapter *qdev =
1118 container_of(work, struct qlge_adapter, mpi_port_cfg_work.work);
1121 status = qlge_mb_get_port_cfg(qdev);
1123 netif_err(qdev, drv, qdev->ndev,
1124 "Bug: Failed to get port config data.\n");
1128 if (qdev->link_config & CFG_JUMBO_FRAME_SIZE &&
1129 qdev->max_frame_size == CFG_DEFAULT_MAX_FRAME_SIZE)
1132 qdev->link_config |= CFG_JUMBO_FRAME_SIZE;
1133 qdev->max_frame_size = CFG_DEFAULT_MAX_FRAME_SIZE;
1134 status = qlge_set_port_cfg(qdev);
1136 netif_err(qdev, drv, qdev->ndev,
1137 "Bug: Failed to set port config data.\n");
1141 clear_bit(QL_PORT_CFG, &qdev->flags);
1144 qlge_queue_fw_error(qdev);
1148 /* Process an inter-device request. This is issues by
1149 * the firmware in response to another function requesting
1150 * a change to the port. We set a flag to indicate a change
1151 * has been made and then send a mailbox command ACKing
1152 * the change request.
1154 void qlge_mpi_idc_work(struct work_struct *work)
1156 struct qlge_adapter *qdev =
1157 container_of(work, struct qlge_adapter, mpi_idc_work.work);
1159 struct mbox_params *mbcp = &qdev->idc_mbc;
1163 aen = mbcp->mbox_out[1] >> 16;
1164 timeout = (mbcp->mbox_out[1] >> 8) & 0xf;
1168 netif_err(qdev, drv, qdev->ndev,
1169 "Bug: Unhandled IDC action.\n");
1171 case MB_CMD_PORT_RESET:
1172 case MB_CMD_STOP_FW:
1173 qlge_link_off(qdev);
1175 case MB_CMD_SET_PORT_CFG:
1176 /* Signal the resulting link up AEN
1177 * that the frame routing and mac addr
1180 set_bit(QL_CAM_RT_SET, &qdev->flags);
1181 /* Do ACK if required */
1183 status = qlge_mb_idc_ack(qdev);
1185 netif_err(qdev, drv, qdev->ndev,
1186 "Bug: No pending IDC!\n");
1188 netif_printk(qdev, drv, KERN_DEBUG, qdev->ndev,
1189 "IDC ACK not required\n");
1190 status = 0; /* success */
1194 /* These sub-commands issued by another (FCoE)
1195 * function are requesting to do an operation
1196 * on the shared resource (MPI environment).
1197 * We currently don't issue these so we just
1200 case MB_CMD_IOP_RESTART_MPI:
1201 case MB_CMD_IOP_PREP_LINK_DOWN:
1202 /* Drop the link, reload the routing
1203 * table when link comes up.
1205 qlge_link_off(qdev);
1206 set_bit(QL_CAM_RT_SET, &qdev->flags);
1208 case MB_CMD_IOP_DVR_START:
1209 case MB_CMD_IOP_FLASH_ACC:
1210 case MB_CMD_IOP_CORE_DUMP_MPI:
1211 case MB_CMD_IOP_PREP_UPDATE_MPI:
1212 case MB_CMD_IOP_COMP_UPDATE_MPI:
1213 case MB_CMD_IOP_NONE: /* an IDC without params */
1214 /* Do ACK if required */
1216 status = qlge_mb_idc_ack(qdev);
1218 netif_err(qdev, drv, qdev->ndev,
1219 "Bug: No pending IDC!\n");
1221 netif_printk(qdev, drv, KERN_DEBUG, qdev->ndev,
1222 "IDC ACK not required\n");
1223 status = 0; /* success */
1229 void qlge_mpi_work(struct work_struct *work)
1231 struct qlge_adapter *qdev =
1232 container_of(work, struct qlge_adapter, mpi_work.work);
1233 struct mbox_params mbc;
1234 struct mbox_params *mbcp = &mbc;
1237 mutex_lock(&qdev->mpi_mutex);
1238 /* Begin polled mode for MPI */
1239 qlge_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
1241 while (qlge_read32(qdev, STS) & STS_PI) {
1242 memset(mbcp, 0, sizeof(struct mbox_params));
1243 mbcp->out_count = 1;
1244 /* Don't continue if an async event
1245 * did not complete properly.
1247 err = qlge_mpi_handler(qdev, mbcp);
1252 /* End polled mode for MPI */
1253 qlge_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16) | INTR_MASK_PI);
1254 mutex_unlock(&qdev->mpi_mutex);
1257 void qlge_mpi_reset_work(struct work_struct *work)
1259 struct qlge_adapter *qdev =
1260 container_of(work, struct qlge_adapter, mpi_reset_work.work);
1261 cancel_delayed_work_sync(&qdev->mpi_work);
1262 cancel_delayed_work_sync(&qdev->mpi_port_cfg_work);
1263 cancel_delayed_work_sync(&qdev->mpi_idc_work);
1264 /* If we're not the dominant NIC function,
1265 * then there is nothing to do.
1267 if (!qlge_own_firmware(qdev)) {
1268 netif_err(qdev, drv, qdev->ndev, "Don't own firmware!\n");
1272 qlge_soft_reset_mpi_risc(qdev);