blob: bcf13c96f73ff5d22137975b345acb27128a2fd1 [file] [log] [blame]
Ron Mercerc4e84bd2008-09-18 11:56:28 -04001#include "qlge.h"
2
Ron Mercerca0413b2009-03-02 08:07:30 +00003static 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
Ron Mercera2e809b2009-02-26 10:08:33 +000023int ql_read_mpi_reg(struct ql_adapter *qdev, u32 reg, u32 *data)
Ron Mercerc4e84bd2008-09-18 11:56:28 -040024{
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);
38exit:
39 return status;
40}
41
Ron Mercera2e809b2009-02-26 10:08:33 +000042int 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;
57exit:
58 return status;
59}
60
61int 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
Hannes Eder2f22d222008-12-26 00:04:53 -080068static int ql_get_mb_sts(struct ql_adapter *qdev, struct mbox_params *mbcp)
Ron Mercerc4e84bd2008-09-18 11:56:28 -040069{
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 =
Ron Mercera2e809b2009-02-26 10:08:33 +000077 ql_read_mpi_reg(qdev, qdev->mailbox_out + i,
Ron Mercerc4e84bd2008-09-18 11:56:28 -040078 &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
Ron Mercerca0413b2009-03-02 08:07:30 +000088/* Wait for a single mailbox command to complete.
89 * Returns zero on success.
90 */
91static int ql_wait_mbx_cmd_cmplt(struct ql_adapter *qdev)
92{
Ron Mercer365da872009-06-07 13:58:29 +000093 int count = 100;
Ron Mercerca0413b2009-03-02 08:07:30 +000094 u32 value;
95
96 do {
97 value = ql_read32(qdev, STS);
98 if (value & STS_PI)
99 return 0;
Ron Mercer365da872009-06-07 13:58:29 +0000100 mdelay(UDELAY_DELAY); /* 100ms */
Ron Mercerca0413b2009-03-02 08:07:30 +0000101 } while (--count);
102 return -ETIMEDOUT;
103}
104
105/* Execute a single mailbox command.
106 * Caller must hold PROC_ADDR semaphore.
107 */
108static 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);
136end:
137 ql_sem_unlock(qdev, SEM_PROC_REG_MASK);
138 return status;
139}
140
Ron Mercer2ee1e272009-03-03 12:10:33 +0000141/* 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
Martin Olsson98a17082009-04-22 18:21:29 +0200144 * parameters, or loopback mode. We wake up a worker
Ron Mercer2ee1e272009-03-03 12:10:33 +0000145 * to handler processing this since a mailbox command
146 * will need to be sent to ACK the request.
147 */
148static 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
Ron Mercerbcc2cb3b2009-03-02 08:07:32 +0000175/* Process an inter-device event completion.
176 * If good, signal the caller's completion.
177 */
178static 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}
Ron Mercer5700abe2009-03-03 12:10:32 +0000196
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400197static void ql_link_up(struct ql_adapter *qdev, struct mbox_params *mbcp)
198{
Ron Mercer5700abe2009-03-03 12:10:32 +0000199 int status;
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400200 mbcp->out_count = 2;
201
Ron Mercer5700abe2009-03-03 12:10:32 +0000202 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 }
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400208
209 qdev->link_status = mbcp->mbox_out[1];
210 QPRINTK(qdev, DRV, ERR, "Link Up.\n");
Ron Mercer5700abe2009-03-03 12:10:32 +0000211
Ron Mercer2ee1e272009-03-03 12:10:33 +0000212 /* 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
Ron Mercer6a473302009-07-02 06:06:12 +0000241 ql_link_on(qdev);
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400242}
243
244static void ql_link_down(struct ql_adapter *qdev, struct mbox_params *mbcp)
245{
Ron Mercer11d9fe62009-03-03 12:10:31 +0000246 int status;
247
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400248 mbcp->out_count = 3;
249
Ron Mercer11d9fe62009-03-03 12:10:31 +0000250 status = ql_get_mb_sts(qdev, mbcp);
251 if (status)
252 QPRINTK(qdev, DRV, ERR, "Link down AEN broken!\n");
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400253
Ron Mercer6a473302009-07-02 06:06:12 +0000254 ql_link_off(qdev);
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400255}
256
Ron Mercereae6b582009-03-03 12:10:30 +0000257static 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
272static 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
Ron Mercerfc1f9ea2009-03-03 12:10:37 +0000287static 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
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400308static void ql_init_fw_done(struct ql_adapter *qdev, struct mbox_params *mbcp)
309{
Ron Mercerf56b54f2009-03-03 12:10:34 +0000310 int status;
311
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400312 mbcp->out_count = 2;
313
Ron Mercerf56b54f2009-03-03 12:10:34 +0000314 status = ql_get_mb_sts(qdev, mbcp);
315 if (status) {
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400316 QPRINTK(qdev, DRV, ERR, "Firmware did not initialize!\n");
Ron Mercerf56b54f2009-03-03 12:10:34 +0000317 } 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");
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400324 }
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400325}
326
Ron Mercer125844e2009-02-26 10:08:34 +0000327/* 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. */
333static int ql_mpi_handler(struct ql_adapter *qdev, struct mbox_params *mbcp)
334{
335 int status;
Ron Mercerca0413b2009-03-02 08:07:30 +0000336 int orig_count = mbcp->out_count;
Ron Mercer125844e2009-02-26 10:08:34 +0000337
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
Ron Mercerca0413b2009-03-02 08:07:30 +0000350 /* 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
Ron Mercer2ee1e272009-03-03 12:10:33 +0000371 /* 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
Martin Olsson98a17082009-04-22 18:21:29 +0200374 * parameters, or loopback mode.
Ron Mercer2ee1e272009-03-03 12:10:33 +0000375 */
376 case AEN_IDC_REQ:
377 status = ql_idc_req_aen(qdev);
378 break;
379
Ron Mercerbcc2cb3b2009-03-02 08:07:32 +0000380 /* Process and inbound IDC event.
381 * This will happen when we're trying to
382 * change tx/rx max frame size, change pause
Martin Olsson98a17082009-04-22 18:21:29 +0200383 * parameters or loopback mode.
Ron Mercerbcc2cb3b2009-03-02 08:07:32 +0000384 */
385 case AEN_IDC_CMPLT:
386 case AEN_IDC_EXT:
387 status = ql_idc_cmplt_aen(qdev);
388 break;
389
Ron Mercer125844e2009-02-26 10:08:34 +0000390 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:
Ron Mercerf56b54f2009-03-03 12:10:34 +0000399 /* 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 }
Ron Mercer125844e2009-02-26 10:08:34 +0000408 ql_init_fw_done(qdev, mbcp);
409 break;
410
Ron Mercereae6b582009-03-03 12:10:30 +0000411 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
Ron Mercer7c921912009-03-03 12:10:35 +0000419 /* This event can arrive at boot time or after an
420 * MPI reset if the firmware failed to initialize.
421 */
Ron Mercer125844e2009-02-26 10:08:34 +0000422 case AEN_FW_INIT_FAIL:
Ron Mercer7c921912009-03-03 12:10:35 +0000423 /* 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
Ron Mercer125844e2009-02-26 10:08:34 +0000438 case AEN_SYS_ERR:
Ron Mercerbb667672009-03-03 12:10:36 +0000439 QPRINTK(qdev, DRV, ERR,
440 "System Error.\n");
Ron Mercer125844e2009-02-26 10:08:34 +0000441 ql_queue_fw_error(qdev);
Ron Mercerbb667672009-03-03 12:10:36 +0000442 status = -EIO;
Ron Mercer125844e2009-02-26 10:08:34 +0000443 break;
444
Ron Mercerfc1f9ea2009-03-03 12:10:37 +0000445 case AEN_AEN_LOST:
446 ql_aen_lost(qdev, mbcp);
447 break;
448
Ron Mercer125844e2009-02-26 10:08:34 +0000449 default:
450 QPRINTK(qdev, DRV, ERR,
451 "Unsupported AE %.08x.\n", mbcp->mbox_out[0]);
452 /* Clear the MPI firmware status. */
453 }
454end:
455 ql_write32(qdev, CSR, CSR_CMD_CLR_R2PCI_INT);
Ron Mercer709ac4f2009-06-07 13:58:26 +0000456 /* Restore the original mailbox count to
457 * what the caller asked for. This can get
458 * changed when a mailbox command is waiting
459 * for a response and an AEN arrives and
460 * is handled.
461 * */
462 mbcp->out_count = orig_count;
Ron Mercer125844e2009-02-26 10:08:34 +0000463 return status;
464}
465
Ron Mercerca0413b2009-03-02 08:07:30 +0000466/* Execute a single mailbox command.
467 * mbcp is a pointer to an array of u32. Each
468 * element in the array contains the value for it's
469 * respective mailbox register.
470 */
471static int ql_mailbox_command(struct ql_adapter *qdev, struct mbox_params *mbcp)
472{
Ron Mercerda039452009-10-28 08:39:21 +0000473 int status;
474 unsigned long count;
Ron Mercerca0413b2009-03-02 08:07:30 +0000475
Ron Mercerca0413b2009-03-02 08:07:30 +0000476
477 /* Begin polled mode for MPI */
478 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
479
480 /* Load the mailbox registers and wake up MPI RISC. */
481 status = ql_exec_mb_cmd(qdev, mbcp);
482 if (status)
483 goto end;
484
485
486 /* If we're generating a system error, then there's nothing
487 * to wait for.
488 */
489 if (mbcp->mbox_in[0] == MB_CMD_MAKE_SYS_ERR)
490 goto end;
491
492 /* Wait for the command to complete. We loop
493 * here because some AEN might arrive while
494 * we're waiting for the mailbox command to
Ron Mercerda039452009-10-28 08:39:21 +0000495 * complete. If more than 5 seconds expire we can
Ron Mercerca0413b2009-03-02 08:07:30 +0000496 * assume something is wrong. */
Ron Mercerda039452009-10-28 08:39:21 +0000497 count = jiffies + HZ * MAILBOX_TIMEOUT;
Ron Mercerca0413b2009-03-02 08:07:30 +0000498 do {
499 /* Wait for the interrupt to come in. */
500 status = ql_wait_mbx_cmd_cmplt(qdev);
501 if (status)
502 goto end;
503
504 /* Process the event. If it's an AEN, it
505 * will be handled in-line or a worker
506 * will be spawned. If it's our completion
507 * we will catch it below.
508 */
509 status = ql_mpi_handler(qdev, mbcp);
510 if (status)
511 goto end;
512
513 /* It's either the completion for our mailbox
514 * command complete or an AEN. If it's our
515 * completion then get out.
516 */
517 if (((mbcp->mbox_out[0] & 0x0000f000) ==
518 MB_CMD_STS_GOOD) ||
519 ((mbcp->mbox_out[0] & 0x0000f000) ==
520 MB_CMD_STS_INTRMDT))
Ron Mercerda039452009-10-28 08:39:21 +0000521 goto done;
522 } while (time_before(jiffies, count));
Ron Mercerca0413b2009-03-02 08:07:30 +0000523
Ron Mercerda039452009-10-28 08:39:21 +0000524 QPRINTK(qdev, DRV, ERR,
525 "Timed out waiting for mailbox complete.\n");
526 status = -ETIMEDOUT;
527 goto end;
528
529done:
Ron Mercerca0413b2009-03-02 08:07:30 +0000530
531 /* Now we can clear the interrupt condition
532 * and look at our status.
533 */
534 ql_write32(qdev, CSR, CSR_CMD_CLR_R2PCI_INT);
535
536 if (((mbcp->mbox_out[0] & 0x0000f000) !=
537 MB_CMD_STS_GOOD) &&
538 ((mbcp->mbox_out[0] & 0x0000f000) !=
539 MB_CMD_STS_INTRMDT)) {
540 ql_display_mb_sts(qdev, mbcp);
541 status = -EIO;
542 }
543end:
Ron Mercerca0413b2009-03-02 08:07:30 +0000544 /* End polled mode for MPI */
545 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16) | INTR_MASK_PI);
546 return status;
547}
548
Ron Mercercfec0cb2009-06-09 05:39:29 +0000549
550/* Get MPI firmware version. This will be used for
551 * driver banner and for ethtool info.
552 * Returns zero on success.
553 */
554int ql_mb_about_fw(struct ql_adapter *qdev)
555{
556 struct mbox_params mbc;
557 struct mbox_params *mbcp = &mbc;
558 int status = 0;
559
560 memset(mbcp, 0, sizeof(struct mbox_params));
561
562 mbcp->in_count = 1;
563 mbcp->out_count = 3;
564
565 mbcp->mbox_in[0] = MB_CMD_ABOUT_FW;
566
567 status = ql_mailbox_command(qdev, mbcp);
568 if (status)
569 return status;
570
571 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
572 QPRINTK(qdev, DRV, ERR,
573 "Failed about firmware command\n");
574 status = -EIO;
575 }
576
577 /* Store the firmware version */
578 qdev->fw_rev_id = mbcp->mbox_out[1];
579
580 return status;
581}
582
Ron Mercerca0413b2009-03-02 08:07:30 +0000583/* Get functional state for MPI firmware.
584 * Returns zero on success.
585 */
586int ql_mb_get_fw_state(struct ql_adapter *qdev)
587{
588 struct mbox_params mbc;
589 struct mbox_params *mbcp = &mbc;
590 int status = 0;
591
592 memset(mbcp, 0, sizeof(struct mbox_params));
593
594 mbcp->in_count = 1;
595 mbcp->out_count = 2;
596
597 mbcp->mbox_in[0] = MB_CMD_GET_FW_STATE;
598
599 status = ql_mailbox_command(qdev, mbcp);
600 if (status)
601 return status;
602
603 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
604 QPRINTK(qdev, DRV, ERR,
605 "Failed Get Firmware State.\n");
606 status = -EIO;
607 }
608
609 /* If bit zero is set in mbx 1 then the firmware is
610 * running, but not initialized. This should never
611 * happen.
612 */
613 if (mbcp->mbox_out[1] & 1) {
614 QPRINTK(qdev, DRV, ERR,
615 "Firmware waiting for initialization.\n");
616 status = -EIO;
617 }
618
619 return status;
620}
621
Ron Mercer2ee1e272009-03-03 12:10:33 +0000622/* Send and ACK mailbox command to the firmware to
623 * let it continue with the change.
624 */
625int ql_mb_idc_ack(struct ql_adapter *qdev)
626{
627 struct mbox_params mbc;
628 struct mbox_params *mbcp = &mbc;
629 int status = 0;
630
631 memset(mbcp, 0, sizeof(struct mbox_params));
632
633 mbcp->in_count = 5;
634 mbcp->out_count = 1;
635
636 mbcp->mbox_in[0] = MB_CMD_IDC_ACK;
637 mbcp->mbox_in[1] = qdev->idc_mbc.mbox_out[1];
638 mbcp->mbox_in[2] = qdev->idc_mbc.mbox_out[2];
639 mbcp->mbox_in[3] = qdev->idc_mbc.mbox_out[3];
640 mbcp->mbox_in[4] = qdev->idc_mbc.mbox_out[4];
641
642 status = ql_mailbox_command(qdev, mbcp);
643 if (status)
644 return status;
645
646 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
647 QPRINTK(qdev, DRV, ERR,
648 "Failed IDC ACK send.\n");
649 status = -EIO;
650 }
651 return status;
652}
653
Ron Mercerbcc2cb3b2009-03-02 08:07:32 +0000654/* Get link settings and maximum frame size settings
655 * for the current port.
656 * Most likely will block.
657 */
658static int ql_mb_set_port_cfg(struct ql_adapter *qdev)
659{
660 struct mbox_params mbc;
661 struct mbox_params *mbcp = &mbc;
662 int status = 0;
663
664 memset(mbcp, 0, sizeof(struct mbox_params));
665
666 mbcp->in_count = 3;
667 mbcp->out_count = 1;
668
669 mbcp->mbox_in[0] = MB_CMD_SET_PORT_CFG;
670 mbcp->mbox_in[1] = qdev->link_config;
671 mbcp->mbox_in[2] = qdev->max_frame_size;
672
673
674 status = ql_mailbox_command(qdev, mbcp);
675 if (status)
676 return status;
677
678 if (mbcp->mbox_out[0] == MB_CMD_STS_INTRMDT) {
679 QPRINTK(qdev, DRV, ERR,
680 "Port Config sent, wait for IDC.\n");
681 } else if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
682 QPRINTK(qdev, DRV, ERR,
683 "Failed Set Port Configuration.\n");
684 status = -EIO;
685 }
686 return status;
687}
688
689/* Get link settings and maximum frame size settings
690 * for the current port.
691 * Most likely will block.
692 */
693static int ql_mb_get_port_cfg(struct ql_adapter *qdev)
694{
695 struct mbox_params mbc;
696 struct mbox_params *mbcp = &mbc;
697 int status = 0;
698
699 memset(mbcp, 0, sizeof(struct mbox_params));
700
701 mbcp->in_count = 1;
702 mbcp->out_count = 3;
703
704 mbcp->mbox_in[0] = MB_CMD_GET_PORT_CFG;
705
706 status = ql_mailbox_command(qdev, mbcp);
707 if (status)
708 return status;
709
710 if (mbcp->mbox_out[0] != MB_CMD_STS_GOOD) {
711 QPRINTK(qdev, DRV, ERR,
712 "Failed Get Port Configuration.\n");
713 status = -EIO;
714 } else {
715 QPRINTK(qdev, DRV, DEBUG,
716 "Passed Get Port Configuration.\n");
717 qdev->link_config = mbcp->mbox_out[1];
718 qdev->max_frame_size = mbcp->mbox_out[2];
719 }
720 return status;
721}
722
723/* IDC - Inter Device Communication...
724 * Some firmware commands require consent of adjacent FCOE
725 * function. This function waits for the OK, or a
726 * counter-request for a little more time.i
727 * The firmware will complete the request if the other
728 * function doesn't respond.
729 */
730static int ql_idc_wait(struct ql_adapter *qdev)
731{
732 int status = -ETIMEDOUT;
733 long wait_time = 1 * HZ;
734 struct mbox_params *mbcp = &qdev->idc_mbc;
735 do {
736 /* Wait here for the command to complete
737 * via the IDC process.
738 */
739 wait_time =
740 wait_for_completion_timeout(&qdev->ide_completion,
741 wait_time);
742 if (!wait_time) {
743 QPRINTK(qdev, DRV, ERR,
744 "IDC Timeout.\n");
745 break;
746 }
747 /* Now examine the response from the IDC process.
748 * We might have a good completion or a request for
749 * more wait time.
750 */
751 if (mbcp->mbox_out[0] == AEN_IDC_EXT) {
752 QPRINTK(qdev, DRV, ERR,
753 "IDC Time Extension from function.\n");
754 wait_time += (mbcp->mbox_out[1] >> 8) & 0x0000000f;
755 } else if (mbcp->mbox_out[0] == AEN_IDC_CMPLT) {
756 QPRINTK(qdev, DRV, ERR,
757 "IDC Success.\n");
758 status = 0;
759 break;
760 } else {
761 QPRINTK(qdev, DRV, ERR,
762 "IDC: Invalid State 0x%.04x.\n",
763 mbcp->mbox_out[0]);
764 status = -EIO;
765 break;
766 }
767 } while (wait_time);
768
769 return status;
770}
771
Ron Mercer84087f42009-10-08 09:54:41 +0000772int ql_mb_set_mgmnt_traffic_ctl(struct ql_adapter *qdev, u32 control)
773{
774 struct mbox_params mbc;
775 struct mbox_params *mbcp = &mbc;
776 int status;
777
778 memset(mbcp, 0, sizeof(struct mbox_params));
779
780 mbcp->in_count = 1;
781 mbcp->out_count = 2;
782
783 mbcp->mbox_in[0] = MB_CMD_SET_MGMNT_TFK_CTL;
784 mbcp->mbox_in[1] = control;
785
786 status = ql_mailbox_command(qdev, mbcp);
787 if (status)
788 return status;
789
790 if (mbcp->mbox_out[0] == MB_CMD_STS_GOOD)
791 return status;
792
793 if (mbcp->mbox_out[0] == MB_CMD_STS_INVLD_CMD) {
794 QPRINTK(qdev, DRV, ERR,
795 "Command not supported by firmware.\n");
796 status = -EINVAL;
797 } else if (mbcp->mbox_out[0] == MB_CMD_STS_ERR) {
798 /* This indicates that the firmware is
799 * already in the state we are trying to
800 * change it to.
801 */
802 QPRINTK(qdev, DRV, ERR,
803 "Command parameters make no change.\n");
804 }
805 return status;
806}
807
808/* Returns a negative error code or the mailbox command status. */
809static int ql_mb_get_mgmnt_traffic_ctl(struct ql_adapter *qdev, u32 *control)
810{
811 struct mbox_params mbc;
812 struct mbox_params *mbcp = &mbc;
813 int status;
814
815 memset(mbcp, 0, sizeof(struct mbox_params));
816 *control = 0;
817
818 mbcp->in_count = 1;
819 mbcp->out_count = 1;
820
821 mbcp->mbox_in[0] = MB_CMD_GET_MGMNT_TFK_CTL;
822
823 status = ql_mailbox_command(qdev, mbcp);
824 if (status)
825 return status;
826
827 if (mbcp->mbox_out[0] == MB_CMD_STS_GOOD) {
828 *control = mbcp->mbox_in[1];
829 return status;
830 }
831
832 if (mbcp->mbox_out[0] == MB_CMD_STS_INVLD_CMD) {
833 QPRINTK(qdev, DRV, ERR,
834 "Command not supported by firmware.\n");
835 status = -EINVAL;
836 } else if (mbcp->mbox_out[0] == MB_CMD_STS_ERR) {
837 QPRINTK(qdev, DRV, ERR,
838 "Failed to get MPI traffic control.\n");
839 status = -EIO;
840 }
841 return status;
842}
843
844int ql_wait_fifo_empty(struct ql_adapter *qdev)
845{
846 int count = 5;
847 u32 mgmnt_fifo_empty;
848 u32 nic_fifo_empty;
849
850 do {
851 nic_fifo_empty = ql_read32(qdev, STS) & STS_NFE;
852 ql_mb_get_mgmnt_traffic_ctl(qdev, &mgmnt_fifo_empty);
853 mgmnt_fifo_empty &= MB_GET_MPI_TFK_FIFO_EMPTY;
854 if (nic_fifo_empty && mgmnt_fifo_empty)
855 return 0;
856 msleep(100);
857 } while (count-- > 0);
858 return -ETIMEDOUT;
859}
860
Ron Mercerbcc2cb3b2009-03-02 08:07:32 +0000861/* API called in work thread context to set new TX/RX
862 * maximum frame size values to match MTU.
863 */
864static int ql_set_port_cfg(struct ql_adapter *qdev)
865{
866 int status;
Ron Mercer86aaf9a2009-10-05 11:46:49 +0000867 rtnl_lock();
Ron Mercerbcc2cb3b2009-03-02 08:07:32 +0000868 status = ql_mb_set_port_cfg(qdev);
Ron Mercer86aaf9a2009-10-05 11:46:49 +0000869 rtnl_unlock();
Ron Mercerbcc2cb3b2009-03-02 08:07:32 +0000870 if (status)
871 return status;
872 status = ql_idc_wait(qdev);
873 return status;
874}
875
876/* The following routines are worker threads that process
877 * events that may sleep waiting for completion.
878 */
879
880/* This thread gets the maximum TX and RX frame size values
881 * from the firmware and, if necessary, changes them to match
882 * the MTU setting.
883 */
884void ql_mpi_port_cfg_work(struct work_struct *work)
885{
886 struct ql_adapter *qdev =
887 container_of(work, struct ql_adapter, mpi_port_cfg_work.work);
Ron Mercerbcc2cb3b2009-03-02 08:07:32 +0000888 int status;
889
Ron Mercer86aaf9a2009-10-05 11:46:49 +0000890 rtnl_lock();
Ron Mercerbcc2cb3b2009-03-02 08:07:32 +0000891 status = ql_mb_get_port_cfg(qdev);
Ron Mercer86aaf9a2009-10-05 11:46:49 +0000892 rtnl_unlock();
Ron Mercerbcc2cb3b2009-03-02 08:07:32 +0000893 if (status) {
894 QPRINTK(qdev, DRV, ERR,
895 "Bug: Failed to get port config data.\n");
896 goto err;
897 }
898
Ron Mercerc8269b22009-06-07 13:58:27 +0000899 if (qdev->link_config & CFG_JUMBO_FRAME_SIZE &&
Ron Mercerbcc2cb3b2009-03-02 08:07:32 +0000900 qdev->max_frame_size ==
901 CFG_DEFAULT_MAX_FRAME_SIZE)
902 goto end;
903
904 qdev->link_config |= CFG_JUMBO_FRAME_SIZE;
905 qdev->max_frame_size = CFG_DEFAULT_MAX_FRAME_SIZE;
906 status = ql_set_port_cfg(qdev);
907 if (status) {
908 QPRINTK(qdev, DRV, ERR,
909 "Bug: Failed to set port config data.\n");
910 goto err;
911 }
912end:
913 clear_bit(QL_PORT_CFG, &qdev->flags);
914 return;
915err:
916 ql_queue_fw_error(qdev);
917 goto end;
918}
919
Ron Mercer2ee1e272009-03-03 12:10:33 +0000920/* Process an inter-device request. This is issues by
921 * the firmware in response to another function requesting
922 * a change to the port. We set a flag to indicate a change
923 * has been made and then send a mailbox command ACKing
924 * the change request.
925 */
926void ql_mpi_idc_work(struct work_struct *work)
927{
928 struct ql_adapter *qdev =
929 container_of(work, struct ql_adapter, mpi_idc_work.work);
930 int status;
931 struct mbox_params *mbcp = &qdev->idc_mbc;
932 u32 aen;
933
934 aen = mbcp->mbox_out[1] >> 16;
935
936 switch (aen) {
937 default:
938 QPRINTK(qdev, DRV, ERR,
939 "Bug: Unhandled IDC action.\n");
940 break;
941 case MB_CMD_PORT_RESET:
942 case MB_CMD_SET_PORT_CFG:
943 case MB_CMD_STOP_FW:
Ron Mercer6a473302009-07-02 06:06:12 +0000944 ql_link_off(qdev);
Ron Mercer2ee1e272009-03-03 12:10:33 +0000945 /* Signal the resulting link up AEN
946 * that the frame routing and mac addr
947 * needs to be set.
948 * */
949 set_bit(QL_CAM_RT_SET, &qdev->flags);
Ron Mercer86aaf9a2009-10-05 11:46:49 +0000950 rtnl_lock();
Ron Mercer2ee1e272009-03-03 12:10:33 +0000951 status = ql_mb_idc_ack(qdev);
Ron Mercer86aaf9a2009-10-05 11:46:49 +0000952 rtnl_unlock();
Ron Mercer2ee1e272009-03-03 12:10:33 +0000953 if (status) {
954 QPRINTK(qdev, DRV, ERR,
955 "Bug: No pending IDC!\n");
956 }
957 }
958}
959
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400960void ql_mpi_work(struct work_struct *work)
961{
962 struct ql_adapter *qdev =
963 container_of(work, struct ql_adapter, mpi_work.work);
964 struct mbox_params mbc;
965 struct mbox_params *mbcp = &mbc;
Ron Mercerd6f58c22009-06-07 13:58:25 +0000966 int err = 0;
Ron Mercer125844e2009-02-26 10:08:34 +0000967
Ron Mercer86aaf9a2009-10-05 11:46:49 +0000968 rtnl_lock();
Ron Mercerefd7d262009-10-08 09:54:43 +0000969 /* Begin polled mode for MPI */
970 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16));
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400971
972 while (ql_read32(qdev, STS) & STS_PI) {
Ron Mercer125844e2009-02-26 10:08:34 +0000973 memset(mbcp, 0, sizeof(struct mbox_params));
974 mbcp->out_count = 1;
Ron Mercerd6f58c22009-06-07 13:58:25 +0000975 /* Don't continue if an async event
976 * did not complete properly.
977 */
978 err = ql_mpi_handler(qdev, mbcp);
979 if (err)
980 break;
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400981 }
Ron Mercer125844e2009-02-26 10:08:34 +0000982
Ron Mercerefd7d262009-10-08 09:54:43 +0000983 /* End polled mode for MPI */
984 ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16) | INTR_MASK_PI);
Ron Mercer86aaf9a2009-10-05 11:46:49 +0000985 rtnl_unlock();
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400986 ql_enable_completion_interrupt(qdev, 0);
987}
988
989void ql_mpi_reset_work(struct work_struct *work)
990{
991 struct ql_adapter *qdev =
992 container_of(work, struct ql_adapter, mpi_reset_work.work);
Ron Mercerbcc2cb3b2009-03-02 08:07:32 +0000993 cancel_delayed_work_sync(&qdev->mpi_work);
994 cancel_delayed_work_sync(&qdev->mpi_port_cfg_work);
Ron Mercer2ee1e272009-03-03 12:10:33 +0000995 cancel_delayed_work_sync(&qdev->mpi_idc_work);
Ron Mercera2e809b2009-02-26 10:08:33 +0000996 ql_soft_reset_mpi_risc(qdev);
Ron Mercerc4e84bd2008-09-18 11:56:28 -0400997}