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) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 #include <sys/types.h>
27 #include <sys/stream.h>
28 #include <sys/strsun.h>
29 #include <sys/stat.h>
30 #include <sys/modctl.h>
31 #include <sys/kstat.h>
32 #include <sys/ethernet.h>
33 #include <sys/devops.h>
34 #include <sys/debug.h>
35 #include <sys/conf.h>
36 #include <sys/mii.h>
37 #include <sys/miiregs.h>
38 #include <sys/mac.h>
39 #include <sys/mac_provider.h>
40 #include <sys/mac_ether.h>
41 #include <sys/sysmacros.h>
42 #include <sys/dditypes.h>
43 #include <sys/ddi.h>
44 #include <sys/sunddi.h>
45 #include <sys/byteorder.h>
46 #include <sys/note.h>
47 #include <sys/vlan.h>
48 #include <sys/strsubr.h>
49 #include <sys/crc32.h>
50 #include <sys/sdt.h>
51 #include <sys/pci.h>
52 #include <sys/pci_cap.h>
53
54 #include "atge.h"
55 #include "atge_cmn_reg.h"
56 #include "atge_l1e_reg.h"
57 #include "atge_l1_reg.h"
58
59
60 /*
61 * Atheros/Attansic Ethernet chips are of three types - L1, L2 and L1E.
62 * This driver is for L1E/L1 but can be extended to support other chips.
63 * L1E comes in 1Gigabit and Fast Ethernet flavors. L1 comes in 1Gigabit
64 * flavors only.
65 *
66 * Atheros/Attansic Ethernet controllers have descriptor based TX and RX
67 * with an exception of L1E. L1E's RX side is not descriptor based ring.
68 * The L1E's RX uses pages (not to be confused with MMU pages) for
69 * receiving pkts. The header has four fields :
70 *
71 * uint32_t seqno; Sequence number of the frame.
72 * uint32_t length; Length of the frame.
73 * uint32_t flags; Flags
74 * uint32_t vtag; We don't use hardware VTAG.
75 *
76 * We use only one queue for RX (each queue can have two pages) and each
77 * page is L1E_RX_PAGE_SZ large in bytes. That's the reason we don't
78 * use zero-copy RX because we are limited to two pages and each page
79 * accomodates large number of pkts.
80 *
81 * The TX side on all three chips is descriptor based ring; and all the
82 * more reason to have one driver for these chips.
83 *
84 * We use two locks - atge_intr_lock and atge_tx_lock. Both the locks
135 /*
136 * L1E/L2E specific functions.
137 */
138 void atge_l1e_device_reset(atge_t *);
139 void atge_l1e_stop_mac(atge_t *);
140 int atge_l1e_alloc_dma(atge_t *);
141 void atge_l1e_free_dma(atge_t *);
142 void atge_l1e_init_tx_ring(atge_t *);
143 void atge_l1e_init_rx_pages(atge_t *);
144 void atge_l1e_program_dma(atge_t *);
145 void atge_l1e_send_packet(atge_ring_t *);
146 mblk_t *atge_l1e_receive(atge_t *);
147 uint_t atge_l1e_interrupt(caddr_t, caddr_t);
148 void atge_l1e_gather_stats(atge_t *);
149 void atge_l1e_clear_stats(atge_t *);
150
151 /*
152 * L1 specific functions.
153 */
154 int atge_l1_alloc_dma(atge_t *);
155 void atge_l1_init_tx_ring(atge_t *);
156 void atge_l1_init_rx_ring(atge_t *);
157 void atge_l1_init_rr_ring(atge_t *);
158 void atge_l1_init_cmb(atge_t *);
159 void atge_l1_init_smb(atge_t *);
160 void atge_l1_program_dma(atge_t *);
161 void atge_l1_stop_tx_mac(atge_t *);
162 void atge_l1_stop_rx_mac(atge_t *);
163 uint_t atge_l1_interrupt(caddr_t, caddr_t);
164 void atge_l1_send_packet(atge_ring_t *);
165
166
167 /*
168 * Function prototyps for MII operations.
169 */
170 uint16_t atge_mii_read(void *, uint8_t, uint8_t);
171 void atge_mii_write(void *, uint8_t, uint8_t, uint16_t);
172 void atge_l1e_mii_reset(void *);
173 void atge_l1_mii_reset(void *);
174 static void atge_mii_notify(void *, link_state_t);
175 void atge_tx_reclaim(atge_t *atgep, int cons);
176
177 /*
178 * L1E/L2E chip.
179 */
180 static mii_ops_t atge_l1e_mii_ops = {
181 MII_OPS_VERSION,
182 atge_mii_read,
183 atge_mii_write,
184 atge_mii_notify,
185 atge_l1e_mii_reset
186 };
187
188 /*
189 * L1 chip.
190 */
191 static mii_ops_t atge_l1_mii_ops = {
192 MII_OPS_VERSION,
193 atge_mii_read,
194 atge_mii_write,
195 atge_mii_notify,
196 atge_l1_mii_reset
197 };
198
199 /*
200 * Function Prototypes for MAC callbacks.
201 */
202 static int atge_m_stat(void *, uint_t, uint64_t *);
203 static int atge_m_start(void *);
204 static void atge_m_stop(void *);
205 static int atge_m_getprop(void *, const char *, mac_prop_id_t, uint_t,
206 void *);
207 static int atge_m_setprop(void *, const char *, mac_prop_id_t, uint_t,
208 const void *);
209 static void atge_m_propinfo(void *, const char *, mac_prop_id_t,
210 mac_prop_info_handle_t);
211 static int atge_m_unicst(void *, const uint8_t *);
212 static int atge_m_multicst(void *, boolean_t, const uint8_t *);
213 static int atge_m_promisc(void *, boolean_t);
214 static mblk_t *atge_m_tx(void *, mblk_t *);
215
216 static mac_callbacks_t atge_m_callbacks = {
217 MC_SETPROP | MC_GETPROP | MC_PROPINFO,
218 atge_m_stat,
219 atge_m_start,
255 */
256 static ddi_dma_attr_t atge_dma_attr_buf = {
257 DMA_ATTR_V0, /* dma_attr_version */
258 0, /* dma_attr_addr_lo */
259 0x00ffffffffffull, /* dma_attr_addr_hi */
260 0x000000003fffull, /* dma_attr_count_max */
261 8, /* dma_attr_align */
262 0x00003ffc, /* dma_attr_burstsizes */
263 1, /* dma_attr_minxfer */
264 0x0000000027ffull, /* dma_attr_maxxfer */
265 0x0000ffffffffull, /* dma_attr_seg */
266 1, /* dma_attr_sgllen */
267 1, /* dma_attr_granular */
268 0 /* dma_attr_flags */
269 };
270
271 /*
272 * Table of supported devices.
273 */
274 #define ATGE_VENDOR_ID 0x1969
275 #define ATGE_L1E_STR "Atheros AR8121/8113/8114"
276
277 static atge_cards_t atge_cards[] = {
278 {ATGE_VENDOR_ID, ATGE_CHIP_L1E_DEV_ID, ATGE_L1E_STR, ATGE_CHIP_L1E},
279 {ATGE_VENDOR_ID, ATGE_CHIP_L1_DEV_ID, "Attansic L1", ATGE_CHIP_L1},
280 };
281
282 /*
283 * Global Debugging flag. Developer level debugging is done only in DEBUG mode.
284 */
285 int atge_debug = 1;
286
287 /*
288 * Debugging and error reporting.
289 */
290 void
291 atge_debug_func(char *fmt, ...)
292 {
293 va_list ap;
294 char buf[256];
295
296 va_start(ap, fmt);
297 (void) vsnprintf(buf, sizeof (buf), fmt, ap);
298 va_end(ap);
299
300 DTRACE_PROBE1(atge__debug, char *, buf);
301 }
302
303 void
304 atge_error(dev_info_t *dip, char *fmt, ...)
305 {
306 va_list ap;
307 char buf[256];
308
309 va_start(ap, fmt);
310 (void) vsnprintf(buf, sizeof (buf), fmt, ap);
311 va_end(ap);
312
313 if (dip) {
314 cmn_err(CE_WARN, "%s%d: %s",
315 ddi_driver_name(dip), ddi_get_instance(dip), buf);
316 } else {
317 cmn_err(CE_WARN, "atge: %s", buf);
318 }
319 }
320
321 void
322 atge_mac_config(atge_t *atgep)
323 {
324 uint32_t reg;
325 int speed;
326 link_duplex_t ld;
327
328 reg = INL(atgep, ATGE_MAC_CFG);
329 reg &= ~(ATGE_CFG_FULL_DUPLEX | ATGE_CFG_TX_FC | ATGE_CFG_RX_FC |
330 ATGE_CFG_SPEED_MASK);
331
332 speed = mii_get_speed(atgep->atge_mii);
333 switch (speed) {
334 case 10:
335 case 100:
336 reg |= ATGE_CFG_SPEED_10_100;
337 break;
338 case 1000:
339 reg |= ATGE_CFG_SPEED_1000;
340 break;
341 }
342
343 ld = mii_get_duplex(atgep->atge_mii);
344 if (ld == LINK_DUPLEX_FULL)
345 reg |= ATGE_CFG_FULL_DUPLEX;
346
347 /* Re-enable TX/RX MACs */
348 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
349 reg |= ATGE_CFG_TX_ENB | ATGE_CFG_RX_ENB | ATGE_CFG_RX_FC;
350 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
351 reg |= ATGE_CFG_TX_ENB | ATGE_CFG_RX_ENB;
352 }
353
354 OUTL(atgep, ATGE_MAC_CFG, reg);
355
356 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
357 reg = ATGE_USECS(ATGE_IM_RX_TIMER_DEFAULT) << IM_TIMER_RX_SHIFT;
358 reg |= ATGE_USECS(ATGE_IM_TX_TIMER_DEFAULT) <<
359 IM_TIMER_TX_SHIFT;
360 OUTL(atgep, ATGE_IM_TIMER, reg);
361 }
362
363 ATGE_DB(("%s: %s() mac_cfg is : %x",
364 atgep->atge_name, __func__, INL(atgep, ATGE_MAC_CFG)));
365 }
366
367 static void
368 atge_mii_notify(void *arg, link_state_t link)
369 {
370 atge_t *atgep = arg;
371
372 ATGE_DB(("%s: %s() LINK STATUS CHANGED from %x -> %x",
373 atgep->atge_name, __func__, atgep->atge_link_state, link));
374
375 mac_link_update(atgep->atge_mh, link);
376
377 /*
378 * Reconfigure MAC if link status is UP now.
379 */
380 mutex_enter(&atgep->atge_tx_lock);
506
507 ATGE_DB(("%s: atge_add_intr_handler() after alloc count"
508 " :%d, avail : %d", atgep->atge_name, count, avail));
509
510 err = ddi_intr_get_pri(atgep->atge_intr_handle[0],
511 &atgep->atge_intr_pri);
512 if (err != DDI_SUCCESS) {
513 atge_error(atgep->atge_dip, "ddi_intr_get_pri failed:%d", err);
514 for (i = 0; i < atgep->atge_intr_cnt; i++) {
515 (void) ddi_intr_free(atgep->atge_intr_handle[i]);
516 }
517 kmem_free(atgep->atge_intr_handle, atgep->atge_intr_size);
518
519 return (DDI_FAILURE);
520 }
521
522 /*
523 * Add interrupt handler now.
524 */
525 for (i = 0; i < atgep->atge_intr_cnt; i++) {
526 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
527 err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
528 atge_l1e_interrupt, atgep, (caddr_t)(uintptr_t)i);
529 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
530 err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
531 atge_l1_interrupt, atgep, (caddr_t)(uintptr_t)i);
532 }
533
534 if (err != DDI_SUCCESS) {
535 atge_error(atgep->atge_dip,
536 "ddi_intr_add_handler failed : %d", err);
537
538 (void) ddi_intr_free(atgep->atge_intr_handle[i]);
539 while (--i >= 0) {
540 (void) ddi_intr_remove_handler(
541 atgep->atge_intr_handle[i]);
542 (void) ddi_intr_free(
543 atgep->atge_intr_handle[i]);
544 }
545
546 kmem_free(atgep->atge_intr_handle,
547 atgep->atge_intr_size);
548
549 return (DDI_FAILURE);
550 }
551 }
692 }
693 }
694
695 return (err);
696 }
697
698 int
699 atge_identify_hardware(atge_t *atgep)
700 {
701 uint16_t vid, did;
702 int i;
703
704 vid = pci_config_get16(atgep->atge_conf_handle, PCI_CONF_VENID);
705 did = pci_config_get16(atgep->atge_conf_handle, PCI_CONF_DEVID);
706
707 atgep->atge_model = 0;
708 for (i = 0; i < (sizeof (atge_cards) / sizeof (atge_cards_t)); i++) {
709 if (atge_cards[i].vendor_id == vid &&
710 atge_cards[i].device_id == did) {
711 atgep->atge_model = atge_cards[i].model;
712 atgep->atge_revid =
713 pci_config_get8(atgep->atge_conf_handle,
714 PCI_CONF_REVID);
715 ATGE_DB(("%s: %s : PCI-ID pci%x,%x and model : %d",
716 atgep->atge_name, __func__, vid, did,
717 atgep->atge_model));
718
719 return (DDI_SUCCESS);
720 }
721 }
722
723 atge_error(atgep->atge_dip, "atge driver is attaching to unknown"
724 " pci%d,%d vendor/device-id card", vid, did);
725
726 /*
727 * Assume it's L1 chip.
728 */
729 atgep->atge_model = ATGE_CHIP_L1;
730 atgep->atge_revid = pci_config_get8(atgep->atge_conf_handle,
731 PCI_CONF_REVID);
732
733 /*
734 * We will leave the decision to caller.
735 */
736 return (DDI_FAILURE);
737 }
738
739 int
740 atge_get_macaddr(atge_t *atgep)
741 {
742 uint32_t reg;
743
744 reg = INL(atgep, ATGE_SPI_CTRL);
745 if ((reg & SPI_VPD_ENB) != 0) {
746 /*
747 * Get VPD stored in TWSI EEPROM.
748 */
749 reg &= ~SPI_VPD_ENB;
757 atgep->atge_ether_addr[3] = INB(atgep, ATGE_PAR0 + 2);
758 atgep->atge_ether_addr[2] = INB(atgep, ATGE_PAR0 + 3);
759 atgep->atge_ether_addr[1] = INB(atgep, ATGE_PAR1 + 0);
760 atgep->atge_ether_addr[0] = INB(atgep, ATGE_PAR1 + 1);
761
762 ATGE_DB(("%s: %s() Station Address - %x:%x:%x:%x:%x:%x",
763 atgep->atge_name, __func__,
764 atgep->atge_ether_addr[0],
765 atgep->atge_ether_addr[1],
766 atgep->atge_ether_addr[2],
767 atgep->atge_ether_addr[3],
768 atgep->atge_ether_addr[4],
769 atgep->atge_ether_addr[5]));
770
771 bcopy(atgep->atge_ether_addr, atgep->atge_dev_addr, ETHERADDRL);
772
773 return (DDI_SUCCESS);
774 }
775
776 /*
777 * Reset functionality for L1 and L1E. It's same.
778 */
779 static void
780 atge_device_reset(atge_t *atgep)
781 {
782 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E ||
783 ATGE_MODEL(atgep) == ATGE_CHIP_L1)
784 atge_device_reset_l1_l1e(atgep);
785 }
786
787 void
788 atge_device_reset_l1_l1e(atge_t *atgep)
789 {
790 uint32_t reg;
791 int t;
792
793 OUTL(atgep, ATGE_MASTER_CFG, MASTER_RESET);
794 reg = INL(atgep, ATGE_MASTER_CFG);
795 for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
796 drv_usecwait(10);
797 reg = INL(atgep, ATGE_MASTER_CFG);
798 if ((reg & MASTER_RESET) == 0)
799 break;
800 }
801
802 if (t == 0) {
803 atge_error(atgep->atge_dip, " master reset timeout reg : %x",
804 reg);
805 }
806
807 for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
808 if ((reg = INL(atgep, ATGE_IDLE_STATUS)) == 0)
809 break;
810
811 drv_usecwait(10);
812 }
813
814 if (t == 0) {
815 atge_error(atgep->atge_dip, "device reset timeout reg : %x",
816 reg);
817 }
818
819 /*
820 * Initialize PCIe module. These values came from FreeBSD and
821 * we don't know the meaning of it.
822 */
823 OUTL(atgep, 0x12FC, 0x6500);
824 reg = INL(atgep, 0x1008) | 0x8000;
825 OUTL(atgep, 0x1008, reg);
826
827 /*
828 * Get chip revision.
829 */
830 atgep->atge_chip_rev = INL(atgep, ATGE_MASTER_CFG) >>
831 MASTER_CHIP_REV_SHIFT;
832
833 ATGE_DB(("%s: %s reset successfully rev : %x", atgep->atge_name,
834 __func__, atgep->atge_chip_rev));
835 }
836
837 /*
838 * DMA allocation for L1 and L1E is bit different since L1E uses RX pages
839 * instead of descriptor based RX model.
840 */
841 static int
842 atge_alloc_dma(atge_t *atgep)
843 {
844 int err = DDI_FAILURE;
845
846 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
847 err = atge_l1e_alloc_dma(atgep);
848 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
849 err = atge_l1_alloc_dma(atgep);
850 }
851
852 return (err);
853 }
854
855 static void
856 atge_free_dma(atge_t *atgep)
857 {
858 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
859 atge_l1e_free_dma(atgep);
860 }
861 }
862
863 /*
864 * Attach entry point in the driver.
865 */
866 static int
867 atge_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd)
868 {
869 atge_t *atgep;
870 mac_register_t *macreg;
871 int instance;
872 uint16_t cap_ptr;
873 uint16_t burst;
874 int err;
875 mii_ops_t *mii_ops;
876
877 instance = ddi_get_instance(devinfo);
878
879 switch (cmd) {
880 default:
881 return (DDI_FAILURE);
882
883 case DDI_RESUME:
884 return (atge_resume(devinfo));
885
886 case DDI_ATTACH:
887 ddi_set_driver_private(devinfo, NULL);
888 break;
889 }
890
891 atgep = kmem_zalloc(sizeof (atge_t), KM_SLEEP);
892 ddi_set_driver_private(devinfo, atgep);
893 atgep->atge_dip = devinfo;
894
895 /*
896 * Setup name and instance number to be used for debugging and
897 * error reporting.
898 */
899 (void) snprintf(atgep->atge_name, sizeof (atgep->atge_name), "%s%d",
900 "atge", instance);
901
902
903 /*
904 * Map PCI config space.
905 */
906 err = pci_config_setup(devinfo, &atgep->atge_conf_handle);
907 if (err != DDI_SUCCESS) {
908 atge_error(devinfo, "pci_config_setup() failed");
934 DDI_INTR_PRI(atgep->atge_intr_pri));
935
936 mutex_init(&atgep->atge_tx_lock, NULL, MUTEX_DRIVER,
937 DDI_INTR_PRI(atgep->atge_intr_pri));
938
939 mutex_init(&atgep->atge_rx_lock, NULL, MUTEX_DRIVER,
940 DDI_INTR_PRI(atgep->atge_intr_pri));
941
942 mutex_init(&atgep->atge_mii_lock, NULL, MUTEX_DRIVER, NULL);
943
944 /*
945 * Used to lock down MBOX register on L1 chip since RX consumer,
946 * TX producer and RX return ring consumer are shared.
947 */
948 mutex_init(&atgep->atge_mbox_lock, NULL, MUTEX_DRIVER,
949 DDI_INTR_PRI(atgep->atge_intr_pri));
950
951 atgep->atge_link_state = LINK_STATE_DOWN;
952 atgep->atge_mtu = ETHERMTU;
953
954 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
955 if (atgep->atge_revid > 0xF0) {
956 /* L2E Rev. B. AR8114 */
957 atgep->atge_flags |= ATGE_FLAG_FASTETHER;
958 } else {
959 if ((INL(atgep, L1E_PHY_STATUS) &
960 PHY_STATUS_100M) != 0) {
961 /* L1E AR8121 */
962 atgep->atge_flags |= ATGE_FLAG_JUMBO;
963 } else {
964 /* L2E Rev. A. AR8113 */
965 atgep->atge_flags |= ATGE_FLAG_FASTETHER;
966 }
967 }
968 }
969
970 /*
971 * Get DMA parameters from PCIe device control register.
972 */
973 err = PCI_CAP_LOCATE(atgep->atge_conf_handle, PCI_CAP_ID_PCI_E,
974 &cap_ptr);
975
976 if (err == DDI_FAILURE) {
977 atgep->atge_dma_rd_burst = DMA_CFG_RD_BURST_128;
978 atgep->atge_dma_wr_burst = DMA_CFG_WR_BURST_128;
979 } else {
980 atgep->atge_flags |= ATGE_FLAG_PCIE;
981 burst = pci_config_get16(atgep->atge_conf_handle,
982 cap_ptr + 0x08);
983
984 /*
985 * Max read request size.
986 */
987 atgep->atge_dma_rd_burst = ((burst >> 12) & 0x07) <<
988 DMA_CFG_RD_BURST_SHIFT;
989
990 /*
991 * Max Payload Size.
992 */
993 atgep->atge_dma_wr_burst = ((burst >> 5) & 0x07) <<
994 DMA_CFG_WR_BURST_SHIFT;
995
996 ATGE_DB(("%s: %s() MRR : %d, MPS : %d",
997 atgep->atge_name, __func__,
998 (128 << ((burst >> 12) & 0x07)),
999 (128 << ((burst >> 5) & 0x07))));
1000 }
1001
1002 /*
1003 * Allocate DMA resources.
1004 */
1005 err = atge_alloc_dma(atgep);
1006 if (err != DDI_SUCCESS) {
1007 atge_error(devinfo, "Failed to allocate DMA resources");
1008 goto fail4;
1009 }
1010
1011 /*
1012 * Get station address.
1013 */
1014 (void) atge_get_macaddr(atgep);
1015
1016 /*
1017 * Setup MII.
1018 */
1019 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1020 mii_ops = &atge_l1e_mii_ops;
1021 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
1022 mii_ops = &atge_l1_mii_ops;
1023 }
1024
1025 if ((atgep->atge_mii = mii_alloc(atgep, devinfo,
1026 mii_ops)) == NULL) {
1027 atge_error(devinfo, "mii_alloc() failed");
1028 goto fail4;
1029 }
1030
1031 /*
1032 * Register with MAC layer.
1033 */
1034 if ((macreg = mac_alloc(MAC_VERSION)) == NULL) {
1035 atge_error(devinfo, "mac_alloc() failed due to version");
1036 goto fail4;
1037 }
1038
1039 macreg->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
1040 macreg->m_driver = atgep;
1041 macreg->m_dip = devinfo;
1042 macreg->m_instance = instance;
1055 mac_free(macreg);
1056
1057 ATGE_DB(("%s: %s() driver attached successfully",
1058 atgep->atge_name, __func__));
1059
1060 atge_device_reset(atgep);
1061
1062 atgep->atge_chip_state = ATGE_CHIP_INITIALIZED;
1063
1064 /*
1065 * At last - enable interrupts.
1066 */
1067 err = atge_enable_intrs(atgep);
1068 if (err == DDI_FAILURE) {
1069 goto fail5;
1070 }
1071
1072 /*
1073 * Reset the PHY before starting.
1074 */
1075 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1076 atge_l1e_mii_reset(atgep);
1077 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
1078 atge_l1_mii_reset(atgep);
1079 }
1080
1081 /*
1082 * Let the PHY run.
1083 */
1084 mii_start(atgep->atge_mii);
1085
1086 return (DDI_SUCCESS);
1087
1088 fail5:
1089 (void) mac_unregister(atgep->atge_mh);
1090 atge_device_stop(atgep);
1091 mii_stop(atgep->atge_mii);
1092 mii_free(atgep->atge_mii);
1093 fail4:
1094 atge_free_dma(atgep);
1095 mutex_destroy(&atgep->atge_intr_lock);
1096 mutex_destroy(&atgep->atge_tx_lock);
1097 mutex_destroy(&atgep->atge_rx_lock);
1098 atge_remove_intr(atgep);
1345 return (DDI_FAILURE);
1346 }
1347
1348 mutex_enter(&atgep->atge_intr_lock);
1349 mutex_enter(&atgep->atge_tx_lock);
1350
1351 atgep->atge_chip_state &= ~ATGE_CHIP_SUSPENDED;
1352
1353 if (atgep->atge_chip_state & ATGE_CHIP_RUNNING) {
1354 atge_device_restart(atgep);
1355 } else {
1356 atge_device_reset(atgep);
1357 }
1358
1359 mutex_exit(&atgep->atge_tx_lock);
1360 mutex_exit(&atgep->atge_intr_lock);
1361
1362 /*
1363 * Reset the PHY before resuming MII.
1364 */
1365 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1366 atge_l1e_mii_reset(atgep);
1367 }
1368
1369 mii_resume(atgep->atge_mii);
1370
1371 /* kick-off downstream */
1372 mac_tx_update(atgep->atge_mh);
1373
1374 return (DDI_SUCCESS);
1375 }
1376
1377 static int
1378 atge_quiesce(dev_info_t *dip)
1379 {
1380 atge_t *atgep;
1381
1382 if ((atgep = ddi_get_driver_private(dip)) == NULL) {
1383 return (DDI_FAILURE);
1384 }
1385
1386 atge_device_stop(atgep);
1780 OUTL(atgep, ATGE_PAR0,
1781 ((e[2] << 24) | (e[3] << 16) | (e[4] << 8) | e[5]));
1782 OUTL(atgep, ATGE_PAR1, (e[0] << 8) | e[1]);
1783 }
1784
1785 /*
1786 * Device specific operations.
1787 */
1788 void
1789 atge_device_start(atge_t *atgep)
1790 {
1791 uint32_t rxf_hi, rxf_lo, rrd_hi, rrd_lo;
1792 uint32_t reg;
1793 uint32_t fsize;
1794
1795 /*
1796 * Reprogram the Station address.
1797 */
1798 atge_program_ether(atgep);
1799
1800 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1801 atge_l1e_program_dma(atgep);
1802 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
1803 atge_l1_program_dma(atgep);
1804 }
1805
1806 ATGE_DB(("%s: %s() dma, counters programmed ", atgep->atge_name,
1807 __func__));
1808
1809 OUTW(atgep, ATGE_INTR_CLR_TIMER, 1*1000/2);
1810
1811 /*
1812 * Set Maximum frame size but don't let MTU be less than ETHER_MTU.
1813 */
1814 if (atgep->atge_mtu < ETHERMTU)
1815 atgep->atge_max_frame_size = ETHERMTU;
1816 else
1817 atgep->atge_max_frame_size = atgep->atge_mtu;
1818
1819 atgep->atge_max_frame_size += sizeof (struct ether_header) +
1820 VLAN_TAGSZ + ETHERFCSL;
1821 OUTL(atgep, ATGE_FRAME_SIZE, atgep->atge_max_frame_size);
1822
1823
1824 /*
1825 * Configure IPG/IFG parameters.
1826 */
1827 OUTL(atgep, ATGE_IPG_IFG_CFG,
1828 ((IPG_IFG_IPG2_DEFAULT << IPG_IFG_IPG2_SHIFT) & IPG_IFG_IPG2_MASK) |
1829 ((IPG_IFG_IPG1_DEFAULT << IPG_IFG_IPG1_SHIFT) & IPG_IFG_IPG1_MASK) |
1830 ((IPG_IFG_MIFG_DEFAULT << IPG_IFG_MIFG_SHIFT) & IPG_IFG_MIFG_MASK) |
1831 ((IPG_IFG_IPGT_DEFAULT << IPG_IFG_IPGT_SHIFT) & IPG_IFG_IPGT_MASK));
1832
1833 /*
1834 * Set parameters for half-duplex media.
1835 */
1836 OUTL(atgep, ATGE_HDPX_CFG,
1837 ((HDPX_CFG_LCOL_DEFAULT << HDPX_CFG_LCOL_SHIFT) &
1838 HDPX_CFG_LCOL_MASK) |
1839 ((HDPX_CFG_RETRY_DEFAULT << HDPX_CFG_RETRY_SHIFT) &
1840 HDPX_CFG_RETRY_MASK) | HDPX_CFG_EXC_DEF_EN |
1841 ((HDPX_CFG_ABEBT_DEFAULT << HDPX_CFG_ABEBT_SHIFT) &
1842 HDPX_CFG_ABEBT_MASK) |
1843 ((HDPX_CFG_JAMIPG_DEFAULT << HDPX_CFG_JAMIPG_SHIFT) &
1844 HDPX_CFG_JAMIPG_MASK));
1845
1846 /*
1847 * Configure jumbo frame.
1848 */
1849 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
1850 fsize = ROUNDUP(atgep->atge_max_frame_size, sizeof (uint64_t));
1851 OUTL(atgep, ATGE_RXQ_JUMBO_CFG,
1852 (((fsize / sizeof (uint64_t)) <<
1853 RXQ_JUMBO_CFG_SZ_THRESH_SHIFT) &
1854 RXQ_JUMBO_CFG_SZ_THRESH_MASK) |
1855 ((RXQ_JUMBO_CFG_LKAH_DEFAULT <<
1856 RXQ_JUMBO_CFG_LKAH_SHIFT) & RXQ_JUMBO_CFG_LKAH_MASK) |
1857 ((ATGE_USECS(8) << RXQ_JUMBO_CFG_RRD_TIMER_SHIFT) &
1858 RXQ_JUMBO_CFG_RRD_TIMER_MASK));
1859 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E &&
1860 atgep->atge_flags & ATGE_FLAG_JUMBO) {
1861
1862 if (atgep->atge_mtu < ETHERMTU)
1863 reg = atgep->atge_max_frame_size;
1864 else if (atgep->atge_mtu < 6 * 1024)
1865 reg = (atgep->atge_max_frame_size * 2) / 3;
1866 else
1867 reg = atgep->atge_max_frame_size / 2;
1868
1869 OUTL(atgep, L1E_TX_JUMBO_THRESH,
1870 ROUNDUP(reg, TX_JUMBO_THRESH_UNIT) >>
1871 TX_JUMBO_THRESH_UNIT_SHIFT);
1872 }
1873
1874 /*
1875 * Configure flow-control parameters.
1876 */
1877 if ((atgep->atge_flags & ATGE_FLAG_PCIE) != 0) {
1878 /*
1879 * Some hardware version require this magic.
1880 */
1881 OUTL(atgep, 0x12FC, 0x6500);
1882 reg = INL(atgep, 0x1008);
1883 OUTL(atgep, 0x1008, reg | 0x8000);
1884 }
1885
1886 /*
1887 * These are all magic parameters which came from FreeBSD.
1888 */
1889 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
1890 switch (atgep->atge_chip_rev) {
1891 case 0x8001:
1892 case 0x9001:
1893 case 0x9002:
1894 case 0x9003:
1895 rxf_hi = L1_RX_RING_CNT / 16;
1896 rxf_lo = (L1_RX_RING_CNT * 7) / 8;
1897 rrd_hi = (L1_RR_RING_CNT * 7) / 8;
1898 rrd_lo = L1_RR_RING_CNT / 16;
1899 break;
1900 default:
1901 reg = INL(atgep, L1_SRAM_RX_FIFO_LEN);
1902 rxf_lo = reg / 16;
1903 if (rxf_lo > 192)
1904 rxf_lo = 192;
1905 rxf_hi = (reg * 7) / 8;
1906 if (rxf_hi < rxf_lo)
1907 rxf_hi = rxf_lo + 16;
1908 reg = INL(atgep, L1_SRAM_RRD_LEN);
1909 rrd_lo = reg / 8;
1910 rrd_hi = (reg * 7) / 8;
1911 if (rrd_lo > 2)
1912 rrd_lo = 2;
1913 if (rrd_hi < rrd_lo)
1914 rrd_hi = rrd_lo + 3;
1915 break;
1916 }
1917
1918 OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
1919 ((rxf_lo << RXQ_FIFO_PAUSE_THRESH_LO_SHIFT) &
1920 RXQ_FIFO_PAUSE_THRESH_LO_MASK) |
1921 ((rxf_hi << RXQ_FIFO_PAUSE_THRESH_HI_SHIFT) &
1922 RXQ_FIFO_PAUSE_THRESH_HI_MASK));
1923
1924 OUTL(atgep, L1_RXQ_RRD_PAUSE_THRESH,
1925 ((rrd_lo << RXQ_RRD_PAUSE_THRESH_LO_SHIFT) &
1926 RXQ_RRD_PAUSE_THRESH_LO_MASK) |
1927 ((rrd_hi << RXQ_RRD_PAUSE_THRESH_HI_SHIFT) &
1928 RXQ_RRD_PAUSE_THRESH_HI_MASK));
1929 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1930 reg = INL(atgep, L1E_SRAM_RX_FIFO_LEN);
1931 rxf_hi = (reg * 4) / 5;
1932 rxf_lo = reg/ 5;
1933
1934 OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
1935 ((rxf_lo << RXQ_FIFO_PAUSE_THRESH_LO_SHIFT) &
1936 RXQ_FIFO_PAUSE_THRESH_LO_MASK) |
1937 ((rxf_hi << RXQ_FIFO_PAUSE_THRESH_HI_SHIFT) &
1938 RXQ_FIFO_PAUSE_THRESH_HI_MASK));
1939 }
1940
1941 /* Configure RxQ. */
1942 reg = 0;
1943 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
1944 reg =
1945 ((RXQ_CFG_RD_BURST_DEFAULT << RXQ_CFG_RD_BURST_SHIFT) &
1946 RXQ_CFG_RD_BURST_MASK) |
1947 ((RXQ_CFG_RRD_BURST_THRESH_DEFAULT <<
1948 RXQ_CFG_RRD_BURST_THRESH_SHIFT) &
1949 RXQ_CFG_RRD_BURST_THRESH_MASK) |
1950 ((RXQ_CFG_RD_PREF_MIN_IPG_DEFAULT <<
1951 RXQ_CFG_RD_PREF_MIN_IPG_SHIFT) &
1952 RXQ_CFG_RD_PREF_MIN_IPG_MASK) |
1953 RXQ_CFG_CUT_THROUGH_ENB | RXQ_CFG_ENB;
1954 OUTL(atgep, ATGE_RXQ_CFG, reg);
1955 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1956 reg = RXQ_CFG_ALIGN_32 | RXQ_CFG_CUT_THROUGH_ENB |
1957 RXQ_CFG_IPV6_CSUM_VERIFY | RXQ_CFG_ENB;
1958 OUTL(atgep, ATGE_RXQ_CFG, reg);
1959 }
1960
1961 /*
1962 * Configure TxQ.
1963 */
1964 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
1965 reg =
1966 (((TXQ_CFG_TPD_BURST_DEFAULT << TXQ_CFG_TPD_BURST_SHIFT) &
1967 TXQ_CFG_TPD_BURST_MASK) |
1968 ((TXQ_CFG_TX_FIFO_BURST_DEFAULT <<
1969 TXQ_CFG_TX_FIFO_BURST_SHIFT) &
1970 TXQ_CFG_TX_FIFO_BURST_MASK) |
1971 ((TXQ_CFG_TPD_FETCH_DEFAULT <<
1972 TXQ_CFG_TPD_FETCH_THRESH_SHIFT) &
1973 TXQ_CFG_TPD_FETCH_THRESH_MASK) |
1974 TXQ_CFG_ENB);
1975 OUTL(atgep, ATGE_TXQ_CFG, reg);
1976 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1977 reg = (128 <<
1978 (atgep->atge_dma_rd_burst >> DMA_CFG_RD_BURST_SHIFT)) <<
1979 TXQ_CFG_TX_FIFO_BURST_SHIFT;
1980
1981 reg |= (TXQ_CFG_TPD_BURST_DEFAULT << TXQ_CFG_TPD_BURST_SHIFT) &
1982 TXQ_CFG_TPD_BURST_MASK;
1983
1984 reg |= TXQ_CFG_ENHANCED_MODE | TXQ_CFG_ENB;
1985
1986 OUTL(atgep, ATGE_TXQ_CFG, reg);
1987 }
1988
1989 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
1990 OUTL(atgep, L1_TX_JUMBO_TPD_TH_IPG,
1991 (((fsize / sizeof (uint64_t) << TX_JUMBO_TPD_TH_SHIFT)) &
1992 TX_JUMBO_TPD_TH_MASK) |
1993 ((TX_JUMBO_TPD_IPG_DEFAULT << TX_JUMBO_TPD_IPG_SHIFT) &
1994 TX_JUMBO_TPD_IPG_MASK));
1995 }
1996
1997 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1998 /* Disable RSS. */
1999 OUTL(atgep, L1E_RSS_IDT_TABLE0, 0);
2000 OUTL(atgep, L1E_RSS_CPU, 0);
2001 }
2002
2003 /*
2004 * Configure DMA parameters.
2005 */
2006 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2007 OUTL(atgep, ATGE_DMA_CFG,
2008 DMA_CFG_ENH_ORDER | DMA_CFG_RCB_64 |
2009 atgep->atge_dma_rd_burst | DMA_CFG_RD_ENB |
2010 atgep->atge_dma_wr_burst | DMA_CFG_WR_ENB);
2011
2012 /* Configure CMB DMA write threshold. */
2013 OUTL(atgep, L1_CMB_WR_THRESH,
2014 ((CMB_WR_THRESH_RRD_DEFAULT << CMB_WR_THRESH_RRD_SHIFT) &
2015 CMB_WR_THRESH_RRD_MASK) |
2016 ((CMB_WR_THRESH_TPD_DEFAULT << CMB_WR_THRESH_TPD_SHIFT) &
2017 CMB_WR_THRESH_TPD_MASK));
2018 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
2019 /*
2020 * Don't use Tx CMB. It is known to cause RRS update failure
2021 * under certain circumstances. Typical phenomenon of the
2022 * issue would be unexpected sequence number encountered in
2023 * Rx handler. Hence we don't set DMA_CFG_TXCMB_ENB.
2024 */
2025 OUTL(atgep, ATGE_DMA_CFG,
2026 DMA_CFG_OUT_ORDER | DMA_CFG_RD_REQ_PRI | DMA_CFG_RCB_64 |
2027 atgep->atge_dma_rd_burst | atgep->atge_dma_wr_burst |
2028 DMA_CFG_RXCMB_ENB |
2029 ((DMA_CFG_RD_DELAY_CNT_DEFAULT <<
2030 DMA_CFG_RD_DELAY_CNT_SHIFT) & DMA_CFG_RD_DELAY_CNT_MASK) |
2031 ((DMA_CFG_WR_DELAY_CNT_DEFAULT <<
2032 DMA_CFG_WR_DELAY_CNT_SHIFT) & DMA_CFG_WR_DELAY_CNT_MASK));
2033 }
2034
2035 /*
2036 * Enable CMB/SMB timer.
2037 */
2038 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2039 /* Set CMB/SMB timer and enable them. */
2040 OUTL(atgep, L1_CMB_WR_TIMER,
2041 ((ATGE_USECS(2) << CMB_WR_TIMER_TX_SHIFT) &
2042 CMB_WR_TIMER_TX_MASK) |
2043 ((ATGE_USECS(2) << CMB_WR_TIMER_RX_SHIFT) &
2044 CMB_WR_TIMER_RX_MASK));
2045
2046 /* Request SMB updates for every seconds. */
2047 OUTL(atgep, L1_SMB_TIMER, ATGE_USECS(1000 * 1000));
2048 OUTL(atgep, L1_CSMB_CTRL,
2049 CSMB_CTRL_SMB_ENB | CSMB_CTRL_CMB_ENB);
2050 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
2051 OUTL(atgep, L1E_SMB_STAT_TIMER, 100000);
2052 atge_l1e_clear_stats(atgep);
2053 }
2054
2055
2056 /*
2057 * Disable all WOL bits as WOL can interfere normal Rx
2058 * operation.
2059 */
2060 OUTL(atgep, ATGE_WOL_CFG, 0);
2061
2062 /*
2063 * Configure Tx/Rx MACs.
2064 * - Auto-padding for short frames.
2065 * - Enable CRC generation.
2066 *
2067 * Start with full-duplex/1000Mbps media. Actual reconfiguration
2068 * of MAC is followed after link establishment.
2069 */
2070 reg = (ATGE_CFG_TX_CRC_ENB | ATGE_CFG_TX_AUTO_PAD |
2071 ATGE_CFG_FULL_DUPLEX |
2072 ((ATGE_CFG_PREAMBLE_DEFAULT << ATGE_CFG_PREAMBLE_SHIFT) &
2073 ATGE_CFG_PREAMBLE_MASK));
2074
2075 if ((atgep->atge_flags & ATGE_FLAG_FASTETHER) != 0) {
2076 reg |= ATGE_CFG_SPEED_10_100;
2077 ATGE_DB(("%s: %s() Fast Ethernet", atgep->atge_name, __func__));
2078 } else {
2079 reg |= ATGE_CFG_SPEED_1000;
2080 ATGE_DB(("%s: %s() 1G speed", atgep->atge_name, __func__));
2081 }
2082
2083 OUTL(atgep, ATGE_MAC_CFG, reg);
2084
2085 atgep->atge_chip_state |= ATGE_CHIP_RUNNING;
2086
2087 /*
2088 * Set up the receive filter.
2089 */
2090 atge_rxfilter(atgep);
2091
2092 /*
2093 * Acknowledge all pending interrupts and clear it.
2094 */
2095 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2096 OUTL(atgep, ATGE_INTR_STATUS, 0);
2097 OUTL(atgep, ATGE_INTR_MASK, atgep->atge_intrs);
2098 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
2099 OUTL(atgep, ATGE_INTR_MASK, L1E_INTRS);
2100 OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2101 OUTL(atgep, ATGE_INTR_STATUS, 0);
2102 }
2103
2104 atge_mac_config(atgep);
2105
2106 ATGE_DB(("%s: %s() device started", atgep->atge_name, __func__));
2107 }
2108
2109 /*
2110 * Generic functions.
2111 */
2112
2113 #define CRC32_POLY_BE 0x04c11db7
2114 uint32_t
2115 atge_ether_crc(const uint8_t *addr, int len)
2116 {
2117 int idx;
2118 int bit;
2119 uint_t data;
2120 uint32_t crc;
2121
2177 }
2178
2179 void
2180 atge_device_stop(atge_t *atgep)
2181 {
2182 uint32_t reg;
2183 int t;
2184
2185 /*
2186 * If the chip is being suspended, then don't touch the state. Caller
2187 * will take care of setting the correct state.
2188 */
2189 if (!(atgep->atge_chip_state & ATGE_CHIP_SUSPENDED)) {
2190 atgep->atge_chip_state |= ATGE_CHIP_STOPPED;
2191 atgep->atge_chip_state &= ~ATGE_CHIP_RUNNING;
2192 }
2193
2194 /*
2195 * Collect stats for L1E. L1 chip's stats are collected by interrupt.
2196 */
2197 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
2198 atge_l1e_gather_stats(atgep);
2199 }
2200
2201 /*
2202 * Disable interrupts.
2203 */
2204 atge_disable_intrs(atgep);
2205
2206 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1)
2207 OUTL(atgep, L1_CSMB_CTRL, 0);
2208
2209 /* Stop DMA Engine */
2210 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2211 atge_l1_stop_tx_mac(atgep);
2212 atge_l1_stop_rx_mac(atgep);
2213
2214 reg = INL(atgep, ATGE_DMA_CFG);
2215 reg &= ~(DMA_CFG_RD_ENB | DMA_CFG_WR_ENB);
2216 OUTL(atgep, ATGE_DMA_CFG, reg);
2217
2218 }
2219
2220 /*
2221 * Disable queue processing.
2222 */
2223 /* Stop TxQ */
2224 reg = INL(atgep, ATGE_TXQ_CFG);
2225 reg = reg & ~TXQ_CFG_ENB;
2226 OUTL(atgep, ATGE_TXQ_CFG, reg);
2227
2228 /* Stop RxQ */
2229 reg = INL(atgep, ATGE_RXQ_CFG);
2230 reg = reg & ~RXQ_CFG_ENB;
2231 OUTL(atgep, ATGE_RXQ_CFG, reg);
2232
2233 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
2234 reg = INL(atgep, ATGE_DMA_CFG);
2235 reg = reg & ~(DMA_CFG_TXCMB_ENB | DMA_CFG_RXCMB_ENB);
2236 OUTL(atgep, ATGE_DMA_CFG, reg);
2237 drv_usecwait(1000);
2238 atge_l1e_stop_mac(atgep);
2239 OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2240 }
2241
2242 for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
2243 if ((reg = INL(atgep, ATGE_IDLE_STATUS)) == 0)
2244 break;
2245 drv_usecwait(10);
2246 }
2247
2248 if (t == 0) {
2249 atge_error(atgep->atge_dip, "%s() stopping TX/RX MAC timeout",
2250 __func__);
2251 }
2252 }
2253
2254 void
2255 atge_disable_intrs(atge_t *atgep)
2256 {
2257 OUTL(atgep, ATGE_INTR_MASK, 0);
2258 OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2259 }
2260
2261 void
2262 atge_device_init(atge_t *atgep)
2263 {
2264 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
2265 atgep->atge_intrs = L1E_INTRS;
2266 atgep->atge_int_mod = ATGE_IM_TIMER_DEFAULT;
2267
2268 atge_l1e_init_tx_ring(atgep);
2269 atge_l1e_init_rx_pages(atgep);
2270 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2271 atgep->atge_intrs = L1_INTRS | INTR_GPHY | INTR_PHY_LINK_DOWN |
2272 INTR_LINK_CHG;
2273 atgep->atge_int_mod = ATGE_IM_TIMER_DEFAULT;
2274
2275 atge_l1_init_tx_ring(atgep);
2276 atge_l1_init_rx_ring(atgep);
2277 atge_l1_init_rr_ring(atgep);
2278 atge_l1_init_cmb(atgep);
2279 atge_l1_init_smb(atgep);
2280 }
2281 }
2282
2283 void
2284 atge_device_restart(atge_t *atgep)
2285 {
2286 ASSERT(MUTEX_HELD(&atgep->atge_intr_lock));
2287 ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
2288
2289 /*
2290 * Cancel any pending I/O.
2291 */
2292 atge_device_stop(atgep);
2293
2294 /*
2295 * Reset the chip to a known state.
2296 */
2297 atge_device_reset(atgep);
2298
2299 /*
2300 * Initialize the ring and other descriptor like CMB/SMB/Rx return.
2301 */
2302 atge_device_init(atgep);
2303
2304 /*
2305 * Start the chip.
2306 */
2307 atge_device_start(atgep);
2308
2309 }
2310
2311 static int
2312 atge_send_a_packet(atge_t *atgep, mblk_t *mp)
2313 {
2314 atge_tx_desc_t *txd;
2315 uchar_t *c;
2316 uint32_t cflags = 0;
2317 atge_ring_t *r;
2318 size_t pktlen;
2319 uchar_t *buf;
2320 int start;
2321
2322 ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
2323 ASSERT(mp != NULL);
2324
2325 pktlen = msgsize(mp);
2326 if (pktlen > atgep->atge_tx_buf_len) {
2327 atgep->atge_macxmt_errors++;
2328
2329 ATGE_DB(("%s: %s() pktlen (%d) > rx_buf_len (%d)",
2330 atgep->atge_name, __func__,
2331 pktlen, atgep->atge_rx_buf_len));
2332
2333 freemsg(mp);
2334 return (DDI_SUCCESS);
2344 atgep->atge_name, __func__));
2345
2346 return (DDI_FAILURE);
2347 }
2348
2349 start = r->r_producer;
2350
2351 /*
2352 * Get the DMA buffer to hold a packet.
2353 */
2354 buf = (uchar_t *)r->r_buf_tbl[start]->addr;
2355
2356 /*
2357 * Copy the msg and free mp
2358 */
2359 mcopymsg(mp, buf);
2360
2361 r->r_avail_desc--;
2362
2363 c = (uchar_t *)r->r_desc_ring->addr;
2364 c += (sizeof (atge_tx_desc_t) * start);
2365 txd = (atge_tx_desc_t *)c;
2366
2367 ATGE_PUT64(r->r_desc_ring, &txd->addr,
2368 r->r_buf_tbl[start]->cookie.dmac_laddress);
2369
2370 ATGE_PUT32(r->r_desc_ring, &txd->len, ATGE_TX_BYTES(pktlen));
2371
2372 cflags |= ATGE_TD_EOP;
2373 ATGE_PUT32(r->r_desc_ring, &txd->flags, cflags);
2374
2375 /*
2376 * Sync buffer first.
2377 */
2378 DMA_SYNC(r->r_buf_tbl[start], 0, pktlen, DDI_DMA_SYNC_FORDEV);
2379
2380 /*
2381 * Increment TX producer count by one.
2382 */
2383 ATGE_INC_SLOT(r->r_producer, ATGE_TX_RING_CNT);
2384
2385 /*
2386 * Sync descriptor table.
2387 */
2388 DMA_SYNC(r->r_desc_ring, 0, ATGE_TX_RING_SZ, DDI_DMA_SYNC_FORDEV);
2389
2390 /*
2391 * Program TX descriptor to send a packet.
2392 */
2393 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
2394 atge_l1e_send_packet(r);
2395 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2396 atge_l1_send_packet(r);
2397 }
2398
2399 r->r_atge->atge_opackets++;
2400 r->r_atge->atge_obytes += pktlen;
2401
2402 ATGE_DB(("%s: %s() pktlen : %d, avail_desc : %d, producer :%d, "
2403 "consumer : %d", atgep->atge_name, __func__, pktlen,
2404 r->r_avail_desc, r->r_producer, r->r_consumer));
2405
2406 return (DDI_SUCCESS);
2407 }
2408
2409 /*
2410 * Stream Information.
2411 */
2412 DDI_DEFINE_STREAM_OPS(atge_devops, nulldev, nulldev, atge_attach, atge_detach,
2413 nodev, NULL, D_MP, NULL, atge_quiesce);
2414
2415 /*
2416 * Module linkage information.
|
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 (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
26 */
27 /*
28 * Copyright (c) 2009, Pyun YongHyeon <yongari@FreeBSD.org>
29 * All rights reserved.
30 *
31 * Redistribution and use in source and binary forms, with or without
32 * modification, are permitted provided that the following conditions
33 * are met:
34 * 1. Redistributions of source code must retain the above copyright
35 * notice unmodified, this list of conditions, and the following
36 * disclaimer.
37 * 2. Redistributions in binary form must reproduce the above copyright
38 * notice, this list of conditions and the following disclaimer in the
39 * documentation and/or other materials provided with the distribution.
40 *
41 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 * SUCH DAMAGE.
52 */
53
54 #include <sys/types.h>
55 #include <sys/stream.h>
56 #include <sys/strsun.h>
57 #include <sys/stat.h>
58 #include <sys/modctl.h>
59 #include <sys/kstat.h>
60 #include <sys/ethernet.h>
61 #include <sys/devops.h>
62 #include <sys/debug.h>
63 #include <sys/conf.h>
64 #include <sys/mii.h>
65 #include <sys/miiregs.h>
66 #include <sys/mac.h>
67 #include <sys/mac_provider.h>
68 #include <sys/mac_ether.h>
69 #include <sys/sysmacros.h>
70 #include <sys/dditypes.h>
71 #include <sys/ddi.h>
72 #include <sys/sunddi.h>
73 #include <sys/byteorder.h>
74 #include <sys/note.h>
75 #include <sys/vlan.h>
76 #include <sys/strsubr.h>
77 #include <sys/crc32.h>
78 #include <sys/sdt.h>
79 #include <sys/pci.h>
80 #include <sys/pci_cap.h>
81
82 #include "atge.h"
83 #include "atge_cmn_reg.h"
84 #include "atge_l1c_reg.h"
85 #include "atge_l1e_reg.h"
86 #include "atge_l1_reg.h"
87
88
89 /*
90 * Atheros/Attansic Ethernet chips are of four types - L1, L2, L1E and L1C.
91 * This driver is for L1E/L1/L1C but can be extended to support other chips.
92 * L1E comes in 1Gigabit and Fast Ethernet flavors. L1 comes in 1Gigabit
93 * flavors only. L1C comes in both flavours.
94 *
95 * Atheros/Attansic Ethernet controllers have descriptor based TX and RX
96 * with an exception of L1E. L1E's RX side is not descriptor based ring.
97 * The L1E's RX uses pages (not to be confused with MMU pages) for
98 * receiving pkts. The header has four fields :
99 *
100 * uint32_t seqno; Sequence number of the frame.
101 * uint32_t length; Length of the frame.
102 * uint32_t flags; Flags
103 * uint32_t vtag; We don't use hardware VTAG.
104 *
105 * We use only one queue for RX (each queue can have two pages) and each
106 * page is L1E_RX_PAGE_SZ large in bytes. That's the reason we don't
107 * use zero-copy RX because we are limited to two pages and each page
108 * accomodates large number of pkts.
109 *
110 * The TX side on all three chips is descriptor based ring; and all the
111 * more reason to have one driver for these chips.
112 *
113 * We use two locks - atge_intr_lock and atge_tx_lock. Both the locks
164 /*
165 * L1E/L2E specific functions.
166 */
167 void atge_l1e_device_reset(atge_t *);
168 void atge_l1e_stop_mac(atge_t *);
169 int atge_l1e_alloc_dma(atge_t *);
170 void atge_l1e_free_dma(atge_t *);
171 void atge_l1e_init_tx_ring(atge_t *);
172 void atge_l1e_init_rx_pages(atge_t *);
173 void atge_l1e_program_dma(atge_t *);
174 void atge_l1e_send_packet(atge_ring_t *);
175 mblk_t *atge_l1e_receive(atge_t *);
176 uint_t atge_l1e_interrupt(caddr_t, caddr_t);
177 void atge_l1e_gather_stats(atge_t *);
178 void atge_l1e_clear_stats(atge_t *);
179
180 /*
181 * L1 specific functions.
182 */
183 int atge_l1_alloc_dma(atge_t *);
184 void atge_l1_free_dma(atge_t *);
185 void atge_l1_init_tx_ring(atge_t *);
186 void atge_l1_init_rx_ring(atge_t *);
187 void atge_l1_init_rr_ring(atge_t *);
188 void atge_l1_init_cmb(atge_t *);
189 void atge_l1_init_smb(atge_t *);
190 void atge_l1_program_dma(atge_t *);
191 void atge_l1_stop_tx_mac(atge_t *);
192 void atge_l1_stop_rx_mac(atge_t *);
193 uint_t atge_l1_interrupt(caddr_t, caddr_t);
194 void atge_l1_send_packet(atge_ring_t *);
195
196 /*
197 * L1C specific functions.
198 */
199 int atge_l1c_alloc_dma(atge_t *);
200 void atge_l1c_free_dma(atge_t *);
201 void atge_l1c_init_tx_ring(atge_t *);
202 void atge_l1c_init_rx_ring(atge_t *);
203 void atge_l1c_init_rr_ring(atge_t *);
204 void atge_l1c_init_cmb(atge_t *);
205 void atge_l1c_init_smb(atge_t *);
206 void atge_l1c_program_dma(atge_t *);
207 void atge_l1c_stop_tx_mac(atge_t *);
208 void atge_l1c_stop_rx_mac(atge_t *);
209 uint_t atge_l1c_interrupt(caddr_t, caddr_t);
210 void atge_l1c_send_packet(atge_ring_t *);
211 void atge_l1c_gather_stats(atge_t *);
212 void atge_l1c_clear_stats(atge_t *);
213
214 /*
215 * Function prototyps for MII operations.
216 */
217 uint16_t atge_mii_read(void *, uint8_t, uint8_t);
218 void atge_mii_write(void *, uint8_t, uint8_t, uint16_t);
219 uint16_t atge_l1c_mii_read(void *, uint8_t, uint8_t);
220 void atge_l1c_mii_write(void *, uint8_t, uint8_t, uint16_t);
221 void atge_l1e_mii_reset(void *);
222 void atge_l1_mii_reset(void *);
223 void atge_l1c_mii_reset(void *);
224 static void atge_mii_notify(void *, link_state_t);
225 void atge_tx_reclaim(atge_t *atgep, int cons);
226
227 /*
228 * L1E/L2E chip.
229 */
230 static mii_ops_t atge_l1e_mii_ops = {
231 MII_OPS_VERSION,
232 atge_mii_read,
233 atge_mii_write,
234 atge_mii_notify,
235 atge_l1e_mii_reset
236 };
237
238 /*
239 * L1 chip.
240 */
241 static mii_ops_t atge_l1_mii_ops = {
242 MII_OPS_VERSION,
243 atge_mii_read,
244 atge_mii_write,
245 atge_mii_notify,
246 atge_l1_mii_reset
247 };
248
249 /*
250 * L1C chip.
251 */
252 static mii_ops_t atge_l1c_mii_ops = {
253 MII_OPS_VERSION,
254 atge_l1c_mii_read,
255 atge_l1c_mii_write,
256 atge_mii_notify,
257 NULL
258 };
259
260 /*
261 * Function Prototypes for MAC callbacks.
262 */
263 static int atge_m_stat(void *, uint_t, uint64_t *);
264 static int atge_m_start(void *);
265 static void atge_m_stop(void *);
266 static int atge_m_getprop(void *, const char *, mac_prop_id_t, uint_t,
267 void *);
268 static int atge_m_setprop(void *, const char *, mac_prop_id_t, uint_t,
269 const void *);
270 static void atge_m_propinfo(void *, const char *, mac_prop_id_t,
271 mac_prop_info_handle_t);
272 static int atge_m_unicst(void *, const uint8_t *);
273 static int atge_m_multicst(void *, boolean_t, const uint8_t *);
274 static int atge_m_promisc(void *, boolean_t);
275 static mblk_t *atge_m_tx(void *, mblk_t *);
276
277 static mac_callbacks_t atge_m_callbacks = {
278 MC_SETPROP | MC_GETPROP | MC_PROPINFO,
279 atge_m_stat,
280 atge_m_start,
316 */
317 static ddi_dma_attr_t atge_dma_attr_buf = {
318 DMA_ATTR_V0, /* dma_attr_version */
319 0, /* dma_attr_addr_lo */
320 0x00ffffffffffull, /* dma_attr_addr_hi */
321 0x000000003fffull, /* dma_attr_count_max */
322 8, /* dma_attr_align */
323 0x00003ffc, /* dma_attr_burstsizes */
324 1, /* dma_attr_minxfer */
325 0x0000000027ffull, /* dma_attr_maxxfer */
326 0x0000ffffffffull, /* dma_attr_seg */
327 1, /* dma_attr_sgllen */
328 1, /* dma_attr_granular */
329 0 /* dma_attr_flags */
330 };
331
332 /*
333 * Table of supported devices.
334 */
335 #define ATGE_VENDOR_ID 0x1969
336 #define ATGE_L1_STR "Attansic L1"
337 #define ATGE_L1CG_STR "Atheros AR8131 Gigabit Ethernet"
338 #define ATGE_L1CF_STR "Atheros AR8132 Fast Ethernet"
339 #define ATGE_L1E_STR "Atheros AR8121/8113/8114"
340 #define ATGE_AR8151V1_STR "Atheros AR8151 v1.0 Gigabit Ethernet"
341 #define ATGE_AR8151V2_STR "Atheros AR8151 v2.0 Gigabit Ethernet"
342 #define ATGE_AR8152V1_STR "Atheros AR8152 v1.1 Fast Ethernet"
343 #define ATGE_AR8152V2_STR "Atheros AR8152 v2.0 Fast Ethernet"
344
345 static atge_cards_t atge_cards[] = {
346 {ATGE_VENDOR_ID, ATGE_CHIP_AR8151V2_DEV_ID, ATGE_AR8151V2_STR,
347 ATGE_CHIP_L1C},
348 {ATGE_VENDOR_ID, ATGE_CHIP_AR8151V1_DEV_ID, ATGE_AR8151V1_STR,
349 ATGE_CHIP_L1C},
350 {ATGE_VENDOR_ID, ATGE_CHIP_AR8152V2_DEV_ID, ATGE_AR8152V2_STR,
351 ATGE_CHIP_L1C},
352 {ATGE_VENDOR_ID, ATGE_CHIP_AR8152V1_DEV_ID, ATGE_AR8152V1_STR,
353 ATGE_CHIP_L1C},
354 {ATGE_VENDOR_ID, ATGE_CHIP_L1CG_DEV_ID, ATGE_L1CG_STR, ATGE_CHIP_L1C},
355 {ATGE_VENDOR_ID, ATGE_CHIP_L1CF_DEV_ID, ATGE_L1CF_STR, ATGE_CHIP_L1C},
356 {ATGE_VENDOR_ID, ATGE_CHIP_L1E_DEV_ID, ATGE_L1E_STR, ATGE_CHIP_L1E},
357 {ATGE_VENDOR_ID, ATGE_CHIP_L1_DEV_ID, ATGE_L1_STR, ATGE_CHIP_L1},
358 };
359
360 /*
361 * Global Debugging flag. Developer level debugging is done only in DEBUG mode.
362 */
363 int atge_debug = 1;
364
365 /*
366 * Debugging and error reporting.
367 */
368 void
369 atge_debug_func(char *fmt, ...)
370 {
371 va_list ap;
372 char buf[256];
373
374 va_start(ap, fmt);
375 (void) vsnprintf(buf, sizeof (buf), fmt, ap);
376 va_end(ap);
377
378 DTRACE_PROBE1(atge__debug, char *, buf);
379 }
380
381 static
382 void
383 atge_message(dev_info_t *dip, int level, char *fmt, va_list ap)
384 {
385 char buf[256];
386 char *p = "!%s%d: %s";
387 char *q = "!atge: %s";
388
389 (void) vsnprintf(buf, sizeof (buf), fmt, ap);
390
391 if (level != CE_NOTE) {
392 p++;
393 q++;
394 }
395
396 if (dip) {
397 cmn_err(level, p,
398 ddi_driver_name(dip), ddi_get_instance(dip), buf);
399 } else {
400 cmn_err(level, q, buf);
401 }
402 }
403
404 void
405 atge_notice(dev_info_t *dip, char *fmt, ...)
406 {
407 va_list ap;
408
409 va_start(ap, fmt);
410 (void) atge_message(dip, CE_NOTE, fmt, ap);
411 va_end(ap);
412 }
413
414 void
415 atge_error(dev_info_t *dip, char *fmt, ...)
416 {
417 va_list ap;
418
419 va_start(ap, fmt);
420 (void) atge_message(dip, CE_WARN, fmt, ap);
421 va_end(ap);
422 }
423
424 void
425 atge_mac_config(atge_t *atgep)
426 {
427 uint32_t reg;
428 int speed;
429 link_duplex_t ld;
430
431 /* Re-enable TX/RX MACs */
432 reg = INL(atgep, ATGE_MAC_CFG);
433 reg &= ~(ATGE_CFG_FULL_DUPLEX | ATGE_CFG_TX_FC | ATGE_CFG_RX_FC |
434 ATGE_CFG_SPEED_MASK);
435
436 switch (ATGE_MODEL(atgep)) {
437 case ATGE_CHIP_L1C:
438 switch (ATGE_DID(atgep)) {
439 case ATGE_CHIP_AR8151V2_DEV_ID:
440 case ATGE_CHIP_AR8151V1_DEV_ID:
441 case ATGE_CHIP_AR8152V2_DEV_ID:
442 reg |= ATGE_CFG_HASH_ALG_CRC32 | ATGE_CFG_SPEED_MODE_SW;
443 break;
444 }
445 break;
446 }
447
448 speed = mii_get_speed(atgep->atge_mii);
449 switch (speed) {
450 case 10:
451 case 100:
452 reg |= ATGE_CFG_SPEED_10_100;
453 break;
454 case 1000:
455 reg |= ATGE_CFG_SPEED_1000;
456 break;
457 }
458
459 ld = mii_get_duplex(atgep->atge_mii);
460 if (ld == LINK_DUPLEX_FULL)
461 reg |= ATGE_CFG_FULL_DUPLEX;
462
463 /* Re-enable TX/RX MACs */
464 switch (ATGE_MODEL(atgep)) {
465 case ATGE_CHIP_L1E:
466 reg |= ATGE_CFG_TX_ENB | ATGE_CFG_RX_ENB | ATGE_CFG_RX_FC;
467 break;
468 case ATGE_CHIP_L1:
469 case ATGE_CHIP_L1C:
470 reg |= ATGE_CFG_TX_ENB | ATGE_CFG_RX_ENB;
471 break;
472 }
473
474 OUTL(atgep, ATGE_MAC_CFG, reg);
475
476 switch (ATGE_MODEL(atgep)) {
477 case ATGE_CHIP_L1E:
478 reg = ATGE_USECS(ATGE_IM_RX_TIMER_DEFAULT) << IM_TIMER_RX_SHIFT;
479 reg |= ATGE_USECS(ATGE_IM_TX_TIMER_DEFAULT) <<
480 IM_TIMER_TX_SHIFT;
481 OUTL(atgep, ATGE_IM_TIMER, reg);
482 break;
483 case ATGE_CHIP_L1:
484 break;
485 case ATGE_CHIP_L1C:
486 /* Configure interrupt moderation timer. */
487 reg = ATGE_USECS(atgep->atge_int_rx_mod) << IM_TIMER_RX_SHIFT;
488 reg |= ATGE_USECS(atgep->atge_int_tx_mod) << IM_TIMER_TX_SHIFT;
489 OUTL(atgep, ATGE_IM_TIMER, reg);
490 /*
491 * We don't want to automatic interrupt clear as task queue
492 * for the interrupt should know interrupt status.
493 */
494 reg = 0;
495 if (ATGE_USECS(atgep->atge_int_rx_mod) != 0)
496 reg |= MASTER_IM_RX_TIMER_ENB;
497 if (ATGE_USECS(atgep->atge_int_tx_mod) != 0)
498 reg |= MASTER_IM_TX_TIMER_ENB;
499 OUTL(atgep, ATGE_MASTER_CFG, reg);
500 break;
501 }
502
503 ATGE_DB(("%s: %s() mac_cfg is : %x",
504 atgep->atge_name, __func__, INL(atgep, ATGE_MAC_CFG)));
505 }
506
507 static void
508 atge_mii_notify(void *arg, link_state_t link)
509 {
510 atge_t *atgep = arg;
511
512 ATGE_DB(("%s: %s() LINK STATUS CHANGED from %x -> %x",
513 atgep->atge_name, __func__, atgep->atge_link_state, link));
514
515 mac_link_update(atgep->atge_mh, link);
516
517 /*
518 * Reconfigure MAC if link status is UP now.
519 */
520 mutex_enter(&atgep->atge_tx_lock);
646
647 ATGE_DB(("%s: atge_add_intr_handler() after alloc count"
648 " :%d, avail : %d", atgep->atge_name, count, avail));
649
650 err = ddi_intr_get_pri(atgep->atge_intr_handle[0],
651 &atgep->atge_intr_pri);
652 if (err != DDI_SUCCESS) {
653 atge_error(atgep->atge_dip, "ddi_intr_get_pri failed:%d", err);
654 for (i = 0; i < atgep->atge_intr_cnt; i++) {
655 (void) ddi_intr_free(atgep->atge_intr_handle[i]);
656 }
657 kmem_free(atgep->atge_intr_handle, atgep->atge_intr_size);
658
659 return (DDI_FAILURE);
660 }
661
662 /*
663 * Add interrupt handler now.
664 */
665 for (i = 0; i < atgep->atge_intr_cnt; i++) {
666 switch (ATGE_MODEL(atgep)) {
667 case ATGE_CHIP_L1E:
668 err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
669 atge_l1e_interrupt, atgep, (caddr_t)(uintptr_t)i);
670 break;
671 case ATGE_CHIP_L1:
672 err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
673 atge_l1_interrupt, atgep, (caddr_t)(uintptr_t)i);
674 break;
675 case ATGE_CHIP_L1C:
676 err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
677 atge_l1c_interrupt, atgep, (caddr_t)(uintptr_t)i);
678 break;
679 }
680
681 if (err != DDI_SUCCESS) {
682 atge_error(atgep->atge_dip,
683 "ddi_intr_add_handler failed : %d", err);
684
685 (void) ddi_intr_free(atgep->atge_intr_handle[i]);
686 while (--i >= 0) {
687 (void) ddi_intr_remove_handler(
688 atgep->atge_intr_handle[i]);
689 (void) ddi_intr_free(
690 atgep->atge_intr_handle[i]);
691 }
692
693 kmem_free(atgep->atge_intr_handle,
694 atgep->atge_intr_size);
695
696 return (DDI_FAILURE);
697 }
698 }
839 }
840 }
841
842 return (err);
843 }
844
845 int
846 atge_identify_hardware(atge_t *atgep)
847 {
848 uint16_t vid, did;
849 int i;
850
851 vid = pci_config_get16(atgep->atge_conf_handle, PCI_CONF_VENID);
852 did = pci_config_get16(atgep->atge_conf_handle, PCI_CONF_DEVID);
853
854 atgep->atge_model = 0;
855 for (i = 0; i < (sizeof (atge_cards) / sizeof (atge_cards_t)); i++) {
856 if (atge_cards[i].vendor_id == vid &&
857 atge_cards[i].device_id == did) {
858 atgep->atge_model = atge_cards[i].model;
859 atgep->atge_vid = vid;
860 atgep->atge_did = did;
861 atgep->atge_revid =
862 pci_config_get8(atgep->atge_conf_handle,
863 PCI_CONF_REVID);
864 atge_notice(atgep->atge_dip, "PCI-ID pci%x,%x,%x: %s",
865 vid, did, atgep->atge_revid,
866 atge_cards[i].cardname);
867 ATGE_DB(("%s: %s : PCI-ID pci%x,%x and model : %d",
868 atgep->atge_name, __func__, vid, did,
869 atgep->atge_model));
870
871 return (DDI_SUCCESS);
872 }
873 }
874
875 atge_error(atgep->atge_dip, "atge driver is attaching to unknown"
876 " pci%x,%x vendor/device-id card", vid, did);
877
878 /*
879 * Assume it's L1C chip.
880 */
881 atgep->atge_model = ATGE_CHIP_L1C;
882 atgep->atge_vid = vid;
883 atgep->atge_did = did;
884 atgep->atge_revid = pci_config_get8(atgep->atge_conf_handle,
885 PCI_CONF_REVID);
886
887 /*
888 * We will leave the decision to caller.
889 */
890 return (DDI_FAILURE);
891 }
892
893 int
894 atge_get_macaddr(atge_t *atgep)
895 {
896 uint32_t reg;
897
898 reg = INL(atgep, ATGE_SPI_CTRL);
899 if ((reg & SPI_VPD_ENB) != 0) {
900 /*
901 * Get VPD stored in TWSI EEPROM.
902 */
903 reg &= ~SPI_VPD_ENB;
911 atgep->atge_ether_addr[3] = INB(atgep, ATGE_PAR0 + 2);
912 atgep->atge_ether_addr[2] = INB(atgep, ATGE_PAR0 + 3);
913 atgep->atge_ether_addr[1] = INB(atgep, ATGE_PAR1 + 0);
914 atgep->atge_ether_addr[0] = INB(atgep, ATGE_PAR1 + 1);
915
916 ATGE_DB(("%s: %s() Station Address - %x:%x:%x:%x:%x:%x",
917 atgep->atge_name, __func__,
918 atgep->atge_ether_addr[0],
919 atgep->atge_ether_addr[1],
920 atgep->atge_ether_addr[2],
921 atgep->atge_ether_addr[3],
922 atgep->atge_ether_addr[4],
923 atgep->atge_ether_addr[5]));
924
925 bcopy(atgep->atge_ether_addr, atgep->atge_dev_addr, ETHERADDRL);
926
927 return (DDI_SUCCESS);
928 }
929
930 /*
931 * Reset functionality for L1, L1E, and L1C. It's same.
932 */
933 static void
934 atge_device_reset(atge_t *atgep)
935 {
936 switch (ATGE_MODEL(atgep)) {
937 case ATGE_CHIP_L1E:
938 case ATGE_CHIP_L1:
939 case ATGE_CHIP_L1C:
940 atge_device_reset_l1_l1e(atgep);
941 break;
942 }
943 }
944
945 void
946 atge_device_reset_l1_l1e(atge_t *atgep)
947 {
948 uint32_t reg;
949 int t;
950 switch (ATGE_MODEL(atgep)) {
951 case ATGE_CHIP_L1C:
952 OUTL(atgep, ATGE_MASTER_CFG, MASTER_RESET | 0x40);
953 break;
954 default:
955 OUTL(atgep, ATGE_MASTER_CFG, MASTER_RESET);
956 break;
957 }
958 reg = INL(atgep, ATGE_MASTER_CFG);
959 for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
960 drv_usecwait(10);
961 reg = INL(atgep, ATGE_MASTER_CFG);
962 if ((reg & MASTER_RESET) == 0)
963 break;
964 }
965
966 if (t == 0) {
967 atge_error(atgep->atge_dip, " master reset timeout reg : %x",
968 reg);
969 }
970
971 for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
972 if ((reg = INL(atgep, ATGE_IDLE_STATUS)) == 0)
973 break;
974
975 drv_usecwait(10);
976 }
977
978 if (t == 0) {
979 atge_error(atgep->atge_dip, "device reset timeout reg : %x",
980 reg);
981 }
982
983 switch (ATGE_MODEL(atgep)) {
984 case ATGE_CHIP_L1E:
985 case ATGE_CHIP_L1:
986 /*
987 * Initialize PCIe module. These values came from FreeBSD and
988 * we don't know the meaning of it.
989 */
990 OUTL(atgep, ATGE_LTSSM_ID_CFG, 0x6500);
991 reg = INL(atgep, 0x1008) | 0x8000;
992 OUTL(atgep, 0x1008, reg);
993 break;
994 case ATGE_CHIP_L1C:
995 break;
996 }
997
998 /*
999 * Get chip revision.
1000 */
1001 atgep->atge_chip_rev = INL(atgep, ATGE_MASTER_CFG) >>
1002 MASTER_CHIP_REV_SHIFT;
1003
1004 ATGE_DB(("%s: %s reset successfully rev : %x", atgep->atge_name,
1005 __func__, atgep->atge_chip_rev));
1006 }
1007
1008 /*
1009 * DMA allocation for L1 and L1E is bit different since L1E uses RX pages
1010 * instead of descriptor based RX model.
1011 */
1012 static int
1013 atge_alloc_dma(atge_t *atgep)
1014 {
1015 int err = DDI_FAILURE;
1016
1017 switch (ATGE_MODEL(atgep)) {
1018 case ATGE_CHIP_L1E:
1019 err = atge_l1e_alloc_dma(atgep);
1020 break;
1021 case ATGE_CHIP_L1:
1022 err = atge_l1_alloc_dma(atgep);
1023 break;
1024 case ATGE_CHIP_L1C:
1025 err = atge_l1c_alloc_dma(atgep);
1026 break;
1027 }
1028
1029 return (err);
1030 }
1031
1032 static void
1033 atge_free_dma(atge_t *atgep)
1034 {
1035 switch (ATGE_MODEL(atgep)) {
1036 case ATGE_CHIP_L1E:
1037 atge_l1e_free_dma(atgep);
1038 break;
1039 case ATGE_CHIP_L1:
1040 atge_l1_free_dma(atgep);
1041 break;
1042 case ATGE_CHIP_L1C:
1043 atge_l1c_free_dma(atgep);
1044 break;
1045 }
1046 }
1047
1048 /*
1049 * Attach entry point in the driver.
1050 */
1051 static int
1052 atge_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd)
1053 {
1054 atge_t *atgep;
1055 mac_register_t *macreg;
1056 int instance;
1057 uint16_t cap_ptr;
1058 uint16_t burst;
1059 int err;
1060 mii_ops_t *mii_ops;
1061
1062 instance = ddi_get_instance(devinfo);
1063
1064 switch (cmd) {
1065 case DDI_RESUME:
1066 return (atge_resume(devinfo));
1067
1068 case DDI_ATTACH:
1069 ddi_set_driver_private(devinfo, NULL);
1070 break;
1071 default:
1072 return (DDI_FAILURE);
1073
1074 }
1075
1076 atgep = kmem_zalloc(sizeof (atge_t), KM_SLEEP);
1077 ddi_set_driver_private(devinfo, atgep);
1078 atgep->atge_dip = devinfo;
1079
1080 /*
1081 * Setup name and instance number to be used for debugging and
1082 * error reporting.
1083 */
1084 (void) snprintf(atgep->atge_name, sizeof (atgep->atge_name), "%s%d",
1085 "atge", instance);
1086
1087
1088 /*
1089 * Map PCI config space.
1090 */
1091 err = pci_config_setup(devinfo, &atgep->atge_conf_handle);
1092 if (err != DDI_SUCCESS) {
1093 atge_error(devinfo, "pci_config_setup() failed");
1119 DDI_INTR_PRI(atgep->atge_intr_pri));
1120
1121 mutex_init(&atgep->atge_tx_lock, NULL, MUTEX_DRIVER,
1122 DDI_INTR_PRI(atgep->atge_intr_pri));
1123
1124 mutex_init(&atgep->atge_rx_lock, NULL, MUTEX_DRIVER,
1125 DDI_INTR_PRI(atgep->atge_intr_pri));
1126
1127 mutex_init(&atgep->atge_mii_lock, NULL, MUTEX_DRIVER, NULL);
1128
1129 /*
1130 * Used to lock down MBOX register on L1 chip since RX consumer,
1131 * TX producer and RX return ring consumer are shared.
1132 */
1133 mutex_init(&atgep->atge_mbox_lock, NULL, MUTEX_DRIVER,
1134 DDI_INTR_PRI(atgep->atge_intr_pri));
1135
1136 atgep->atge_link_state = LINK_STATE_DOWN;
1137 atgep->atge_mtu = ETHERMTU;
1138
1139 switch (ATGE_MODEL(atgep)) {
1140 case ATGE_CHIP_L1E:
1141 if (atgep->atge_revid > 0xF0) {
1142 /* L2E Rev. B. AR8114 */
1143 atgep->atge_flags |= ATGE_FLAG_FASTETHER;
1144 } else {
1145 if ((INL(atgep, L1E_PHY_STATUS) &
1146 PHY_STATUS_100M) != 0) {
1147 /* L1E AR8121 */
1148 atgep->atge_flags |= ATGE_FLAG_JUMBO;
1149 } else {
1150 /* L2E Rev. A. AR8113 */
1151 atgep->atge_flags |= ATGE_FLAG_FASTETHER;
1152 }
1153 }
1154 break;
1155 case ATGE_CHIP_L1:
1156 break;
1157 case ATGE_CHIP_L1C:
1158 /*
1159 * One odd thing is AR8132 uses the same PHY hardware(F1
1160 * gigabit PHY) of AR8131. So atphy(4) of AR8132 reports
1161 * the PHY supports 1000Mbps but that's not true. The PHY
1162 * used in AR8132 can't establish gigabit link even if it
1163 * shows the same PHY model/revision number of AR8131.
1164 *
1165 * It seems that AR813x/AR815x has silicon bug for SMB. In
1166 * addition, Atheros said that enabling SMB wouldn't improve
1167 * performance. However I think it's bad to access lots of
1168 * registers to extract MAC statistics.
1169 *
1170 * Don't use Tx CMB. It is known to have silicon bug.
1171 */
1172 switch (ATGE_DID(atgep)) {
1173 case ATGE_CHIP_AR8152V2_DEV_ID:
1174 case ATGE_CHIP_AR8152V1_DEV_ID:
1175 atgep->atge_flags |= ATGE_FLAG_APS |
1176 ATGE_FLAG_FASTETHER |
1177 ATGE_FLAG_ASPM_MON | ATGE_FLAG_JUMBO |
1178 ATGE_FLAG_SMB_BUG | ATGE_FLAG_CMB_BUG;
1179 break;
1180 case ATGE_CHIP_AR8151V2_DEV_ID:
1181 case ATGE_CHIP_AR8151V1_DEV_ID:
1182 atgep->atge_flags |= ATGE_FLAG_APS |
1183 ATGE_FLAG_ASPM_MON | ATGE_FLAG_JUMBO |
1184 ATGE_FLAG_SMB_BUG | ATGE_FLAG_CMB_BUG;
1185 break;
1186 case ATGE_CHIP_L1CF_DEV_ID:
1187 atgep->atge_flags |= ATGE_FLAG_FASTETHER;
1188 break;
1189 case ATGE_CHIP_L1CG_DEV_ID:
1190 break;
1191 }
1192 break;
1193 }
1194
1195 /*
1196 * Get DMA parameters from PCIe device control register.
1197 */
1198 err = PCI_CAP_LOCATE(atgep->atge_conf_handle, PCI_CAP_ID_PCI_E,
1199 &cap_ptr);
1200
1201 if (err == DDI_FAILURE) {
1202 atgep->atge_dma_rd_burst = DMA_CFG_RD_BURST_128;
1203 atgep->atge_dma_wr_burst = DMA_CFG_WR_BURST_128;
1204 } else {
1205 atgep->atge_flags |= ATGE_FLAG_PCIE;
1206 burst = pci_config_get16(atgep->atge_conf_handle,
1207 cap_ptr + 0x08);
1208
1209 /*
1210 * Max read request size.
1211 */
1212 atgep->atge_dma_rd_burst = ((burst >> 12) & 0x07) <<
1213 DMA_CFG_RD_BURST_SHIFT;
1214
1215 /*
1216 * Max Payload Size.
1217 */
1218 atgep->atge_dma_wr_burst = ((burst >> 5) & 0x07) <<
1219 DMA_CFG_WR_BURST_SHIFT;
1220
1221 ATGE_DB(("%s: %s() MRR : %d, MPS : %d",
1222 atgep->atge_name, __func__,
1223 (128 << ((burst >> 12) & 0x07)),
1224 (128 << ((burst >> 5) & 0x07))));
1225 }
1226
1227 /* Clear data link and flow-control protocol error. */
1228 switch (ATGE_MODEL(atgep)) {
1229 case ATGE_CHIP_L1E:
1230 break;
1231 case ATGE_CHIP_L1:
1232 break;
1233 case ATGE_CHIP_L1C:
1234 OUTL_AND(atgep, ATGE_PEX_UNC_ERR_SEV,
1235 ~(PEX_UNC_ERR_SEV_UC | PEX_UNC_ERR_SEV_FCP));
1236 OUTL_AND(atgep, ATGE_LTSSM_ID_CFG, ~LTSSM_ID_WRO_ENB);
1237 OUTL_OR(atgep, ATGE_PCIE_PHYMISC, PCIE_PHYMISC_FORCE_RCV_DET);
1238 break;
1239 }
1240
1241 /*
1242 * Allocate DMA resources.
1243 */
1244 err = atge_alloc_dma(atgep);
1245 if (err != DDI_SUCCESS) {
1246 atge_error(devinfo, "Failed to allocate DMA resources");
1247 goto fail4;
1248 }
1249
1250 /*
1251 * Get station address.
1252 */
1253 (void) atge_get_macaddr(atgep);
1254
1255 /*
1256 * Setup MII.
1257 */
1258 switch (ATGE_MODEL(atgep)) {
1259 case ATGE_CHIP_L1E:
1260 mii_ops = &atge_l1e_mii_ops;
1261 break;
1262 case ATGE_CHIP_L1:
1263 mii_ops = &atge_l1_mii_ops;
1264 break;
1265 case ATGE_CHIP_L1C:
1266 mii_ops = &atge_l1c_mii_ops;
1267 break;
1268 }
1269
1270 if ((atgep->atge_mii = mii_alloc(atgep, devinfo,
1271 mii_ops)) == NULL) {
1272 atge_error(devinfo, "mii_alloc() failed");
1273 goto fail4;
1274 }
1275
1276 /*
1277 * Register with MAC layer.
1278 */
1279 if ((macreg = mac_alloc(MAC_VERSION)) == NULL) {
1280 atge_error(devinfo, "mac_alloc() failed due to version");
1281 goto fail4;
1282 }
1283
1284 macreg->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
1285 macreg->m_driver = atgep;
1286 macreg->m_dip = devinfo;
1287 macreg->m_instance = instance;
1300 mac_free(macreg);
1301
1302 ATGE_DB(("%s: %s() driver attached successfully",
1303 atgep->atge_name, __func__));
1304
1305 atge_device_reset(atgep);
1306
1307 atgep->atge_chip_state = ATGE_CHIP_INITIALIZED;
1308
1309 /*
1310 * At last - enable interrupts.
1311 */
1312 err = atge_enable_intrs(atgep);
1313 if (err == DDI_FAILURE) {
1314 goto fail5;
1315 }
1316
1317 /*
1318 * Reset the PHY before starting.
1319 */
1320 switch (ATGE_MODEL(atgep)) {
1321 case ATGE_CHIP_L1E:
1322 atge_l1e_mii_reset(atgep);
1323 break;
1324 case ATGE_CHIP_L1:
1325 atge_l1_mii_reset(atgep);
1326 break;
1327 case ATGE_CHIP_L1C:
1328 atge_l1c_mii_reset(atgep);
1329 break;
1330 }
1331
1332 /*
1333 * Let the PHY run.
1334 */
1335 mii_start(atgep->atge_mii);
1336
1337 return (DDI_SUCCESS);
1338
1339 fail5:
1340 (void) mac_unregister(atgep->atge_mh);
1341 atge_device_stop(atgep);
1342 mii_stop(atgep->atge_mii);
1343 mii_free(atgep->atge_mii);
1344 fail4:
1345 atge_free_dma(atgep);
1346 mutex_destroy(&atgep->atge_intr_lock);
1347 mutex_destroy(&atgep->atge_tx_lock);
1348 mutex_destroy(&atgep->atge_rx_lock);
1349 atge_remove_intr(atgep);
1596 return (DDI_FAILURE);
1597 }
1598
1599 mutex_enter(&atgep->atge_intr_lock);
1600 mutex_enter(&atgep->atge_tx_lock);
1601
1602 atgep->atge_chip_state &= ~ATGE_CHIP_SUSPENDED;
1603
1604 if (atgep->atge_chip_state & ATGE_CHIP_RUNNING) {
1605 atge_device_restart(atgep);
1606 } else {
1607 atge_device_reset(atgep);
1608 }
1609
1610 mutex_exit(&atgep->atge_tx_lock);
1611 mutex_exit(&atgep->atge_intr_lock);
1612
1613 /*
1614 * Reset the PHY before resuming MII.
1615 */
1616 switch (ATGE_MODEL(atgep)) {
1617 case ATGE_CHIP_L1E:
1618 atge_l1e_mii_reset(atgep);
1619 break;
1620 case ATGE_CHIP_L1:
1621 break;
1622 case ATGE_CHIP_L1C:
1623 break;
1624 }
1625
1626 mii_resume(atgep->atge_mii);
1627
1628 /* kick-off downstream */
1629 mac_tx_update(atgep->atge_mh);
1630
1631 return (DDI_SUCCESS);
1632 }
1633
1634 static int
1635 atge_quiesce(dev_info_t *dip)
1636 {
1637 atge_t *atgep;
1638
1639 if ((atgep = ddi_get_driver_private(dip)) == NULL) {
1640 return (DDI_FAILURE);
1641 }
1642
1643 atge_device_stop(atgep);
2037 OUTL(atgep, ATGE_PAR0,
2038 ((e[2] << 24) | (e[3] << 16) | (e[4] << 8) | e[5]));
2039 OUTL(atgep, ATGE_PAR1, (e[0] << 8) | e[1]);
2040 }
2041
2042 /*
2043 * Device specific operations.
2044 */
2045 void
2046 atge_device_start(atge_t *atgep)
2047 {
2048 uint32_t rxf_hi, rxf_lo, rrd_hi, rrd_lo;
2049 uint32_t reg;
2050 uint32_t fsize;
2051
2052 /*
2053 * Reprogram the Station address.
2054 */
2055 atge_program_ether(atgep);
2056
2057 switch (ATGE_MODEL(atgep)) {
2058 case ATGE_CHIP_L1E:
2059 atge_l1e_program_dma(atgep);
2060 break;
2061 case ATGE_CHIP_L1:
2062 atge_l1_program_dma(atgep);
2063 break;
2064 case ATGE_CHIP_L1C:
2065 atge_l1c_program_dma(atgep);
2066 break;
2067 }
2068
2069 ATGE_DB(("%s: %s() dma, counters programmed ", atgep->atge_name,
2070 __func__));
2071
2072 switch (ATGE_MODEL(atgep)) {
2073 case ATGE_CHIP_L1E:
2074 case ATGE_CHIP_L1:
2075 OUTW(atgep, ATGE_INTR_CLR_TIMER, 1*1000/2);
2076 break;
2077 case ATGE_CHIP_L1C:
2078 /*
2079 * Disable interrupt re-trigger timer. We don't want automatic
2080 * re-triggering of un-ACKed interrupts.
2081 */
2082 OUTL(atgep, ATGE_INTR_RETRIG_TIMER, ATGE_USECS(0));
2083 /* Configure CMB. */
2084 OUTL(atgep, ATGE_CMB_TX_TIMER, ATGE_USECS(0));
2085 /*
2086 * Hardware can be configured to issue SMB interrupt based
2087 * on programmed interval. Since there is a callout that is
2088 * invoked for every hz in driver we use that instead of
2089 * relying on periodic SMB interrupt.
2090 */
2091 OUTL(atgep, ATGE_SMB_STAT_TIMER, ATGE_USECS(0));
2092 /* Clear MAC statistics. */
2093 atge_l1c_clear_stats(atgep);
2094 break;
2095 }
2096
2097 /*
2098 * Set Maximum frame size but don't let MTU be less than ETHER_MTU.
2099 */
2100 if (atgep->atge_mtu < ETHERMTU)
2101 atgep->atge_max_frame_size = ETHERMTU;
2102 else
2103 atgep->atge_max_frame_size = atgep->atge_mtu;
2104
2105 atgep->atge_max_frame_size += sizeof (struct ether_header) +
2106 VLAN_TAGSZ + ETHERFCSL;
2107 OUTL(atgep, ATGE_FRAME_SIZE, atgep->atge_max_frame_size);
2108
2109 switch (ATGE_MODEL(atgep)) {
2110 case ATGE_CHIP_L1E:
2111 break;
2112 case ATGE_CHIP_L1:
2113 break;
2114 case ATGE_CHIP_L1C:
2115 /* Disable header split(?) */
2116 OUTL(atgep, ATGE_HDS_CFG, 0);
2117 break;
2118 }
2119
2120 /*
2121 * Configure IPG/IFG parameters.
2122 */
2123 OUTL(atgep, ATGE_IPG_IFG_CFG,
2124 ((IPG_IFG_IPG2_DEFAULT << IPG_IFG_IPG2_SHIFT) & IPG_IFG_IPG2_MASK) |
2125 ((IPG_IFG_IPG1_DEFAULT << IPG_IFG_IPG1_SHIFT) & IPG_IFG_IPG1_MASK) |
2126 ((IPG_IFG_MIFG_DEFAULT << IPG_IFG_MIFG_SHIFT) & IPG_IFG_MIFG_MASK) |
2127 ((IPG_IFG_IPGT_DEFAULT << IPG_IFG_IPGT_SHIFT) & IPG_IFG_IPGT_MASK));
2128
2129 /*
2130 * Set parameters for half-duplex media.
2131 */
2132 OUTL(atgep, ATGE_HDPX_CFG,
2133 ((HDPX_CFG_LCOL_DEFAULT << HDPX_CFG_LCOL_SHIFT) &
2134 HDPX_CFG_LCOL_MASK) |
2135 ((HDPX_CFG_RETRY_DEFAULT << HDPX_CFG_RETRY_SHIFT) &
2136 HDPX_CFG_RETRY_MASK) | HDPX_CFG_EXC_DEF_EN |
2137 ((HDPX_CFG_ABEBT_DEFAULT << HDPX_CFG_ABEBT_SHIFT) &
2138 HDPX_CFG_ABEBT_MASK) |
2139 ((HDPX_CFG_JAMIPG_DEFAULT << HDPX_CFG_JAMIPG_SHIFT) &
2140 HDPX_CFG_JAMIPG_MASK));
2141
2142 /*
2143 * Configure jumbo frame.
2144 */
2145 switch (ATGE_MODEL(atgep)) {
2146 case ATGE_CHIP_L1E:
2147 if (atgep->atge_flags & ATGE_FLAG_JUMBO) {
2148
2149 if (atgep->atge_mtu < ETHERMTU)
2150 reg = atgep->atge_max_frame_size;
2151 else if (atgep->atge_mtu < 6 * 1024)
2152 reg = (atgep->atge_max_frame_size * 2) / 3;
2153 else
2154 reg = atgep->atge_max_frame_size / 2;
2155
2156 OUTL(atgep, L1E_TX_JUMBO_THRESH,
2157 ROUNDUP(reg, TX_JUMBO_THRESH_UNIT) >>
2158 TX_JUMBO_THRESH_UNIT_SHIFT);
2159 }
2160 break;
2161 case ATGE_CHIP_L1:
2162 fsize = ROUNDUP(atgep->atge_max_frame_size, sizeof (uint64_t));
2163 OUTL(atgep, ATGE_RXQ_JUMBO_CFG,
2164 (((fsize / sizeof (uint64_t)) <<
2165 RXQ_JUMBO_CFG_SZ_THRESH_SHIFT) &
2166 RXQ_JUMBO_CFG_SZ_THRESH_MASK) |
2167 ((RXQ_JUMBO_CFG_LKAH_DEFAULT <<
2168 RXQ_JUMBO_CFG_LKAH_SHIFT) & RXQ_JUMBO_CFG_LKAH_MASK) |
2169 ((ATGE_USECS(8) << RXQ_JUMBO_CFG_RRD_TIMER_SHIFT) &
2170 RXQ_JUMBO_CFG_RRD_TIMER_MASK));
2171 break;
2172 case ATGE_CHIP_L1C:
2173 break;
2174 }
2175
2176 /*
2177 * Configure flow-control parameters.
2178 */
2179 switch (ATGE_MODEL(atgep)) {
2180 case ATGE_CHIP_L1E:
2181 case ATGE_CHIP_L1:
2182 if ((atgep->atge_flags & ATGE_FLAG_PCIE) != 0) {
2183 /*
2184 * Some hardware version require this magic.
2185 */
2186 OUTL(atgep, ATGE_LTSSM_ID_CFG, 0x6500);
2187 reg = INL(atgep, 0x1008);
2188 OUTL(atgep, 0x1008, reg | 0x8000);
2189 }
2190 break;
2191 case ATGE_CHIP_L1C:
2192 break;
2193 }
2194
2195 /*
2196 * These are all magic parameters which came from FreeBSD.
2197 */
2198 switch (ATGE_MODEL(atgep)) {
2199 case ATGE_CHIP_L1E:
2200 reg = INL(atgep, L1E_SRAM_RX_FIFO_LEN);
2201 rxf_hi = (reg * 4) / 5;
2202 rxf_lo = reg/ 5;
2203
2204 OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
2205 ((rxf_lo << RXQ_FIFO_PAUSE_THRESH_LO_SHIFT) &
2206 RXQ_FIFO_PAUSE_THRESH_LO_MASK) |
2207 ((rxf_hi << RXQ_FIFO_PAUSE_THRESH_HI_SHIFT) &
2208 RXQ_FIFO_PAUSE_THRESH_HI_MASK));
2209 break;
2210 case ATGE_CHIP_L1:
2211 switch (atgep->atge_chip_rev) {
2212 case 0x8001:
2213 case 0x9001:
2214 case 0x9002:
2215 case 0x9003:
2216 rxf_hi = L1_RX_RING_CNT / 16;
2217 rxf_lo = (L1_RX_RING_CNT * 7) / 8;
2218 rrd_hi = (L1_RR_RING_CNT * 7) / 8;
2219 rrd_lo = L1_RR_RING_CNT / 16;
2220 break;
2221 default:
2222 reg = INL(atgep, L1_SRAM_RX_FIFO_LEN);
2223 rxf_lo = reg / 16;
2224 if (rxf_lo > 192)
2225 rxf_lo = 192;
2226 rxf_hi = (reg * 7) / 8;
2227 if (rxf_hi < rxf_lo)
2228 rxf_hi = rxf_lo + 16;
2229 reg = INL(atgep, L1_SRAM_RRD_LEN);
2230 rrd_lo = reg / 8;
2231 rrd_hi = (reg * 7) / 8;
2232 if (rrd_lo > 2)
2233 rrd_lo = 2;
2234 if (rrd_hi < rrd_lo)
2235 rrd_hi = rrd_lo + 3;
2236 break;
2237 }
2238
2239 OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
2240 ((rxf_lo << RXQ_FIFO_PAUSE_THRESH_LO_SHIFT) &
2241 RXQ_FIFO_PAUSE_THRESH_LO_MASK) |
2242 ((rxf_hi << RXQ_FIFO_PAUSE_THRESH_HI_SHIFT) &
2243 RXQ_FIFO_PAUSE_THRESH_HI_MASK));
2244
2245 OUTL(atgep, L1_RXQ_RRD_PAUSE_THRESH,
2246 ((rrd_lo << RXQ_RRD_PAUSE_THRESH_LO_SHIFT) &
2247 RXQ_RRD_PAUSE_THRESH_LO_MASK) |
2248 ((rrd_hi << RXQ_RRD_PAUSE_THRESH_HI_SHIFT) &
2249 RXQ_RRD_PAUSE_THRESH_HI_MASK));
2250 break;
2251 case ATGE_CHIP_L1C:
2252 switch (ATGE_DID(atgep)) {
2253 case ATGE_CHIP_AR8151V2_DEV_ID:
2254 case ATGE_CHIP_AR8152V1_DEV_ID:
2255 OUTL(atgep, ATGE_SERDES_LOCK,
2256 INL(atgep, ATGE_SERDES_LOCK) |
2257 SERDES_MAC_CLK_SLOWDOWN |
2258 SERDES_PHY_CLK_SLOWDOWN);
2259 break;
2260 case ATGE_CHIP_L1CG_DEV_ID:
2261 case ATGE_CHIP_L1CF_DEV_ID:
2262 /*
2263 * Configure flow control parameters.
2264 * XON : 80% of Rx FIFO
2265 * XOFF : 30% of Rx FIFO
2266 */
2267 reg = INL(atgep, L1C_SRAM_RX_FIFO_LEN);
2268 rxf_hi = (reg * 8) / 10;
2269 rxf_lo = (reg * 3) / 10;
2270
2271 OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
2272 ((rxf_lo << RXQ_FIFO_PAUSE_THRESH_LO_SHIFT) &
2273 RXQ_FIFO_PAUSE_THRESH_LO_MASK) |
2274 ((rxf_hi << RXQ_FIFO_PAUSE_THRESH_HI_SHIFT) &
2275 RXQ_FIFO_PAUSE_THRESH_HI_MASK));
2276 break;
2277 }
2278 break;
2279 }
2280
2281 switch (ATGE_MODEL(atgep)) {
2282 case ATGE_CHIP_L1E:
2283 /* Configure RxQ. */
2284 reg = RXQ_CFG_ALIGN_32 | RXQ_CFG_CUT_THROUGH_ENB |
2285 RXQ_CFG_IPV6_CSUM_VERIFY | RXQ_CFG_ENB;
2286 OUTL(atgep, ATGE_RXQ_CFG, reg);
2287 /*
2288 * Configure TxQ.
2289 */
2290 reg = (128 <<
2291 (atgep->atge_dma_rd_burst >> DMA_CFG_RD_BURST_SHIFT)) <<
2292 TXQ_CFG_TX_FIFO_BURST_SHIFT;
2293
2294 reg |= (TXQ_CFG_TPD_BURST_DEFAULT << TXQ_CFG_TPD_BURST_SHIFT) &
2295 TXQ_CFG_TPD_BURST_MASK;
2296
2297 reg |= TXQ_CFG_ENHANCED_MODE | TXQ_CFG_ENB;
2298
2299 OUTL(atgep, ATGE_TXQ_CFG, reg);
2300 /* Disable RSS. */
2301 OUTL(atgep, L1E_RSS_IDT_TABLE0, 0);
2302 OUTL(atgep, L1E_RSS_CPU, 0);
2303 /*
2304 * Configure DMA parameters.
2305 */
2306 /*
2307 * Don't use Tx CMB. It is known to cause RRS update failure
2308 * under certain circumstances. Typical phenomenon of the
2309 * issue would be unexpected sequence number encountered in
2310 * Rx handler. Hence we don't set DMA_CFG_TXCMB_ENB.
2311 */
2312 OUTL(atgep, ATGE_DMA_CFG,
2313 DMA_CFG_OUT_ORDER | DMA_CFG_RD_REQ_PRI | DMA_CFG_RCB_64 |
2314 atgep->atge_dma_rd_burst | atgep->atge_dma_wr_burst |
2315 DMA_CFG_RXCMB_ENB |
2316 ((DMA_CFG_RD_DELAY_CNT_DEFAULT <<
2317 DMA_CFG_RD_DELAY_CNT_SHIFT) & DMA_CFG_RD_DELAY_CNT_MASK) |
2318 ((DMA_CFG_WR_DELAY_CNT_DEFAULT <<
2319 DMA_CFG_WR_DELAY_CNT_SHIFT) & DMA_CFG_WR_DELAY_CNT_MASK));
2320 /*
2321 * Enable CMB/SMB timer.
2322 */
2323 OUTL(atgep, L1E_SMB_STAT_TIMER, 100000);
2324 atge_l1e_clear_stats(atgep);
2325 break;
2326 case ATGE_CHIP_L1:
2327 /* Configure RxQ. */
2328 reg =
2329 ((RXQ_CFG_RD_BURST_DEFAULT << RXQ_CFG_RD_BURST_SHIFT) &
2330 RXQ_CFG_RD_BURST_MASK) |
2331 ((RXQ_CFG_RRD_BURST_THRESH_DEFAULT <<
2332 RXQ_CFG_RRD_BURST_THRESH_SHIFT) &
2333 RXQ_CFG_RRD_BURST_THRESH_MASK) |
2334 ((RXQ_CFG_RD_PREF_MIN_IPG_DEFAULT <<
2335 RXQ_CFG_RD_PREF_MIN_IPG_SHIFT) &
2336 RXQ_CFG_RD_PREF_MIN_IPG_MASK) |
2337 RXQ_CFG_CUT_THROUGH_ENB | RXQ_CFG_ENB;
2338 OUTL(atgep, ATGE_RXQ_CFG, reg);
2339 /*
2340 * Configure TxQ.
2341 */
2342 reg =
2343 (((TXQ_CFG_TPD_BURST_DEFAULT << TXQ_CFG_TPD_BURST_SHIFT) &
2344 TXQ_CFG_TPD_BURST_MASK) |
2345 ((TXQ_CFG_TX_FIFO_BURST_DEFAULT <<
2346 TXQ_CFG_TX_FIFO_BURST_SHIFT) &
2347 TXQ_CFG_TX_FIFO_BURST_MASK) |
2348 ((TXQ_CFG_TPD_FETCH_DEFAULT <<
2349 TXQ_CFG_TPD_FETCH_THRESH_SHIFT) &
2350 TXQ_CFG_TPD_FETCH_THRESH_MASK) |
2351 TXQ_CFG_ENB);
2352 OUTL(atgep, ATGE_TXQ_CFG, reg);
2353 /* Jumbo frames */
2354 OUTL(atgep, L1_TX_JUMBO_TPD_TH_IPG,
2355 (((fsize / sizeof (uint64_t) << TX_JUMBO_TPD_TH_SHIFT)) &
2356 TX_JUMBO_TPD_TH_MASK) |
2357 ((TX_JUMBO_TPD_IPG_DEFAULT << TX_JUMBO_TPD_IPG_SHIFT) &
2358 TX_JUMBO_TPD_IPG_MASK));
2359 /*
2360 * Configure DMA parameters.
2361 */
2362 OUTL(atgep, ATGE_DMA_CFG,
2363 DMA_CFG_ENH_ORDER | DMA_CFG_RCB_64 |
2364 atgep->atge_dma_rd_burst | DMA_CFG_RD_ENB |
2365 atgep->atge_dma_wr_burst | DMA_CFG_WR_ENB);
2366
2367 /* Configure CMB DMA write threshold. */
2368 OUTL(atgep, L1_CMB_WR_THRESH,
2369 ((CMB_WR_THRESH_RRD_DEFAULT << CMB_WR_THRESH_RRD_SHIFT) &
2370 CMB_WR_THRESH_RRD_MASK) |
2371 ((CMB_WR_THRESH_TPD_DEFAULT << CMB_WR_THRESH_TPD_SHIFT) &
2372 CMB_WR_THRESH_TPD_MASK));
2373 /*
2374 * Enable CMB/SMB timer.
2375 */
2376 /* Set CMB/SMB timer and enable them. */
2377 OUTL(atgep, L1_CMB_WR_TIMER,
2378 ((ATGE_USECS(2) << CMB_WR_TIMER_TX_SHIFT) &
2379 CMB_WR_TIMER_TX_MASK) |
2380 ((ATGE_USECS(2) << CMB_WR_TIMER_RX_SHIFT) &
2381 CMB_WR_TIMER_RX_MASK));
2382
2383 /* Request SMB updates for every seconds. */
2384 OUTL(atgep, L1_SMB_TIMER, ATGE_USECS(1000 * 1000));
2385 OUTL(atgep, L1_CSMB_CTRL,
2386 CSMB_CTRL_SMB_ENB | CSMB_CTRL_CMB_ENB);
2387 break;
2388 case ATGE_CHIP_L1C:
2389 /* Configure RxQ. */
2390 reg =
2391 RXQ_CFG_RD_BURST_DEFAULT << L1C_RXQ_CFG_RD_BURST_SHIFT |
2392 RXQ_CFG_IPV6_CSUM_VERIFY | RXQ_CFG_ENB;
2393 if ((atgep->atge_flags & ATGE_FLAG_ASPM_MON) != 0)
2394 reg |= RXQ_CFG_ASPM_THROUGHPUT_LIMIT_1M;
2395 OUTL(atgep, ATGE_RXQ_CFG, reg);
2396 /*
2397 * Configure TxQ.
2398 */
2399 reg = (128 <<
2400 (atgep->atge_dma_rd_burst >> DMA_CFG_RD_BURST_SHIFT)) <<
2401 TXQ_CFG_TX_FIFO_BURST_SHIFT;
2402
2403 switch (ATGE_DID(atgep)) {
2404 case ATGE_CHIP_AR8152V2_DEV_ID:
2405 case ATGE_CHIP_AR8152V1_DEV_ID:
2406 reg >>= 1;
2407 break;
2408 }
2409
2410 reg |= (L1C_TXQ_CFG_TPD_BURST_DEFAULT <<
2411 TXQ_CFG_TPD_BURST_SHIFT) & TXQ_CFG_TPD_BURST_MASK;
2412
2413 reg |= TXQ_CFG_ENHANCED_MODE | TXQ_CFG_ENB;
2414
2415 OUTL(atgep, L1C_TXQ_CFG, reg);
2416 /* Disable RSS until I understand L1C/L2C's RSS logic. */
2417 OUTL(atgep, L1C_RSS_IDT_TABLE0, 0xe4e4e4e4);
2418 OUTL(atgep, L1C_RSS_CPU, 0);
2419 /*
2420 * Configure DMA parameters.
2421 */
2422 OUTL(atgep, ATGE_DMA_CFG,
2423 DMA_CFG_SMB_DIS |
2424 DMA_CFG_OUT_ORDER | DMA_CFG_RD_REQ_PRI | DMA_CFG_RCB_64 |
2425 DMA_CFG_RD_DELAY_CNT_DEFAULT << DMA_CFG_RD_DELAY_CNT_SHIFT |
2426 DMA_CFG_WR_DELAY_CNT_DEFAULT << DMA_CFG_WR_DELAY_CNT_SHIFT |
2427
2428 atgep->atge_dma_rd_burst | DMA_CFG_RD_ENB |
2429 atgep->atge_dma_wr_burst | DMA_CFG_WR_ENB);
2430 /* Configure CMB DMA write threshold not required. */
2431 /* Set CMB/SMB timer and enable them not required. */
2432 break;
2433 }
2434
2435 /*
2436 * Disable all WOL bits as WOL can interfere normal Rx
2437 * operation.
2438 */
2439 OUTL(atgep, ATGE_WOL_CFG, 0);
2440
2441 /*
2442 * Configure Tx/Rx MACs.
2443 * - Auto-padding for short frames.
2444 * - Enable CRC generation.
2445 *
2446 * Start with full-duplex/1000Mbps media. Actual reconfiguration
2447 * of MAC is followed after link establishment.
2448 */
2449 reg = (ATGE_CFG_TX_CRC_ENB | ATGE_CFG_TX_AUTO_PAD |
2450 ATGE_CFG_FULL_DUPLEX |
2451 ((ATGE_CFG_PREAMBLE_DEFAULT << ATGE_CFG_PREAMBLE_SHIFT) &
2452 ATGE_CFG_PREAMBLE_MASK));
2453
2454 /*
2455 * AR813x/AR815x always does checksum computation regardless
2456 * of MAC_CFG_RXCSUM_ENB bit. Also the controller is known to
2457 * have bug in protocol field in Rx return structure so
2458 * these controllers can't handle fragmented frames. Disable
2459 * Rx checksum offloading until there is a newer controller
2460 * that has sane implementation.
2461 */
2462 switch (ATGE_DID(atgep)) {
2463 case ATGE_CHIP_AR8151V2_DEV_ID:
2464 case ATGE_CHIP_AR8151V1_DEV_ID:
2465 case ATGE_CHIP_AR8152V2_DEV_ID:
2466 reg |= ATGE_CFG_HASH_ALG_CRC32 | ATGE_CFG_SPEED_MODE_SW;
2467 break;
2468 }
2469
2470 if ((atgep->atge_flags & ATGE_FLAG_FASTETHER) != 0) {
2471 reg |= ATGE_CFG_SPEED_10_100;
2472 ATGE_DB(("%s: %s() Fast Ethernet", atgep->atge_name, __func__));
2473 } else {
2474 reg |= ATGE_CFG_SPEED_1000;
2475 ATGE_DB(("%s: %s() 1G speed", atgep->atge_name, __func__));
2476 }
2477 switch (ATGE_MODEL(atgep)) {
2478 case ATGE_CHIP_L1C:
2479 reg |= L1C_CFG_SINGLE_PAUSE_ENB;
2480 break;
2481 }
2482
2483 OUTL(atgep, ATGE_MAC_CFG, reg);
2484
2485 atgep->atge_chip_state |= ATGE_CHIP_RUNNING;
2486
2487 /*
2488 * Set up the receive filter.
2489 */
2490 atge_rxfilter(atgep);
2491
2492 /*
2493 * Acknowledge all pending interrupts and clear it.
2494 */
2495 switch (ATGE_MODEL(atgep)) {
2496 case ATGE_CHIP_L1E:
2497 OUTL(atgep, ATGE_INTR_MASK, L1E_INTRS);
2498 OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2499 OUTL(atgep, ATGE_INTR_STATUS, 0);
2500 break;
2501 case ATGE_CHIP_L1:
2502 case ATGE_CHIP_L1C:
2503 OUTL(atgep, ATGE_INTR_STATUS, 0);
2504 OUTL(atgep, ATGE_INTR_MASK, atgep->atge_intrs);
2505 break;
2506 }
2507
2508 atge_mac_config(atgep);
2509
2510 ATGE_DB(("%s: %s() device started", atgep->atge_name, __func__));
2511 }
2512
2513 /*
2514 * Generic functions.
2515 */
2516
2517 #define CRC32_POLY_BE 0x04c11db7
2518 uint32_t
2519 atge_ether_crc(const uint8_t *addr, int len)
2520 {
2521 int idx;
2522 int bit;
2523 uint_t data;
2524 uint32_t crc;
2525
2581 }
2582
2583 void
2584 atge_device_stop(atge_t *atgep)
2585 {
2586 uint32_t reg;
2587 int t;
2588
2589 /*
2590 * If the chip is being suspended, then don't touch the state. Caller
2591 * will take care of setting the correct state.
2592 */
2593 if (!(atgep->atge_chip_state & ATGE_CHIP_SUSPENDED)) {
2594 atgep->atge_chip_state |= ATGE_CHIP_STOPPED;
2595 atgep->atge_chip_state &= ~ATGE_CHIP_RUNNING;
2596 }
2597
2598 /*
2599 * Collect stats for L1E. L1 chip's stats are collected by interrupt.
2600 */
2601 switch (ATGE_MODEL(atgep)) {
2602 case ATGE_CHIP_L1E:
2603 atge_l1e_gather_stats(atgep);
2604 break;
2605 case ATGE_CHIP_L1:
2606 case ATGE_CHIP_L1C:
2607 break;
2608 }
2609
2610 /*
2611 * Disable interrupts.
2612 */
2613 atge_disable_intrs(atgep);
2614
2615 switch (ATGE_MODEL(atgep)) {
2616 case ATGE_CHIP_L1E:
2617 /* Clear CTRL not required. */
2618 /* Stop DMA Engine not required. */
2619 /*
2620 * Disable queue processing.
2621 */
2622 /* Stop TxQ */
2623 reg = INL(atgep, ATGE_TXQ_CFG);
2624 reg = reg & ~TXQ_CFG_ENB;
2625 OUTL(atgep, ATGE_TXQ_CFG, reg);
2626 /* Stop RxQ */
2627 reg = INL(atgep, ATGE_RXQ_CFG);
2628 reg = reg & ~RXQ_CFG_ENB;
2629 OUTL(atgep, ATGE_RXQ_CFG, reg);
2630 /* Stop DMA */
2631 reg = INL(atgep, ATGE_DMA_CFG);
2632 reg = reg & ~(DMA_CFG_TXCMB_ENB | DMA_CFG_RXCMB_ENB);
2633 OUTL(atgep, ATGE_DMA_CFG, reg);
2634 drv_usecwait(1000);
2635 atge_l1e_stop_mac(atgep);
2636 OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2637 break;
2638 case ATGE_CHIP_L1:
2639 /* Clear CTRL. */
2640 OUTL(atgep, L1_CSMB_CTRL, 0);
2641 /* Stop DMA Engine */
2642 atge_l1_stop_tx_mac(atgep);
2643 atge_l1_stop_rx_mac(atgep);
2644 reg = INL(atgep, ATGE_DMA_CFG);
2645 reg &= ~(DMA_CFG_RD_ENB | DMA_CFG_WR_ENB);
2646 OUTL(atgep, ATGE_DMA_CFG, reg);
2647 /*
2648 * Disable queue processing.
2649 */
2650 /* Stop TxQ */
2651 reg = INL(atgep, ATGE_TXQ_CFG);
2652 reg = reg & ~TXQ_CFG_ENB;
2653 OUTL(atgep, ATGE_TXQ_CFG, reg);
2654 /* Stop RxQ */
2655 reg = INL(atgep, ATGE_RXQ_CFG);
2656 reg = reg & ~RXQ_CFG_ENB;
2657 OUTL(atgep, ATGE_RXQ_CFG, reg);
2658 break;
2659 case ATGE_CHIP_L1C:
2660 /* Clear CTRL not required. */
2661 /* Stop DMA Engine */
2662 atge_l1c_stop_tx_mac(atgep);
2663 atge_l1c_stop_rx_mac(atgep);
2664 reg = INL(atgep, ATGE_DMA_CFG);
2665 reg &= ~(DMA_CFG_RD_ENB | DMA_CFG_WR_ENB);
2666 OUTL(atgep, ATGE_DMA_CFG, reg);
2667 /*
2668 * Disable queue processing.
2669 */
2670 /* Stop TxQ */
2671 reg = INL(atgep, L1C_TXQ_CFG);
2672 reg = reg & ~TXQ_CFG_ENB;
2673 OUTL(atgep, L1C_TXQ_CFG, reg);
2674 /* Stop RxQ */
2675 reg = INL(atgep, ATGE_RXQ_CFG);
2676 reg = reg & ~RXQ_CFG_ENB;
2677 OUTL(atgep, ATGE_RXQ_CFG, reg);
2678 break;
2679 }
2680
2681 for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
2682 if ((reg = INL(atgep, ATGE_IDLE_STATUS)) == 0)
2683 break;
2684 drv_usecwait(10);
2685 }
2686
2687 if (t == 0) {
2688 atge_error(atgep->atge_dip, "%s() stopping TX/RX MAC timeout",
2689 __func__);
2690 }
2691 }
2692
2693 void
2694 atge_disable_intrs(atge_t *atgep)
2695 {
2696 OUTL(atgep, ATGE_INTR_MASK, 0);
2697 OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2698 }
2699
2700 void
2701 atge_device_init(atge_t *atgep)
2702 {
2703 switch (ATGE_MODEL(atgep)) {
2704 case ATGE_CHIP_L1E:
2705 atgep->atge_intrs = L1E_INTRS;
2706 atgep->atge_int_mod = ATGE_IM_TIMER_DEFAULT;
2707
2708 atge_l1e_init_tx_ring(atgep);
2709 atge_l1e_init_rx_pages(atgep);
2710 break;
2711 case ATGE_CHIP_L1:
2712 atgep->atge_intrs = L1_INTRS | INTR_GPHY | INTR_PHY_LINK_DOWN |
2713 INTR_LINK_CHG;
2714 atgep->atge_int_mod = ATGE_IM_TIMER_DEFAULT;
2715
2716 atge_l1_init_tx_ring(atgep);
2717 atge_l1_init_rx_ring(atgep);
2718 atge_l1_init_rr_ring(atgep);
2719 atge_l1_init_cmb(atgep);
2720 atge_l1_init_smb(atgep);
2721 break;
2722 case ATGE_CHIP_L1C:
2723 atgep->atge_intrs = L1C_INTRS | L1C_INTR_GPHY |
2724 L1C_INTR_PHY_LINK_DOWN;
2725 atgep->atge_int_rx_mod = 400/2;
2726 atgep->atge_int_tx_mod = 2000/1;
2727
2728 atge_l1c_init_tx_ring(atgep);
2729 atge_l1c_init_rx_ring(atgep);
2730 atge_l1c_init_rr_ring(atgep);
2731 atge_l1c_init_cmb(atgep);
2732 atge_l1c_init_smb(atgep);
2733
2734 /* Enable all clocks. */
2735 OUTL(atgep, ATGE_CLK_GATING_CFG, 0);
2736 break;
2737 }
2738 }
2739
2740 void
2741 atge_device_restart(atge_t *atgep)
2742 {
2743 ASSERT(MUTEX_HELD(&atgep->atge_intr_lock));
2744 ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
2745
2746 /*
2747 * Cancel any pending I/O.
2748 */
2749 atge_device_stop(atgep);
2750
2751 /*
2752 * Reset the chip to a known state.
2753 */
2754 atge_device_reset(atgep);
2755
2756 /*
2757 * Initialize the ring and other descriptor like CMB/SMB/Rx return.
2758 */
2759 atge_device_init(atgep);
2760
2761 /*
2762 * Start the chip.
2763 */
2764 atge_device_start(atgep);
2765
2766 }
2767
2768 static int
2769 atge_send_a_packet(atge_t *atgep, mblk_t *mp)
2770 {
2771 uchar_t *c;
2772 uint32_t cflags = 0;
2773 atge_ring_t *r;
2774 size_t pktlen;
2775 uchar_t *buf;
2776 int start;
2777
2778 ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
2779 ASSERT(mp != NULL);
2780
2781 pktlen = msgsize(mp);
2782 if (pktlen > atgep->atge_tx_buf_len) {
2783 atgep->atge_macxmt_errors++;
2784
2785 ATGE_DB(("%s: %s() pktlen (%d) > rx_buf_len (%d)",
2786 atgep->atge_name, __func__,
2787 pktlen, atgep->atge_rx_buf_len));
2788
2789 freemsg(mp);
2790 return (DDI_SUCCESS);
2800 atgep->atge_name, __func__));
2801
2802 return (DDI_FAILURE);
2803 }
2804
2805 start = r->r_producer;
2806
2807 /*
2808 * Get the DMA buffer to hold a packet.
2809 */
2810 buf = (uchar_t *)r->r_buf_tbl[start]->addr;
2811
2812 /*
2813 * Copy the msg and free mp
2814 */
2815 mcopymsg(mp, buf);
2816
2817 r->r_avail_desc--;
2818
2819 c = (uchar_t *)r->r_desc_ring->addr;
2820 switch (ATGE_MODEL(atgep)) {
2821 case ATGE_CHIP_L1C:
2822 {
2823 l1c_tx_desc_t *txd;
2824
2825 c += (sizeof (l1c_tx_desc_t) * start);
2826 txd = (l1c_tx_desc_t *)c;
2827
2828 ATGE_PUT64(r->r_desc_ring, &txd->addr,
2829 r->r_buf_tbl[start]->cookie.dmac_laddress);
2830
2831 ATGE_PUT32(r->r_desc_ring, &txd->len, L1C_TX_BYTES(pktlen));
2832
2833 cflags |= L1C_TD_EOP;
2834 ATGE_PUT32(r->r_desc_ring, &txd->flags, cflags);
2835 break;
2836 }
2837 default:
2838 {
2839 atge_tx_desc_t *txd;
2840
2841 c += (sizeof (atge_tx_desc_t) * start);
2842 txd = (atge_tx_desc_t *)c;
2843
2844 ATGE_PUT64(r->r_desc_ring, &txd->addr,
2845 r->r_buf_tbl[start]->cookie.dmac_laddress);
2846
2847 ATGE_PUT32(r->r_desc_ring, &txd->len, ATGE_TX_BYTES(pktlen));
2848
2849 cflags |= ATGE_TD_EOP;
2850 ATGE_PUT32(r->r_desc_ring, &txd->flags, cflags);
2851 break;
2852 }
2853 }
2854 /*
2855 * Sync buffer first.
2856 */
2857 DMA_SYNC(r->r_buf_tbl[start], 0, pktlen, DDI_DMA_SYNC_FORDEV);
2858
2859 /*
2860 * Increment TX producer count by one.
2861 */
2862 ATGE_INC_SLOT(r->r_producer, ATGE_TX_RING_CNT);
2863
2864 /*
2865 * Sync descriptor table.
2866 */
2867 DMA_SYNC(r->r_desc_ring, 0, ATGE_TX_RING_SZ, DDI_DMA_SYNC_FORDEV);
2868
2869 /*
2870 * Program TX descriptor to send a packet.
2871 */
2872 switch (ATGE_MODEL(atgep)) {
2873 case ATGE_CHIP_L1E:
2874 atge_l1e_send_packet(r);
2875 break;
2876 case ATGE_CHIP_L1:
2877 atge_l1_send_packet(r);
2878 break;
2879 case ATGE_CHIP_L1C:
2880 atge_l1c_send_packet(r);
2881 break;
2882 }
2883
2884 r->r_atge->atge_opackets++;
2885 r->r_atge->atge_obytes += pktlen;
2886
2887 ATGE_DB(("%s: %s() pktlen : %d, avail_desc : %d, producer :%d, "
2888 "consumer : %d", atgep->atge_name, __func__, pktlen,
2889 r->r_avail_desc, r->r_producer, r->r_consumer));
2890
2891 return (DDI_SUCCESS);
2892 }
2893
2894 /*
2895 * Stream Information.
2896 */
2897 DDI_DEFINE_STREAM_OPS(atge_devops, nulldev, nulldev, atge_attach, atge_detach,
2898 nodev, NULL, D_MP, NULL, atge_quiesce);
2899
2900 /*
2901 * Module linkage information.
|