1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2012 Gary Mills
24 *
25 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
26 * Use is subject to license terms.
27 */
28 /*
29 * Copyright (c) 2009, Pyun YongHyeon <yongari@FreeBSD.org>
30 * All rights reserved.
31 *
32 * Redistribution and use in source and binary forms, with or without
33 * modification, are permitted provided that the following conditions
34 * are met:
35 * 1. Redistributions of source code must retain the above copyright
36 * notice unmodified, this list of conditions, and the following
37 * disclaimer.
38 * 2. Redistributions in binary form must reproduce the above copyright
39 * notice, this list of conditions and the following disclaimer in the
40 * documentation and/or other materials provided with the distribution.
41 *
42 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
43 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
46 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
48 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
49 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
50 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
51 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52 * SUCH DAMAGE.
53 */
54
55 #include <sys/types.h>
56 #include <sys/stream.h>
57 #include <sys/strsun.h>
58 #include <sys/stat.h>
59 #include <sys/modctl.h>
60 #include <sys/ethernet.h>
61 #include <sys/debug.h>
62 #include <sys/conf.h>
63 #include <sys/mii.h>
64 #include <sys/miiregs.h>
65 #include <sys/sysmacros.h>
66 #include <sys/dditypes.h>
67 #include <sys/ddi.h>
68 #include <sys/sunddi.h>
69 #include <sys/byteorder.h>
70 #include <sys/note.h>
71 #include <sys/vlan.h>
72 #include <sys/stream.h>
73
74 #include "atge.h"
75 #include "atge_l1c_reg.h"
76 #include "atge_cmn_reg.h"
77
78 static ddi_dma_attr_t atge_l1c_dma_attr_tx_desc = {
79 DMA_ATTR_V0, /* dma_attr_version */
80 0, /* dma_attr_addr_lo */
81 0x0000ffffffffull, /* dma_attr_addr_hi */
82 0x0000ffffffffull, /* dma_attr_count_max */
83 L1C_TX_RING_ALIGN, /* dma_attr_align */
84 0x0000fffc, /* dma_attr_burstsizes */
85 1, /* dma_attr_minxfer */
86 0x0000ffffffffull, /* dma_attr_maxxfer */
87 0x0000ffffffffull, /* dma_attr_seg */
88 1, /* dma_attr_sgllen */
89 1, /* dma_attr_granular */
90 0 /* dma_attr_flags */
91 };
92
93 static ddi_dma_attr_t atge_l1c_dma_attr_rx_desc = {
94 DMA_ATTR_V0, /* dma_attr_version */
95 0, /* dma_attr_addr_lo */
96 0x0000ffffffffull, /* dma_attr_addr_hi */
97 0x0000ffffffffull, /* dma_attr_count_max */
98 L1C_RX_RING_ALIGN, /* dma_attr_align */
99 0x0000fffc, /* dma_attr_burstsizes */
100 1, /* dma_attr_minxfer */
101 0x0000ffffffffull, /* dma_attr_maxxfer */
102 0x0000ffffffffull, /* dma_attr_seg */
103 1, /* dma_attr_sgllen */
104 1, /* dma_attr_granular */
105 0 /* dma_attr_flags */
106 };
107
108 static ddi_dma_attr_t atge_l1c_dma_attr_cmb = {
109 DMA_ATTR_V0, /* dma_attr_version */
110 0, /* dma_attr_addr_lo */
111 0x0000ffffffffull, /* dma_attr_addr_hi */
112 0x0000ffffffffull, /* dma_attr_count_max */
113 L1C_CMB_ALIGN, /* dma_attr_align */
114 0x0000fffc, /* dma_attr_burstsizes */
115 1, /* dma_attr_minxfer */
116 0x0000ffffffffull, /* dma_attr_maxxfer */
117 0x0000ffffffffull, /* dma_attr_seg */
118 1, /* dma_attr_sgllen */
119 1, /* dma_attr_granular */
120 0 /* dma_attr_flags */
121 };
122
123 static ddi_dma_attr_t atge_l1c_dma_attr_smb = {
124 DMA_ATTR_V0, /* dma_attr_version */
125 0, /* dma_attr_addr_lo */
126 0x0000ffffffffull, /* dma_attr_addr_hi */
127 0x0000ffffffffull, /* dma_attr_count_max */
128 L1C_SMB_ALIGN, /* dma_attr_align */
129 0x0000fffc, /* dma_attr_burstsizes */
130 1, /* dma_attr_minxfer */
131 0x0000ffffffffull, /* dma_attr_maxxfer */
132 0x0000ffffffffull, /* dma_attr_seg */
133 1, /* dma_attr_sgllen */
134 1, /* dma_attr_granular */
135 0 /* dma_attr_flags */
136 };
137
138 static ddi_dma_attr_t atge_l1c_dma_attr_rr = {
139 DMA_ATTR_V0, /* dma_attr_version */
140 0, /* dma_attr_addr_lo */
141 0x0000ffffffffull, /* dma_attr_addr_hi */
142 0x0000ffffffffull, /* dma_attr_count_max */
143 L1C_RR_RING_ALIGN, /* dma_attr_align */
144 0x0000fffc, /* dma_attr_burstsizes */
145 1, /* dma_attr_minxfer */
146 0x0000ffffffffull, /* dma_attr_maxxfer */
147 0x0000ffffffffull, /* dma_attr_seg */
148 1, /* dma_attr_sgllen */
149 1, /* dma_attr_granular */
150 0 /* dma_attr_flags */
151 };
152
153 int
atge_l1c_alloc_dma(atge_t * atgep)154 atge_l1c_alloc_dma(atge_t *atgep)
155 {
156 atge_l1c_data_t *l1c;
157 atge_dma_t *dma;
158 int err;
159
160 l1c = kmem_zalloc(sizeof (atge_l1c_data_t), KM_SLEEP);
161 atgep->atge_private_data = l1c;
162
163 /*
164 * Allocate TX ring descriptor.
165 */
166 atgep->atge_tx_buf_len = atgep->atge_mtu +
167 sizeof (struct ether_header) + VLAN_TAGSZ + ETHERFCSL;
168 atgep->atge_tx_ring = kmem_alloc(sizeof (atge_ring_t), KM_SLEEP);
169 atgep->atge_tx_ring->r_atge = atgep;
170 atgep->atge_tx_ring->r_desc_ring = NULL;
171 dma = atge_alloc_a_dma_blk(atgep, &atge_l1c_dma_attr_tx_desc,
172 ATGE_TX_RING_SZ, DDI_DMA_RDWR);
173 if (dma == NULL) {
174 atge_error(atgep->atge_dip, "DMA allocation failed for TX"
175 " desc ring");
176 return (DDI_FAILURE);
177 }
178 atgep->atge_tx_ring->r_desc_ring = dma;
179
180 /*
181 * Allocate DMA buffers for TX ring.
182 */
183 err = atge_alloc_buffers(atgep->atge_tx_ring, ATGE_TX_RING_CNT,
184 atgep->atge_tx_buf_len, DDI_DMA_WRITE);
185 if (err != DDI_SUCCESS) {
186 atge_error(atgep->atge_dip, "DMA allocation failed for"
187 " TX Ring");
188 return (err);
189 }
190
191 /*
192 * Allocate RX ring.
193 */
194 atgep->atge_rx_buf_len = atgep->atge_mtu +
195 sizeof (struct ether_header) + VLAN_TAGSZ + ETHERFCSL;
196 l1c->atge_rx_ring = kmem_alloc(sizeof (atge_ring_t), KM_SLEEP);
197 l1c->atge_rx_ring->r_atge = atgep;
198 l1c->atge_rx_ring->r_desc_ring = NULL;
199 dma = atge_alloc_a_dma_blk(atgep, &atge_l1c_dma_attr_rx_desc,
200 L1C_RX_RING_SZ, DDI_DMA_RDWR);
201 if (dma == NULL) {
202 atge_error(atgep->atge_dip, "DMA allocation failed"
203 " for RX Ring");
204 return (DDI_FAILURE);
205 }
206 l1c->atge_rx_ring->r_desc_ring = dma;
207
208 /*
209 * Allocate DMA buffers for RX ring.
210 */
211 err = atge_alloc_buffers(l1c->atge_rx_ring, L1C_RX_RING_CNT,
212 atgep->atge_rx_buf_len, DDI_DMA_READ);
213 if (err != DDI_SUCCESS) {
214 atge_error(atgep->atge_dip, "DMA allocation failed for"
215 " RX buffers");
216 return (err);
217 }
218
219 /*
220 * Allocate CMB used for fetching interrupt status data.
221 */
222 ATGE_DB(("%s: %s() L1C_CMB_BLOCK_SZ : 0x%x", atgep->atge_name,
223 __func__, L1C_CMB_BLOCK_SZ));
224
225 dma = atge_alloc_a_dma_blk(atgep, &atge_l1c_dma_attr_cmb,
226 L1C_CMB_BLOCK_SZ, DDI_DMA_RDWR);
227 l1c->atge_l1c_cmb = dma;
228 if (dma == NULL) {
229 atge_error(atgep->atge_dip, "DMA allocation failed for CMB");
230 return (DDI_FAILURE);
231 }
232
233 /*
234 * RR ring (Return Ring for RX and TX).
235 */
236 ATGE_DB(("%s: %s() L1C_RR_RING_SZ : 0x%x", atgep->atge_name,
237 __func__, L1C_RR_RING_SZ));
238
239 dma = atge_alloc_a_dma_blk(atgep, &atge_l1c_dma_attr_rr,
240 L1C_RR_RING_SZ, DDI_DMA_RDWR);
241 l1c->atge_l1c_rr = dma;
242 if (dma == NULL) {
243 atge_error(atgep->atge_dip, "DMA allocation failed"
244 " for RX RR ring");
245 return (DDI_FAILURE);
246 }
247
248 /*
249 * SMB for statistics.
250 */
251 ATGE_DB(("%s: %s() L1C_SMB_BLOCK_SZ : 0x%x", atgep->atge_name,
252 __func__, L1C_SMB_BLOCK_SZ));
253
254 dma = atge_alloc_a_dma_blk(atgep, &atge_l1c_dma_attr_smb,
255 L1C_SMB_BLOCK_SZ, DDI_DMA_RDWR);
256 l1c->atge_l1c_smb = dma;
257 if (dma == NULL) {
258 atge_error(atgep->atge_dip, "DMA allocation failed for SMB");
259 return (DDI_FAILURE);
260 }
261
262 atgep->atge_hw_stats = kmem_zalloc(sizeof (atge_l1c_smb_t), KM_SLEEP);
263
264 return (DDI_SUCCESS);
265 }
266
267 void
atge_l1c_free_dma(atge_t * atgep)268 atge_l1c_free_dma(atge_t *atgep)
269 {
270 atge_l1c_data_t *l1c;
271
272 l1c = atgep->atge_private_data;
273
274 /*
275 * Free TX ring.
276 */
277 if (atgep->atge_tx_ring != NULL) {
278 atge_free_buffers(atgep->atge_tx_ring, ATGE_TX_RING_CNT);
279
280 if (atgep->atge_tx_ring->r_desc_ring != NULL) {
281 atge_free_a_dma_blk(atgep->atge_tx_ring->r_desc_ring);
282 }
283
284 kmem_free(atgep->atge_tx_ring, sizeof (atge_ring_t));
285 atgep->atge_tx_ring = NULL;
286 }
287
288 if (l1c && l1c->atge_l1c_cmb != NULL) {
289 atge_free_a_dma_blk(l1c->atge_l1c_cmb);
290 l1c->atge_l1c_cmb = NULL;
291 }
292
293 if (l1c && l1c->atge_l1c_rr != NULL) {
294 atge_free_a_dma_blk(l1c->atge_l1c_rr);
295 l1c->atge_l1c_rr = NULL;
296 }
297
298 if (l1c && l1c->atge_l1c_smb != NULL) {
299 atge_free_a_dma_blk(l1c->atge_l1c_smb);
300 l1c->atge_l1c_smb = NULL;
301 }
302
303 /*
304 * Free RX ring.
305 */
306 if (l1c && l1c->atge_rx_ring != NULL) {
307 atge_free_buffers(l1c->atge_rx_ring, L1C_RX_RING_CNT);
308
309 if (l1c->atge_rx_ring->r_desc_ring != NULL) {
310 atge_free_a_dma_blk(l1c->atge_rx_ring->r_desc_ring);
311 }
312
313 kmem_free(l1c->atge_rx_ring, sizeof (atge_ring_t));
314 l1c->atge_rx_ring = NULL;
315 }
316
317 /*
318 * Free the memory allocated for gathering hw stats.
319 */
320 if (atgep->atge_hw_stats != NULL) {
321 kmem_free(atgep->atge_hw_stats, sizeof (atge_l1c_smb_t));
322 atgep->atge_hw_stats = NULL;
323 }
324
325 /*
326 * Free the private area.
327 */
328 if (l1c != NULL) {
329 kmem_free(l1c, sizeof (atge_l1c_data_t));
330 atgep->atge_private_data = NULL;
331 }
332 }
333
334 void
atge_l1c_init_rx_ring(atge_t * atgep)335 atge_l1c_init_rx_ring(atge_t *atgep)
336 {
337 atge_l1c_data_t *l1c;
338 atge_dma_t *dma;
339 l1c_rx_desc_t *rx;
340 int i;
341
342 l1c = atgep->atge_private_data;
343 l1c->atge_rx_ring->r_consumer = L1C_RX_RING_CNT - 1;
344 dma = l1c->atge_rx_ring->r_desc_ring;
345 bzero(dma->addr, L1C_RX_RING_SZ);
346
347 for (i = 0; i < L1C_RX_RING_CNT; i++) {
348 rx = (l1c_rx_desc_t *)(dma->addr +
349 (i * sizeof (l1c_rx_desc_t)));
350
351 ATGE_PUT64(dma, &rx->addr,
352 l1c->atge_rx_ring->r_buf_tbl[i]->cookie.dmac_laddress);
353 /* No length field. */
354 }
355
356 DMA_SYNC(dma, 0, 0, DDI_DMA_SYNC_FORDEV);
357 /* Let controller know availability of new Rx buffers. */
358 OUTL(atgep, ATGE_MBOX_RD0_PROD_IDX, l1c->atge_rx_ring->r_consumer);
359 }
360
361 void
atge_l1c_init_tx_ring(atge_t * atgep)362 atge_l1c_init_tx_ring(atge_t *atgep)
363 {
364 atgep->atge_tx_ring->r_producer = 0;
365 atgep->atge_tx_ring->r_consumer = 0;
366 atgep->atge_tx_ring->r_avail_desc = ATGE_TX_RING_CNT;
367
368 bzero(atgep->atge_tx_ring->r_desc_ring->addr, ATGE_TX_RING_SZ);
369 DMA_SYNC(atgep->atge_tx_ring->r_desc_ring, 0, 0, DDI_DMA_SYNC_FORDEV);
370 }
371
372 void
atge_l1c_init_rr_ring(atge_t * atgep)373 atge_l1c_init_rr_ring(atge_t *atgep)
374 {
375 atge_l1c_data_t *l1c;
376 atge_dma_t *dma;
377
378 l1c = atgep->atge_private_data;
379 l1c->atge_l1c_rr_consumers = 0;
380
381 dma = l1c->atge_l1c_rr;
382 bzero(dma->addr, L1C_RR_RING_SZ);
383 DMA_SYNC(dma, 0, 0, DDI_DMA_SYNC_FORDEV);
384 }
385
386 void
atge_l1c_init_smb(atge_t * atgep)387 atge_l1c_init_smb(atge_t *atgep)
388 {
389 atge_l1c_data_t *l1c;
390 atge_dma_t *dma;
391
392 l1c = atgep->atge_private_data;
393 dma = l1c->atge_l1c_smb;
394 bzero(dma->addr, L1C_SMB_BLOCK_SZ);
395 DMA_SYNC(dma, 0, 0, DDI_DMA_SYNC_FORDEV);
396 }
397
398 void
atge_l1c_init_cmb(atge_t * atgep)399 atge_l1c_init_cmb(atge_t *atgep)
400 {
401 atge_l1c_data_t *l1c;
402 atge_dma_t *dma;
403
404 l1c = atgep->atge_private_data;
405 dma = l1c->atge_l1c_cmb;
406 bzero(dma->addr, L1C_CMB_BLOCK_SZ);
407 DMA_SYNC(dma, 0, 0, DDI_DMA_SYNC_FORDEV);
408 }
409
410 void
atge_l1c_program_dma(atge_t * atgep)411 atge_l1c_program_dma(atge_t *atgep)
412 {
413 atge_l1c_data_t *l1c;
414 atge_ring_t *r;
415 uint32_t reg;
416
417 l1c = atgep->atge_private_data;
418
419 /*
420 * Clear WOL status and disable all WOL feature as WOL
421 * would interfere Rx operation under normal environments.
422 */
423 (void) INL(atgep, ATGE_WOL_CFG);
424 OUTL(atgep, ATGE_WOL_CFG, 0);
425
426 /* TX */
427 r = atgep->atge_tx_ring;
428 OUTL(atgep, L1C_TX_BASE_ADDR_HI,
429 ATGE_ADDR_HI(r->r_desc_ring->cookie.dmac_laddress));
430 OUTL(atgep, L1C_TDL_HEAD_ADDR_LO,
431 ATGE_ADDR_LO(r->r_desc_ring->cookie.dmac_laddress));
432 /* We don't use high priority ring. */
433 OUTL(atgep, L1C_TDH_HEAD_ADDR_LO, 0);
434
435 /* RX */
436 r = l1c->atge_rx_ring;
437 OUTL(atgep, L1C_RX_BASE_ADDR_HI,
438 ATGE_ADDR_HI(r->r_desc_ring->cookie.dmac_laddress));
439 OUTL(atgep, L1C_RD0_HEAD_ADDR_LO,
440 ATGE_ADDR_LO(r->r_desc_ring->cookie.dmac_laddress));
441 /* We use one Rx ring. */
442 OUTL(atgep, L1C_RD1_HEAD_ADDR_LO, 0);
443 OUTL(atgep, L1C_RD2_HEAD_ADDR_LO, 0);
444 OUTL(atgep, L1C_RD3_HEAD_ADDR_LO, 0);
445
446 /* RR Ring */
447 /*
448 * Let hardware split jumbo frames into alc_max_buf_sized chunks.
449 * if it do not fit the buffer size. Rx return descriptor holds
450 * a counter that indicates how many fragments were made by the
451 * hardware. The buffer size should be multiple of 8 bytes.
452 * Since hardware has limit on the size of buffer size, always
453 * use the maximum value.
454 * For strict-alignment architectures make sure to reduce buffer
455 * size by 8 bytes to make room for alignment fixup.
456 */
457 OUTL(atgep, L1C_RX_BUF_SIZE, RX_BUF_SIZE_MAX); /* XXX */
458
459 /* Set Rx return descriptor base addresses. */
460 OUTL(atgep, L1C_RRD0_HEAD_ADDR_LO,
461 ATGE_ADDR_LO(l1c->atge_l1c_rr->cookie.dmac_laddress));
462 /* We use one Rx return ring. */
463 OUTL(atgep, L1C_RRD1_HEAD_ADDR_LO, 0);
464 OUTL(atgep, L1C_RRD2_HEAD_ADDR_LO, 0);
465 OUTL(atgep, L1C_RRD3_HEAD_ADDR_LO, 0);
466
467 /* CMB */
468 OUTL(atgep, L1C_CMB_BASE_ADDR_LO,
469 ATGE_ADDR_LO(l1c->atge_l1c_cmb->cookie.dmac_laddress));
470
471 /* SMB */
472 OUTL(atgep, L1C_SMB_BASE_ADDR_HI,
473 ATGE_ADDR_HI(l1c->atge_l1c_smb->cookie.dmac_laddress));
474 OUTL(atgep, L1C_SMB_BASE_ADDR_LO,
475 ATGE_ADDR_LO(l1c->atge_l1c_smb->cookie.dmac_laddress));
476
477 /*
478 * Set RX return ring (RR) counter.
479 */
480 /* Set Rx descriptor counter. */
481 OUTL(atgep, L1C_RD_RING_CNT,
482 (L1C_RX_RING_CNT << RD_RING_CNT_SHIFT) & RD_RING_CNT_MASK);
483 /* Set Rx return descriptor counter. */
484 OUTL(atgep, L1C_RRD_RING_CNT,
485 (L1C_RR_RING_CNT << RRD_RING_CNT_SHIFT) & RRD_RING_CNT_MASK);
486
487 /*
488 * Set TX descriptor counter.
489 */
490 OUTL(atgep, L1C_TD_RING_CNT,
491 (ATGE_TX_RING_CNT << TD_RING_CNT_SHIFT) & TD_RING_CNT_MASK);
492
493 switch (ATGE_DID(atgep)) {
494 case ATGE_CHIP_AR8152V1_DEV_ID:
495 /* Reconfigure SRAM - Vendor magic. */
496 OUTL(atgep, L1C_SRAM_RX_FIFO_LEN, 0x000002A0);
497 OUTL(atgep, L1C_SRAM_TX_FIFO_LEN, 0x00000100);
498 OUTL(atgep, L1C_SRAM_RX_FIFO_ADDR, 0x029F0000);
499 OUTL(atgep, L1C_SRAM_RD_ADDR, 0x02BF02A0);
500 OUTL(atgep, L1C_SRAM_TX_FIFO_ADDR, 0x03BF02C0);
501 OUTL(atgep, L1C_SRAM_TRD_ADDR, 0x03DF03C0);
502 OUTL(atgep, L1C_TXF_WATER_MARK, 0x00000000);
503 OUTL(atgep, L1C_RD_DMA_CFG, 0x00000000);
504 break;
505 }
506
507 /*
508 * Inform hardware that we have loaded DMA registers.
509 */
510 OUTL(atgep, ATGE_DMA_BLOCK, DMA_BLOCK_LOAD);
511
512 /* Configure interrupt moderation timer. */
513 reg = ATGE_USECS(atgep->atge_int_rx_mod) << IM_TIMER_RX_SHIFT;
514 reg |= ATGE_USECS(atgep->atge_int_tx_mod) << IM_TIMER_TX_SHIFT;
515 OUTL(atgep, ATGE_IM_TIMER, reg);
516 /*
517 * We don't want to automatic interrupt clear as task queue
518 * for the interrupt should know interrupt status.
519 */
520 reg = 0;
521 if (ATGE_USECS(atgep->atge_int_rx_mod) != 0)
522 reg |= MASTER_IM_RX_TIMER_ENB;
523 if (ATGE_USECS(atgep->atge_int_tx_mod) != 0)
524 reg |= MASTER_IM_TX_TIMER_ENB;
525 OUTL(atgep, ATGE_MASTER_CFG, reg);
526 }
527
528 void
atge_l1c_clear_stats(atge_t * atgep)529 atge_l1c_clear_stats(atge_t *atgep)
530 {
531 atge_l1c_smb_t smb;
532 uint32_t *reg;
533 int i;
534
535 /*
536 * Clear RX stats first.
537 */
538 i = 0;
539 reg = &smb.rx_frames;
540 while (reg++ <= &smb.rx_pkts_filtered) {
541 (void) INL(atgep, ATGE_RX_MIB_BASE + i);
542 i += sizeof (uint32_t);
543 }
544
545 /*
546 * Clear TX stats.
547 */
548 i = 0;
549 reg = &smb.tx_frames;
550 while (reg++ <= &smb.tx_mcast_bytes) {
551 (void) INL(atgep, ATGE_TX_MIB_BASE + i);
552 i += sizeof (uint32_t);
553 }
554 }
555
556 void
atge_l1c_gather_stats(atge_t * atgep)557 atge_l1c_gather_stats(atge_t *atgep)
558 {
559 atge_l1c_data_t *l1c;
560 atge_dma_t *dma;
561 atge_l1c_smb_t *stat;
562 atge_l1c_smb_t *smb;
563
564 ASSERT(atgep != NULL);
565
566 l1c = atgep->atge_private_data;
567 dma = l1c->atge_l1c_smb;
568 DMA_SYNC(dma, 0, 0, DDI_DMA_SYNC_FORKERNEL);
569 stat = (atge_l1c_smb_t *)atgep->atge_hw_stats;
570 smb = (atge_l1c_smb_t *)dma->addr;
571
572 /* Rx stats. */
573 stat->rx_frames += smb->rx_frames;
574 stat->rx_bcast_frames += smb->rx_bcast_frames;
575 stat->rx_mcast_frames += smb->rx_mcast_frames;
576 stat->rx_pause_frames += smb->rx_pause_frames;
577 stat->rx_control_frames += smb->rx_control_frames;
578 stat->rx_crcerrs += smb->rx_crcerrs;
579 stat->rx_lenerrs += smb->rx_lenerrs;
580 stat->rx_bytes += smb->rx_bytes;
581 stat->rx_runts += smb->rx_runts;
582 stat->rx_fragments += smb->rx_fragments;
583 stat->rx_pkts_64 += smb->rx_pkts_64;
584 stat->rx_pkts_65_127 += smb->rx_pkts_65_127;
585 stat->rx_pkts_128_255 += smb->rx_pkts_128_255;
586 stat->rx_pkts_256_511 += smb->rx_pkts_256_511;
587 stat->rx_pkts_512_1023 += smb->rx_pkts_512_1023;
588 stat->rx_pkts_1024_1518 += smb->rx_pkts_1024_1518;
589 stat->rx_pkts_1519_max += smb->rx_pkts_1519_max;
590 stat->rx_pkts_truncated += smb->rx_pkts_truncated;
591 stat->rx_fifo_oflows += smb->rx_fifo_oflows;
592 stat->rx_alignerrs += smb->rx_alignerrs;
593 stat->rx_bcast_bytes += smb->rx_bcast_bytes;
594 stat->rx_mcast_bytes += smb->rx_mcast_bytes;
595 stat->rx_pkts_filtered += smb->rx_pkts_filtered;
596
597 /* Tx stats. */
598 stat->tx_frames += smb->tx_frames;
599 stat->tx_bcast_frames += smb->tx_bcast_frames;
600 stat->tx_mcast_frames += smb->tx_mcast_frames;
601 stat->tx_pause_frames += smb->tx_pause_frames;
602 stat->tx_excess_defer += smb->tx_excess_defer;
603 stat->tx_control_frames += smb->tx_control_frames;
604 stat->tx_deferred += smb->tx_deferred;
605 stat->tx_bytes += smb->tx_bytes;
606 stat->tx_pkts_64 += smb->tx_pkts_64;
607 stat->tx_pkts_65_127 += smb->tx_pkts_65_127;
608 stat->tx_pkts_128_255 += smb->tx_pkts_128_255;
609 stat->tx_pkts_256_511 += smb->tx_pkts_256_511;
610 stat->tx_pkts_512_1023 += smb->tx_pkts_512_1023;
611 stat->tx_pkts_1024_1518 += smb->tx_pkts_1024_1518;
612 stat->tx_pkts_1519_max += smb->tx_pkts_1519_max;
613 stat->tx_single_colls += smb->tx_single_colls;
614 stat->tx_multi_colls += smb->tx_multi_colls;
615 stat->tx_late_colls += smb->tx_late_colls;
616 stat->tx_excess_colls += smb->tx_excess_colls;
617 stat->tx_underrun += smb->tx_underrun;
618 stat->tx_desc_underrun += smb->tx_desc_underrun;
619 stat->tx_lenerrs += smb->tx_lenerrs;
620 stat->tx_pkts_truncated += smb->tx_pkts_truncated;
621 stat->tx_bcast_bytes += smb->tx_bcast_bytes;
622 stat->tx_mcast_bytes += smb->tx_mcast_bytes;
623
624 /*
625 * Update global counters in atge_t.
626 */
627 atgep->atge_brdcstrcv += smb->rx_bcast_frames;
628 atgep->atge_multircv += smb->rx_mcast_frames;
629 atgep->atge_multixmt += smb->tx_mcast_frames;
630 atgep->atge_brdcstxmt += smb->tx_bcast_frames;
631
632 atgep->atge_align_errors += smb->rx_alignerrs;
633 atgep->atge_fcs_errors += smb->rx_crcerrs;
634 atgep->atge_defer_xmts += smb->tx_deferred;
635 atgep->atge_first_collisions += smb->tx_single_colls;
636 atgep->atge_multi_collisions += smb->tx_multi_colls * 2;
637 atgep->atge_tx_late_collisions += smb->tx_late_colls;
638 atgep->atge_ex_collisions += smb->tx_excess_colls;
639 atgep->atge_toolong_errors += smb->rx_lenerrs;
640 atgep->atge_overflow += smb->rx_fifo_oflows;
641 atgep->atge_underflow += (smb->tx_underrun + smb->tx_desc_underrun);
642 atgep->atge_runt += smb->rx_runts;
643
644
645 atgep->atge_collisions += smb->tx_single_colls +
646 smb->tx_multi_colls * 2 + smb->tx_late_colls;
647
648 /*
649 * tx_pkts_truncated counter looks suspicious. It constantly
650 * increments with no sign of Tx errors. Hence we don't factor it.
651 */
652 atgep->atge_macxmt_errors += smb->tx_late_colls + smb->tx_underrun;
653
654 atgep->atge_macrcv_errors += smb->rx_crcerrs + smb->rx_lenerrs +
655 smb->rx_runts + smb->rx_pkts_truncated +
656 smb->rx_alignerrs;
657
658 smb->updated = 0;
659 DMA_SYNC(dma, 0, 0, DDI_DMA_SYNC_FORDEV);
660 }
661
662 void
atge_l1c_stop_tx_mac(atge_t * atgep)663 atge_l1c_stop_tx_mac(atge_t *atgep)
664 {
665 uint32_t reg;
666 int t;
667
668 ATGE_DB(("%s: %s() called", atgep->atge_name, __func__));
669
670 reg = INL(atgep, ATGE_MAC_CFG);
671 if ((reg & ATGE_CFG_TX_ENB) != 0) {
672 reg &= ~ATGE_CFG_TX_ENB;
673 OUTL(atgep, ATGE_MAC_CFG, reg);
674 }
675
676 /* Stop TX DMA engine. */
677 reg = INL(atgep, ATGE_DMA_CFG);
678 if ((reg & DMA_CFG_RD_ENB) != 0) {
679 reg &= ~DMA_CFG_RD_ENB;
680 OUTL(atgep, ATGE_DMA_CFG, reg);
681 }
682
683 for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
684 if ((INL(atgep, ATGE_IDLE_STATUS) &
685 (IDLE_STATUS_TXMAC | IDLE_STATUS_DMARD)) == 0)
686 break;
687
688 drv_usecwait(10);
689 }
690
691 if (t == 0) {
692 /* This should be an FMA event. */
693 atge_error(atgep->atge_dip, "stopping TX DMA Engine timeout");
694 }
695 }
696
697 void
atge_l1c_stop_rx_mac(atge_t * atgep)698 atge_l1c_stop_rx_mac(atge_t *atgep)
699 {
700 uint32_t reg;
701 int t;
702
703 ATGE_DB(("%s: %s() called", atgep->atge_name, __func__));
704
705 reg = INL(atgep, ATGE_MAC_CFG);
706 if ((reg & ATGE_CFG_RX_ENB) != 0) {
707 reg &= ~ATGE_CFG_RX_ENB;
708 OUTL(atgep, ATGE_MAC_CFG, reg);
709 }
710
711 /* Stop RX DMA engine. */
712 reg = INL(atgep, ATGE_DMA_CFG);
713 if ((reg & DMA_CFG_WR_ENB) != 0) {
714 reg &= ~DMA_CFG_WR_ENB;
715 OUTL(atgep, ATGE_DMA_CFG, reg);
716 }
717
718 for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
719 if ((INL(atgep, ATGE_IDLE_STATUS) &
720 (IDLE_STATUS_RXMAC | IDLE_STATUS_DMAWR)) == 0)
721 break;
722 drv_usecwait(10);
723 }
724
725 if (t == 0) {
726 /* This should be an FMA event. */
727 atge_error(atgep->atge_dip, " stopping RX DMA Engine timeout");
728 }
729 }
730
731 /*
732 * Receives (consumes) packets.
733 */
734 static mblk_t *
atge_l1c_rx(atge_t * atgep)735 atge_l1c_rx(atge_t *atgep)
736 {
737 atge_l1c_data_t *l1c;
738 mblk_t *mp = NULL, *rx_head = NULL, *rx_tail = NULL;
739 l1c_rx_rdesc_t *rx_rr;
740 uint32_t rdinfo, status, totlen, pktlen, slotlen;
741 int nsegs, rx_cons = 0, cnt;
742 atge_dma_t *buf;
743 uchar_t *bufp;
744 int sync = 0;
745
746 l1c = atgep->atge_private_data;
747 ASSERT(l1c != NULL);
748
749 DMA_SYNC(l1c->atge_l1c_rr, 0, 0, DDI_DMA_SYNC_FORKERNEL);
750 for (;;) {
751 rx_rr = (l1c_rx_rdesc_t *)(l1c->atge_l1c_rr->addr +
752 (l1c->atge_l1c_rr_consumers * sizeof (l1c_rx_rdesc_t)));
753
754 rdinfo = ATGE_GET32(l1c->atge_l1c_rr, &rx_rr->rdinfo);
755 status = ATGE_GET32(l1c->atge_l1c_rr, &rx_rr->status);
756
757 rx_cons = L1C_RRD_RD_IDX(rdinfo);
758 nsegs = L1C_RRD_RD_CNT(rdinfo);
759 totlen = L1C_RRD_BYTES(status);
760
761 ATGE_DB(("%s: %s() PKT -- rdinfo : 0x%x,"
762 "status : 0x%x, totlen : %d,"
763 " rx_cons : %d, nsegs : %d", atgep->atge_name, __func__,
764 rdinfo, status, totlen, rx_cons, nsegs));
765
766 if ((status & L1C_RRD_VALID) == 0) {
767 break;
768 }
769
770 if ((status & (L1C_RRD_ERR_CRC | L1C_RRD_ERR_ALIGN |
771 L1C_RRD_ERR_TRUNC | L1C_RRD_ERR_RUNT |
772 L1C_RRD_ERR_ICMP | L1C_RRD_ERR_LENGTH)) != 0) {
773 atge_error(atgep->atge_dip, "errored pkt");
774
775 l1c->atge_rx_ring->r_consumer += nsegs;
776 l1c->atge_rx_ring->r_consumer %= L1C_RX_RING_CNT;
777 break;
778 }
779
780 ASSERT(rx_cons >= 0 && rx_cons <= L1C_RX_RING_CNT);
781
782 mp = allocb(totlen + L1C_HEADROOM, BPRI_MED);
783 if (mp != NULL) {
784 mp->b_rptr += L1C_HEADROOM;
785 bufp = mp->b_rptr;
786 mp->b_wptr = bufp + totlen;
787 mp->b_next = NULL;
788
789 atgep->atge_ipackets++;
790 atgep->atge_rbytes += totlen;
791
792 /*
793 * If there are more than one segments, then the first
794 * segment should be of size MTU. We couldn't verify
795 * this as our driver does not support changing MTU
796 * or Jumbo Frames.
797 */
798 if (nsegs > 1) {
799 slotlen = atgep->atge_mtu;
800 } else {
801 slotlen = totlen;
802 }
803 } else {
804 ATGE_DB(("%s: %s() PKT mp == NULL totlen : %d",
805 atgep->atge_name, __func__, totlen));
806
807 if (slotlen > atgep->atge_rx_buf_len) {
808 atgep->atge_toolong_errors++;
809 } else if (mp == NULL) {
810 atgep->atge_norcvbuf++;
811 }
812
813 rx_rr->status = 0;
814 break;
815 }
816
817 for (cnt = 0, pktlen = 0; cnt < nsegs; cnt++) {
818 buf = l1c->atge_rx_ring->r_buf_tbl[rx_cons];
819
820 slotlen = min(atgep->atge_max_frame_size, totlen);
821
822 bcopy(buf->addr, (bufp + pktlen), slotlen);
823 pktlen += slotlen;
824 totlen -= slotlen;
825
826 ATGE_DB(("%s: %s() len : %d, rxcons : %d, pktlen : %d",
827 atgep->atge_name, __func__, slotlen, rx_cons,
828 pktlen));
829
830 ATGE_INC_SLOT(rx_cons, L1C_RX_RING_CNT);
831 }
832
833 if (rx_tail == NULL) {
834 rx_head = rx_tail = mp;
835 } else {
836 rx_tail->b_next = mp;
837 rx_tail = mp;
838 }
839
840 if (cnt != nsegs) {
841 l1c->atge_rx_ring->r_consumer += nsegs;
842 l1c->atge_rx_ring->r_consumer %= L1C_RX_RING_CNT;
843 } else {
844 l1c->atge_rx_ring->r_consumer = rx_cons;
845 }
846
847 /*
848 * Tell the chip that this RR can be reused.
849 */
850 rx_rr->status = 0;
851
852 ATGE_INC_SLOT(l1c->atge_l1c_rr_consumers, L1C_RR_RING_CNT);
853 sync++;
854 }
855
856 if (sync) {
857 DMA_SYNC(l1c->atge_rx_ring->r_desc_ring, 0, 0,
858 DDI_DMA_SYNC_FORDEV);
859
860 DMA_SYNC(l1c->atge_l1c_rr, 0, 0, DDI_DMA_SYNC_FORDEV);
861 /*
862 * Let controller know availability of new Rx buffers.
863 */
864 OUTL(atgep, ATGE_MBOX_RD0_PROD_IDX,
865 l1c->atge_rx_ring->r_consumer);
866
867 ATGE_DB(("%s: %s() PKT Recved -> r_consumer : %d, rx_cons : %d"
868 " atge_l1c_rr_consumers : %d",
869 atgep->atge_name, __func__, l1c->atge_rx_ring->r_consumer,
870 rx_cons, l1c->atge_l1c_rr_consumers));
871 }
872
873
874 return (rx_head);
875 }
876
877 /*
878 * The interrupt handler for L1C chip.
879 */
880 /*ARGSUSED*/
881 uint_t
atge_l1c_interrupt(caddr_t arg1,caddr_t arg2)882 atge_l1c_interrupt(caddr_t arg1, caddr_t arg2)
883 {
884 atge_t *atgep = (void *)arg1;
885 mblk_t *rx_head = NULL;
886 uint32_t status;
887 int resched = 0;
888
889 ASSERT(atgep != NULL);
890
891 mutex_enter(&atgep->atge_intr_lock);
892
893 if (atgep->atge_chip_state & ATGE_CHIP_SUSPENDED) {
894 mutex_exit(&atgep->atge_intr_lock);
895 return (DDI_INTR_UNCLAIMED);
896 }
897
898 status = INL(atgep, ATGE_INTR_STATUS);
899 if (status == 0 || (status & atgep->atge_intrs) == 0) {
900 mutex_exit(&atgep->atge_intr_lock);
901
902 if (atgep->atge_flags & ATGE_FIXED_TYPE)
903 return (DDI_INTR_UNCLAIMED);
904
905 return (DDI_INTR_CLAIMED);
906 }
907
908 ATGE_DB(("%s: %s() entry status : %x",
909 atgep->atge_name, __func__, status));
910
911 /*
912 * Disable interrupts.
913 */
914 if (status & L1C_INTR_GPHY) {
915 /* clear PHY interrupt source before we ack interrupts */
916 (void) atge_mii_read(atgep,
917 atgep->atge_phyaddr, ATGE_ISR_ACK_GPHY);
918 }
919
920 OUTL(atgep, ATGE_INTR_STATUS, status | L1C_INTR_DIS_INT);
921 FLUSH(atgep, ATGE_INTR_STATUS);
922
923 /*
924 * Check if chip is running, only then do the work.
925 */
926 if (atgep->atge_chip_state & ATGE_CHIP_RUNNING) {
927 atge_l1c_data_t *l1c;
928
929 l1c = atgep->atge_private_data;
930
931 ATGE_DB(("%s: %s() atge_l1c_intr_status : %x, "
932 "atge_l1c_rx_prod_cons : %d, atge_l1c_tx_prod_cons : %d"
933 " atge_l1c_rr_consumers : %d",
934 atgep->atge_name, __func__, l1c->atge_l1c_intr_status,
935 l1c->atge_l1c_rx_prod_cons, l1c->atge_l1c_tx_prod_cons,
936 l1c->atge_l1c_rr_consumers));
937
938 if (status & L1C_INTR_SMB)
939 atge_l1c_gather_stats(atgep);
940
941 /*
942 * Check for errors.
943 */
944 if (status & (L1C_INTR_DMA_RD_TO_RST |
945 L1C_INTR_DMA_WR_TO_RST | L1C_INTR_TXQ_TO_RST)) {
946 /* This should be an FMA event. */
947 atge_error(atgep->atge_dip,
948 "L1C chip detected a fatal error, "
949 "interrupt status: %x", status);
950
951 if (status & L1C_INTR_DMA_RD_TO_RST) {
952 atge_error(atgep->atge_dip,
953 "DMA read error");
954 }
955 if (status & L1C_INTR_DMA_WR_TO_RST) {
956 atge_error(atgep->atge_dip,
957 "DMA write error");
958 }
959 if (status & L1C_INTR_TXQ_TO_RST) {
960 atge_error(atgep->atge_dip,
961 "Transmit queue error");
962 }
963
964 /* This should be an FMA event. */
965 atge_device_stop(atgep);
966 /*
967 * Device has failed fatally.
968 * It will not be restarted by the driver.
969 */
970 goto done;
971
972 }
973
974 rx_head = atge_l1c_rx(atgep);
975 if (status & L1C_INTR_TX_PKT) {
976 int cons;
977
978 mutex_enter(&atgep->atge_tx_lock);
979 cons = INL(atgep, ATGE_MBOX_TD_CONS_IDX) >> 16;
980 atge_tx_reclaim(atgep, cons);
981 if (atgep->atge_tx_resched) {
982 atgep->atge_tx_resched = 0;
983 resched = 1;
984 }
985
986 mutex_exit(&atgep->atge_tx_lock);
987 }
988 }
989
990 /* Re-enable interrupts. */
991 OUTL(atgep, ATGE_INTR_STATUS, 0);
992
993 done:
994 mutex_exit(&atgep->atge_intr_lock);
995
996 if (status & L1C_INTR_GPHY) {
997 /* link down */
998 ATGE_DB(("%s: %s() MII_CHECK Performed",
999 atgep->atge_name, __func__));
1000 mii_check(atgep->atge_mii);
1001 }
1002
1003 /*
1004 * Pass the list of packets received from chip to MAC layer.
1005 */
1006 if (rx_head) {
1007 mac_rx(atgep->atge_mh, 0, rx_head);
1008 }
1009
1010 /*
1011 * Let MAC start sending pkts if the downstream was asked to pause.
1012 */
1013 if (resched)
1014 mac_tx_update(atgep->atge_mh);
1015
1016 return (DDI_INTR_CLAIMED);
1017 }
1018
1019 void
atge_l1c_send_packet(atge_ring_t * r)1020 atge_l1c_send_packet(atge_ring_t *r)
1021 {
1022 atge_t *atgep;
1023
1024 atgep = r->r_atge;
1025
1026 mutex_enter(&atgep->atge_mbox_lock);
1027 /* Sync descriptors. */
1028 DMA_SYNC(atgep->atge_tx_ring->r_desc_ring, 0, 0, DDI_DMA_SYNC_FORDEV);
1029 /* Kick. Assume we're using normal Tx priority queue. */
1030 OUTL(atgep, ATGE_MBOX_TD_PROD_IDX,
1031 (atgep->atge_tx_ring->r_producer << MBOX_TD_PROD_LO_IDX_SHIFT) &
1032 MBOX_TD_PROD_LO_IDX_MASK);
1033 mutex_exit(&atgep->atge_mbox_lock);
1034 }
1035