[171] | 1 | /* $OpenBSD: if_mos.c,v 1.7 2009/10/13 19:33:17 pirofti Exp $ */
|
---|
| 2 | #define USB_DEBUG 1
|
---|
| 3 | /*
|
---|
[267] | 4 | * Copyright (c) 2011 Rick van der Zwet <info@rickvanderzwet.nl>
|
---|
[171] | 5 | *
|
---|
| 6 | * Permission to use, copy, modify, and distribute this software for any
|
---|
| 7 | * purpose with or without fee is hereby granted, provided that the above
|
---|
| 8 | * copyright notice and this permission notice appear in all copies.
|
---|
| 9 | *
|
---|
| 10 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
---|
| 11 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
---|
| 12 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
---|
| 13 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
---|
| 14 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
---|
| 15 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
---|
| 16 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
---|
| 17 | */
|
---|
| 18 |
|
---|
| 19 | /*
|
---|
| 20 | * Copyright (c) 2008 Johann Christian Rode <jcrode@gmx.net>
|
---|
| 21 | *
|
---|
| 22 | * Permission to use, copy, modify, and distribute this software for any
|
---|
| 23 | * purpose with or without fee is hereby granted, provided that the above
|
---|
| 24 | * copyright notice and this permission notice appear in all copies.
|
---|
| 25 | *
|
---|
| 26 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
---|
| 27 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
---|
| 28 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
---|
| 29 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
---|
| 30 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
---|
| 31 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
---|
| 32 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
---|
| 33 | */
|
---|
| 34 |
|
---|
| 35 | /*
|
---|
| 36 | * Copyright (c) 2005, 2006, 2007 Jonathan Gray <jsg@openbsd.org>
|
---|
| 37 | *
|
---|
| 38 | * Permission to use, copy, modify, and distribute this software for any
|
---|
| 39 | * purpose with or without fee is hereby granted, provided that the above
|
---|
| 40 | * copyright notice and this permission notice appear in all copies.
|
---|
| 41 | *
|
---|
| 42 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
---|
| 43 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
---|
| 44 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
---|
| 45 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
---|
| 46 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
---|
| 47 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
---|
| 48 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
---|
| 49 | */
|
---|
| 50 |
|
---|
| 51 | /*
|
---|
| 52 | * Copyright (c) 1997, 1998, 1999, 2000-2003
|
---|
| 53 | * Bill Paul <wpaul@windriver.com>. All rights reserved.
|
---|
| 54 | *
|
---|
| 55 | * Redistribution and use in source and binary forms, with or without
|
---|
| 56 | * modification, are permitted provided that the following conditions
|
---|
| 57 | * are met:
|
---|
| 58 | * 1. Redistributions of source code must retain the above copyright
|
---|
| 59 | * notice, this list of conditions and the following disclaimer.
|
---|
| 60 | * 2. Redistributions in binary form must reproduce the above copyright
|
---|
| 61 | * notice, this list of conditions and the following disclaimer in the
|
---|
| 62 | * documentation and/or other materials provided with the distribution.
|
---|
| 63 | * 3. All advertising materials mentioning features or use of this software
|
---|
| 64 | * must display the following acknowledgement:
|
---|
| 65 | * This product includes software developed by Bill Paul.
|
---|
| 66 | * 4. Neither the name of the author nor the names of any co-contributors
|
---|
| 67 | * may be used to endorse or promote products derived from this software
|
---|
| 68 | * without specific prior written permission.
|
---|
| 69 | *
|
---|
| 70 | * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
|
---|
| 71 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
---|
| 72 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
---|
| 73 | * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
|
---|
| 74 | * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
---|
| 75 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
---|
| 76 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
---|
| 77 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
---|
| 78 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
---|
| 79 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
---|
| 80 | * THE POSSIBILITY OF SUCH DAMAGE.
|
---|
| 81 | */
|
---|
| 82 |
|
---|
| 83 | #include <sys/cdefs.h>
|
---|
| 84 |
|
---|
| 85 | /*
|
---|
| 86 | * Moschip MCS7730/MCS7830 USB to Ethernet controller
|
---|
| 87 | * The datasheet is available at the following URL:
|
---|
| 88 | * http://www.moschip.com/data/products/MCS7830/Data%20Sheet_7830.pdf
|
---|
| 89 | */
|
---|
| 90 |
|
---|
| 91 | #include <sys/stdint.h>
|
---|
| 92 | #include <sys/stddef.h>
|
---|
| 93 | #include <sys/param.h>
|
---|
| 94 | #include <sys/queue.h>
|
---|
| 95 | #include <sys/types.h>
|
---|
| 96 | #include <sys/systm.h>
|
---|
| 97 | #include <sys/kernel.h>
|
---|
| 98 | #include <sys/bus.h>
|
---|
| 99 | #include <sys/linker_set.h>
|
---|
| 100 | #include <sys/module.h>
|
---|
| 101 | #include <sys/lock.h>
|
---|
| 102 | #include <sys/mutex.h>
|
---|
| 103 | #include <sys/condvar.h>
|
---|
| 104 | #include <sys/sysctl.h>
|
---|
| 105 | #include <sys/sx.h>
|
---|
| 106 | #include <sys/unistd.h>
|
---|
| 107 | #include <sys/callout.h>
|
---|
| 108 | #include <sys/malloc.h>
|
---|
| 109 | #include <sys/priv.h>
|
---|
| 110 |
|
---|
| 111 | #include <dev/usb/usb.h>
|
---|
| 112 | #include <dev/usb/usbdi.h>
|
---|
| 113 | #include <dev/usb/usbdi_util.h>
|
---|
| 114 | #include "usbdevs.h"
|
---|
| 115 |
|
---|
| 116 | #define USB_DEBUG_VAR mos_debug
|
---|
| 117 | #include <dev/usb/usb_debug.h>
|
---|
| 118 | #include <dev/usb/usb_process.h>
|
---|
| 119 |
|
---|
| 120 | #include <dev/usb/net/usb_ethernet.h>
|
---|
| 121 |
|
---|
| 122 | //#include <dev/usb/net/if_mosreg.h>
|
---|
| 123 | #include "if_mosreg.h"
|
---|
| 124 |
|
---|
| 125 | #ifdef USB_DEBUG
|
---|
| 126 | static int mos_debug = 10;
|
---|
| 127 |
|
---|
| 128 | SYSCTL_NODE(_hw_usb, OID_AUTO, mos, CTLFLAG_RW, 0, "USB mos");
|
---|
| 129 | SYSCTL_INT(_hw_usb_mos, OID_AUTO, debug, CTLFLAG_RW, &mos_debug, 0,
|
---|
| 130 | "Debug level");
|
---|
| 131 | #endif
|
---|
| 132 |
|
---|
| 133 | #define USB_PRODUCT_MOSCHIP_MCS7730 0x7730 /* MCS7730 Ethernet */
|
---|
| 134 | #define USB_PRODUCT_SITECOMEU_LN030 0x0021 /* LN-030 */
|
---|
| 135 |
|
---|
| 136 |
|
---|
| 137 |
|
---|
| 138 | /*
|
---|
| 139 | * Various supported device vendors/products.
|
---|
| 140 | */
|
---|
| 141 | static const struct usb_device_id mos_devs[] = {
|
---|
| 142 | { USB_VPI(USB_VENDOR_MOSCHIP, USB_PRODUCT_MOSCHIP_MCS7730, MCS7730) },
|
---|
| 143 | { USB_VPI(USB_VENDOR_MOSCHIP, USB_PRODUCT_MOSCHIP_MCS7830 , MCS7830) },
|
---|
| 144 | { USB_VPI( USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_LN030 , MCS7830) },
|
---|
| 145 | };
|
---|
| 146 |
|
---|
| 147 | int mos_probe(device_t dev);
|
---|
| 148 | int mos_attach(device_t dev);
|
---|
| 149 | void mos_attach_post(struct usb_ether *ue);
|
---|
| 150 | int mos_detach(device_t dev);
|
---|
| 151 |
|
---|
| 152 | int mos_encap(struct mos_softc *, struct mbuf *, int);
|
---|
| 153 | void mos_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error);
|
---|
| 154 | void mos_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error);
|
---|
| 155 | void mos_intr_callback(struct usb_xfer *xfer, usb_error_t error);
|
---|
| 156 | void mos_tick(struct usb_ether *);
|
---|
| 157 | void mos_start(struct usb_ether *);
|
---|
| 158 | void mos_init(struct usb_ether *);
|
---|
| 159 | void mos_chip_init(struct mos_softc *);
|
---|
| 160 | void mos_stop(struct usb_ether *);
|
---|
| 161 | void mos_watchdog(struct usb_ether *);
|
---|
| 162 | int mos_miibus_readreg(device_t , int, int);
|
---|
| 163 | int mos_miibus_writereg(device_t , int, int, int);
|
---|
| 164 | void mos_miibus_statchg(device_t);
|
---|
| 165 | int mos_ifmedia_upd(struct ifnet *);
|
---|
| 166 | void mos_ifmedia_sts(struct ifnet *, struct ifmediareq *);
|
---|
| 167 | void mos_reset(struct mos_softc *sc);
|
---|
| 168 |
|
---|
| 169 | int mos_reg_read_1(struct mos_softc *, int);
|
---|
| 170 | int mos_reg_read_2(struct mos_softc *, int);
|
---|
| 171 | int mos_reg_write_1(struct mos_softc *, int, int);
|
---|
| 172 | int mos_reg_write_2(struct mos_softc *, int, int);
|
---|
[176] | 173 | int mos_readmac(struct mos_softc *, uint8_t *);
|
---|
[177] | 174 | int mos_writemac(struct mos_softc *, uint8_t *);
|
---|
[171] | 175 | int mos_write_mcast(struct mos_softc *, u_char *);
|
---|
| 176 |
|
---|
| 177 | void mos_setmulti(struct usb_ether *);
|
---|
| 178 |
|
---|
| 179 | static const struct usb_config mos_config[MOS_ENDPT_MAX] = {
|
---|
| 180 |
|
---|
| 181 | [MOS_ENDPT_TX] = {
|
---|
| 182 | .type = UE_BULK,
|
---|
| 183 | .endpoint = UE_ADDR_ANY,
|
---|
| 184 | .direction = UE_DIR_OUT,
|
---|
| 185 | .bufsize = (MCLBYTES + 2),
|
---|
| 186 | .flags = {.pipe_bof = 1,.force_short_xfer = 1,},
|
---|
| 187 | .callback = mos_bulk_write_callback,
|
---|
| 188 | .timeout = 10000, /* 10 seconds */
|
---|
| 189 | },
|
---|
| 190 |
|
---|
| 191 | [MOS_ENDPT_RX] = {
|
---|
| 192 | .type = UE_BULK,
|
---|
| 193 | .endpoint = UE_ADDR_ANY,
|
---|
| 194 | .direction = UE_DIR_IN,
|
---|
| 195 | .bufsize = (MCLBYTES + 4 + ETHER_CRC_LEN),
|
---|
| 196 | .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
|
---|
| 197 | .callback = mos_bulk_read_callback,
|
---|
| 198 | },
|
---|
| 199 |
|
---|
| 200 | [MOS_ENDPT_INTR] = {
|
---|
| 201 | .type = UE_INTERRUPT,
|
---|
| 202 | .endpoint = UE_ADDR_ANY,
|
---|
| 203 | .direction = UE_DIR_IN,
|
---|
| 204 | .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
|
---|
| 205 | .bufsize = 0, /* use wMaxPacketSize */
|
---|
| 206 | .callback = mos_intr_callback,
|
---|
| 207 | },
|
---|
| 208 | };
|
---|
| 209 |
|
---|
| 210 | static device_method_t mos_methods[] = {
|
---|
| 211 | /* Device interface */
|
---|
| 212 | DEVMETHOD(device_probe, mos_probe),
|
---|
| 213 | DEVMETHOD(device_attach, mos_attach),
|
---|
| 214 | DEVMETHOD(device_detach, mos_detach),
|
---|
| 215 |
|
---|
| 216 | /* bus interface */
|
---|
| 217 | DEVMETHOD(bus_print_child, bus_generic_print_child),
|
---|
| 218 | DEVMETHOD(bus_driver_added, bus_generic_driver_added),
|
---|
| 219 |
|
---|
| 220 | /* MII interface */
|
---|
| 221 | DEVMETHOD(miibus_readreg, mos_miibus_readreg),
|
---|
| 222 | DEVMETHOD(miibus_writereg, mos_miibus_writereg),
|
---|
| 223 | DEVMETHOD(miibus_statchg, mos_miibus_statchg),
|
---|
| 224 |
|
---|
| 225 | {0, 0}
|
---|
| 226 | };
|
---|
| 227 |
|
---|
| 228 | static driver_t mos_driver = {
|
---|
| 229 | .name = "mos",
|
---|
| 230 | .methods = mos_methods,
|
---|
| 231 | .size = sizeof(struct mos_softc)
|
---|
| 232 | };
|
---|
| 233 |
|
---|
| 234 | static devclass_t mos_devclass;
|
---|
| 235 |
|
---|
| 236 | DRIVER_MODULE(mos, uhub, mos_driver, mos_devclass, NULL, 0);
|
---|
| 237 | DRIVER_MODULE(miibus, mos, miibus_driver, miibus_devclass, 0, 0);
|
---|
| 238 | MODULE_DEPEND(mos, uether, 1, 1, 1);
|
---|
| 239 | MODULE_DEPEND(mos, usb, 1, 1, 1);
|
---|
| 240 | MODULE_DEPEND(mos, ether, 1, 1, 1);
|
---|
| 241 | MODULE_DEPEND(mos, miibus, 1, 1, 1);
|
---|
| 242 |
|
---|
| 243 | static const struct usb_ether_methods mos_ue_methods = {
|
---|
| 244 | .ue_attach_post = mos_attach_post,
|
---|
| 245 | .ue_start = mos_start,
|
---|
| 246 | .ue_init = mos_init,
|
---|
| 247 | .ue_stop = mos_stop,
|
---|
| 248 | .ue_tick = mos_tick,
|
---|
| 249 | .ue_setmulti = mos_setmulti,
|
---|
| 250 | //.ue_setpromisc = mos_setpromisc,
|
---|
| 251 | .ue_mii_upd = mos_ifmedia_upd,
|
---|
| 252 | .ue_mii_sts = mos_ifmedia_sts,
|
---|
| 253 | };
|
---|
| 254 |
|
---|
| 255 |
|
---|
| 256 | int
|
---|
| 257 | mos_reg_read_1(struct mos_softc *sc, int reg)
|
---|
| 258 | {
|
---|
| 259 | struct usb_device_request req;
|
---|
| 260 | usb_error_t err;
|
---|
| 261 | uByte val = 0;
|
---|
| 262 |
|
---|
| 263 | req.bmRequestType = UT_READ_VENDOR_DEVICE;
|
---|
| 264 | req.bRequest = MOS_UR_READREG;
|
---|
| 265 | USETW(req.wValue, 0);
|
---|
| 266 | USETW(req.wIndex, reg);
|
---|
| 267 | USETW(req.wLength, 1);
|
---|
| 268 |
|
---|
| 269 | err = uether_do_request(&sc->sc_ue, &req, &val, 1000);
|
---|
| 270 |
|
---|
| 271 | if (err) {
|
---|
| 272 | DPRINTF("mos_reg_read_1 error, reg: %d\n", reg);
|
---|
| 273 | return (-1);
|
---|
| 274 | }
|
---|
| 275 |
|
---|
| 276 | return (val);
|
---|
| 277 | }
|
---|
| 278 |
|
---|
| 279 | int
|
---|
| 280 | mos_reg_read_2(struct mos_softc *sc, int reg)
|
---|
| 281 | {
|
---|
| 282 | struct usb_device_request req;
|
---|
| 283 | usb_error_t err;
|
---|
| 284 | uWord val;
|
---|
| 285 |
|
---|
| 286 | USETW(val,0);
|
---|
| 287 |
|
---|
| 288 | req.bmRequestType = UT_READ_VENDOR_DEVICE;
|
---|
| 289 | req.bRequest = MOS_UR_READREG;
|
---|
| 290 | USETW(req.wValue, 0);
|
---|
| 291 | USETW(req.wIndex, reg);
|
---|
| 292 | USETW(req.wLength, 2);
|
---|
| 293 |
|
---|
| 294 | err = uether_do_request(&sc->sc_ue, &req, &val, 1000);
|
---|
| 295 |
|
---|
| 296 | if (err) {
|
---|
| 297 | DPRINTF("mos_reg_read_2 error, reg: %d\n", reg);
|
---|
| 298 | return (-1);
|
---|
| 299 | }
|
---|
| 300 |
|
---|
| 301 | return(UGETW(val));
|
---|
| 302 | }
|
---|
| 303 |
|
---|
| 304 | int
|
---|
| 305 | mos_reg_write_1(struct mos_softc *sc, int reg, int aval)
|
---|
| 306 | {
|
---|
| 307 | struct usb_device_request req;
|
---|
| 308 | usb_error_t err;
|
---|
| 309 | uByte val;
|
---|
| 310 |
|
---|
| 311 | val = aval;
|
---|
| 312 |
|
---|
| 313 | req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
|
---|
| 314 | req.bRequest = MOS_UR_WRITEREG;
|
---|
| 315 | USETW(req.wValue, 0);
|
---|
| 316 | USETW(req.wIndex, reg);
|
---|
| 317 | USETW(req.wLength, 1);
|
---|
| 318 |
|
---|
| 319 | err = uether_do_request(&sc->sc_ue, &req, &val, 1000);
|
---|
| 320 |
|
---|
| 321 | if (err) {
|
---|
| 322 | DPRINTF("mos_reg_write_1 error, reg: %d\n", reg);
|
---|
| 323 | return (-1);
|
---|
| 324 | }
|
---|
| 325 |
|
---|
| 326 | return(0);
|
---|
| 327 | }
|
---|
| 328 |
|
---|
| 329 | int
|
---|
| 330 | mos_reg_write_2(struct mos_softc *sc, int reg, int aval)
|
---|
| 331 | {
|
---|
| 332 | struct usb_device_request req;
|
---|
| 333 | usb_error_t err;
|
---|
| 334 | uWord val;
|
---|
| 335 |
|
---|
| 336 | USETW(val, aval);
|
---|
| 337 |
|
---|
| 338 | req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
|
---|
| 339 | req.bRequest = MOS_UR_WRITEREG;
|
---|
| 340 | USETW(req.wValue, 0);
|
---|
| 341 | USETW(req.wIndex, reg);
|
---|
| 342 | USETW(req.wLength, 2);
|
---|
| 343 |
|
---|
| 344 | err = uether_do_request(&sc->sc_ue, &req, &val, 1000);
|
---|
| 345 |
|
---|
| 346 | if (err) {
|
---|
| 347 | DPRINTF("mos_reg_write_2 error, reg: %d\n", reg);
|
---|
| 348 | return (-1);
|
---|
| 349 | }
|
---|
| 350 |
|
---|
| 351 | return (0);
|
---|
| 352 | }
|
---|
| 353 |
|
---|
| 354 | int
|
---|
| 355 | mos_readmac(struct mos_softc *sc, u_char *mac)
|
---|
| 356 | {
|
---|
| 357 | struct usb_device_request req;
|
---|
| 358 | usb_error_t err;
|
---|
| 359 |
|
---|
| 360 | req.bmRequestType = UT_READ_VENDOR_DEVICE;
|
---|
| 361 | req.bRequest = MOS_UR_READREG;
|
---|
| 362 | USETW(req.wValue, 0);
|
---|
| 363 | USETW(req.wIndex, MOS_MAC);
|
---|
| 364 | USETW(req.wLength, ETHER_ADDR_LEN);
|
---|
| 365 |
|
---|
| 366 | err = uether_do_request(&sc->sc_ue, &req, mac, 1000);
|
---|
| 367 |
|
---|
| 368 | if (err) {
|
---|
| 369 | return (-1);
|
---|
| 370 | }
|
---|
| 371 |
|
---|
| 372 | return (0);
|
---|
| 373 | }
|
---|
| 374 |
|
---|
| 375 | int
|
---|
[177] | 376 | mos_writemac(struct mos_softc *sc, uint8_t *mac)
|
---|
[171] | 377 | {
|
---|
| 378 | struct usb_device_request req;
|
---|
| 379 | usb_error_t err;
|
---|
| 380 |
|
---|
| 381 | req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
|
---|
| 382 | req.bRequest = MOS_UR_WRITEREG;
|
---|
| 383 | USETW(req.wValue, 0);
|
---|
| 384 | USETW(req.wIndex, MOS_MAC);
|
---|
| 385 | USETW(req.wLength, ETHER_ADDR_LEN);
|
---|
| 386 |
|
---|
| 387 | err = uether_do_request(&sc->sc_ue, &req, mac, 1000);
|
---|
| 388 |
|
---|
| 389 | if (err) {
|
---|
| 390 | DPRINTF("mos_writemac error");
|
---|
| 391 | return (-1);
|
---|
| 392 | }
|
---|
| 393 |
|
---|
| 394 | return (0);
|
---|
| 395 | }
|
---|
| 396 |
|
---|
| 397 | int
|
---|
| 398 | mos_write_mcast(struct mos_softc *sc, u_char *hashtbl)
|
---|
| 399 | {
|
---|
| 400 | struct usb_device_request req;
|
---|
| 401 | usb_error_t err;
|
---|
| 402 |
|
---|
| 403 | req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
|
---|
| 404 | req.bRequest = MOS_UR_WRITEREG;
|
---|
| 405 | USETW(req.wValue, 0);
|
---|
| 406 | USETW(req.wIndex, MOS_MCAST_TABLE);
|
---|
| 407 | USETW(req.wLength, 8);
|
---|
| 408 |
|
---|
| 409 | err = uether_do_request(&sc->sc_ue, &req, hashtbl, 1000);
|
---|
| 410 |
|
---|
| 411 | if (err) {
|
---|
| 412 | DPRINTF("mos_reg_mcast error\n");
|
---|
| 413 | return(-1);
|
---|
| 414 | }
|
---|
| 415 |
|
---|
| 416 | return(0);
|
---|
| 417 | }
|
---|
| 418 |
|
---|
| 419 | int
|
---|
| 420 | mos_miibus_readreg(struct device *dev, int phy, int reg)
|
---|
| 421 | {
|
---|
[172] | 422 | struct mos_softc *sc = device_get_softc(dev);
|
---|
[171] | 423 | uWord val;
|
---|
| 424 | int i,res, locked;
|
---|
| 425 |
|
---|
| 426 | USETW(val, 0);
|
---|
| 427 |
|
---|
| 428 | locked = mtx_owned(&sc->sc_mtx);
|
---|
| 429 | if (!locked)
|
---|
| 430 | MOS_LOCK(sc);
|
---|
| 431 |
|
---|
| 432 | mos_reg_write_2(sc, MOS_PHY_DATA, 0);
|
---|
| 433 | mos_reg_write_1(sc, MOS_PHY_CTL, (phy & MOS_PHYCTL_PHYADDR) |
|
---|
| 434 | MOS_PHYCTL_READ);
|
---|
| 435 | mos_reg_write_1(sc, MOS_PHY_STS, (reg & MOS_PHYSTS_PHYREG) |
|
---|
| 436 | MOS_PHYSTS_PENDING);
|
---|
| 437 |
|
---|
| 438 | for (i = 0; i < MOS_TIMEOUT; i++) {
|
---|
| 439 | if (mos_reg_read_1(sc, MOS_PHY_STS) & MOS_PHYSTS_READY)
|
---|
| 440 | break;
|
---|
| 441 | }
|
---|
| 442 | if (i == MOS_TIMEOUT) {
|
---|
[267] | 443 | DPRINTF("%s: %s: MII read timeout\n", "mos", __func__);
|
---|
[171] | 444 | }
|
---|
| 445 |
|
---|
| 446 | res = mos_reg_read_2(sc, MOS_PHY_DATA);
|
---|
| 447 |
|
---|
| 448 | if (!locked)
|
---|
| 449 | MOS_UNLOCK(sc);
|
---|
| 450 | return (res);
|
---|
| 451 | }
|
---|
| 452 |
|
---|
| 453 | int
|
---|
| 454 | mos_miibus_writereg(device_t dev, int phy, int reg, int val)
|
---|
| 455 | {
|
---|
[172] | 456 | struct mos_softc *sc = device_get_softc(dev);
|
---|
[171] | 457 | int i, locked;
|
---|
[175] | 458 | DPRINTF("%s enter\n", __func__);
|
---|
[171] | 459 |
|
---|
| 460 | locked = mtx_owned(&sc->sc_mtx);
|
---|
| 461 | if (!locked)
|
---|
| 462 | MOS_LOCK(sc);
|
---|
| 463 |
|
---|
| 464 | mos_reg_write_2(sc, MOS_PHY_DATA, val);
|
---|
| 465 | mos_reg_write_1(sc, MOS_PHY_CTL, (phy & MOS_PHYCTL_PHYADDR) |
|
---|
| 466 | MOS_PHYCTL_WRITE);
|
---|
| 467 | mos_reg_write_1(sc, MOS_PHY_STS, (reg & MOS_PHYSTS_PHYREG) |
|
---|
| 468 | MOS_PHYSTS_PENDING);
|
---|
| 469 |
|
---|
| 470 | for (i = 0; i < MOS_TIMEOUT; i++) {
|
---|
| 471 | if (mos_reg_read_1(sc, MOS_PHY_STS) & MOS_PHYSTS_READY)
|
---|
| 472 | break;
|
---|
| 473 | }
|
---|
| 474 | if (i == MOS_TIMEOUT) {
|
---|
[267] | 475 | DPRINTF("%s: MII write timeout\n", "mos");
|
---|
[171] | 476 | }
|
---|
| 477 |
|
---|
| 478 | if (!locked)
|
---|
| 479 | MOS_UNLOCK(sc);
|
---|
| 480 | return 0;
|
---|
| 481 | }
|
---|
| 482 |
|
---|
| 483 | void
|
---|
| 484 | mos_miibus_statchg(device_t dev)
|
---|
| 485 | {
|
---|
| 486 | struct mos_softc *sc = device_get_softc(dev);
|
---|
| 487 | struct mii_data *mii = GET_MII(sc);
|
---|
| 488 | int val, err, locked;
|
---|
[175] | 489 | DPRINTF("%s enter\n", __func__);
|
---|
[171] | 490 |
|
---|
| 491 | locked = mtx_owned(&sc->sc_mtx);
|
---|
| 492 | if (!locked)
|
---|
| 493 | MOS_LOCK(sc);
|
---|
| 494 |
|
---|
| 495 | /* disable RX, TX prior to changing FDX, SPEEDSEL */
|
---|
| 496 | val = mos_reg_read_1(sc, MOS_CTL);
|
---|
| 497 | val &= ~(MOS_CTL_TX_ENB | MOS_CTL_RX_ENB);
|
---|
| 498 | mos_reg_write_1(sc, MOS_CTL, val);
|
---|
| 499 |
|
---|
| 500 | /* reset register which counts dropped frames */
|
---|
| 501 | mos_reg_write_1(sc, MOS_FRAME_DROP_CNT, 0);
|
---|
| 502 |
|
---|
| 503 | if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX)
|
---|
| 504 | val |= MOS_CTL_FDX_ENB;
|
---|
| 505 | else
|
---|
| 506 | val &= ~(MOS_CTL_FDX_ENB);
|
---|
| 507 |
|
---|
| 508 | switch (IFM_SUBTYPE(mii->mii_media_active)) {
|
---|
| 509 | case IFM_100_TX:
|
---|
| 510 | val |= MOS_CTL_SPEEDSEL;
|
---|
| 511 | break;
|
---|
| 512 | case IFM_10_T:
|
---|
| 513 | val &= ~(MOS_CTL_SPEEDSEL);
|
---|
| 514 | break;
|
---|
| 515 | }
|
---|
| 516 |
|
---|
| 517 | /* re-enable TX, RX */
|
---|
| 518 | val |= (MOS_CTL_TX_ENB | MOS_CTL_RX_ENB);
|
---|
| 519 | err = mos_reg_write_1(sc, MOS_CTL, val);
|
---|
| 520 |
|
---|
| 521 | if (err)
|
---|
[267] | 522 | DPRINTF("%s: media change failed\n", "mos");
|
---|
[171] | 523 |
|
---|
| 524 | if (!locked)
|
---|
| 525 | MOS_UNLOCK(sc);
|
---|
| 526 | }
|
---|
| 527 |
|
---|
| 528 | /*
|
---|
| 529 | * Set media options.
|
---|
| 530 | */
|
---|
| 531 | int
|
---|
| 532 | mos_ifmedia_upd(struct ifnet *ifp)
|
---|
| 533 | {
|
---|
| 534 | struct mos_softc *sc = ifp->if_softc;
|
---|
| 535 | struct mii_data *mii = GET_MII(sc);
|
---|
| 536 |
|
---|
[172] | 537 | MOS_LOCK_ASSERT(sc, MA_OWNED);
|
---|
| 538 |
|
---|
[171] | 539 | sc->mos_link = 0;
|
---|
| 540 | if (mii->mii_instance) {
|
---|
[172] | 541 | struct mii_softc *miisc;
|
---|
| 542 |
|
---|
[171] | 543 | LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
|
---|
| 544 | mii_phy_reset(miisc);
|
---|
| 545 | }
|
---|
| 546 | mii_mediachg(mii);
|
---|
| 547 | return (0);
|
---|
| 548 | }
|
---|
| 549 |
|
---|
| 550 | /*
|
---|
| 551 | * Report current media status.
|
---|
| 552 | */
|
---|
| 553 | void
|
---|
| 554 | mos_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
|
---|
| 555 | {
|
---|
| 556 | struct mos_softc *sc = ifp->if_softc;
|
---|
| 557 | struct mii_data *mii = GET_MII(sc);
|
---|
| 558 |
|
---|
[172] | 559 | MOS_LOCK(sc);
|
---|
[171] | 560 | mii_pollstat(mii);
|
---|
[172] | 561 | MOS_UNLOCK(sc);
|
---|
| 562 |
|
---|
[171] | 563 | ifmr->ifm_active = mii->mii_media_active;
|
---|
| 564 | ifmr->ifm_status = mii->mii_media_status;
|
---|
| 565 | }
|
---|
| 566 |
|
---|
| 567 | void
|
---|
| 568 | mos_setmulti(struct usb_ether *ue)
|
---|
| 569 | {
|
---|
| 570 | struct mos_softc *sc = uether_getsc(ue);
|
---|
| 571 | struct ifnet *ifp = uether_getifp(ue);
|
---|
| 572 | struct ifmultiaddr *ifma;
|
---|
[174] | 573 |
|
---|
[171] | 574 | u_int32_t h = 0;
|
---|
| 575 | u_int8_t rxmode;
|
---|
| 576 | u_int8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
|
---|
[174] | 577 | int allmulti = 0;
|
---|
[175] | 578 | DPRINTF("%s enter\n", __func__);
|
---|
[171] | 579 |
|
---|
[172] | 580 | MOS_LOCK_ASSERT(sc, MA_OWNED);
|
---|
[171] | 581 |
|
---|
| 582 | rxmode = mos_reg_read_1(sc, MOS_CTL);
|
---|
| 583 |
|
---|
[174] | 584 | if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC)
|
---|
| 585 | allmulti = 1;
|
---|
[171] | 586 |
|
---|
[174] | 587 | /* get all new ones */
|
---|
[171] | 588 | if_maddr_rlock(ifp);
|
---|
| 589 | TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
|
---|
[174] | 590 | if (ifma->ifma_addr->sa_family != AF_LINK) {
|
---|
| 591 | allmulti = 1;
|
---|
| 592 | continue;
|
---|
| 593 | };
|
---|
[171] | 594 | h = ether_crc32_be(LLADDR((struct sockaddr_dl *)
|
---|
| 595 | ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
|
---|
| 596 | //h = ether_crc32_be(enm->enm_addrlo, ETHER_ADDR_LEN) >> 26;
|
---|
| 597 | hashtbl[h / 8] |= 1 << (h % 8);
|
---|
| 598 | }
|
---|
| 599 | if_maddr_runlock(ifp);
|
---|
| 600 |
|
---|
[174] | 601 | /* now program new ones */
|
---|
| 602 | if (allmulti == 1) {
|
---|
| 603 | rxmode |= MOS_CTL_ALLMULTI;
|
---|
| 604 | mos_reg_write_1(sc, MOS_CTL, rxmode);
|
---|
| 605 | } else {
|
---|
| 606 | rxmode &= ~MOS_CTL_ALLMULTI;
|
---|
| 607 | ifp->if_flags &= ~IFF_ALLMULTI;
|
---|
| 608 | mos_write_mcast(sc, (void *)&hashtbl);
|
---|
| 609 | mos_reg_write_1(sc, MOS_CTL, rxmode);
|
---|
| 610 | }
|
---|
[171] | 611 | }
|
---|
| 612 |
|
---|
| 613 | void
|
---|
| 614 | mos_reset(struct mos_softc *sc)
|
---|
| 615 | {
|
---|
| 616 | u_int8_t ctl;
|
---|
[175] | 617 | DPRINTF("%s enter\n", __func__);
|
---|
[171] | 618 |
|
---|
| 619 | ctl = mos_reg_read_1(sc, MOS_CTL);
|
---|
| 620 | ctl &= ~(MOS_CTL_RX_PROMISC | MOS_CTL_ALLMULTI | MOS_CTL_TX_ENB |
|
---|
| 621 | MOS_CTL_RX_ENB);
|
---|
| 622 | /* Disable RX, TX, promiscuous and allmulticast mode */
|
---|
| 623 | mos_reg_write_1(sc, MOS_CTL, ctl);
|
---|
| 624 |
|
---|
| 625 | /* Reset frame drop counter register to zero */
|
---|
| 626 | mos_reg_write_1(sc, MOS_FRAME_DROP_CNT, 0);
|
---|
| 627 |
|
---|
| 628 | /* Wait a little while for the chip to get its brains in order. */
|
---|
| 629 | DELAY(1000);
|
---|
| 630 | return;
|
---|
| 631 | }
|
---|
| 632 |
|
---|
| 633 | void
|
---|
| 634 | mos_chip_init(struct mos_softc *sc)
|
---|
| 635 | {
|
---|
| 636 | int i;
|
---|
[175] | 637 | DPRINTF("%s enter\n", __func__);
|
---|
[171] | 638 |
|
---|
| 639 | /*
|
---|
| 640 | * Rev.C devices have a pause threshold register which needs to be set
|
---|
| 641 | * at startup.
|
---|
| 642 | */
|
---|
| 643 | if (mos_reg_read_1(sc, MOS_PAUSE_TRHD) != -1) {
|
---|
| 644 | for (i=0;i<MOS_PAUSE_REWRITES;i++)
|
---|
| 645 | mos_reg_write_1(sc, MOS_PAUSE_TRHD, 0);
|
---|
| 646 | }
|
---|
| 647 |
|
---|
| 648 | sc->mos_phyaddrs[0] = 1; sc->mos_phyaddrs[1] = 0xFF;
|
---|
| 649 | }
|
---|
| 650 |
|
---|
| 651 | /*
|
---|
| 652 | * Probe for a MCS7x30 chip.
|
---|
| 653 | */
|
---|
| 654 | int
|
---|
| 655 | mos_probe(device_t dev)
|
---|
| 656 | {
|
---|
[175] | 657 | DPRINTFN(11, "mos: probe\n");
|
---|
[171] | 658 | struct usb_attach_arg *uaa = device_get_ivars(dev);
|
---|
| 659 |
|
---|
| 660 | if (uaa->usb_mode != USB_MODE_HOST) {
|
---|
[175] | 661 | DPRINTFN(11, "mos: not USB_MODE_HOST\n");
|
---|
[171] | 662 | return (ENXIO);
|
---|
| 663 | }
|
---|
| 664 | //uint8_t bIfaceIndex;
|
---|
| 665 | //uint8_t bIfaceNum;
|
---|
| 666 | //uint8_t bConfigIndex;
|
---|
| 667 | //uint8_t bConfigNum;
|
---|
| 668 |
|
---|
| 669 | if (uaa->info.bConfigNum != MOS_CONFIG_NO) {
|
---|
[175] | 670 | DPRINTFN(11, "mos: not MOS_CONFIG_NO %i vs %i\n", uaa->info.bConfigNum , MOS_CONFIG_NO);
|
---|
[171] | 671 | return (ENXIO);
|
---|
| 672 | }
|
---|
| 673 | if (uaa->info.bIfaceIndex != MOS_IFACE_IDX) {
|
---|
[175] | 674 | DPRINTFN(11, "mos: not MOS_IFACE_IDX %i vs %i\n", uaa->info.bIfaceIndex, MOS_IFACE_IDX);
|
---|
[171] | 675 | return (ENXIO);
|
---|
| 676 | }
|
---|
| 677 |
|
---|
[175] | 678 | DPRINTFN(11, "mos: probe by generic means\n");
|
---|
[171] | 679 | int retval = usbd_lookup_id_by_uaa(mos_devs, sizeof(mos_devs), uaa);
|
---|
[175] | 680 | DPRINTFN(11, "mos: probe retval: %i (ENXIO:%i)\n", retval, ENXIO);
|
---|
[171] | 681 | return retval;
|
---|
| 682 | }
|
---|
| 683 |
|
---|
| 684 | /*
|
---|
| 685 | * Attach the interface. Allocate softc structures, do ifmedia
|
---|
| 686 | * setup and ethernet/BPF attach.
|
---|
| 687 | */
|
---|
| 688 | int
|
---|
| 689 | mos_attach(device_t dev)
|
---|
| 690 | {
|
---|
| 691 | struct usb_attach_arg *uaa = device_get_ivars(dev);
|
---|
| 692 | struct mos_softc *sc = device_get_softc(dev);
|
---|
| 693 | struct usb_ether *ue = &sc->sc_ue;
|
---|
| 694 |
|
---|
| 695 | uint8_t iface_index;
|
---|
| 696 | int error;
|
---|
| 697 |
|
---|
| 698 | sc->mos_flags = USB_GET_DRIVER_INFO(uaa);
|
---|
| 699 |
|
---|
| 700 | device_set_usb_desc(dev);
|
---|
| 701 | mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
|
---|
| 702 |
|
---|
| 703 | iface_index = MOS_IFACE_IDX;
|
---|
| 704 | error = usbd_transfer_setup(uaa->device, &iface_index,
|
---|
[200] | 705 | sc->sc_xfer, mos_config, MOS_ENDPT_MAX,
|
---|
[171] | 706 | sc, &sc->sc_mtx);
|
---|
| 707 |
|
---|
| 708 | if (error) {
|
---|
| 709 | device_printf(dev, "allocating USB transfers failed\n");
|
---|
| 710 | goto detach;
|
---|
| 711 | }
|
---|
| 712 |
|
---|
| 713 | ue->ue_sc = sc;
|
---|
| 714 | ue->ue_dev = dev;
|
---|
| 715 | ue->ue_udev = uaa->device;
|
---|
| 716 | ue->ue_mtx = &sc->sc_mtx;
|
---|
| 717 | ue->ue_methods = &mos_ue_methods;
|
---|
| 718 |
|
---|
| 719 |
|
---|
| 720 | if (sc->mos_flags & MCS7730) {
|
---|
[199] | 721 | DPRINTF("model: MCS7730\n");
|
---|
[171] | 722 | } else if (sc->mos_flags & MCS7830) {
|
---|
[199] | 723 | DPRINTF("model: MCS7830\n");
|
---|
[171] | 724 | }
|
---|
| 725 |
|
---|
| 726 | error = uether_ifattach(ue);
|
---|
| 727 | if (error) {
|
---|
| 728 | device_printf(dev, "could not attach interface\n");
|
---|
| 729 | goto detach;
|
---|
| 730 | }
|
---|
| 731 | return (0); /* success */
|
---|
| 732 |
|
---|
| 733 |
|
---|
| 734 | detach:
|
---|
| 735 | mos_detach(dev);
|
---|
| 736 | return (ENXIO); /* failure */
|
---|
| 737 | }
|
---|
| 738 |
|
---|
| 739 |
|
---|
| 740 | void
|
---|
| 741 | mos_attach_post(struct usb_ether *ue)
|
---|
| 742 | {
|
---|
| 743 | struct mos_softc *sc = uether_getsc(ue);
|
---|
| 744 | /*
|
---|
| 745 | * Read MAC address, inform the world.
|
---|
| 746 | */
|
---|
[176] | 747 | int err = mos_readmac(sc, ue->ue_eaddr);
|
---|
| 748 | if (err) {
|
---|
[267] | 749 | DPRINTF("couldn't get MAC address\n");
|
---|
[176] | 750 | }
|
---|
| 751 | DPRINTF("address: %s\n", ether_sprintf(ue->ue_eaddr));
|
---|
| 752 |
|
---|
[171] | 753 | mos_chip_init(sc);
|
---|
| 754 |
|
---|
[200] | 755 | // ifp = GET_IFP(sc);
|
---|
| 756 | // ifp->if_softc = sc;
|
---|
| 757 | // ifp->if_flags = IFF_SIMPLEX | IFF_MULTICAST;
|
---|
| 758 | // ifp->if_ioctl = mos_ioctl;
|
---|
| 759 | // ifp->if_start = mos_start;
|
---|
| 760 | // ifp->if_watchdog = mos_watchdog;
|
---|
| 761 | // strlcpy(ifp->if_xname, sc->mos_dev.dv_xname, IFNAMSIZ);
|
---|
| 762 |
|
---|
| 763 | // IFQ_SET_READY(&ifp->if_snd);
|
---|
| 764 | // ifp->if_capabilities = IFCAP_VLAN_MTU;
|
---|
| 765 |
|
---|
[171] | 766 | sc->mos_attached = 1;
|
---|
| 767 | }
|
---|
| 768 |
|
---|
| 769 | int
|
---|
| 770 | mos_detach(device_t dev)
|
---|
| 771 | {
|
---|
| 772 | struct mos_softc *sc = device_get_softc(dev);
|
---|
| 773 | struct usb_ether *ue = &sc->sc_ue;
|
---|
| 774 |
|
---|
[200] | 775 | usbd_transfer_unsetup(sc->sc_xfer, MOS_ENDPT_MAX);
|
---|
[171] | 776 | uether_ifdetach(ue);
|
---|
| 777 | mtx_destroy(&sc->sc_mtx);
|
---|
| 778 |
|
---|
| 779 | return (0);
|
---|
| 780 | }
|
---|
| 781 |
|
---|
| 782 |
|
---|
| 783 |
|
---|
| 784 |
|
---|
| 785 | /*
|
---|
| 786 | * A frame has been uploaded: pass the resulting mbuf chain up to
|
---|
| 787 | * the higher level protocols.
|
---|
| 788 | */
|
---|
| 789 | void
|
---|
| 790 | mos_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
|
---|
| 791 | {
|
---|
| 792 | struct mos_softc *sc = usbd_xfer_softc(xfer);
|
---|
| 793 | struct usb_ether *ue = &sc->sc_ue;
|
---|
| 794 | struct ifnet *ifp = uether_getifp(ue);
|
---|
| 795 |
|
---|
| 796 | u_int8_t rxstat = 0;
|
---|
| 797 | u_int32_t actlen;
|
---|
| 798 | u_int16_t pktlen = 0;
|
---|
| 799 | struct mbuf *stat;
|
---|
| 800 | struct usb_page_cache *pc;
|
---|
| 801 |
|
---|
[173] | 802 | DPRINTF("%s: %s: enter\n", "mos",__func__);
|
---|
[171] | 803 |
|
---|
| 804 | usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
|
---|
| 805 | pc = usbd_xfer_get_frame(xfer, 0);
|
---|
| 806 |
|
---|
[199] | 807 | switch (USB_GET_STATE(xfer)) {
|
---|
| 808 | case USB_ST_TRANSFERRED:
|
---|
| 809 | DPRINTF("read_callback actlen : %d\n", actlen);
|
---|
| 810 | if (actlen <= 1)
|
---|
| 811 | ifp->if_ierrors++;
|
---|
| 812 | goto tr_setup;
|
---|
[171] | 813 |
|
---|
[199] | 814 | usbd_copy_out(pc, actlen - sizeof(stat), &stat,
|
---|
| 815 | sizeof(stat));
|
---|
[171] | 816 |
|
---|
[199] | 817 | /* evaluate status byte at the end */
|
---|
| 818 | pktlen = actlen - 1;
|
---|
[200] | 819 | rxstat = stat->m_pktdat[pktlen] & MOS_RXSTS_MASK;
|
---|
[171] | 820 |
|
---|
[199] | 821 | if (rxstat != MOS_RXSTS_VALID) {
|
---|
| 822 | DPRINTF("%s: erroneous frame received: ",
|
---|
| 823 | "mos");
|
---|
| 824 | if (rxstat & MOS_RXSTS_SHORT_FRAME)
|
---|
| 825 | DPRINTF("frame size less than 64 bytes\n");
|
---|
| 826 | if (rxstat & MOS_RXSTS_LARGE_FRAME)
|
---|
| 827 | DPRINTF("frame size larger than 1532 bytes\n");
|
---|
| 828 | if (rxstat & MOS_RXSTS_CRC_ERROR)
|
---|
| 829 | DPRINTF("CRC error\n");
|
---|
| 830 | if (rxstat & MOS_RXSTS_ALIGN_ERROR)
|
---|
| 831 | DPRINTF("alignment error\n");
|
---|
| 832 | ifp->if_ierrors++;
|
---|
| 833 | goto tr_setup;
|
---|
| 834 | }
|
---|
[171] | 835 |
|
---|
[199] | 836 | if ( pktlen < sizeof(struct ether_header) ) {
|
---|
| 837 | ifp->if_ierrors++;
|
---|
| 838 | goto tr_setup;
|
---|
| 839 | }
|
---|
[171] | 840 |
|
---|
[199] | 841 | uether_rxbuf(ue, pc, 0, actlen);
|
---|
[171] | 842 |
|
---|
[199] | 843 | /* FALLTHROUGH */
|
---|
| 844 | case USB_ST_SETUP:
|
---|
| 845 | tr_setup:
|
---|
| 846 | usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
|
---|
| 847 | usbd_transfer_submit(xfer);
|
---|
| 848 | uether_rxflush(ue);
|
---|
| 849 | return;
|
---|
| 850 | default: /* Error */
|
---|
| 851 | DPRINTF("bulk read error, %s\n", usbd_errstr(error));
|
---|
| 852 | if (error != USB_ERR_CANCELLED) {
|
---|
| 853 | /* try to clear stall first */
|
---|
| 854 | usbd_xfer_set_stall(xfer);
|
---|
| 855 | goto tr_setup;
|
---|
[171] | 856 | }
|
---|
[199] | 857 | DPRINTF("start rx %i\n", usbd_xfer_max_len(xfer));
|
---|
| 858 | return;
|
---|
[171] | 859 | }
|
---|
| 860 | }
|
---|
| 861 |
|
---|
| 862 | /*
|
---|
| 863 | * A frame was downloaded to the chip. It's safe for us to clean up
|
---|
| 864 | * the list buffers.
|
---|
| 865 | */
|
---|
| 866 |
|
---|
| 867 | void
|
---|
| 868 | mos_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
|
---|
| 869 | {
|
---|
| 870 | struct mos_softc *sc = usbd_xfer_softc(xfer);
|
---|
| 871 | struct ifnet *ifp = uether_getifp(&sc->sc_ue);
|
---|
| 872 | struct usb_page_cache *pc;
|
---|
| 873 | struct mbuf *m;
|
---|
| 874 |
|
---|
[199] | 875 | DPRINTF("%s: %s: enter\n", "mos",__func__);
|
---|
| 876 |
|
---|
[171] | 877 |
|
---|
[199] | 878 | switch (USB_GET_STATE(xfer)) {
|
---|
| 879 | case USB_ST_TRANSFERRED:
|
---|
[267] | 880 | DPRINTF("transfer of complete\n");
|
---|
[199] | 881 | ifp->if_opackets++;
|
---|
| 882 | /* FALLTHROUGH */
|
---|
| 883 | case USB_ST_SETUP:
|
---|
| 884 | tr_setup:
|
---|
| 885 | /*
|
---|
| 886 | * XXX: don't send anything if there is no link?
|
---|
| 887 | */
|
---|
| 888 | IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
|
---|
[267] | 889 | if (m == NULL)
|
---|
| 890 | return;
|
---|
[171] | 891 |
|
---|
[267] | 892 | pc = usbd_xfer_get_frame(xfer, 0);
|
---|
| 893 | usbd_m_copy_in(pc, 0, m, 0, m->m_pkthdr.len);
|
---|
| 894 |
|
---|
[199] | 895 | usbd_xfer_set_frame_len(xfer, 0, m->m_pkthdr.len);
|
---|
[171] | 896 |
|
---|
| 897 |
|
---|
[199] | 898 | /*
|
---|
| 899 | * if there's a BPF listener, bounce a copy
|
---|
| 900 | * of this frame to him:
|
---|
| 901 | */
|
---|
| 902 | BPF_MTAP(ifp, m);
|
---|
[171] | 903 |
|
---|
[199] | 904 | m_freem(m);
|
---|
[171] | 905 |
|
---|
[199] | 906 | usbd_transfer_submit(xfer);
|
---|
[171] | 907 |
|
---|
[199] | 908 | ifp->if_opackets++;
|
---|
| 909 | return;
|
---|
| 910 | default: /* Error */
|
---|
| 911 | DPRINTF("%s: usb error on tx: %s\n", "mos", usbd_errstr(error));
|
---|
| 912 | ifp->if_oerrors++;
|
---|
| 913 | if (error != USB_ERR_CANCELLED) {
|
---|
| 914 | /* try to clear stall first */
|
---|
| 915 | usbd_xfer_set_stall(xfer);
|
---|
| 916 | goto tr_setup;
|
---|
| 917 | }
|
---|
| 918 | return;
|
---|
| 919 | }
|
---|
[171] | 920 | }
|
---|
| 921 |
|
---|
| 922 | void
|
---|
| 923 | mos_tick(struct usb_ether *ue)
|
---|
| 924 | {
|
---|
| 925 | struct mos_softc *sc = uether_getsc(ue);
|
---|
| 926 | struct mii_data *mii = GET_MII(sc);
|
---|
| 927 |
|
---|
[172] | 928 | MOS_LOCK_ASSERT(sc, MA_OWNED);
|
---|
[173] | 929 | DPRINTF("%s: %s: enter\n", "mos", __func__);
|
---|
[171] | 930 |
|
---|
| 931 | mii_tick(mii);
|
---|
| 932 | if (!sc->mos_link && mii->mii_media_status & IFM_ACTIVE &&
|
---|
| 933 | IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
|
---|
| 934 | DPRINTF("%s: %s: got link\n",
|
---|
| 935 | "mos", __func__);
|
---|
| 936 | sc->mos_link++;
|
---|
[173] | 937 | mos_start(ue);
|
---|
[171] | 938 | }
|
---|
| 939 | }
|
---|
| 940 |
|
---|
| 941 |
|
---|
| 942 | //int
|
---|
| 943 | //mos_encap(struct mos_softc *sc, struct mbuf *m, int idx)
|
---|
| 944 | //{
|
---|
| 945 | // struct mos_chain *c;
|
---|
| 946 | // int err;
|
---|
| 947 | // int length;
|
---|
| 948 | //
|
---|
| 949 | // c = &sc->mos_cdata.mos_tx_chain[idx];
|
---|
| 950 | //
|
---|
| 951 | // m_copydata(m, 0, m->m_pkthdr.len, c->mos_buf);
|
---|
| 952 | // length = m->m_pkthdr.len;
|
---|
| 953 | //
|
---|
| 954 | // c->mos_mbuf = m;
|
---|
| 955 | //
|
---|
| 956 | // usbd_setup_xfer(c->mos_xfer, sc->mos_ep[MOS_ENDPT_TX],
|
---|
| 957 | // c, c->mos_buf, length, USBD_FORCE_SHORT_XFER | USBD_NO_COPY,
|
---|
| 958 | // 10000, mos_txeof);
|
---|
| 959 | //
|
---|
| 960 | // /* Transmit */
|
---|
| 961 | // err = usbd_transfer(c->mos_xfer);
|
---|
| 962 | // if (err != USBD_IN_PROGRESS) {
|
---|
| 963 | // mos_stop(sc);
|
---|
| 964 | // return(EIO);
|
---|
| 965 | // }
|
---|
| 966 | //
|
---|
| 967 | // sc->mos_cdata.mos_tx_cnt++;
|
---|
| 968 | //
|
---|
| 969 | // return(0);
|
---|
| 970 | //}
|
---|
| 971 |
|
---|
| 972 | void
|
---|
| 973 | mos_start(struct usb_ether *ue)
|
---|
| 974 | {
|
---|
| 975 | struct mos_softc *sc = uether_getsc(ue);
|
---|
| 976 |
|
---|
| 977 | /*
|
---|
[173] | 978 | * start the USB transfers, if not already started:
|
---|
[171] | 979 | */
|
---|
[173] | 980 | usbd_transfer_start(sc->sc_xfer[MOS_ENDPT_TX]);
|
---|
| 981 | usbd_transfer_start(sc->sc_xfer[MOS_ENDPT_RX]);
|
---|
| 982 | usbd_transfer_start(sc->sc_xfer[MOS_ENDPT_INTR]);
|
---|
[171] | 983 | }
|
---|
| 984 |
|
---|
| 985 | void
|
---|
| 986 | mos_init(struct usb_ether *ue)
|
---|
| 987 | {
|
---|
| 988 | struct mos_softc *sc = uether_getsc(ue);
|
---|
| 989 | struct ifnet *ifp = uether_getifp(ue);
|
---|
| 990 | u_int8_t rxmode;
|
---|
[175] | 991 | DPRINTF("%s enter\n", __func__);
|
---|
[171] | 992 |
|
---|
[172] | 993 | MOS_LOCK_ASSERT(sc, MA_OWNED);
|
---|
| 994 |
|
---|
[171] | 995 | /*
|
---|
| 996 | * Cancel pending I/O and free all RX/TX buffers.
|
---|
| 997 | */
|
---|
| 998 | mos_reset(sc);
|
---|
| 999 |
|
---|
| 1000 | /*
|
---|
| 1001 | * Write MAC address
|
---|
| 1002 | */
|
---|
[177] | 1003 | mos_writemac(sc, IF_LLADDR(ifp));
|
---|
[171] | 1004 |
|
---|
| 1005 |
|
---|
| 1006 |
|
---|
| 1007 | /* Read and set transmitter IPG values */
|
---|
| 1008 | sc->mos_ipgs[0] = mos_reg_read_1(sc, MOS_IPG0);
|
---|
| 1009 | sc->mos_ipgs[1] = mos_reg_read_1(sc, MOS_IPG1);
|
---|
| 1010 | mos_reg_write_1(sc, MOS_IPG0, sc->mos_ipgs[0]);
|
---|
| 1011 | mos_reg_write_1(sc, MOS_IPG1, sc->mos_ipgs[1]);
|
---|
| 1012 |
|
---|
| 1013 | /* Enable receiver and transmitter, bridge controls speed/duplex mode */
|
---|
| 1014 | rxmode = mos_reg_read_1(sc, MOS_CTL);
|
---|
| 1015 | rxmode |= MOS_CTL_RX_ENB | MOS_CTL_TX_ENB | MOS_CTL_BS_ENB;
|
---|
| 1016 | rxmode &= ~(MOS_CTL_SLEEP);
|
---|
| 1017 |
|
---|
| 1018 | /* If we want promiscuous mode, set the allframes bit. */
|
---|
| 1019 | if (ifp->if_flags & IFF_PROMISC)
|
---|
| 1020 | rxmode |= MOS_CTL_RX_PROMISC;
|
---|
| 1021 |
|
---|
| 1022 | /* XXX: broadcast mode? */
|
---|
| 1023 |
|
---|
| 1024 | mos_reg_write_1(sc, MOS_CTL, rxmode);
|
---|
| 1025 |
|
---|
| 1026 | /* Load the multicast filter. */
|
---|
| 1027 | mos_setmulti(ue);
|
---|
| 1028 |
|
---|
| 1029 | ifp->if_flags |= IFF_DRV_RUNNING;
|
---|
| 1030 | mos_start(ue);
|
---|
| 1031 | }
|
---|
| 1032 |
|
---|
| 1033 |
|
---|
| 1034 | void
|
---|
| 1035 | mos_intr_callback(struct usb_xfer *xfer, usb_error_t error)
|
---|
| 1036 | {
|
---|
| 1037 | struct mos_softc *sc = usbd_xfer_softc(xfer);
|
---|
| 1038 | struct ifnet *ifp = uether_getifp(&sc->sc_ue);
|
---|
[267] | 1039 | struct usb_page_cache *pc;
|
---|
[171] | 1040 | int actlen;
|
---|
| 1041 |
|
---|
[267] | 1042 | // DPRINTF("%s: %s: enter\n", "mos", __func__);
|
---|
[171] | 1043 | ifp->if_oerrors++;
|
---|
| 1044 |
|
---|
| 1045 | usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
|
---|
| 1046 |
|
---|
| 1047 | //XXX: Porting, how? mos_txeof(c->mos_xfer, c, stat);
|
---|
[200] | 1048 | switch (USB_GET_STATE(xfer)) {
|
---|
| 1049 | case USB_ST_TRANSFERRED:
|
---|
[267] | 1050 | // DPRINTF("State is ST_TRANS\n");
|
---|
| 1051 |
|
---|
| 1052 | pc = usbd_xfer_get_frame(xfer, 0);
|
---|
| 1053 | //usbd_copy_out(pc, 0, &pkt, sizeof(pkt));
|
---|
[200] | 1054 | /* FALLTHROUGH */
|
---|
| 1055 | case USB_ST_SETUP:
|
---|
| 1056 | tr_setup:
|
---|
[267] | 1057 | //DPRINTF("State is ST_SETUP\n");
|
---|
[200] | 1058 | usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
|
---|
| 1059 | usbd_transfer_submit(xfer);
|
---|
| 1060 | return;
|
---|
| 1061 | default: /* Error */
|
---|
[267] | 1062 | DPRINTF("State is default\n");
|
---|
[200] | 1063 | if (error != USB_ERR_CANCELLED) {
|
---|
| 1064 | /* try to clear stall first */
|
---|
| 1065 | usbd_xfer_set_stall(xfer);
|
---|
| 1066 | goto tr_setup;
|
---|
| 1067 | }
|
---|
| 1068 | return;
|
---|
| 1069 | }
|
---|
[171] | 1070 | }
|
---|
| 1071 |
|
---|
| 1072 |
|
---|
| 1073 | /*
|
---|
| 1074 | * Stop the adapter and free any mbufs allocated to the
|
---|
| 1075 | * RX and TX lists.
|
---|
| 1076 | */
|
---|
| 1077 | void
|
---|
| 1078 | mos_stop(struct usb_ether *ue)
|
---|
| 1079 | {
|
---|
| 1080 | struct mos_softc *sc = uether_getsc(ue);
|
---|
| 1081 | struct ifnet *ifp = uether_getifp(ue);
|
---|
| 1082 |
|
---|
| 1083 | mos_reset(sc);
|
---|
| 1084 |
|
---|
[172] | 1085 | MOS_LOCK_ASSERT(sc, MA_OWNED);
|
---|
[171] | 1086 | ifp->if_flags &= ~IFF_DRV_RUNNING;
|
---|
| 1087 |
|
---|
| 1088 | /*
|
---|
| 1089 | * stop all the transfers, if not already stopped:
|
---|
| 1090 | */
|
---|
| 1091 | usbd_transfer_stop(sc->sc_xfer[MOS_ENDPT_TX]);
|
---|
| 1092 | usbd_transfer_stop(sc->sc_xfer[MOS_ENDPT_RX]);
|
---|
| 1093 | usbd_transfer_stop(sc->sc_xfer[MOS_ENDPT_INTR]);
|
---|
| 1094 |
|
---|
| 1095 | sc->mos_link = 0;
|
---|
| 1096 | }
|
---|
| 1097 |
|
---|