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