3 static void ql_display_mb_sts(struct ql_adapter *qdev,
4 struct mbox_params *mbcp)
7 static char *err_sts[] = {
9 "Command Not Supported",
10 "Host Interface Error",
12 "Unused Completion Status",
14 "Command Parameter Error"};
16 QPRINTK(qdev, DRV, DEBUG, "%s.\n",
17 err_sts[mbcp->mbox_out[0] & 0x0000000f]);
18 for (i = 0; i < mbcp->out_count; i++)
19 QPRINTK(qdev, DRV, DEBUG, "mbox_out[%d] = 0x%.08x.\n",
20 i, mbcp->mbox_out[i]);
23 int ql_read_mpi_reg(struct ql_adapter *qdev, u32 reg, u32 *data)
26 /* wait for reg to come ready */
27 status = ql_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
30 /* set up for reg read */
31 ql_write32(qdev, PROC_ADDR, reg | PROC_ADDR_R);
32 /* wait for reg to come ready */
33 status = ql_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
37 *data = ql_read32(qdev, PROC_DATA);
42 int ql_write_mpi_reg(struct ql_adapter *qdev, u32 reg, u32 data)
45 /* wait for reg to come ready */
46 status = ql_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
49 /* write the data to the data reg */
50 ql_write32(qdev, PROC_DATA, data);
51 /* trigger the write */
52 ql_write32(qdev, PROC_ADDR, reg);
53 /* wait for reg to come ready */
54 status = ql_wait_reg_rdy(qdev, PROC_ADDR, PROC_ADDR_RDY, PROC_ADDR_ERR);
61 int ql_soft_reset_mpi_risc(struct ql_adapter *qdev)
64 status = ql_write_mpi_reg(qdev, 0x00001010, 1);
68 static int ql_get_mb_sts(struct ql_adapter *qdev, struct mbox_params *mbcp)
72 status = ql_sem_spinlock(qdev, SEM_PROC_REG_MASK);
75 for (i = 0; i < mbcp->out_count; i++) {
77 ql_read_mpi_reg(qdev, qdev->mailbox_out + i,
80 QPRINTK(qdev, DRV, ERR, "Failed mailbox read.\n");
84 ql_sem_unlock(qdev, SEM_PROC_REG_MASK); /* does flush too */
88 /* Wait for a single mailbox command to complete.
89 * Returns zero on success.
91 static int ql_wait_mbx_cmd_cmplt(struct ql_adapter *qdev)
93 int count = 50; /* TODO: arbitrary for now. */
97 value = ql_read32(qdev, STS);
100 udelay(UDELAY_DELAY); /* 10us */
105 /* Execute a single mailbox command.
106 * Caller must hold PROC_ADDR semaphore.
108 static int ql_exec_mb_cmd(struct ql_adapter *qdev, struct mbox_params *mbcp)
113 * Make sure there's nothing pending.
114 * This shouldn't happen.
116 if (ql_read32(qdev, CSR) & CSR_HRI)
119 status = ql_sem_spinlock(qdev, SEM_PROC_REG_MASK);
124 * Fill the outbound mailboxes.
126 for (i = 0; i < mbcp->in_count; i++) {
127 status = ql_write_mpi_reg(qdev, qdev->mailbox_in + i,
133 * Wake up the MPI firmware.
135 ql_write32(qdev, CSR, CSR_CMD_SET_H2R_INT);
137 ql_sem_unlock(qdev, SEM_PROC_REG_MASK);
141 /* We are being asked by firmware to accept
142 * a change to the port. This is only
143 * a change to max frame sizes (Tx/Rx), pause
144 * paramters, or loopback mode. We wake up a worker
145 * to handler processing this since a mailbox command
146 * will need to be sent to ACK the request.
148 static int ql_idc_req_aen(struct ql_adapter *qdev)
151 struct mbox_params *mbcp = &qdev->idc_mbc;
153 QPRINTK(qdev, DRV, ERR, "Enter!\n");
154 /* Get the status data and start up a thread to
155 * handle the request.
157 mbcp = &qdev->idc_mbc;
159 status = ql_get_mb_sts(qdev, mbcp);
161 QPRINTK(qdev, DRV, ERR,
162 "Could not read MPI, resetting ASIC!\n");
163 ql_queue_asic_error(qdev);
165 /* Begin polled mode early so
166 * we don't get another interrupt
167 * when we leave mpi_worker.
169 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
170 queue_delayed_work(qdev->workqueue, &qdev->mpi_idc_work, 0);
175 /* Process an inter-device event completion.
176 * If good, signal the caller's completion.
178 static int ql_idc_cmplt_aen(struct ql_adapter *qdev)
181 struct mbox_params *mbcp = &qdev->idc_mbc;
183 status = ql_get_mb_sts(qdev, mbcp);
185 QPRINTK(qdev, DRV, ERR,
186 "Could not read MPI, resetting RISC!\n");
187 ql_queue_fw_error(qdev);
189 /* Wake up the sleeping mpi_idc_work thread that is
190 * waiting for this event.
192 complete(&qdev->ide_completion);
197 static void ql_link_up(struct ql_adapter *qdev, struct mbox_params *mbcp)
202 status = ql_get_mb_sts(qdev, mbcp);
204 QPRINTK(qdev, DRV, ERR,
205 "%s: Could not get mailbox status.\n", __func__);
209 qdev->link_status = mbcp->mbox_out[1];
210 QPRINTK(qdev, DRV, ERR, "Link Up.\n");
212 /* If we're coming back from an IDC event
213 * then set up the CAM and frame routing.
215 if (test_bit(QL_CAM_RT_SET, &qdev->flags)) {
216 status = ql_cam_route_initialize(qdev);
218 QPRINTK(qdev, IFUP, ERR,
219 "Failed to init CAM/Routing tables.\n");
222 clear_bit(QL_CAM_RT_SET, &qdev->flags);
225 /* Queue up a worker to check the frame
226 * size information, and fix it if it's not
229 if (!test_bit(QL_PORT_CFG, &qdev->flags)) {
230 QPRINTK(qdev, DRV, ERR, "Queue Port Config Worker!\n");
231 set_bit(QL_PORT_CFG, &qdev->flags);
232 /* Begin polled mode early so
233 * we don't get another interrupt
234 * when we leave mpi_worker dpc.
236 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
237 queue_delayed_work(qdev->workqueue,
238 &qdev->mpi_port_cfg_work, 0);
241 netif_carrier_on(qdev->ndev);
244 static void ql_link_down(struct ql_adapter *qdev, struct mbox_params *mbcp)
250 status = ql_get_mb_sts(qdev, mbcp);
252 QPRINTK(qdev, DRV, ERR, "Link down AEN broken!\n");
254 netif_carrier_off(qdev->ndev);
257 static int ql_sfp_in(struct ql_adapter *qdev, struct mbox_params *mbcp)
263 status = ql_get_mb_sts(qdev, mbcp);
265 QPRINTK(qdev, DRV, ERR, "SFP in AEN broken!\n");
267 QPRINTK(qdev, DRV, ERR, "SFP insertion detected.\n");
272 static int ql_sfp_out(struct ql_adapter *qdev, struct mbox_params *mbcp)
278 status = ql_get_mb_sts(qdev, mbcp);
280 QPRINTK(qdev, DRV, ERR, "SFP out AEN broken!\n");
282 QPRINTK(qdev, DRV, ERR, "SFP removal detected.\n");
287 static void ql_init_fw_done(struct ql_adapter *qdev, struct mbox_params *mbcp)
293 status = ql_get_mb_sts(qdev, mbcp);
295 QPRINTK(qdev, DRV, ERR, "Firmware did not initialize!\n");
297 QPRINTK(qdev, DRV, ERR, "Firmware Revision = 0x%.08x.\n",
299 status = ql_cam_route_initialize(qdev);
301 QPRINTK(qdev, IFUP, ERR,
302 "Failed to init CAM/Routing tables.\n");
306 /* Process an async event and clear it unless it's an
308 * This can get called iteratively from the mpi_work thread
309 * when events arrive via an interrupt.
310 * It also gets called when a mailbox command is polling for
311 * it's completion. */
312 static int ql_mpi_handler(struct ql_adapter *qdev, struct mbox_params *mbcp)
315 int orig_count = mbcp->out_count;
317 /* Just get mailbox zero for now. */
319 status = ql_get_mb_sts(qdev, mbcp);
321 QPRINTK(qdev, DRV, ERR,
322 "Could not read MPI, resetting ASIC!\n");
323 ql_queue_asic_error(qdev);
327 switch (mbcp->mbox_out[0]) {
329 /* This case is only active when we arrive here
330 * as a result of issuing a mailbox command to
333 case MB_CMD_STS_INTRMDT:
334 case MB_CMD_STS_GOOD:
335 case MB_CMD_STS_INVLD_CMD:
336 case MB_CMD_STS_XFC_ERR:
337 case MB_CMD_STS_CSUM_ERR:
339 case MB_CMD_STS_PARAM_ERR:
340 /* We can only get mailbox status if we're polling from an
341 * unfinished command. Get the rest of the status data and
342 * return back to the caller.
343 * We only end up here when we're polling for a mailbox
344 * command completion.
346 mbcp->out_count = orig_count;
347 status = ql_get_mb_sts(qdev, mbcp);
350 /* We are being asked by firmware to accept
351 * a change to the port. This is only
352 * a change to max frame sizes (Tx/Rx), pause
353 * paramters, or loopback mode.
356 status = ql_idc_req_aen(qdev);
359 /* Process and inbound IDC event.
360 * This will happen when we're trying to
361 * change tx/rx max frame size, change pause
362 * paramters or loopback mode.
366 status = ql_idc_cmplt_aen(qdev);
370 ql_link_up(qdev, mbcp);
374 ql_link_down(qdev, mbcp);
377 case AEN_FW_INIT_DONE:
378 /* If we're in process on executing the firmware,
379 * then convert the status to normal mailbox status.
381 if (mbcp->mbox_in[0] == MB_CMD_EX_FW) {
382 mbcp->out_count = orig_count;
383 status = ql_get_mb_sts(qdev, mbcp);
384 mbcp->mbox_out[0] = MB_CMD_STS_GOOD;
387 ql_init_fw_done(qdev, mbcp);
391 ql_sfp_in(qdev, mbcp);
394 case AEN_AEN_SFP_OUT:
395 ql_sfp_out(qdev, mbcp);
398 /* This event can arrive at boot time or after an
399 * MPI reset if the firmware failed to initialize.
401 case AEN_FW_INIT_FAIL:
402 /* If we're in process on executing the firmware,
403 * then convert the status to normal mailbox status.
405 if (mbcp->mbox_in[0] == MB_CMD_EX_FW) {
406 mbcp->out_count = orig_count;
407 status = ql_get_mb_sts(qdev, mbcp);
408 mbcp->mbox_out[0] = MB_CMD_STS_ERR;
411 QPRINTK(qdev, DRV, ERR,
412 "Firmware initialization failed.\n");
414 ql_queue_fw_error(qdev);
418 QPRINTK(qdev, DRV, ERR,
420 ql_queue_fw_error(qdev);
425 QPRINTK(qdev, DRV, ERR,
426 "Unsupported AE %.08x.\n", mbcp->mbox_out[0]);
427 /* Clear the MPI firmware status. */
430 ql_write32(qdev, CSR, CSR_CMD_CLR_R2PCI_INT);
434 /* Execute a single mailbox command.
435 * mbcp is a pointer to an array of u32. Each
436 * element in the array contains the value for it's
437 * respective mailbox register.
439 static int ql_mailbox_command(struct ql_adapter *qdev, struct mbox_params *mbcp)
443 mutex_lock(&qdev->mpi_mutex);
445 /* Begin polled mode for MPI */
446 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
448 /* Load the mailbox registers and wake up MPI RISC. */
449 status = ql_exec_mb_cmd(qdev, mbcp);
454 /* If we're generating a system error, then there's nothing
457 if (mbcp->mbox_in[0] == MB_CMD_MAKE_SYS_ERR)
460 /* Wait for the command to complete. We loop
461 * here because some AEN might arrive while
462 * we're waiting for the mailbox command to
463 * complete. If more than 5 arrive then we can
464 * assume something is wrong. */
467 /* Wait for the interrupt to come in. */
468 status = ql_wait_mbx_cmd_cmplt(qdev);
472 /* Process the event. If it's an AEN, it
473 * will be handled in-line or a worker
474 * will be spawned. If it's our completion
475 * we will catch it below.
477 status = ql_mpi_handler(qdev, mbcp);
481 /* It's either the completion for our mailbox
482 * command complete or an AEN. If it's our
483 * completion then get out.
485 if (((mbcp->mbox_out[0] & 0x0000f000) ==
487 ((mbcp->mbox_out[0] & 0x0000f000) ==
493 QPRINTK(qdev, DRV, ERR,
494 "Timed out waiting for mailbox complete.\n");
499 /* Now we can clear the interrupt condition
500 * and look at our status.
502 ql_write32(qdev, CSR, CSR_CMD_CLR_R2PCI_INT);
504 if (((mbcp->mbox_out[0] & 0x0000f000) !=
506 ((mbcp->mbox_out[0] & 0x0000f000) !=
507 MB_CMD_STS_INTRMDT)) {
508 ql_display_mb_sts(qdev, mbcp);
512 mutex_unlock(&qdev->mpi_mutex);
513 /* End polled mode for MPI */
514 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16) | INTR_MASK_PI);
518 /* Get functional state for MPI firmware.
519 * Returns zero on success.
521 int ql_mb_get_fw_state(struct ql_adapter *qdev)
523 struct mbox_params mbc;
524 struct mbox_params *mbcp = &mbc;
527 memset(mbcp, 0, sizeof(struct mbox_params));
532 mbcp->mbox_in[0] = MB_CMD_GET_FW_STATE;
534 status = ql_mailbox_command(qdev, mbcp);
538 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
539 QPRINTK(qdev, DRV, ERR,
540 "Failed Get Firmware State.\n");
544 /* If bit zero is set in mbx 1 then the firmware is
545 * running, but not initialized. This should never
548 if (mbcp->mbox_out[1] & 1) {
549 QPRINTK(qdev, DRV, ERR,
550 "Firmware waiting for initialization.\n");
557 /* Send and ACK mailbox command to the firmware to
558 * let it continue with the change.
560 int ql_mb_idc_ack(struct ql_adapter *qdev)
562 struct mbox_params mbc;
563 struct mbox_params *mbcp = &mbc;
566 memset(mbcp, 0, sizeof(struct mbox_params));
571 mbcp->mbox_in[0] = MB_CMD_IDC_ACK;
572 mbcp->mbox_in[1] = qdev->idc_mbc.mbox_out[1];
573 mbcp->mbox_in[2] = qdev->idc_mbc.mbox_out[2];
574 mbcp->mbox_in[3] = qdev->idc_mbc.mbox_out[3];
575 mbcp->mbox_in[4] = qdev->idc_mbc.mbox_out[4];
577 status = ql_mailbox_command(qdev, mbcp);
581 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
582 QPRINTK(qdev, DRV, ERR,
583 "Failed IDC ACK send.\n");
589 /* Get link settings and maximum frame size settings
590 * for the current port.
591 * Most likely will block.
593 static int ql_mb_set_port_cfg(struct ql_adapter *qdev)
595 struct mbox_params mbc;
596 struct mbox_params *mbcp = &mbc;
599 memset(mbcp, 0, sizeof(struct mbox_params));
604 mbcp->mbox_in[0] = MB_CMD_SET_PORT_CFG;
605 mbcp->mbox_in[1] = qdev->link_config;
606 mbcp->mbox_in[2] = qdev->max_frame_size;
609 status = ql_mailbox_command(qdev, mbcp);
613 if (mbcp->mbox_out[0] == MB_CMD_STS_INTRMDT) {
614 QPRINTK(qdev, DRV, ERR,
615 "Port Config sent, wait for IDC.\n");
616 } else if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
617 QPRINTK(qdev, DRV, ERR,
618 "Failed Set Port Configuration.\n");
624 /* Get link settings and maximum frame size settings
625 * for the current port.
626 * Most likely will block.
628 static int ql_mb_get_port_cfg(struct ql_adapter *qdev)
630 struct mbox_params mbc;
631 struct mbox_params *mbcp = &mbc;
634 memset(mbcp, 0, sizeof(struct mbox_params));
639 mbcp->mbox_in[0] = MB_CMD_GET_PORT_CFG;
641 status = ql_mailbox_command(qdev, mbcp);
645 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
646 QPRINTK(qdev, DRV, ERR,
647 "Failed Get Port Configuration.\n");
650 QPRINTK(qdev, DRV, DEBUG,
651 "Passed Get Port Configuration.\n");
652 qdev->link_config = mbcp->mbox_out[1];
653 qdev->max_frame_size = mbcp->mbox_out[2];
658 /* IDC - Inter Device Communication...
659 * Some firmware commands require consent of adjacent FCOE
660 * function. This function waits for the OK, or a
661 * counter-request for a little more time.i
662 * The firmware will complete the request if the other
663 * function doesn't respond.
665 static int ql_idc_wait(struct ql_adapter *qdev)
667 int status = -ETIMEDOUT;
668 long wait_time = 1 * HZ;
669 struct mbox_params *mbcp = &qdev->idc_mbc;
671 /* Wait here for the command to complete
672 * via the IDC process.
675 wait_for_completion_timeout(&qdev->ide_completion,
678 QPRINTK(qdev, DRV, ERR,
682 /* Now examine the response from the IDC process.
683 * We might have a good completion or a request for
686 if (mbcp->mbox_out[0] == AEN_IDC_EXT) {
687 QPRINTK(qdev, DRV, ERR,
688 "IDC Time Extension from function.\n");
689 wait_time += (mbcp->mbox_out[1] >> 8) & 0x0000000f;
690 } else if (mbcp->mbox_out[0] == AEN_IDC_CMPLT) {
691 QPRINTK(qdev, DRV, ERR,
696 QPRINTK(qdev, DRV, ERR,
697 "IDC: Invalid State 0x%.04x.\n",
707 /* API called in work thread context to set new TX/RX
708 * maximum frame size values to match MTU.
710 static int ql_set_port_cfg(struct ql_adapter *qdev)
713 status = ql_mb_set_port_cfg(qdev);
716 status = ql_idc_wait(qdev);
720 /* The following routines are worker threads that process
721 * events that may sleep waiting for completion.
724 /* This thread gets the maximum TX and RX frame size values
725 * from the firmware and, if necessary, changes them to match
728 void ql_mpi_port_cfg_work(struct work_struct *work)
730 struct ql_adapter *qdev =
731 container_of(work, struct ql_adapter, mpi_port_cfg_work.work);
732 struct net_device *ndev = qdev->ndev;
735 status = ql_mb_get_port_cfg(qdev);
737 QPRINTK(qdev, DRV, ERR,
738 "Bug: Failed to get port config data.\n");
742 if (ndev->mtu <= 2500)
744 else if (qdev->link_config & CFG_JUMBO_FRAME_SIZE &&
745 qdev->max_frame_size ==
746 CFG_DEFAULT_MAX_FRAME_SIZE)
749 qdev->link_config |= CFG_JUMBO_FRAME_SIZE;
750 qdev->max_frame_size = CFG_DEFAULT_MAX_FRAME_SIZE;
751 status = ql_set_port_cfg(qdev);
753 QPRINTK(qdev, DRV, ERR,
754 "Bug: Failed to set port config data.\n");
758 clear_bit(QL_PORT_CFG, &qdev->flags);
761 ql_queue_fw_error(qdev);
765 /* Process an inter-device request. This is issues by
766 * the firmware in response to another function requesting
767 * a change to the port. We set a flag to indicate a change
768 * has been made and then send a mailbox command ACKing
769 * the change request.
771 void ql_mpi_idc_work(struct work_struct *work)
773 struct ql_adapter *qdev =
774 container_of(work, struct ql_adapter, mpi_idc_work.work);
776 struct mbox_params *mbcp = &qdev->idc_mbc;
779 aen = mbcp->mbox_out[1] >> 16;
783 QPRINTK(qdev, DRV, ERR,
784 "Bug: Unhandled IDC action.\n");
786 case MB_CMD_PORT_RESET:
787 case MB_CMD_SET_PORT_CFG:
789 netif_carrier_off(qdev->ndev);
790 /* Signal the resulting link up AEN
791 * that the frame routing and mac addr
794 set_bit(QL_CAM_RT_SET, &qdev->flags);
795 status = ql_mb_idc_ack(qdev);
797 QPRINTK(qdev, DRV, ERR,
798 "Bug: No pending IDC!\n");
803 void ql_mpi_work(struct work_struct *work)
805 struct ql_adapter *qdev =
806 container_of(work, struct ql_adapter, mpi_work.work);
807 struct mbox_params mbc;
808 struct mbox_params *mbcp = &mbc;
810 mutex_lock(&qdev->mpi_mutex);
812 while (ql_read32(qdev, STS) & STS_PI) {
813 memset(mbcp, 0, sizeof(struct mbox_params));
815 ql_mpi_handler(qdev, mbcp);
818 mutex_unlock(&qdev->mpi_mutex);
819 ql_enable_completion_interrupt(qdev, 0);
822 void ql_mpi_reset_work(struct work_struct *work)
824 struct ql_adapter *qdev =
825 container_of(work, struct ql_adapter, mpi_reset_work.work);
826 cancel_delayed_work_sync(&qdev->mpi_work);
827 cancel_delayed_work_sync(&qdev->mpi_port_cfg_work);
828 cancel_delayed_work_sync(&qdev->mpi_idc_work);
829 ql_soft_reset_mpi_risc(qdev);