1/*
2 * udmfE_usbgem.c : Davicom DM9601E USB to Fast Ethernet Driver for Solaris
3 *
4 * Copyright (c) 2009-2012 Masayuki Murayama.  All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright notice,
10 *    this list of conditions and the following disclaimer.
11 *
12 * 2. Redistributions in binary form must reproduce the above copyright notice,
13 *    this list of conditions and the following disclaimer in the documentation
14 *    and/or other materials provided with the distribution.
15 *
16 * 3. Neither the name of the author nor the names of its contributors may be
17 *    used to endorse or promote products derived from this software without
18 *    specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
30 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
31 * DAMAGE.
32 */
33
34/*
35 *  Changelog:
36 */
37
38/*
39 * TODO
40 */
41/* ======================================================= */
42
43/*
44 * Solaris system header files and macros
45 */
46
47/* minimum kernel headers for drivers */
48#include <sys/types.h>
49#include <sys/conf.h>
50#include <sys/debug.h>
51#include <sys/kmem.h>
52#include <sys/modctl.h>
53#include <sys/errno.h>
54#include <sys/ddi.h>
55#include <sys/sunddi.h>
56#include <sys/byteorder.h>
57
58/* ethernet stuff */
59#include <sys/ethernet.h>
60
61/* interface card depend stuff */
62#include <sys/stropts.h>
63#include <sys/stream.h>
64#include <sys/strlog.h>
65#include <sys/strsun.h>
66#include <sys/usb/usba.h>
67#include "usbgem.h"
68
69/* hardware stuff */
70#include "usbgem_mii.h"
71#include "dm9601reg.h"
72
73char	ident[] = "dm9601 usbnic driver v" VERSION;
74
75/*
76 * Useful macros
77 */
78#define	CHECK_AND_JUMP(err, label)	if (err != USB_SUCCESS) goto label
79#define	LE16P(p)	((((uint8_t *)(p))[1] << 8) | ((uint8_t *)(p))[0])
80
81/*
82 * Debugging
83 */
84#ifdef DEBUG_LEVEL
85static int udmf_debug = DEBUG_LEVEL;
86#define	DPRINTF(n, args)	if (udmf_debug > (n)) cmn_err args
87#else
88#define	DPRINTF(n, args)
89#endif
90
91/*
92 * Our configration for dm9601
93 */
94/* timeouts */
95#define	ONESEC	(drv_usectohz(1*1000000))
96
97/*
98 * Local device definitions
99 */
100struct udmf_dev {
101	/*
102	 * Misc HW information
103	 */
104	uint8_t	rcr;
105	uint8_t	last_nsr;
106	uint8_t	mac_addr[ETHERADDRL];
107};
108
109/*
110 * private functions
111 */
112
113/* mii operations */
114static uint16_t udmf_mii_read(struct usbgem_dev *, uint_t, int *errp);
115static void udmf_mii_write(struct usbgem_dev *, uint_t, uint16_t, int *errp);
116
117/* nic operations */
118static int udmf_reset_chip(struct usbgem_dev *);
119static int udmf_init_chip(struct usbgem_dev *);
120static int udmf_start_chip(struct usbgem_dev *);
121static int udmf_stop_chip(struct usbgem_dev *);
122static int udmf_set_media(struct usbgem_dev *);
123static int udmf_set_rx_filter(struct usbgem_dev *);
124static int udmf_get_stats(struct usbgem_dev *);
125static void udmf_interrupt(struct usbgem_dev *, mblk_t *);
126
127/* packet operations */
128static mblk_t *udmf_tx_make_packet(struct usbgem_dev *, mblk_t *);
129static mblk_t *udmf_rx_make_packet(struct usbgem_dev *, mblk_t *);
130
131/* =============================================================== */
132/*
133 * I/O functions
134 */
135/* =============================================================== */
136#define	OUT(dp, ix, len, buf, errp, label)	\
137	if ((*(errp) = usbgem_ctrl_out((dp), 	\
138	/* bmRequestType */ USB_DEV_REQ_HOST_TO_DEV	\
139		    | USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_RCPT_DEV,	\
140	/* bRequest */	1,	\
141	/* wValue */	0,	\
142	/* wIndex */	(ix),	\
143	/* wLength */	(len),	\
144	/* value */	(buf),	\
145	/* size */	(len))) != USB_SUCCESS) goto label
146
147#define	OUTB(dp, ix, val, errp, label)	\
148	if ((*(errp) = usbgem_ctrl_out((dp), 	\
149	/* bmRequestType */ USB_DEV_REQ_HOST_TO_DEV	\
150		    | USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_RCPT_DEV,	\
151	/* bRequest */	3,	\
152	/* wValue */	(val),	\
153	/* wIndex */	(ix),	\
154	/* wLength */	0,	\
155	/* value */	NULL,	\
156	/* size */	0)) != USB_SUCCESS) goto label
157
158#define	IN(dp, ix, len, buf, errp, label)	\
159	if ((*(errp) = usbgem_ctrl_in((dp), 	\
160	/* bmRequestType */ USB_DEV_REQ_DEV_TO_HOST	\
161		    | USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_RCPT_DEV,	\
162	/* bRequest */	0,	\
163	/* wValue */	0,	\
164	/* wIndex */	(ix),	\
165	/* wLength */	(len),	\
166	/* valuep */	(buf),	\
167	/* size */	(len))) != USB_SUCCESS) goto label
168
169/* =============================================================== */
170/*
171 * Hardware manupilation
172 */
173/* =============================================================== */
174static void
175udmf_enable_phy(struct usbgem_dev *dp)
176{
177	int	err = USB_SUCCESS;
178
179	/* de-assert reset signal to phy */
180	OUTB(dp, GPCR, GPCR_OUT(0), &err, usberr);
181	OUTB(dp, GPR, 0, &err, usberr);
182usberr:
183	;
184}
185
186static int
187udmf_reset_chip(struct usbgem_dev *dp)
188{
189	int	err = USB_SUCCESS;
190
191	DPRINTF(2, (CE_CONT, "!%s: %s: called", dp->name, __func__));
192
193	OUTB(dp, NCR, NCR_LBK_NORMAL | NCR_RST, &err, usberr);
194	drv_usecwait(100);
195usberr:
196	return (err);
197}
198
199/*
200 * Setup dm9601
201 */
202static int
203udmf_init_chip(struct usbgem_dev *dp)
204{
205	int		i;
206	uint32_t	val;
207	int		err = USB_SUCCESS;
208	uint16_t	reg;
209	uint8_t		buf[2];
210	struct udmf_dev	*lp = dp->private;
211
212	DPRINTF(2, (CE_CONT, "!%s: %s: called", dp->name, __func__));
213
214	OUTB(dp, NCR, NCR_LBK_NORMAL, &err, usberr);
215
216	/* tx control regiser: enable padding and crc generation */
217	OUTB(dp, TCR, 0, &err, usberr);
218
219	/* rx control register: will be set later by udmf_set_rx_filer() */
220	lp->rcr = RCR_RUNT;
221
222	/* back pressure threshold: */
223	OUTB(dp, BPTR, (2 << BPTR_BPHW_SHIFT) | BPTR_JPT_200us,
224	    &err, usberr);
225
226	/* flow control threshold: same as default */
227	OUTB(dp, FCTR, (3 << FCTR_HWOT_SHIFT) | (8 << FCTR_LWOT_SHIFT),
228	    &err, usberr);
229
230	/* usb control register */
231	OUTB(dp, USBC, USBC_EP3ACK | 0x06, &err, usberr);
232
233	/* flow control: will be set later by udmf_set_media() */
234
235	/* wake up control register: */
236	OUTB(dp, WCR, 0, &err, usberr);
237
238usberr:
239	DPRINTF(2, (CE_CONT, "!%s: %s: end err:%d(%s)",
240	    dp->name, __func__,
241	    err, err == USB_SUCCESS ? "success" : "error"));
242	return (err);
243}
244
245static int
246udmf_start_chip(struct usbgem_dev *dp)
247{
248	int	err = USB_SUCCESS;
249	struct udmf_dev	*lp = dp->private;
250
251	/* enable Rx */
252	lp->rcr |= RCR_RXEN;
253	OUTB(dp, RCR, lp->rcr, &err, usberr);
254
255usberr:
256	DPRINTF(2, (CE_CONT, "!%s: %s: end err:%d(%s)",
257	    dp->name, __func__,
258	    err, err == USB_SUCCESS ? "success" : "error"));
259	return (err);
260}
261
262static int
263udmf_stop_chip(struct usbgem_dev *dp)
264{
265	int	err = USB_SUCCESS;
266	struct udmf_dev	*lp = dp->private;
267
268	/* disable rx */
269	lp->rcr &= ~RCR_RXEN;
270	OUTB(dp, RCR, lp->rcr, &err, usberr);
271
272usberr:
273	DPRINTF(2, (CE_CONT, "!%s: %s: end err:%d(%s)",
274	    dp->name, __func__,
275	    err, err == USB_SUCCESS ? "success" : "error"));
276	return (err);
277}
278
279static int
280udmf_get_stats(struct usbgem_dev *dp)
281{
282	/* empty */
283	return (USB_SUCCESS);
284}
285
286static uint_t
287udmf_mcast_hash(struct usbgem_dev *dp, const uint8_t *addr)
288{
289	return (usbgem_ether_crc_le(addr) & 0x3f);
290}
291
292static int
293udmf_set_rx_filter(struct usbgem_dev *dp)
294{
295	int		i;
296	uint8_t		rcr;
297	uint8_t		mode;
298	uint8_t		mhash[8];
299	uint8_t		*mac;
300	uint_t		h;
301	int		err = USB_SUCCESS;
302	struct udmf_dev	*lp = dp->private;
303	static uint8_t	invalid_mac[ETHERADDRL] = {0, 0, 0, 0, 0, 0};
304
305	DPRINTF(2, (CE_CONT, "!%s: %s: called, rxmode:%x",
306	    dp->name, __func__, dp->rxmode));
307
308	if (lp->rcr & RCR_RXEN) {
309		/* set promiscuous mode before changing rx filter mode */
310		OUTB(dp, RCR, lp->rcr | RCR_PRMSC, &err, usberr);
311	}
312
313	lp->rcr &= ~(RCR_ALL | RCR_PRMSC);
314	mode = 0;
315	bzero(mhash, sizeof (mhash));
316	mac = dp->cur_addr.ether_addr_octet;
317
318	if ((dp->rxmode & RXMODE_ENABLE) == 0) {
319		mac = invalid_mac;
320	} else if (dp->rxmode & RXMODE_PROMISC) {
321		/* promiscious mode implies all multicast and all physical */
322		mode |= RCR_PRMSC;
323	} else if ((dp->rxmode & RXMODE_ALLMULTI) || dp->mc_count > 32) {
324		/* accept all multicast packets */
325		mode |= RCR_ALL;
326	} else if (dp->mc_count > 0) {
327		/*
328		 * make hash table to select interresting
329		 * multicast address only.
330		 */
331		for (i = 0; i < dp->mc_count; i++) {
332			/* hash table is 64 = 2^6 bit width */
333			h = dp->mc_list[i].hash;
334			mhash[h / 8] |= 1 << (h % 8);
335		}
336	}
337
338	/* set node address */
339	if (bcmp(mac, lp->mac_addr, ETHERADDRL) != 0) {
340		OUT(dp, PAR, ETHERADDRL, dp->cur_addr.ether_addr_octet,
341		    &err, usberr);
342		bcopy(mac, lp->mac_addr, ETHERADDRL);
343	}
344
345	/* set multicast hash table */
346	OUT(dp, MAR, sizeof (mhash), &mhash[0], &err, usberr);
347
348	/* update rcr */
349	lp->rcr |= mode;
350	OUTB(dp, RCR, lp->rcr, &err, usberr);
351
352#if DEBUG_LEVEL > 1
353	/* verify rcr */
354	IN(dp, RCR, 1, &rcr, &err, usberr);
355	cmn_err(CE_CONT, "!%s: %s: rcr:%b returned",
356	    dp->name, __func__, rcr, RCR_BITS);
357#endif
358usberr:
359	DPRINTF(2, (CE_CONT, "!%s: %s: end err:%d(%s)",
360	    dp->name, __func__,
361	    err, err == USB_SUCCESS ? "success" : "error"));
362	return (err);
363}
364
365static int
366udmf_set_media(struct usbgem_dev *dp)
367{
368	int	err = USB_SUCCESS;
369	uint8_t	fcr;
370	struct udmf_dev	*lp = dp->private;
371
372	DPRINTF(0, (CE_CONT, "!%s: %s: called", dp->name, __func__));
373
374	/* setup flow control */
375	fcr = 0;
376	if (dp->full_duplex) {
377		/* select flow control */
378		switch (dp->flow_control) {
379		case FLOW_CONTROL_RX_PAUSE:
380			fcr |= FCR_FLCE;
381			break;
382
383		case FLOW_CONTROL_TX_PAUSE:
384			fcr |= FCR_TXPEN;
385			break;
386
387		case FLOW_CONTROL_SYMMETRIC:
388			fcr |= FCR_FLCE | FCR_TXPEN;
389			break;
390		}
391	}
392
393	/* update flow control register */
394	OUTB(dp, FCR, fcr, &err, usberr);
395
396usberr:
397	DPRINTF(2, (CE_CONT, "!%s: %s: end err:%d(%s)",
398	    dp->name, __func__,
399	    err, err == USB_SUCCESS ? "success" : "error"));
400	return (err);
401}
402
403/*
404 * send/receive packet check
405 */
406static mblk_t *
407udmf_tx_make_packet(struct usbgem_dev *dp, mblk_t *mp)
408{
409	int		n;
410	size_t		pkt_size;
411	mblk_t		*new;
412	mblk_t		*tp;
413	uint8_t		*bp;
414	uint8_t		*last_pos;
415	uint_t		align_mask;
416
417	pkt_size = msgdsize(mp);
418	align_mask = 63;
419
420	/*
421	 * re-allocate the mp
422	 */
423
424	/* minimum ethernet packet size of ETHERMIN */
425	pkt_size = max(pkt_size, ETHERMIN);
426
427#if 0 /* CONFIG_ADD_TX_DELIMITOR_ALWAYS */
428	pkt_size += TX_HEADER_SIZE;
429#endif
430	if (((pkt_size + TX_HEADER_SIZE) & align_mask) == 0) {
431		/* padding is required in usb communication */
432		pkt_size += TX_HEADER_SIZE;
433	}
434
435	if ((new = allocb(TX_HEADER_SIZE + pkt_size, 0)) == NULL) {
436		return (NULL);
437	}
438	new->b_wptr = new->b_rptr + TX_HEADER_SIZE + pkt_size;
439
440	/* add a header */
441	bp = new->b_rptr;
442	bp[0] = (uint8_t)pkt_size;
443	bp[1] = (uint8_t)(pkt_size >> 8);
444	bp += TX_HEADER_SIZE;
445
446	/* copy contents of the buffer */
447	for (tp = mp; tp; tp = tp->b_cont) {
448		n = MBLKL(tp);
449		bcopy(tp->b_rptr, bp, n);
450		bp += n;
451	}
452
453	/* clear the rest including the next zero length header */
454	last_pos = new->b_wptr;
455	while (bp < last_pos) {
456		*bp++ = 0;
457	}
458
459	return (new);
460}
461
462static void
463udmf_dump_packet(struct usbgem_dev *dp, uint8_t *bp, int n)
464{
465	int	i;
466
467	for (i = 0; i < n; i += 8, bp += 8) {
468		cmn_err(CE_CONT, "%02x %02x %02x %02x %02x %02x %02x %02x",
469		    bp[0], bp[1], bp[2], bp[3], bp[4], bp[5], bp[6], bp[7]);
470	}
471}
472
473static mblk_t *
474udmf_rx_make_packet(struct usbgem_dev *dp, mblk_t *mp)
475{
476	size_t len;
477	uint8_t	rx_stat;
478
479	len = MBLKL(mp);
480
481	if (len <= RX_HEADER_SIZE) {
482		/*
483		 * the usb bulk-in frame doesn't include a valid
484		 * ethernet packet.
485		 */
486		return (NULL);
487	}
488
489	/* remove rx header */
490	rx_stat = mp->b_rptr[0];
491	if (rx_stat & (RSR_RF |  RSR_LCS | RSR_RWTO |
492	    RSR_PLE | RSR_AE | RSR_CE |  RSR_FOE)) {
493		if (rx_stat & RSR_RF) {
494			dp->stats.runt++;
495		}
496		if (rx_stat & RSR_LCS) {
497			/* late collision */
498			dp->stats.rcv_internal_err++;
499		}
500		if (rx_stat & RSR_RWTO) {
501			/* rx timeout */
502			dp->stats.rcv_internal_err++;
503		}
504		if (rx_stat & RSR_PLE) {
505			/* physical layer error */
506			dp->stats.rcv_internal_err++;
507		}
508		if (rx_stat & RSR_AE) {
509			/* alignment error */
510			dp->stats.frame++;
511		}
512		if (rx_stat & RSR_CE) {
513			/* crc error */
514			dp->stats.crc++;
515		}
516		if (rx_stat & RSR_FOE) {
517			/* fifo overflow error */
518			dp->stats.overflow++;
519		}
520		dp->stats.errrcv++;
521	}
522	len = LE16P(&mp->b_rptr[1]);
523	if (len >= ETHERFCSL) {
524		len -= ETHERFCSL;
525	}
526	mp->b_rptr += RX_HEADER_SIZE;
527	mp->b_wptr = mp->b_rptr + len;
528
529	return (mp);
530}
531
532/*
533 * MII Interfaces
534 */
535static uint16_t
536udmf_ep_read(struct usbgem_dev *dp, uint_t which, uint_t addr, int *errp)
537{
538	int	i;
539	uint8_t	epcr;
540	uint16_t	val;
541
542	DPRINTF(4, (CE_CONT, "!%s: %s: called, ix:%d",
543	    dp->name, __func__, addr));
544
545	OUTB(dp, EPAR, addr, errp, usberr);
546	OUTB(dp, EPCR, which | EPCR_ERPRR, errp, usberr);
547
548	for (i = 0; i < 100; i++) {
549		IN(dp, EPCR, sizeof (epcr), &epcr, errp, usberr);
550		if ((epcr & EPCR_ERRE) == 0) {
551			/* done */
552			IN(dp, EPDR, sizeof (val), &val, errp, usberr);
553			val = LE_16(val);
554			goto done;
555		}
556		drv_usecwait(10);
557	}
558	/* timeout */
559	cmn_err(CE_WARN, "!%s: %s: timeout", dp->name, __func__);
560	val = 0;
561done:
562	OUTB(dp, EPCR, 0, errp, usberr);
563	return (val);
564
565usberr:
566	DPRINTF(2, (CE_CONT, "!%s: %s: end err:%d(%s)",
567	    dp->name, __func__,
568	    *errp, *errp == USB_SUCCESS ? "success" : "error"));
569	return (0);
570}
571
572static void
573udmf_ep_write(struct usbgem_dev *dp, uint_t which, uint_t addr,
574    uint16_t val, int *errp)
575{
576	int	i;
577	uint8_t	epcr;
578
579	DPRINTF(5, (CE_CONT, "!%s: %s called", dp->name, __func__));
580
581	val = LE_16(val);
582	OUT(dp, EPDR, sizeof (val), &val, errp, usberr);
583
584	OUTB(dp, EPAR, addr, errp, usberr);
585
586	OUTB(dp, EPCR, which | EPCR_WEP | EPCR_ERPRW, errp, usberr);
587
588	for (i = 0; i < 100; i++) {
589		IN(dp, EPCR, 1, &epcr, errp, usberr);
590		if ((epcr & EPCR_ERRE) == 0) {
591			/* done */
592			goto done;
593		}
594		drv_usecwait(10);
595	}
596	/* timeout */
597	cmn_err(CE_WARN, "!%s: %s: timeout", dp->name, __func__);
598done:
599	OUTB(dp, EPCR, 0, errp, usberr);
600	return;
601
602usberr:
603	DPRINTF(2, (CE_CONT, "!%s: %s: end err:%d(%s)",
604	    dp->name, __func__,
605	    *errp, *errp == USB_SUCCESS ? "success" : "error"));
606}
607
608static uint16_t
609udmf_mii_read(struct usbgem_dev *dp, uint_t index, int *errp)
610{
611	uint16_t	val;
612
613	val = udmf_ep_read(dp, EPCR_EPOS,
614	    (dp->mii_phy_addr << EPAR_PHYADR_SHIFT) | index, errp);
615
616	return (val);
617}
618
619static void
620udmf_mii_write(struct usbgem_dev *dp, uint_t index, uint16_t val, int *errp)
621{
622	udmf_ep_write(dp, EPCR_EPOS,
623	    (dp->mii_phy_addr << EPAR_PHYADR_SHIFT) | index, val, errp);
624}
625
626static void
627udmf_interrupt(struct usbgem_dev *dp, mblk_t *mp)
628{
629	struct intr_msg	*imp;
630	struct udmf_dev	*lp = dp->private;
631
632	imp = (struct intr_msg *)&mp->b_rptr[0];
633
634	DPRINTF(4, (CE_CONT,
635	    "!%s: %s: size:%d, nsr:%b tsr1:%b tsr2:%b"
636	    " rsr:%b rocr:%b rxc:%02x txc:%b gpr:%b",
637	    dp->name, __func__, mp->b_wptr - mp->b_rptr,
638	    imp->im_nsr, NSR_BITS,
639	    imp->im_tsr1, TSR_BITS,
640	    imp->im_tsr2, TSR_BITS,
641	    imp->im_rsr, RSR_BITS,
642	    imp->im_rocr, ROCR_BITS,
643	    imp->im_rxc,
644	    imp->im_txc, TUSR_BITS,
645	    imp->im_gpr, GPR_BITS));
646
647	if ((lp->last_nsr ^ imp->im_nsr) & NSR_LINKST) {
648		usbgem_mii_update_link(dp);
649	}
650
651	lp->last_nsr = imp->im_nsr;
652}
653
654/* ======================================================== */
655/*
656 * OS depend (device driver DKI) routine
657 */
658/* ======================================================== */
659static uint16_t
660udmf_eeprom_read(struct usbgem_dev *dp, uint_t index, int *errp)
661{
662	uint16_t	val;
663
664	val = udmf_ep_read(dp, 0, index, errp);
665
666	return (val);
667}
668
669#ifdef DEBUG_LEVEL
670static void
671udmf_eeprom_dump(struct usbgem_dev *dp, int size)
672{
673	int	i;
674	int	err;
675	uint16_t	w0, w1, w2, w3;
676
677	cmn_err(CE_CONT, "!%s: eeprom dump:", dp->name);
678
679	err = USB_SUCCESS;
680
681	for (i = 0; i < size; i += 4) {
682		w0 = udmf_eeprom_read(dp, i + 0, &err);
683		w1 = udmf_eeprom_read(dp, i + 1, &err);
684		w2 = udmf_eeprom_read(dp, i + 2, &err);
685		w3 = udmf_eeprom_read(dp, i + 3, &err);
686		cmn_err(CE_CONT, "!0x%02x: 0x%04x 0x%04x 0x%04x 0x%04x",
687		    i, w0, w1, w2, w3);
688	}
689usberr:
690	;
691}
692#endif
693
694static int
695udmf_attach_chip(struct usbgem_dev *dp)
696{
697	int	i;
698	uint_t	val;
699	uint8_t	*m;
700	int	err;
701	struct udmf_dev	*lp = dp->private;
702
703	DPRINTF(0, (CE_CONT, "!%s: %s enter", dp->name, __func__));
704
705	/*
706	 * get mac address from EEPROM
707	 */
708	m = dp->dev_addr.ether_addr_octet;
709	for (i = 0; i < ETHERADDRL; i += 2)  {
710		val = udmf_eeprom_read(dp, i/2, &err);
711		m[i + 0] = (uint8_t)val;
712		m[i + 1] = (uint8_t)(val >> 8);
713	}
714
715	/* invalidate a private cache for mac addr */
716	bzero(lp->mac_addr, sizeof (lp->mac_addr));
717#ifdef CONFIG_VLAN
718	dp->misc_flag = USBGEM_VLAN;
719#endif
720#if DEBUG_LEVEL > 0
721	udmf_eeprom_dump(dp, /* 0x3f + 1 */ 128);
722#endif
723{
724	static uint8_t bcst[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
725	DPRINTF(0, (CE_CONT, "!%s: %s: hash of bcast:%x",
726	    dp->name, __func__, usbgem_ether_crc_be(bcst)));
727}
728	return (USB_SUCCESS);
729
730usberr:
731	cmn_err(CE_WARN, "%s: %s: usb error detected (%d)",
732	    dp->name, __func__, err);
733	return (USB_FAILURE);
734}
735
736static int
737udmf_mii_probe(struct usbgem_dev *dp)
738{
739	DPRINTF(2, (CE_CONT, "!%s: %s: called", dp->name, __func__));
740
741	udmf_enable_phy(dp);
742	return (usbgem_mii_probe_default(dp));
743}
744
745static int
746udmf_mii_init(struct usbgem_dev *dp)
747{
748	DPRINTF(2, (CE_CONT, "!%s: %s: called", dp->name, __func__));
749	udmf_enable_phy(dp);
750	return (USB_SUCCESS);
751}
752
753static int
754udmfattach(dev_info_t *dip, ddi_attach_cmd_t cmd)
755{
756	int			i;
757	ddi_iblock_cookie_t	c;
758	int			ret;
759	int			revid;
760	int			unit;
761	int			len;
762	const char		*drv_name;
763	struct usbgem_dev	*dp;
764	void			*base;
765	struct usbgem_conf	*ugcp;
766	struct udmf_dev		*lp;
767
768	unit = ddi_get_instance(dip);
769	drv_name = ddi_driver_name(dip);
770
771	DPRINTF(3, (CE_CONT, "!%s%d: %s: called, cmd:%d",
772	    drv_name, unit, __func__, cmd));
773
774	if (cmd == DDI_ATTACH) {
775		/*
776		 * construct usbgem configration
777		 */
778		ugcp = kmem_zalloc(sizeof (*ugcp), KM_SLEEP);
779
780		/* name */
781		/*
782		 * softmac requires that ppa is the instance number
783		 * of the device, otherwise it hangs in seaching the device.
784		 */
785		(void) sprintf(ugcp->usbgc_name, "%s%d", drv_name, unit);
786		ugcp->usbgc_ppa = unit;
787
788		ugcp->usbgc_ifnum = 0;
789		ugcp->usbgc_alt = 0;
790
791		ugcp->usbgc_tx_list_max = 64;
792
793		ugcp->usbgc_rx_header_len = RX_HEADER_SIZE;
794		ugcp->usbgc_rx_list_max = 64;
795
796		/* time out parameters */
797		ugcp->usbgc_tx_timeout = USBGEM_TX_TIMEOUT;
798		ugcp->usbgc_tx_timeout_interval = USBGEM_TX_TIMEOUT_INTERVAL;
799#if 1
800		/* flow control */
801		ugcp->usbgc_flow_control = FLOW_CONTROL_RX_PAUSE;
802#else
803		/*
804		 * XXX - flow control caused link down frequently under
805		 * heavy traffic
806		 */
807		ugcp->usbgc_flow_control = FLOW_CONTROL_NONE;
808#endif
809		/* MII timeout parameters */
810		ugcp->usbgc_mii_link_watch_interval =
811		    USBGEM_LINK_WATCH_INTERVAL;
812		ugcp->usbgc_mii_an_watch_interval =
813		    USBGEM_LINK_WATCH_INTERVAL/5;
814		ugcp->usbgc_mii_reset_timeout = MII_RESET_TIMEOUT; /* 1 sec */
815		ugcp->usbgc_mii_an_timeout = MII_AN_TIMEOUT;	/* 5 sec */
816		ugcp->usbgc_mii_an_wait = (25*ONESEC)/10;
817		ugcp->usbgc_mii_linkdown_timeout = MII_LINKDOWN_TIMEOUT;
818
819		ugcp->usbgc_mii_an_delay = ONESEC/10;
820		ugcp->usbgc_mii_linkdown_action = MII_ACTION_RSA;
821		ugcp->usbgc_mii_linkdown_timeout_action = MII_ACTION_RESET;
822		ugcp->usbgc_mii_dont_reset = B_FALSE;
823		ugcp->usbgc_mii_hw_link_detection = B_TRUE;
824
825		/* I/O methods */
826
827		/* mac operation */
828		ugcp->usbgc_attach_chip = &udmf_attach_chip;
829		ugcp->usbgc_reset_chip = &udmf_reset_chip;
830		ugcp->usbgc_init_chip = &udmf_init_chip;
831		ugcp->usbgc_start_chip = &udmf_start_chip;
832		ugcp->usbgc_stop_chip = &udmf_stop_chip;
833		ugcp->usbgc_multicast_hash = &udmf_mcast_hash;
834
835		ugcp->usbgc_set_rx_filter = &udmf_set_rx_filter;
836		ugcp->usbgc_set_media = &udmf_set_media;
837		ugcp->usbgc_get_stats = &udmf_get_stats;
838		ugcp->usbgc_interrupt = &udmf_interrupt;
839
840		/* packet operation */
841		ugcp->usbgc_tx_make_packet = &udmf_tx_make_packet;
842		ugcp->usbgc_rx_make_packet = &udmf_rx_make_packet;
843
844		/* mii operations */
845		ugcp->usbgc_mii_probe = &udmf_mii_probe;
846		ugcp->usbgc_mii_init = &udmf_mii_init;
847		ugcp->usbgc_mii_config = &usbgem_mii_config_default;
848		ugcp->usbgc_mii_read = &udmf_mii_read;
849		ugcp->usbgc_mii_write = &udmf_mii_write;
850		ugcp->usbgc_mii_addr_min = 1;
851
852		/* mtu */
853		ugcp->usbgc_min_mtu = ETHERMTU;
854		ugcp->usbgc_max_mtu = ETHERMTU;
855		ugcp->usbgc_default_mtu = ETHERMTU;
856
857		lp = kmem_zalloc(sizeof (struct udmf_dev), KM_SLEEP);
858
859		ddi_set_driver_private(dip, NULL);
860
861		dp = usbgem_do_attach(dip, ugcp, lp, sizeof (struct udmf_dev));
862
863		kmem_free(ugcp, sizeof (*ugcp));
864
865		if (dp != NULL) {
866			return (DDI_SUCCESS);
867		}
868
869err_free_mem:
870		kmem_free(lp, sizeof (struct udmf_dev));
871err_close_pipe:
872err:
873		return (DDI_FAILURE);
874	}
875
876	if (cmd == DDI_RESUME) {
877		return (usbgem_resume(dip));
878	}
879
880	return (DDI_FAILURE);
881}
882
883static int
884udmfdetach(dev_info_t *dip, ddi_detach_cmd_t cmd)
885{
886	int	ret;
887
888	if (cmd == DDI_DETACH) {
889		ret = usbgem_do_detach(dip);
890		if (ret != DDI_SUCCESS) {
891			return (DDI_FAILURE);
892		}
893		return (DDI_SUCCESS);
894	}
895	if (cmd == DDI_SUSPEND) {
896		return (usbgem_suspend(dip));
897	}
898	return (DDI_FAILURE);
899}
900
901/* ======================================================== */
902/*
903 * OS depend (loadable streams driver) routine
904 */
905/* ======================================================== */
906#ifdef USBGEM_CONFIG_GLDv3
907USBGEM_STREAM_OPS(udmf_ops, udmfattach, udmfdetach);
908#else
909static	struct module_info udmfminfo = {
910	0,			/* mi_idnum */
911	"udmf",			/* mi_idname */
912	0,			/* mi_minpsz */
913	ETHERMTU,		/* mi_maxpsz */
914	ETHERMTU*128,		/* mi_hiwat */
915	1,			/* mi_lowat */
916};
917
918static	struct qinit udmfrinit = {
919	(int (*)()) NULL,	/* qi_putp */
920	usbgem_rsrv,		/* qi_srvp */
921	usbgem_open,		/* qi_qopen */
922	usbgem_close,		/* qi_qclose */
923	(int (*)()) NULL,	/* qi_qadmin */
924	&udmfminfo,		/* qi_minfo */
925	NULL			/* qi_mstat */
926};
927
928static	struct qinit udmfwinit = {
929	usbgem_wput,		/* qi_putp */
930	usbgem_wsrv,		/* qi_srvp */
931	(int (*)()) NULL,	/* qi_qopen */
932	(int (*)()) NULL,	/* qi_qclose */
933	(int (*)()) NULL,	/* qi_qadmin */
934	&udmfminfo,		/* qi_minfo */
935	NULL			/* qi_mstat */
936};
937
938static struct streamtab	udmf_info = {
939	&udmfrinit,	/* st_rdinit */
940	&udmfwinit,	/* st_wrinit */
941	NULL,		/* st_muxrinit */
942	NULL		/* st_muxwrinit */
943};
944
945static	struct cb_ops cb_udmf_ops = {
946	nulldev,	/* cb_open */
947	nulldev,	/* cb_close */
948	nodev,		/* cb_strategy */
949	nodev,		/* cb_print */
950	nodev,		/* cb_dump */
951	nodev,		/* cb_read */
952	nodev,		/* cb_write */
953	nodev,		/* cb_ioctl */
954	nodev,		/* cb_devmap */
955	nodev,		/* cb_mmap */
956	nodev,		/* cb_segmap */
957	nochpoll,	/* cb_chpoll */
958	ddi_prop_op,	/* cb_prop_op */
959	&udmf_info,	/* cb_stream */
960	D_NEW|D_MP	/* cb_flag */
961};
962
963static	struct dev_ops udmf_ops = {
964	DEVO_REV,	/* devo_rev */
965	0,		/* devo_refcnt */
966	usbgem_getinfo,	/* devo_getinfo */
967	nulldev,	/* devo_identify */
968	nulldev,	/* devo_probe */
969	udmfattach,	/* devo_attach */
970	udmfdetach,	/* devo_detach */
971	nodev,		/* devo_reset */
972	&cb_udmf_ops,	/* devo_cb_ops */
973	NULL,		/* devo_bus_ops */
974	usbgem_power,   /* devo_power */
975#if DEVO_REV >= 4
976	usbgem_quiesce, /* devo_quiesce */
977#endif
978};
979#endif
980
981static struct modldrv modldrv = {
982	&mod_driverops,	/* Type of module.  This one is a driver */
983	ident,
984	&udmf_ops,	/* driver ops */
985};
986
987static struct modlinkage modlinkage = {
988	MODREV_1, &modldrv, NULL
989};
990
991/* ======================================================== */
992/*
993 * _init : done
994 */
995/* ======================================================== */
996int
997_init(void)
998{
999	int 	status;
1000
1001	DPRINTF(2, (CE_CONT, "!udmf: _init: called"));
1002
1003	status = usbgem_mod_init(&udmf_ops, "udmf");
1004	if (status != DDI_SUCCESS) {
1005		return (status);
1006	}
1007	status = mod_install(&modlinkage);
1008	if (status != DDI_SUCCESS) {
1009		usbgem_mod_fini(&udmf_ops);
1010	}
1011	return (status);
1012}
1013
1014/*
1015 * _fini : done
1016 */
1017int
1018_fini(void)
1019{
1020	int	status;
1021
1022	DPRINTF(2, (CE_CONT, "!udmf: _fini: called"));
1023	status = mod_remove(&modlinkage);
1024	if (status == DDI_SUCCESS) {
1025		usbgem_mod_fini(&udmf_ops);
1026	}
1027	return (status);
1028}
1029
1030int
1031_info(struct modinfo *modinfop)
1032{
1033	return (mod_info(&modlinkage, modinfop));
1034}
1035