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
73 char 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
85 static 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 */
100 struct 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 */
114 static uint16_t udmf_mii_read(struct usbgem_dev *, uint_t, int *errp);
115 static void udmf_mii_write(struct usbgem_dev *, uint_t, uint16_t, int *errp);
116
117 /* nic operations */
118 static int udmf_reset_chip(struct usbgem_dev *);
119 static int udmf_init_chip(struct usbgem_dev *);
120 static int udmf_start_chip(struct usbgem_dev *);
121 static int udmf_stop_chip(struct usbgem_dev *);
122 static int udmf_set_media(struct usbgem_dev *);
123 static int udmf_set_rx_filter(struct usbgem_dev *);
124 static int udmf_get_stats(struct usbgem_dev *);
125 static void udmf_interrupt(struct usbgem_dev *, mblk_t *);
126
127 /* packet operations */
128 static mblk_t *udmf_tx_make_packet(struct usbgem_dev *, mblk_t *);
129 static 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 /* =============================================================== */
174 static void
udmf_enable_phy(struct usbgem_dev * dp)175 udmf_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);
182 usberr:
183 ;
184 }
185
186 static int
udmf_reset_chip(struct usbgem_dev * dp)187 udmf_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);
195 usberr:
196 return (err);
197 }
198
199 /*
200 * Setup dm9601
201 */
202 static int
udmf_init_chip(struct usbgem_dev * dp)203 udmf_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
238 usberr:
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
245 static int
udmf_start_chip(struct usbgem_dev * dp)246 udmf_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
255 usberr:
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
262 static int
udmf_stop_chip(struct usbgem_dev * dp)263 udmf_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
272 usberr:
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
279 static int
udmf_get_stats(struct usbgem_dev * dp)280 udmf_get_stats(struct usbgem_dev *dp)
281 {
282 /* empty */
283 return (USB_SUCCESS);
284 }
285
286 static uint_t
udmf_mcast_hash(struct usbgem_dev * dp,const uint8_t * addr)287 udmf_mcast_hash(struct usbgem_dev *dp, const uint8_t *addr)
288 {
289 return (usbgem_ether_crc_le(addr) & 0x3f);
290 }
291
292 static int
udmf_set_rx_filter(struct usbgem_dev * dp)293 udmf_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
358 usberr:
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
365 static int
udmf_set_media(struct usbgem_dev * dp)366 udmf_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
396 usberr:
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 */
406 static mblk_t *
udmf_tx_make_packet(struct usbgem_dev * dp,mblk_t * mp)407 udmf_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
462 static void
udmf_dump_packet(struct usbgem_dev * dp,uint8_t * bp,int n)463 udmf_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
473 static mblk_t *
udmf_rx_make_packet(struct usbgem_dev * dp,mblk_t * mp)474 udmf_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 */
535 static uint16_t
udmf_ep_read(struct usbgem_dev * dp,uint_t which,uint_t addr,int * errp)536 udmf_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;
561 done:
562 OUTB(dp, EPCR, 0, errp, usberr);
563 return (val);
564
565 usberr:
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
572 static void
udmf_ep_write(struct usbgem_dev * dp,uint_t which,uint_t addr,uint16_t val,int * errp)573 udmf_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__);
598 done:
599 OUTB(dp, EPCR, 0, errp, usberr);
600 return;
601
602 usberr:
603 DPRINTF(2, (CE_CONT, "!%s: %s: end err:%d(%s)",
604 dp->name, __func__,
605 *errp, *errp == USB_SUCCESS ? "success" : "error"));
606 }
607
608 static uint16_t
udmf_mii_read(struct usbgem_dev * dp,uint_t index,int * errp)609 udmf_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
619 static void
udmf_mii_write(struct usbgem_dev * dp,uint_t index,uint16_t val,int * errp)620 udmf_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
626 static void
udmf_interrupt(struct usbgem_dev * dp,mblk_t * mp)627 udmf_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 /* ======================================================== */
659 static uint16_t
udmf_eeprom_read(struct usbgem_dev * dp,uint_t index,int * errp)660 udmf_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
670 static void
udmf_eeprom_dump(struct usbgem_dev * dp,int size)671 udmf_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 }
689 usberr:
690 ;
691 }
692 #endif
693
694 static int
udmf_attach_chip(struct usbgem_dev * dp)695 udmf_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 }
730
731 static int
udmf_mii_probe(struct usbgem_dev * dp)732 udmf_mii_probe(struct usbgem_dev *dp)
733 {
734 DPRINTF(2, (CE_CONT, "!%s: %s: called", dp->name, __func__));
735
736 udmf_enable_phy(dp);
737 return (usbgem_mii_probe_default(dp));
738 }
739
740 static int
udmf_mii_init(struct usbgem_dev * dp)741 udmf_mii_init(struct usbgem_dev *dp)
742 {
743 DPRINTF(2, (CE_CONT, "!%s: %s: called", dp->name, __func__));
744 udmf_enable_phy(dp);
745 return (USB_SUCCESS);
746 }
747
748 static int
udmfattach(dev_info_t * dip,ddi_attach_cmd_t cmd)749 udmfattach(dev_info_t *dip, ddi_attach_cmd_t cmd)
750 {
751 int i;
752 ddi_iblock_cookie_t c;
753 int ret;
754 int revid;
755 int unit;
756 int len;
757 const char *drv_name;
758 struct usbgem_dev *dp;
759 void *base;
760 struct usbgem_conf *ugcp;
761 struct udmf_dev *lp;
762
763 unit = ddi_get_instance(dip);
764 drv_name = ddi_driver_name(dip);
765
766 DPRINTF(3, (CE_CONT, "!%s%d: %s: called, cmd:%d",
767 drv_name, unit, __func__, cmd));
768
769 if (cmd == DDI_ATTACH) {
770 /*
771 * construct usbgem configration
772 */
773 ugcp = kmem_zalloc(sizeof (*ugcp), KM_SLEEP);
774
775 /* name */
776 /*
777 * softmac requires that ppa is the instance number
778 * of the device, otherwise it hangs in seaching the device.
779 */
780 (void) sprintf(ugcp->usbgc_name, "%s%d", drv_name, unit);
781 ugcp->usbgc_ppa = unit;
782
783 ugcp->usbgc_ifnum = 0;
784 ugcp->usbgc_alt = 0;
785
786 ugcp->usbgc_tx_list_max = 64;
787
788 ugcp->usbgc_rx_header_len = RX_HEADER_SIZE;
789 ugcp->usbgc_rx_list_max = 64;
790
791 /* time out parameters */
792 ugcp->usbgc_tx_timeout = USBGEM_TX_TIMEOUT;
793 ugcp->usbgc_tx_timeout_interval = USBGEM_TX_TIMEOUT_INTERVAL;
794 #if 1
795 /* flow control */
796 ugcp->usbgc_flow_control = FLOW_CONTROL_RX_PAUSE;
797 #else
798 /*
799 * XXX - flow control caused link down frequently under
800 * heavy traffic
801 */
802 ugcp->usbgc_flow_control = FLOW_CONTROL_NONE;
803 #endif
804 /* MII timeout parameters */
805 ugcp->usbgc_mii_link_watch_interval =
806 USBGEM_LINK_WATCH_INTERVAL;
807 ugcp->usbgc_mii_an_watch_interval =
808 USBGEM_LINK_WATCH_INTERVAL/5;
809 ugcp->usbgc_mii_reset_timeout = MII_RESET_TIMEOUT; /* 1 sec */
810 ugcp->usbgc_mii_an_timeout = MII_AN_TIMEOUT; /* 5 sec */
811 ugcp->usbgc_mii_an_wait = (25*ONESEC)/10;
812 ugcp->usbgc_mii_linkdown_timeout = MII_LINKDOWN_TIMEOUT;
813
814 ugcp->usbgc_mii_an_delay = ONESEC/10;
815 ugcp->usbgc_mii_linkdown_action = MII_ACTION_RSA;
816 ugcp->usbgc_mii_linkdown_timeout_action = MII_ACTION_RESET;
817 ugcp->usbgc_mii_dont_reset = B_FALSE;
818 ugcp->usbgc_mii_hw_link_detection = B_TRUE;
819
820 /* I/O methods */
821
822 /* mac operation */
823 ugcp->usbgc_attach_chip = &udmf_attach_chip;
824 ugcp->usbgc_reset_chip = &udmf_reset_chip;
825 ugcp->usbgc_init_chip = &udmf_init_chip;
826 ugcp->usbgc_start_chip = &udmf_start_chip;
827 ugcp->usbgc_stop_chip = &udmf_stop_chip;
828 ugcp->usbgc_multicast_hash = &udmf_mcast_hash;
829
830 ugcp->usbgc_set_rx_filter = &udmf_set_rx_filter;
831 ugcp->usbgc_set_media = &udmf_set_media;
832 ugcp->usbgc_get_stats = &udmf_get_stats;
833 ugcp->usbgc_interrupt = &udmf_interrupt;
834
835 /* packet operation */
836 ugcp->usbgc_tx_make_packet = &udmf_tx_make_packet;
837 ugcp->usbgc_rx_make_packet = &udmf_rx_make_packet;
838
839 /* mii operations */
840 ugcp->usbgc_mii_probe = &udmf_mii_probe;
841 ugcp->usbgc_mii_init = &udmf_mii_init;
842 ugcp->usbgc_mii_config = &usbgem_mii_config_default;
843 ugcp->usbgc_mii_read = &udmf_mii_read;
844 ugcp->usbgc_mii_write = &udmf_mii_write;
845 ugcp->usbgc_mii_addr_min = 1;
846
847 /* mtu */
848 ugcp->usbgc_min_mtu = ETHERMTU;
849 ugcp->usbgc_max_mtu = ETHERMTU;
850 ugcp->usbgc_default_mtu = ETHERMTU;
851
852 lp = kmem_zalloc(sizeof (struct udmf_dev), KM_SLEEP);
853
854 ddi_set_driver_private(dip, NULL);
855
856 dp = usbgem_do_attach(dip, ugcp, lp, sizeof (struct udmf_dev));
857
858 kmem_free(ugcp, sizeof (*ugcp));
859
860 if (dp != NULL) {
861 return (DDI_SUCCESS);
862 }
863
864 kmem_free(lp, sizeof (struct udmf_dev));
865 return (DDI_FAILURE);
866 }
867
868 if (cmd == DDI_RESUME) {
869 return (usbgem_resume(dip));
870 }
871
872 return (DDI_FAILURE);
873 }
874
875 static int
udmfdetach(dev_info_t * dip,ddi_detach_cmd_t cmd)876 udmfdetach(dev_info_t *dip, ddi_detach_cmd_t cmd)
877 {
878 int ret;
879
880 if (cmd == DDI_DETACH) {
881 ret = usbgem_do_detach(dip);
882 if (ret != DDI_SUCCESS) {
883 return (DDI_FAILURE);
884 }
885 return (DDI_SUCCESS);
886 }
887 if (cmd == DDI_SUSPEND) {
888 return (usbgem_suspend(dip));
889 }
890 return (DDI_FAILURE);
891 }
892
893 /* ======================================================== */
894 /*
895 * OS depend (loadable streams driver) routine
896 */
897 /* ======================================================== */
898 USBGEM_STREAM_OPS(udmf_ops, udmfattach, udmfdetach);
899
900 static struct modldrv modldrv = {
901 &mod_driverops, /* Type of module. This one is a driver */
902 ident,
903 &udmf_ops, /* driver ops */
904 };
905
906 static struct modlinkage modlinkage = {
907 MODREV_1, &modldrv, NULL
908 };
909
910 /* ======================================================== */
911 /*
912 * _init : done
913 */
914 /* ======================================================== */
915 int
_init(void)916 _init(void)
917 {
918 int status;
919
920 DPRINTF(2, (CE_CONT, "!udmf: _init: called"));
921
922 status = usbgem_mod_init(&udmf_ops, "udmf");
923 if (status != DDI_SUCCESS) {
924 return (status);
925 }
926 status = mod_install(&modlinkage);
927 if (status != DDI_SUCCESS) {
928 usbgem_mod_fini(&udmf_ops);
929 }
930 return (status);
931 }
932
933 /*
934 * _fini : done
935 */
936 int
_fini(void)937 _fini(void)
938 {
939 int status;
940
941 DPRINTF(2, (CE_CONT, "!udmf: _fini: called"));
942 status = mod_remove(&modlinkage);
943 if (status == DDI_SUCCESS) {
944 usbgem_mod_fini(&udmf_ops);
945 }
946 return (status);
947 }
948
949 int
_info(struct modinfo * modinfop)950 _info(struct modinfo *modinfop)
951 {
952 return (mod_info(&modlinkage, modinfop));
953 }
954