1/* $FreeBSD$ */
2/*-
3 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 *
5 * Copyright (c) 2009 Andrew Thompson (thompsa@FreeBSD.org)
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD$");
31
32#include <sys/param.h>
33#include <sys/systm.h>
34#include <sys/bus.h>
35#include <sys/condvar.h>
36#include <sys/kernel.h>
37#include <sys/lock.h>
38#include <sys/malloc.h>
39#include <sys/mbuf.h>
40#include <sys/module.h>
41#include <sys/mutex.h>
42#include <sys/socket.h>
43#include <sys/sockio.h>
44#include <sys/sysctl.h>
45#include <sys/sx.h>
46
47#include <net/if.h>
48#include <net/if_var.h>
49#include <net/ethernet.h>
50#include <net/if_types.h>
51#include <net/if_media.h>
52#include <net/if_vlan_var.h>
53
54#include <dev/mii/mii.h>
55#include <dev/mii/miivar.h>
56
57#include <dev/usb/usb.h>
58#include <dev/usb/usbdi.h>
59
60#include <dev/usb/usb_process.h>
61#include <dev/usb/net/usb_ethernet.h>
62
63static SYSCTL_NODE(_net, OID_AUTO, ue, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
64    "USB Ethernet parameters");
65
66#define	UE_LOCK(_ue)		mtx_lock((_ue)->ue_mtx)
67#define	UE_UNLOCK(_ue)		mtx_unlock((_ue)->ue_mtx)
68#define	UE_LOCK_ASSERT(_ue, t)	mtx_assert((_ue)->ue_mtx, t)
69
70MODULE_DEPEND(uether, usb, 1, 1, 1);
71MODULE_DEPEND(uether, miibus, 1, 1, 1);
72
73static struct unrhdr *ueunit;
74
75static usb_proc_callback_t ue_attach_post_task;
76static usb_proc_callback_t ue_promisc_task;
77static usb_proc_callback_t ue_setmulti_task;
78static usb_proc_callback_t ue_ifmedia_task;
79static usb_proc_callback_t ue_tick_task;
80static usb_proc_callback_t ue_start_task;
81static usb_proc_callback_t ue_stop_task;
82
83static void	ue_init(void *);
84static void	ue_start(struct ifnet *);
85static int	ue_ifmedia_upd(struct ifnet *);
86static void	ue_watchdog(void *);
87
88/*
89 * Return values:
90 *    0: success
91 * Else: device has been detached
92 */
93uint8_t
94uether_pause(struct usb_ether *ue, unsigned int _ticks)
95{
96	if (usb_proc_is_gone(&ue->ue_tq)) {
97		/* nothing to do */
98		return (1);
99	}
100	usb_pause_mtx(ue->ue_mtx, _ticks);
101	return (0);
102}
103
104static void
105ue_queue_command(struct usb_ether *ue,
106    usb_proc_callback_t *fn,
107    struct usb_proc_msg *t0, struct usb_proc_msg *t1)
108{
109	struct usb_ether_cfg_task *task;
110
111	UE_LOCK_ASSERT(ue, MA_OWNED);
112
113	if (usb_proc_is_gone(&ue->ue_tq)) {
114		return;         /* nothing to do */
115	}
116	/*
117	 * NOTE: The task cannot get executed before we drop the
118	 * "sc_mtx" mutex. It is safe to update fields in the message
119	 * structure after that the message got queued.
120	 */
121	task = (struct usb_ether_cfg_task *)
122	  usb_proc_msignal(&ue->ue_tq, t0, t1);
123
124	/* Setup callback and self pointers */
125	task->hdr.pm_callback = fn;
126	task->ue = ue;
127
128	/*
129	 * Start and stop must be synchronous!
130	 */
131	if ((fn == ue_start_task) || (fn == ue_stop_task))
132		usb_proc_mwait(&ue->ue_tq, t0, t1);
133}
134
135struct ifnet *
136uether_getifp(struct usb_ether *ue)
137{
138	return (ue->ue_ifp);
139}
140
141struct mii_data *
142uether_getmii(struct usb_ether *ue)
143{
144	return (device_get_softc(ue->ue_miibus));
145}
146
147void *
148uether_getsc(struct usb_ether *ue)
149{
150	return (ue->ue_sc);
151}
152
153static int
154ue_sysctl_parent(SYSCTL_HANDLER_ARGS)
155{
156	struct usb_ether *ue = arg1;
157	const char *name;
158
159	name = device_get_nameunit(ue->ue_dev);
160	return SYSCTL_OUT_STR(req, name);
161}
162
163int
164uether_ifattach(struct usb_ether *ue)
165{
166	int error;
167
168	/* check some critical parameters */
169	if ((ue->ue_dev == NULL) ||
170	    (ue->ue_udev == NULL) ||
171	    (ue->ue_mtx == NULL) ||
172	    (ue->ue_methods == NULL))
173		return (EINVAL);
174
175	error = usb_proc_create(&ue->ue_tq, ue->ue_mtx,
176	    device_get_nameunit(ue->ue_dev), USB_PRI_MED);
177	if (error) {
178		device_printf(ue->ue_dev, "could not setup taskqueue\n");
179		goto error;
180	}
181
182	/* fork rest of the attach code */
183	UE_LOCK(ue);
184	ue_queue_command(ue, ue_attach_post_task,
185	    &ue->ue_sync_task[0].hdr,
186	    &ue->ue_sync_task[1].hdr);
187	UE_UNLOCK(ue);
188
189error:
190	return (error);
191}
192
193void
194uether_ifattach_wait(struct usb_ether *ue)
195{
196
197	UE_LOCK(ue);
198	usb_proc_mwait(&ue->ue_tq,
199	    &ue->ue_sync_task[0].hdr,
200	    &ue->ue_sync_task[1].hdr);
201	UE_UNLOCK(ue);
202}
203
204static void
205ue_attach_post_task(struct usb_proc_msg *_task)
206{
207	struct usb_ether_cfg_task *task =
208	    (struct usb_ether_cfg_task *)_task;
209	struct usb_ether *ue = task->ue;
210	struct ifnet *ifp;
211	int error;
212	char num[14];			/* sufficient for 32 bits */
213
214	/* first call driver's post attach routine */
215	ue->ue_methods->ue_attach_post(ue);
216
217	UE_UNLOCK(ue);
218
219	ue->ue_unit = alloc_unr(ueunit);
220	usb_callout_init_mtx(&ue->ue_watchdog, ue->ue_mtx, 0);
221	sysctl_ctx_init(&ue->ue_sysctl_ctx);
222	mbufq_init(&ue->ue_rxq, 0 /* unlimited length */);
223
224	error = 0;
225	CURVNET_SET_QUIET(vnet0);
226	ifp = if_alloc(IFT_ETHER);
227	if (ifp == NULL) {
228		device_printf(ue->ue_dev, "could not allocate ifnet\n");
229		goto fail;
230	}
231
232	ifp->if_softc = ue;
233	if_initname(ifp, "ue", ue->ue_unit);
234	if (ue->ue_methods->ue_attach_post_sub != NULL) {
235		ue->ue_ifp = ifp;
236		error = ue->ue_methods->ue_attach_post_sub(ue);
237	} else {
238		ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
239		if (ue->ue_methods->ue_ioctl != NULL)
240			ifp->if_ioctl = ue->ue_methods->ue_ioctl;
241		else
242			ifp->if_ioctl = uether_ioctl;
243		ifp->if_start = ue_start;
244		ifp->if_init = ue_init;
245		IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
246		ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
247		IFQ_SET_READY(&ifp->if_snd);
248		ue->ue_ifp = ifp;
249
250		if (ue->ue_methods->ue_mii_upd != NULL &&
251		    ue->ue_methods->ue_mii_sts != NULL) {
252			/* device_xxx() depends on this */
253			mtx_lock(&Giant);
254			error = mii_attach(ue->ue_dev, &ue->ue_miibus, ifp,
255			    ue_ifmedia_upd, ue->ue_methods->ue_mii_sts,
256			    BMSR_DEFCAPMASK, MII_PHY_ANY, MII_OFFSET_ANY, 0);
257			mtx_unlock(&Giant);
258		}
259	}
260
261	if (error) {
262		device_printf(ue->ue_dev, "attaching PHYs failed\n");
263		goto fail;
264	}
265
266	if_printf(ifp, "<USB Ethernet> on %s\n", device_get_nameunit(ue->ue_dev));
267	ether_ifattach(ifp, ue->ue_eaddr);
268	/* Tell upper layer we support VLAN oversized frames. */
269	if (ifp->if_capabilities & IFCAP_VLAN_MTU)
270		ifp->if_hdrlen = sizeof(struct ether_vlan_header);
271
272	CURVNET_RESTORE();
273
274	snprintf(num, sizeof(num), "%u", ue->ue_unit);
275	ue->ue_sysctl_oid = SYSCTL_ADD_NODE(&ue->ue_sysctl_ctx,
276	    &SYSCTL_NODE_CHILDREN(_net, ue),
277	    OID_AUTO, num, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "");
278	SYSCTL_ADD_PROC(&ue->ue_sysctl_ctx,
279	    SYSCTL_CHILDREN(ue->ue_sysctl_oid), OID_AUTO, "%parent",
280	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, ue, 0,
281	    ue_sysctl_parent, "A", "parent device");
282
283	UE_LOCK(ue);
284	return;
285
286fail:
287	CURVNET_RESTORE();
288
289	/* drain mbuf queue */
290	mbufq_drain(&ue->ue_rxq);
291
292	/* free unit */
293	free_unr(ueunit, ue->ue_unit);
294	if (ue->ue_ifp != NULL) {
295		if_free(ue->ue_ifp);
296		ue->ue_ifp = NULL;
297	}
298	UE_LOCK(ue);
299	return;
300}
301
302void
303uether_ifdetach(struct usb_ether *ue)
304{
305	struct ifnet *ifp;
306
307	/* wait for any post attach or other command to complete */
308	usb_proc_drain(&ue->ue_tq);
309
310	/* read "ifnet" pointer after taskqueue drain */
311	ifp = ue->ue_ifp;
312
313	if (ifp != NULL) {
314		/* we are not running any more */
315		UE_LOCK(ue);
316		ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
317		UE_UNLOCK(ue);
318
319		/* drain any callouts */
320		usb_callout_drain(&ue->ue_watchdog);
321
322		/*
323		 * Detach ethernet first to stop miibus calls from
324		 * user-space:
325		 */
326		ether_ifdetach(ifp);
327
328		/* detach miibus */
329		if (ue->ue_miibus != NULL) {
330			mtx_lock(&Giant);	/* device_xxx() depends on this */
331			device_delete_child(ue->ue_dev, ue->ue_miibus);
332			mtx_unlock(&Giant);
333		}
334
335		/* free interface instance */
336		if_free(ifp);
337
338		/* free sysctl */
339		sysctl_ctx_free(&ue->ue_sysctl_ctx);
340
341		/* drain mbuf queue */
342		mbufq_drain(&ue->ue_rxq);
343
344		/* free unit */
345		free_unr(ueunit, ue->ue_unit);
346	}
347
348	/* free taskqueue, if any */
349	usb_proc_free(&ue->ue_tq);
350}
351
352uint8_t
353uether_is_gone(struct usb_ether *ue)
354{
355	return (usb_proc_is_gone(&ue->ue_tq));
356}
357
358void
359uether_init(void *arg)
360{
361
362	ue_init(arg);
363}
364
365static void
366ue_init(void *arg)
367{
368	struct usb_ether *ue = arg;
369
370	UE_LOCK(ue);
371	ue_queue_command(ue, ue_start_task,
372	    &ue->ue_sync_task[0].hdr,
373	    &ue->ue_sync_task[1].hdr);
374	UE_UNLOCK(ue);
375}
376
377static void
378ue_start_task(struct usb_proc_msg *_task)
379{
380	struct usb_ether_cfg_task *task =
381	    (struct usb_ether_cfg_task *)_task;
382	struct usb_ether *ue = task->ue;
383	struct ifnet *ifp = ue->ue_ifp;
384
385	UE_LOCK_ASSERT(ue, MA_OWNED);
386
387	ue->ue_methods->ue_init(ue);
388
389	if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
390		return;
391
392	if (ue->ue_methods->ue_tick != NULL)
393		usb_callout_reset(&ue->ue_watchdog, hz, ue_watchdog, ue);
394}
395
396static void
397ue_stop_task(struct usb_proc_msg *_task)
398{
399	struct usb_ether_cfg_task *task =
400	    (struct usb_ether_cfg_task *)_task;
401	struct usb_ether *ue = task->ue;
402
403	UE_LOCK_ASSERT(ue, MA_OWNED);
404
405	usb_callout_stop(&ue->ue_watchdog);
406
407	ue->ue_methods->ue_stop(ue);
408}
409
410void
411uether_start(struct ifnet *ifp)
412{
413
414	ue_start(ifp);
415}
416
417static void
418ue_start(struct ifnet *ifp)
419{
420	struct usb_ether *ue = ifp->if_softc;
421
422	if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
423		return;
424
425	UE_LOCK(ue);
426	ue->ue_methods->ue_start(ue);
427	UE_UNLOCK(ue);
428}
429
430static void
431ue_promisc_task(struct usb_proc_msg *_task)
432{
433	struct usb_ether_cfg_task *task =
434	    (struct usb_ether_cfg_task *)_task;
435	struct usb_ether *ue = task->ue;
436
437	ue->ue_methods->ue_setpromisc(ue);
438}
439
440static void
441ue_setmulti_task(struct usb_proc_msg *_task)
442{
443	struct usb_ether_cfg_task *task =
444	    (struct usb_ether_cfg_task *)_task;
445	struct usb_ether *ue = task->ue;
446
447	ue->ue_methods->ue_setmulti(ue);
448}
449
450int
451uether_ifmedia_upd(struct ifnet *ifp)
452{
453
454	return (ue_ifmedia_upd(ifp));
455}
456
457static int
458ue_ifmedia_upd(struct ifnet *ifp)
459{
460	struct usb_ether *ue = ifp->if_softc;
461
462	/* Defer to process context */
463	UE_LOCK(ue);
464	ue_queue_command(ue, ue_ifmedia_task,
465	    &ue->ue_media_task[0].hdr,
466	    &ue->ue_media_task[1].hdr);
467	UE_UNLOCK(ue);
468
469	return (0);
470}
471
472static void
473ue_ifmedia_task(struct usb_proc_msg *_task)
474{
475	struct usb_ether_cfg_task *task =
476	    (struct usb_ether_cfg_task *)_task;
477	struct usb_ether *ue = task->ue;
478	struct ifnet *ifp = ue->ue_ifp;
479
480	ue->ue_methods->ue_mii_upd(ifp);
481}
482
483static void
484ue_watchdog(void *arg)
485{
486	struct usb_ether *ue = arg;
487	struct ifnet *ifp = ue->ue_ifp;
488
489	if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
490		return;
491
492	ue_queue_command(ue, ue_tick_task,
493	    &ue->ue_tick_task[0].hdr,
494	    &ue->ue_tick_task[1].hdr);
495
496	usb_callout_reset(&ue->ue_watchdog, hz, ue_watchdog, ue);
497}
498
499static void
500ue_tick_task(struct usb_proc_msg *_task)
501{
502	struct usb_ether_cfg_task *task =
503	    (struct usb_ether_cfg_task *)_task;
504	struct usb_ether *ue = task->ue;
505	struct ifnet *ifp = ue->ue_ifp;
506
507	if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
508		return;
509
510	ue->ue_methods->ue_tick(ue);
511}
512
513int
514uether_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
515{
516	struct usb_ether *ue = ifp->if_softc;
517	struct ifreq *ifr = (struct ifreq *)data;
518	struct mii_data *mii;
519	int error = 0;
520
521	switch (command) {
522	case SIOCSIFFLAGS:
523		UE_LOCK(ue);
524		if (ifp->if_flags & IFF_UP) {
525			if (ifp->if_drv_flags & IFF_DRV_RUNNING)
526				ue_queue_command(ue, ue_promisc_task,
527				    &ue->ue_promisc_task[0].hdr,
528				    &ue->ue_promisc_task[1].hdr);
529			else
530				ue_queue_command(ue, ue_start_task,
531				    &ue->ue_sync_task[0].hdr,
532				    &ue->ue_sync_task[1].hdr);
533		} else {
534			ue_queue_command(ue, ue_stop_task,
535			    &ue->ue_sync_task[0].hdr,
536			    &ue->ue_sync_task[1].hdr);
537		}
538		UE_UNLOCK(ue);
539		break;
540	case SIOCADDMULTI:
541	case SIOCDELMULTI:
542		UE_LOCK(ue);
543		ue_queue_command(ue, ue_setmulti_task,
544		    &ue->ue_multi_task[0].hdr,
545		    &ue->ue_multi_task[1].hdr);
546		UE_UNLOCK(ue);
547		break;
548	case SIOCGIFMEDIA:
549	case SIOCSIFMEDIA:
550		if (ue->ue_miibus != NULL) {
551			mii = device_get_softc(ue->ue_miibus);
552			error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command);
553		} else
554			error = ether_ioctl(ifp, command, data);
555		break;
556	default:
557		error = ether_ioctl(ifp, command, data);
558		break;
559	}
560	return (error);
561}
562
563static int
564uether_modevent(module_t mod, int type, void *data)
565{
566
567	switch (type) {
568	case MOD_LOAD:
569		ueunit = new_unrhdr(0, INT_MAX, NULL);
570		break;
571	case MOD_UNLOAD:
572		break;
573	default:
574		return (EOPNOTSUPP);
575	}
576	return (0);
577}
578static moduledata_t uether_mod = {
579	"uether",
580	uether_modevent,
581	0
582};
583
584struct mbuf *
585uether_newbuf(void)
586{
587	struct mbuf *m_new;
588
589	m_new = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
590	if (m_new == NULL)
591		return (NULL);
592	m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
593
594	m_adj(m_new, ETHER_ALIGN);
595	return (m_new);
596}
597
598int
599uether_rxmbuf(struct usb_ether *ue, struct mbuf *m,
600    unsigned int len)
601{
602	struct ifnet *ifp = ue->ue_ifp;
603
604	UE_LOCK_ASSERT(ue, MA_OWNED);
605
606	/* finalize mbuf */
607	if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
608	m->m_pkthdr.rcvif = ifp;
609	m->m_pkthdr.len = m->m_len = len;
610
611	/* enqueue for later when the lock can be released */
612	(void)mbufq_enqueue(&ue->ue_rxq, m);
613	return (0);
614}
615
616int
617uether_rxbuf(struct usb_ether *ue, struct usb_page_cache *pc,
618    unsigned int offset, unsigned int len)
619{
620	struct ifnet *ifp = ue->ue_ifp;
621	struct mbuf *m;
622
623	UE_LOCK_ASSERT(ue, MA_OWNED);
624
625	if (len < ETHER_HDR_LEN || len > MCLBYTES - ETHER_ALIGN)
626		return (1);
627
628	m = uether_newbuf();
629	if (m == NULL) {
630		if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
631		return (ENOMEM);
632	}
633
634	usbd_copy_out(pc, offset, mtod(m, uint8_t *), len);
635
636	/* finalize mbuf */
637	if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
638	m->m_pkthdr.rcvif = ifp;
639	m->m_pkthdr.len = m->m_len = len;
640
641	/* enqueue for later when the lock can be released */
642	(void)mbufq_enqueue(&ue->ue_rxq, m);
643	return (0);
644}
645
646void
647uether_rxflush(struct usb_ether *ue)
648{
649	struct ifnet *ifp = ue->ue_ifp;
650	struct epoch_tracker et;
651	struct mbuf *m, *n;
652
653	UE_LOCK_ASSERT(ue, MA_OWNED);
654
655	n = mbufq_flush(&ue->ue_rxq);
656	UE_UNLOCK(ue);
657	NET_EPOCH_ENTER(et);
658	while ((m = n) != NULL) {
659		n = STAILQ_NEXT(m, m_stailqpkt);
660		m->m_nextpkt = NULL;
661		ifp->if_input(ifp, m);
662	}
663	NET_EPOCH_EXIT(et);
664	UE_LOCK(ue);
665}
666
667/*
668 * USB net drivers are run by DRIVER_MODULE() thus SI_SUB_DRIVERS,
669 * SI_ORDER_MIDDLE.  Run uether after that.
670 */
671DECLARE_MODULE(uether, uether_mod, SI_SUB_DRIVERS, SI_ORDER_ANY);
672MODULE_VERSION(uether, 1);
673