Context Navigation

source: freebsd-mos-driver/if_mos.c@ 275

Last change on this file since 275 was 275, checked in by Rick van der Zwet, 14 years ago
Applying style(9)
File size: 26.0 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: