Deleted Added
sdiff udiff text old ( 194271 ) new ( 194677 )
full compact
if_cdce.c (194271) if_cdce.c (194677)
1/* $NetBSD: if_cdce.c,v 1.4 2004/10/24 12:50:54 augustss Exp $ */
2
3/*-
4 * Copyright (c) 1997, 1998, 1999, 2000-2003 Bill Paul <wpaul@windriver.com>
5 * Copyright (c) 2003-2005 Craig Boston
6 * Copyright (c) 2004 Daniel Hartmeier
7 * Copyright (c) 2009 Hans Petter Selasky
8 * All rights reserved.

--- 27 unchanged lines hidden (view full) ---

36 */
37
38/*
39 * USB Communication Device Class (Ethernet Networking Control Model)
40 * http://www.usb.org/developers/devclass_docs/usbcdc11.pdf
41 */
42
43#include <sys/cdefs.h>
1/* $NetBSD: if_cdce.c,v 1.4 2004/10/24 12:50:54 augustss Exp $ */
2
3/*-
4 * Copyright (c) 1997, 1998, 1999, 2000-2003 Bill Paul <wpaul@windriver.com>
5 * Copyright (c) 2003-2005 Craig Boston
6 * Copyright (c) 2004 Daniel Hartmeier
7 * Copyright (c) 2009 Hans Petter Selasky
8 * All rights reserved.

--- 27 unchanged lines hidden (view full) ---

36 */
37
38/*
39 * USB Communication Device Class (Ethernet Networking Control Model)
40 * http://www.usb.org/developers/devclass_docs/usbcdc11.pdf
41 */
42
43#include <sys/cdefs.h>
44__FBSDID("$FreeBSD: head/sys/dev/usb/net/if_cdce.c 194271 2009-06-15 22:38:05Z thompsa $");
44__FBSDID("$FreeBSD: head/sys/dev/usb/net/if_cdce.c 194677 2009-06-23 02:19:59Z thompsa $");
45
45
46#include "usbdevs.h"
46#include <sys/stdint.h>
47#include <sys/stddef.h>
48#include <sys/param.h>
49#include <sys/queue.h>
50#include <sys/types.h>
51#include <sys/systm.h>
52#include <sys/kernel.h>
53#include <sys/bus.h>
54#include <sys/linker_set.h>
55#include <sys/module.h>
56#include <sys/lock.h>
57#include <sys/mutex.h>
58#include <sys/condvar.h>
59#include <sys/sysctl.h>
60#include <sys/sx.h>
61#include <sys/unistd.h>
62#include <sys/callout.h>
63#include <sys/malloc.h>
64#include <sys/priv.h>
65
47#include <dev/usb/usb.h>
66#include <dev/usb/usb.h>
48#include <dev/usb/usb_mfunc.h>
49#include <dev/usb/usb_error.h>
67#include <dev/usb/usbdi.h>
68#include <dev/usb/usbdi_util.h>
50#include <dev/usb/usb_cdc.h>
69#include <dev/usb/usb_cdc.h>
70#include "usbdevs.h"
51
52#define USB_DEBUG_VAR cdce_debug
71
72#define USB_DEBUG_VAR cdce_debug
53
54#include <dev/usb/usb_core.h>
55#include <dev/usb/usb_lookup.h>
56#include <dev/usb/usb_process.h>
57#include <dev/usb/usb_debug.h>
73#include <dev/usb/usb_debug.h>
58#include <dev/usb/usb_request.h>
59#include <dev/usb/usb_busdma.h>
60#include <dev/usb/usb_util.h>
61#include <dev/usb/usb_parse.h>
62#include <dev/usb/usb_device.h>
74#include <dev/usb/usb_process.h>
75#include "usb_if.h"
63
64#include <dev/usb/net/usb_ethernet.h>
65#include <dev/usb/net/if_cdcereg.h>
66
67static device_probe_t cdce_probe;
68static device_attach_t cdce_attach;
69static device_detach_t cdce_detach;
70static device_suspend_t cdce_suspend;

--- 350 unchanged lines hidden (view full) ---

421 if (ppm[x] != NULL) {
422 m_freem(ppm[x]);
423 ppm[x] = NULL;
424 }
425 }
426}
427
428static void
76
77#include <dev/usb/net/usb_ethernet.h>
78#include <dev/usb/net/if_cdcereg.h>
79
80static device_probe_t cdce_probe;
81static device_attach_t cdce_attach;
82static device_detach_t cdce_detach;
83static device_suspend_t cdce_suspend;

--- 350 unchanged lines hidden (view full) ---

434 if (ppm[x] != NULL) {
435 m_freem(ppm[x]);
436 ppm[x] = NULL;
437 }
438 }
439}
440
441static void
429cdce_bulk_write_callback(struct usb_xfer *xfer)
442cdce_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
430{
443{
431 struct cdce_softc *sc = xfer->priv_sc;
444 struct cdce_softc *sc = usbd_xfer_softc(xfer);
432 struct ifnet *ifp = uether_getifp(&sc->sc_ue);
433 struct mbuf *m;
434 struct mbuf *mt;
435 uint32_t crc;
436 uint8_t x;
445 struct ifnet *ifp = uether_getifp(&sc->sc_ue);
446 struct mbuf *m;
447 struct mbuf *mt;
448 uint32_t crc;
449 uint8_t x;
450 int actlen, aframes;
437
451
452 usbd_xfer_status(xfer, &actlen, NULL, &aframes, NULL);
453
438 DPRINTFN(1, "\n");
439
440 switch (USB_GET_STATE(xfer)) {
441 case USB_ST_TRANSFERRED:
454 DPRINTFN(1, "\n");
455
456 switch (USB_GET_STATE(xfer)) {
457 case USB_ST_TRANSFERRED:
442 DPRINTFN(11, "transfer complete: "
443 "%u bytes in %u frames\n", xfer->actlen,
444 xfer->aframes);
458 DPRINTFN(11, "transfer complete: %u bytes in %u frames\n",
459 actlen, aframes);
445
446 ifp->if_opackets++;
447
448 /* free all previous TX buffers */
449 cdce_free_queue(sc->sc_tx_buf, CDCE_FRAMES_MAX);
450
451 /* FALLTHROUGH */
452 case USB_ST_SETUP:

--- 28 unchanged lines hidden (view full) ---

481 continue;
482 }
483 m = mt;
484 }
485 if (m->m_pkthdr.len > MCLBYTES) {
486 m->m_pkthdr.len = MCLBYTES;
487 }
488 sc->sc_tx_buf[x] = m;
460
461 ifp->if_opackets++;
462
463 /* free all previous TX buffers */
464 cdce_free_queue(sc->sc_tx_buf, CDCE_FRAMES_MAX);
465
466 /* FALLTHROUGH */
467 case USB_ST_SETUP:

--- 28 unchanged lines hidden (view full) ---

496 continue;
497 }
498 m = mt;
499 }
500 if (m->m_pkthdr.len > MCLBYTES) {
501 m->m_pkthdr.len = MCLBYTES;
502 }
503 sc->sc_tx_buf[x] = m;
489 xfer->frlengths[x] = m->m_len;
490 usbd_set_frame_data(xfer, m->m_data, x);
504 usbd_xfer_set_frame_data(xfer, x, m->m_data, m->m_len);
491
492 /*
493 * If there's a BPF listener, bounce a copy of
494 * this frame to him:
495 */
496 BPF_MTAP(ifp, m);
497 }
498 if (x != 0) {
505
506 /*
507 * If there's a BPF listener, bounce a copy of
508 * this frame to him:
509 */
510 BPF_MTAP(ifp, m);
511 }
512 if (x != 0) {
499 xfer->nframes = x;
513 usbd_xfer_set_frames(xfer, x);
514
500 usbd_transfer_submit(xfer);
501 }
502 break;
503
504 default: /* Error */
505 DPRINTFN(11, "transfer error, %s\n",
515 usbd_transfer_submit(xfer);
516 }
517 break;
518
519 default: /* Error */
520 DPRINTFN(11, "transfer error, %s\n",
506 usbd_errstr(xfer->error));
521 usbd_errstr(error));
507
508 /* free all previous TX buffers */
509 cdce_free_queue(sc->sc_tx_buf, CDCE_FRAMES_MAX);
510
511 /* count output errors */
512 ifp->if_oerrors++;
513
522
523 /* free all previous TX buffers */
524 cdce_free_queue(sc->sc_tx_buf, CDCE_FRAMES_MAX);
525
526 /* count output errors */
527 ifp->if_oerrors++;
528
514 if (xfer->error != USB_ERR_CANCELLED) {
529 if (error != USB_ERR_CANCELLED) {
515 /* try to clear stall first */
530 /* try to clear stall first */
516 xfer->flags.stall_pipe = 1;
531 usbd_xfer_set_stall(xfer);
517 goto tr_setup;
518 }
519 break;
520 }
521}
522
523static int32_t
524cdce_m_crc32_cb(void *arg, void *src, uint32_t count)

--- 24 unchanged lines hidden (view full) ---

549
550 ifp->if_drv_flags |= IFF_DRV_RUNNING;
551
552 /* start interrupt transfer */
553 usbd_transfer_start(sc->sc_xfer[CDCE_INTR_RX]);
554 usbd_transfer_start(sc->sc_xfer[CDCE_INTR_TX]);
555
556 /* stall data write direction, which depends on USB mode */
532 goto tr_setup;
533 }
534 break;
535 }
536}
537
538static int32_t
539cdce_m_crc32_cb(void *arg, void *src, uint32_t count)

--- 24 unchanged lines hidden (view full) ---

564
565 ifp->if_drv_flags |= IFF_DRV_RUNNING;
566
567 /* start interrupt transfer */
568 usbd_transfer_start(sc->sc_xfer[CDCE_INTR_RX]);
569 usbd_transfer_start(sc->sc_xfer[CDCE_INTR_TX]);
570
571 /* stall data write direction, which depends on USB mode */
557 usbd_transfer_set_stall(sc->sc_xfer[CDCE_BULK_TX]);
572 usbd_xfer_set_stall(sc->sc_xfer[CDCE_BULK_TX]);
558
559 /* start data transfers */
560 cdce_start(ue);
561}
562
563static void
564cdce_stop(struct usb_ether *ue)
565{

--- 37 unchanged lines hidden (view full) ---

603static int
604cdce_resume(device_t dev)
605{
606 device_printf(dev, "Resuming\n");
607 return (0);
608}
609
610static void
573
574 /* start data transfers */
575 cdce_start(ue);
576}
577
578static void
579cdce_stop(struct usb_ether *ue)
580{

--- 37 unchanged lines hidden (view full) ---

618static int
619cdce_resume(device_t dev)
620{
621 device_printf(dev, "Resuming\n");
622 return (0);
623}
624
625static void
611cdce_bulk_read_callback(struct usb_xfer *xfer)
626cdce_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
612{
627{
613 struct cdce_softc *sc = xfer->priv_sc;
628 struct cdce_softc *sc = usbd_xfer_softc(xfer);
614 struct mbuf *m;
615 uint8_t x;
629 struct mbuf *m;
630 uint8_t x;
631 int actlen, aframes, len;
616
632
633 usbd_xfer_status(xfer, &actlen, NULL, &aframes, NULL);
634
617 switch (USB_GET_STATE(xfer)) {
618 case USB_ST_TRANSFERRED:
619
635 switch (USB_GET_STATE(xfer)) {
636 case USB_ST_TRANSFERRED:
637
620 DPRINTF("received %u bytes in %u frames\n",
621 xfer->actlen, xfer->aframes);
638 DPRINTF("received %u bytes in %u frames\n", actlen, aframes);
622
639
623 for (x = 0; x != xfer->aframes; x++) {
640 for (x = 0; x != aframes; x++) {
624
625 m = sc->sc_rx_buf[x];
626 sc->sc_rx_buf[x] = NULL;
641
642 m = sc->sc_rx_buf[x];
643 sc->sc_rx_buf[x] = NULL;
644 len = usbd_xfer_get_frame_len(xfer, x);
627
628 /* Strip off CRC added by Zaurus, if any */
645
646 /* Strip off CRC added by Zaurus, if any */
629 if ((sc->sc_flags & CDCE_FLAG_ZAURUS) &&
630 (xfer->frlengths[x] >= 14))
631 xfer->frlengths[x] -= 4;
647 if ((sc->sc_flags & CDCE_FLAG_ZAURUS) && len >= 14)
648 len -= 4;
632
649
633 if (xfer->frlengths[x] < sizeof(struct ether_header)) {
650 if (len < sizeof(struct ether_header)) {
634 m_freem(m);
635 continue;
636 }
637 /* queue up mbuf */
651 m_freem(m);
652 continue;
653 }
654 /* queue up mbuf */
638 uether_rxmbuf(&sc->sc_ue, m, xfer->frlengths[x]);
655 uether_rxmbuf(&sc->sc_ue, m, len);
639 }
640
641 /* FALLTHROUGH */
642 case USB_ST_SETUP:
643 /*
644 * TODO: Implement support for multi frame transfers,
645 * when the USB hardware supports it.
646 */
647 for (x = 0; x != 1; x++) {
648 if (sc->sc_rx_buf[x] == NULL) {
649 m = uether_newbuf();
650 if (m == NULL)
651 goto tr_stall;
652 sc->sc_rx_buf[x] = m;
653 } else {
654 m = sc->sc_rx_buf[x];
655 }
656
656 }
657
658 /* FALLTHROUGH */
659 case USB_ST_SETUP:
660 /*
661 * TODO: Implement support for multi frame transfers,
662 * when the USB hardware supports it.
663 */
664 for (x = 0; x != 1; x++) {
665 if (sc->sc_rx_buf[x] == NULL) {
666 m = uether_newbuf();
667 if (m == NULL)
668 goto tr_stall;
669 sc->sc_rx_buf[x] = m;
670 } else {
671 m = sc->sc_rx_buf[x];
672 }
673
657 usbd_set_frame_data(xfer, m->m_data, x);
658 xfer->frlengths[x] = m->m_len;
674 usbd_xfer_set_frame_data(xfer, x, m->m_data, m->m_len);
659 }
660 /* set number of frames and start hardware */
675 }
676 /* set number of frames and start hardware */
661 xfer->nframes = x;
677 usbd_xfer_set_frames(xfer, x);
662 usbd_transfer_submit(xfer);
663 /* flush any received frames */
664 uether_rxflush(&sc->sc_ue);
665 break;
666
667 default: /* Error */
668 DPRINTF("error = %s\n",
678 usbd_transfer_submit(xfer);
679 /* flush any received frames */
680 uether_rxflush(&sc->sc_ue);
681 break;
682
683 default: /* Error */
684 DPRINTF("error = %s\n",
669 usbd_errstr(xfer->error));
685 usbd_errstr(error));
670
686
671 if (xfer->error != USB_ERR_CANCELLED) {
687 if (error != USB_ERR_CANCELLED) {
672tr_stall:
673 /* try to clear stall first */
688tr_stall:
689 /* try to clear stall first */
674 xfer->flags.stall_pipe = 1;
675 xfer->nframes = 0;
690 usbd_xfer_set_stall(xfer);
691 usbd_xfer_set_frames(xfer, 0);
676 usbd_transfer_submit(xfer);
677 break;
678 }
679
680 /* need to free the RX-mbufs when we are cancelled */
681 cdce_free_queue(sc->sc_rx_buf, CDCE_FRAMES_MAX);
682 break;
683 }
684}
685
686static void
692 usbd_transfer_submit(xfer);
693 break;
694 }
695
696 /* need to free the RX-mbufs when we are cancelled */
697 cdce_free_queue(sc->sc_rx_buf, CDCE_FRAMES_MAX);
698 break;
699 }
700}
701
702static void
687cdce_intr_read_callback(struct usb_xfer *xfer)
703cdce_intr_read_callback(struct usb_xfer *xfer, usb_error_t error)
688{
704{
689 ; /* style fix */
705 int actlen;
706
707 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
708
690 switch (USB_GET_STATE(xfer)) {
691 case USB_ST_TRANSFERRED:
692
709 switch (USB_GET_STATE(xfer)) {
710 case USB_ST_TRANSFERRED:
711
693 DPRINTF("Received %d bytes\n",
694 xfer->actlen);
712 DPRINTF("Received %d bytes\n", actlen);
695
696 /* TODO: decode some indications */
697
698 /* FALLTHROUGH */
699 case USB_ST_SETUP:
700tr_setup:
713
714 /* TODO: decode some indications */
715
716 /* FALLTHROUGH */
717 case USB_ST_SETUP:
718tr_setup:
701 xfer->frlengths[0] = xfer->max_data_length;
719 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
702 usbd_transfer_submit(xfer);
703 break;
704
705 default: /* Error */
720 usbd_transfer_submit(xfer);
721 break;
722
723 default: /* Error */
706 if (xfer->error != USB_ERR_CANCELLED) {
724 if (error != USB_ERR_CANCELLED) {
707 /* start clear stall */
725 /* start clear stall */
708 xfer->flags.stall_pipe = 1;
726 usbd_xfer_set_stall(xfer);
709 goto tr_setup;
710 }
711 break;
712 }
713}
714
715static void
727 goto tr_setup;
728 }
729 break;
730 }
731}
732
733static void
716cdce_intr_write_callback(struct usb_xfer *xfer)
734cdce_intr_write_callback(struct usb_xfer *xfer, usb_error_t error)
717{
735{
718 ; /* style fix */
736 int actlen;
737
738 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
739
719 switch (USB_GET_STATE(xfer)) {
720 case USB_ST_TRANSFERRED:
721
740 switch (USB_GET_STATE(xfer)) {
741 case USB_ST_TRANSFERRED:
742
722 DPRINTF("Transferred %d bytes\n", xfer->actlen);
743 DPRINTF("Transferred %d bytes\n", actlen);
723
724 /* FALLTHROUGH */
725 case USB_ST_SETUP:
726tr_setup:
727#if 0
744
745 /* FALLTHROUGH */
746 case USB_ST_SETUP:
747tr_setup:
748#if 0
728 xfer->frlengths[0] = XXX;
749 usbd_xfer_set_frame_len(xfer, 0, XXX);
729 usbd_transfer_submit(xfer);
730#endif
731 break;
732
733 default: /* Error */
750 usbd_transfer_submit(xfer);
751#endif
752 break;
753
754 default: /* Error */
734 if (xfer->error != USB_ERR_CANCELLED) {
755 if (error != USB_ERR_CANCELLED) {
735 /* start clear stall */
756 /* start clear stall */
736 xfer->flags.stall_pipe = 1;
757 usbd_xfer_set_stall(xfer);
737 goto tr_setup;
738 }
739 break;
740 }
741}
742
743static int
744cdce_handle_request(device_t dev,
745 const void *req, void **pptr, uint16_t *plen,
746 uint16_t offset, uint8_t is_complete)
747{
748 return (ENXIO); /* use builtin handler */
749}
758 goto tr_setup;
759 }
760 break;
761 }
762}
763
764static int
765cdce_handle_request(device_t dev,
766 const void *req, void **pptr, uint16_t *plen,
767 uint16_t offset, uint8_t is_complete)
768{
769 return (ENXIO); /* use builtin handler */
770}