static int
kue_send(struct kue_softc *sc, struct mbuf *m, int idx)
{
int total_len;
struct kue_chain *c;
usbd_status err;
DPRINTFN(10,("%s: %s: enter\n", device_xname(sc->kue_dev),__func__));
c = &sc->kue_cdata.kue_tx_chain[idx];
/* Frame length is specified in the first 2 bytes of the buffer. */
le16enc(c->kue_buf, (uint16_t)m->m_pkthdr.len);
/*
* Copy the mbuf data into a contiguous buffer, leaving two
* bytes at the beginning to hold the frame length.
*/
m_copydata(m, 0, m->m_pkthdr.len, c->kue_buf + 2);
total_len = 2 + m->m_pkthdr.len;
total_len = roundup2(total_len, 64);
usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_TX],
c, c->kue_buf, total_len, USBD_NO_COPY, USBD_DEFAULT_TIMEOUT,
kue_txeof);
/* Transmit */
err = usbd_transfer(c->kue_xfer);
if (err != USBD_IN_PROGRESS) {
printf("%s: kue_send error=%s\n", device_xname(sc->kue_dev),
usbd_errstr(err));
kue_stop(sc);
return (EIO);
}
sc->kue_cdata.kue_tx_cnt++;
return (0);
}
int
kue_open_pipes(struct kue_softc *sc)
{
usbd_status err;
struct kue_chain *c;
int i;
DPRINTFN(5,("%s: %s: enter\n", sc->kue_dev.dv_xname,__func__));
/* Open RX and TX pipes. */
err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_RX],
USBD_EXCLUSIVE_USE, &sc->kue_ep[KUE_ENDPT_RX]);
if (err) {
printf("%s: open rx pipe failed: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
return (EIO);
}
err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_TX],
USBD_EXCLUSIVE_USE, &sc->kue_ep[KUE_ENDPT_TX]);
if (err) {
printf("%s: open tx pipe failed: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
return (EIO);
}
/* Start up the receive pipe. */
for (i = 0; i < KUE_RX_LIST_CNT; i++) {
c = &sc->kue_cdata.kue_rx_chain[i];
usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX],
c, c->kue_buf, KUE_BUFSZ,
USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT,
kue_rxeof);
DPRINTFN(5,("%s: %s: start read\n", sc->kue_dev.dv_xname,
__func__));
usbd_transfer(c->kue_xfer);
}
return (0);
}
/* General CDC asynchronous transfer function */
static jresult_t cdc_async_transfer(cdc_cmd_priv_t *priv,
usbd_pipe_handle pipe, void *membuf, juint32_t size,
usbd_xfer_handle xfer)
{
jresult_t rc;
usbd_status status;
juint16_t flags = USBD_SHORT_XFER_OK | USBD_FORCE_SHORT_XFER;
DECLARE_FNAME("cdc_async_transfer");
DBG_X(DHOST_CDC_GENERAL, ("%s: Entered\n", fname));
/* Allocate a transfer request object and set up a xfer */
xfer = usbd_alloc_xfer(priv->sc->device);
if (!xfer)
{
DBG_E(DHOST_CDC_GENERAL, ("%s: Failed to allocate xfer\n", fname));
rc = JENOMEM;
goto Error;
}
usbd_setup_xfer(xfer, pipe, (void *)priv, membuf, size, flags,
CDC_DATA_XFER_TIMEOUT, cdc_data_xfer_complete);
/* Execute xfer */
status = usbd_transfer(xfer);
if (status && status != USBD_IN_PROGRESS)
{
DBG_W(DHOST_CDC_GENERAL, ("%s: failed to setup transfer, %s\n", fname,
usbd_errstr(status)));
rc = status_to_result(status);
goto Error;
}
return 0;
Error:
if (xfer)
usbd_free_xfer(xfer);
return rc;
}
static usbd_status
udsir_start_read(struct udsir_softc *sc)
{
usbd_status err;
DPRINTFN(60, ("%s: sc=%p, size=%d\n", __func__, sc, sc->sc_rd_maxpsz));
if (sc->sc_dying)
return USBD_IOERROR;
if (UDSIR_BLOCK_RX_DATA(sc) || deframe_rd_ur(sc)) {
/*
* Can't start reading just yet. Since we aren't
* going to start a read, have to switch direction to
* idle.
*/
sc->sc_direction = udir_idle;
return USBD_NORMAL_COMPLETION;
}
/* Starting a read... */
sc->sc_rd_readinprogress = 1;
sc->sc_direction = udir_input;
if (sc->sc_rd_err) {
sc->sc_rd_err = 0;
DPRINTFN(0, ("%s: clear stall\n", __func__));
usbd_clear_endpoint_stall(sc->sc_rd_pipe);
}
usbd_setup_xfer(sc->sc_rd_xfer, sc, sc->sc_rd_buf, sc->sc_rd_maxpsz,
USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, udsir_rd_cb);
err = usbd_transfer(sc->sc_rd_xfer);
if (err != USBD_IN_PROGRESS) {
DPRINTFN(0, ("%s: err=%d\n", __func__, (int)err));
return err;
}
return USBD_NORMAL_COMPLETION;
}
void
ubt_recv_acl_start(struct ubt_softc *sc)
{
usbd_status status;
DPRINTFN(15, "sc=%p\n", sc);
if (sc->sc_aclrd_busy || sc->sc_dying) {
DPRINTF("sc_aclrd_busy=%d, sc_dying=%d\n",
sc->sc_aclrd_busy,
sc->sc_dying);
return;
}
sc->sc_refcnt++;
sc->sc_aclrd_busy = 1;
usbd_setup_xfer(sc->sc_aclrd_xfer,
sc->sc_aclrd_pipe,
sc,
sc->sc_aclrd_buf,
UBT_BUFSIZ_ACL,
USBD_NO_COPY | USBD_SHORT_XFER_OK,
USBD_NO_TIMEOUT,
ubt_recv_acl_complete);
status = usbd_transfer(sc->sc_aclrd_xfer);
KKASSERT(status != USBD_NORMAL_COMPLETION);
if (status != USBD_IN_PROGRESS) {
DPRINTF("usbd_transfer status=%s (%d)\n",
usbd_errstr(status), status);
sc->sc_refcnt--;
sc->sc_aclrd_busy = 0;
}
}
/*
* Start transfer from internal queue
*/
static int
lgue_start_transfer(struct lgue_softc *sc) {
usbd_status err;
struct lgue_queue_entry *entry;
struct ifnet *ifp;
if (STAILQ_EMPTY(&sc->lgue_tx_queue))
return(0);
ifp = &sc->lgue_arpcom.ac_if;
entry = STAILQ_FIRST(&sc->lgue_tx_queue);
STAILQ_REMOVE_HEAD(&sc->lgue_tx_queue, entry_next);
m_copydata(entry->entry_mbuf, 0, entry->entry_mbuf->m_pkthdr.len,
sc->lgue_tx_buf);
/* Transmit */
usbd_setup_xfer(sc->lgue_tx_xfer, sc->lgue_ep[LGUE_ENDPT_TX], sc,
sc->lgue_tx_buf, entry->entry_mbuf->m_pkthdr.len,
USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, lgue_txeof);
err = usbd_transfer(sc->lgue_tx_xfer);
if (err != USBD_IN_PROGRESS) {
m_freem(entry->entry_mbuf);
kfree(entry, M_USBDEV);
lgue_stop(sc);
ifq_clr_oactive(&ifp->if_snd);
return(EIO);
}
m_freem(entry->entry_mbuf);
kfree(entry, M_USBDEV);
sc->lgue_tx_cnt++;
ifq_set_oactive(&ifp->if_snd);
ifp->if_timer = 5;
return(0);
}
static int
emdtv_dtv_isoc_start(struct emdtv_softc *sc, struct emdtv_isoc_xfer *ix)
{
int i;
if (sc->sc_isoc_pipe == NULL)
return EIO;
for (i = 0; i < EMDTV_NFRAMES; i++)
ix->ix_frlengths[i] = sc->sc_isoc_maxpacketsize;
usbd_setup_isoc_xfer(ix->ix_xfer,
ix,
ix->ix_frlengths,
EMDTV_NFRAMES,
USBD_SHORT_XFER_OK,
emdtv_dtv_isoc);
KERNEL_LOCK(1, curlwp);
usbd_transfer(ix->ix_xfer);
KERNEL_UNLOCK_ONE(curlwp);
return 0;
}
int
wi_usb_open_pipes(struct wi_usb_softc *sc)
{
usbd_status err;
int error = 0;
struct wi_usb_chain *c;
int i;
DPRINTFN(10,("%s: %s: enter\n", sc->wi_usb_dev.dv_xname,__func__));
sc->wi_usb_refcnt++;
/* Open RX and TX pipes. */
err = usbd_open_pipe(sc->wi_usb_iface, sc->wi_usb_ed[WI_USB_ENDPT_RX],
USBD_EXCLUSIVE_USE, &sc->wi_usb_ep[WI_USB_ENDPT_RX]);
if (err) {
printf("%s: open rx pipe failed: %s\n",
sc->wi_usb_dev.dv_xname, usbd_errstr(err));
error = EIO;
goto done;
}
err = usbd_open_pipe(sc->wi_usb_iface, sc->wi_usb_ed[WI_USB_ENDPT_TX],
USBD_EXCLUSIVE_USE, &sc->wi_usb_ep[WI_USB_ENDPT_TX]);
if (err) {
printf("%s: open tx pipe failed: %s\n",
sc->wi_usb_dev.dv_xname, usbd_errstr(err));
error = EIO;
goto done;
}
/* is this used? */
err = usbd_open_pipe_intr(sc->wi_usb_iface,
sc->wi_usb_ed[WI_USB_ENDPT_INTR], USBD_EXCLUSIVE_USE,
&sc->wi_usb_ep[WI_USB_ENDPT_INTR], sc, &sc->wi_usb_ibuf,
WI_USB_INTR_PKTLEN, wi_usb_intr, WI_USB_INTR_INTERVAL);
if (err) {
printf("%s: open intr pipe failed: %s\n",
sc->wi_usb_dev.dv_xname, usbd_errstr(err));
error = EIO;
goto done;
}
/* Start up the receive pipe. */
for (i = 0; i < WI_USB_RX_LIST_CNT; i++) {
c = &sc->wi_usb_rx_chain[i];
usbd_setup_xfer(c->wi_usb_xfer, sc->wi_usb_ep[WI_USB_ENDPT_RX],
c, c->wi_usb_buf, WI_USB_BUFSZ,
USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT,
wi_usb_rxeof);
DPRINTFN(10,("%s: %s: start read\n", sc->wi_usb_dev.dv_xname,
__func__));
usbd_transfer(c->wi_usb_xfer);
}
done:
if (--sc->wi_usb_refcnt < 0)
usb_detach_wakeup(&sc->wi_usb_dev);
return (error);
}
static int
uticom_download_fw(struct uticom_softc *sc, int pipeno,
struct usbd_device *dev)
{
u_char *obuf, *firmware;
size_t firmware_size;
int buffer_size, pos;
uint8_t cs = 0, *buffer;
usbd_status err;
struct uticom_fw_header *header;
struct usbd_xfer *oxfer = 0;
usbd_status error = 0;
struct usbd_pipe *pipe;
error = loadfirmware("tusb3410", &firmware, &firmware_size);
if (error)
return (error);
buffer_size = UTICOM_FW_BUFSZ + sizeof(struct uticom_fw_header);
buffer = malloc(buffer_size, M_USBDEV, M_WAITOK | M_CANFAIL);
if (!buffer) {
printf("%s: uticom_download_fw: out of memory\n",
sc->sc_dev.dv_xname);
free(firmware, M_DEVBUF);
return ENOMEM;
}
memcpy(buffer, firmware, firmware_size);
memset(buffer + firmware_size, 0xff, buffer_size - firmware_size);
for (pos = sizeof(struct uticom_fw_header); pos < buffer_size; pos++)
cs = (uint8_t)(cs + buffer[pos]);
header = (struct uticom_fw_header*)buffer;
header->length = (uint16_t)(buffer_size -
sizeof(struct uticom_fw_header));
header->checkSum = cs;
DPRINTF(("%s: downloading firmware ...\n",
sc->sc_dev.dv_xname));
err = usbd_open_pipe(sc->sc_iface, pipeno, USBD_EXCLUSIVE_USE,
&pipe);
if (err) {
printf("%s: open bulk out error (addr %d): %s\n",
sc->sc_dev.dv_xname, pipeno, usbd_errstr(err));
error = EIO;
goto finish;
}
oxfer = usbd_alloc_xfer(dev);
if (oxfer == NULL) {
error = ENOMEM;
goto finish;
}
obuf = usbd_alloc_buffer(oxfer, buffer_size);
if (obuf == NULL) {
error = ENOMEM;
goto finish;
}
memcpy(obuf, buffer, buffer_size);
usbd_setup_xfer(oxfer, pipe, (void *)sc, obuf, buffer_size,
USBD_NO_COPY | USBD_SYNCHRONOUS, USBD_NO_TIMEOUT, 0);
err = usbd_transfer(oxfer);
if (err != USBD_NORMAL_COMPLETION)
printf("%s: uticom_download_fw: error: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
finish:
free(firmware, M_DEVBUF);
usbd_free_buffer(oxfer);
usbd_free_xfer(oxfer);
oxfer = NULL;
usbd_abort_pipe(pipe);
usbd_close_pipe(pipe);
free(buffer, M_USBDEV);
return err;
}
usbd_status
umsm_umass_changemode(struct umsm_softc *sc)
{
#define UMASS_CMD_REZERO_UNIT 0x01
#define UMASS_CMD_START_STOP 0x1b
#define UMASS_CMDPARAM_EJECT 0x02
#define UMASS_SERVICE_ACTION_OUT 0x9f
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
struct usbd_xfer *xfer;
struct usbd_pipe *cmdpipe;
usbd_status err;
u_int32_t n;
void *bufp;
int target_ep, i;
struct umass_bbb_cbw cbw;
static int dCBWTag = 0x12345678;
USETDW(cbw.dCBWSignature, CBWSIGNATURE);
USETDW(cbw.dCBWTag, dCBWTag);
cbw.bCBWLUN = 0;
cbw.bCDBLength= 6;
bzero(cbw.CBWCDB, sizeof(cbw.CBWCDB));
switch (sc->sc_flag) {
case DEV_UMASS1:
USETDW(cbw.dCBWDataTransferLength, 0x0);
cbw.bCBWFlags = CBWFLAGS_OUT;
cbw.CBWCDB[0] = UMASS_CMD_REZERO_UNIT;
cbw.CBWCDB[1] = 0x0; /* target LUN: 0 */
break;
case DEV_UMASS2:
USETDW(cbw.dCBWDataTransferLength, 0x1);
cbw.bCBWFlags = CBWFLAGS_IN;
cbw.CBWCDB[0] = UMASS_CMD_REZERO_UNIT;
cbw.CBWCDB[1] = 0x0; /* target LUN: 0 */
break;
case DEV_UMASS3: /* longcheer */
USETDW(cbw.dCBWDataTransferLength, 0x80);
cbw.bCBWFlags = CBWFLAGS_IN;
cbw.CBWCDB[0] = 0x06;
cbw.CBWCDB[1] = 0xf5;
cbw.CBWCDB[2] = 0x04;
cbw.CBWCDB[3] = 0x02;
cbw.CBWCDB[4] = 0x52;
cbw.CBWCDB[5] = 0x70;
break;
case DEV_UMASS4:
USETDW(cbw.dCBWDataTransferLength, 0x0);
cbw.bCBWFlags = CBWFLAGS_OUT;
cbw.CBWCDB[0] = UMASS_CMD_START_STOP;
cbw.CBWCDB[1] = 0x00; /* target LUN: 0 */
cbw.CBWCDB[4] = UMASS_CMDPARAM_EJECT;
break;
case DEV_UMASS5:
cbw.bCBWFlags = CBWFLAGS_OUT;
cbw.CBWCDB[0] = 0x11;
cbw.CBWCDB[1] = 0x06;
break;
case DEV_UMASS6: /* ZTE */
USETDW(cbw.dCBWDataTransferLength, 0x20);
cbw.bCBWFlags = CBWFLAGS_IN;
cbw.bCDBLength= 12;
cbw.CBWCDB[0] = 0x85;
cbw.CBWCDB[1] = 0x01;
cbw.CBWCDB[2] = 0x01;
cbw.CBWCDB[3] = 0x01;
cbw.CBWCDB[4] = 0x18;
cbw.CBWCDB[5] = 0x01;
cbw.CBWCDB[6] = 0x01;
cbw.CBWCDB[7] = 0x01;
cbw.CBWCDB[8] = 0x01;
cbw.CBWCDB[9] = 0x01;
break;
case DEV_UMASS7: /* ZTE */
USETDW(cbw.dCBWDataTransferLength, 0xc0);
cbw.bCBWFlags = CBWFLAGS_IN;
cbw.CBWCDB[0] = UMASS_SERVICE_ACTION_OUT;
cbw.CBWCDB[1] = 0x03;
break;
case DEV_UMASS8:
USETDW(cbw.dCBWDataTransferLength, 0x0);
cbw.bCBWFlags = CBWFLAGS_OUT;
cbw.CBWCDB[0] = 0xf0;
cbw.CBWCDB[1] = 0x01;
cbw.CBWCDB[2] = 0x03;
break;
default:
DPRINTF(("%s: unknown device type.\n", sc->sc_dev.dv_xname));
break;
}
/* get command endpoint address */
id = usbd_get_interface_descriptor(sc->sc_iface);
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
if (ed == NULL) {
return (USBD_IOERROR);
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
target_ep = ed->bEndpointAddress;
}
/* open command endppoint */
err = usbd_open_pipe(sc->sc_iface, target_ep,
USBD_EXCLUSIVE_USE, &cmdpipe);
if (err) {
DPRINTF(("%s: open pipe for modem change cmd failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err)));
return (err);
}
xfer = usbd_alloc_xfer(sc->sc_udev);
if (xfer == NULL) {
usbd_close_pipe(cmdpipe);
return (USBD_NOMEM);
} else {
bufp = usbd_alloc_buffer(xfer, UMASS_BBB_CBW_SIZE);
if (bufp == NULL)
err = USBD_NOMEM;
else {
n = UMASS_BBB_CBW_SIZE;
memcpy(bufp, &cbw, UMASS_BBB_CBW_SIZE);
usbd_setup_xfer(xfer, cmdpipe, 0, bufp, n,
USBD_NO_COPY | USBD_SYNCHRONOUS, 0, NULL);
err = usbd_transfer(xfer);
if (err) {
usbd_clear_endpoint_stall(cmdpipe);
DPRINTF(("%s: send error:%s", __func__,
usbd_errstr(err)));
}
}
usbd_close_pipe(cmdpipe);
usbd_free_buffer(xfer);
usbd_free_xfer(xfer);
}
return (err);
}
void
ubt_xmit_sco_start1(struct ubt_softc *sc, struct ubt_isoc_xfer *isoc)
{
struct mbuf *m;
uint8_t *buf;
int num, len, size, space;
if (sc->sc_dying)
return;
space = sc->sc_scowr_size * UBT_NFRAMES;
buf = isoc->buf;
len = 0;
/*
* Fill the request buffer with data from the queue,
* keeping any leftover packet on our private hook.
*
* Complete packets are passed back up to the stack
* for disposal, since we can't rely on the controller
* to tell us when it has finished with them.
*/
m = sc->sc_scowr_mbuf;
while (space > 0) {
if (m == NULL) {
crit_enter();
IF_DEQUEUE(&sc->sc_scowr_queue, m);
crit_exit();
if (m == NULL)
break;
m_adj(m, 1); /* packet type */
}
if (m->m_pkthdr.len > 0) {
size = MIN(m->m_pkthdr.len, space);
m_copydata(m, 0, size, buf);
m_adj(m, size);
buf += size;
len += size;
space -= size;
}
if (m->m_pkthdr.len == 0) {
sc->sc_stats.sco_tx++;
if (!hci_complete_sco(sc->sc_unit, m))
sc->sc_stats.err_tx++;
m = NULL;
}
}
sc->sc_scowr_mbuf = m;
DPRINTFN(15, "isoc=%p, len=%d, space=%d\n", isoc, len, space);
if (len == 0) /* nothing to send */
return;
sc->sc_refcnt++;
sc->sc_scowr_busy = 1;
sc->sc_stats.byte_tx += len;
isoc->busy = 1;
/*
* calculate number of isoc frames and sizes
*/
for (num = 0 ; len > 0 ; num++) {
size = MIN(sc->sc_scowr_size, len);
isoc->size[num] = size;
len -= size;
}
usbd_setup_isoc_xfer(isoc->xfer,
sc->sc_scowr_pipe,
isoc,
isoc->size,
num,
USBD_NO_COPY | USBD_FORCE_SHORT_XFER,
ubt_xmit_sco_complete);
usbd_transfer(isoc->xfer);
}
/*
* A frame has been uploaded: pass the resulting mbuf chain up to
* the higher level protocols.
*/
void
kue_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
{
struct kue_chain *c = priv;
struct kue_softc *sc = c->kue_sc;
struct ifnet *ifp = GET_IFP(sc);
struct mbuf *m;
int total_len = 0;
int s;
DPRINTFN(10,("%s: %s: enter status=%d\n", sc->kue_dev.dv_xname,
__func__, status));
if (sc->kue_dying)
return;
if (!(ifp->if_flags & IFF_RUNNING))
return;
if (status != USBD_NORMAL_COMPLETION) {
if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
return;
sc->kue_rx_errs++;
if (usbd_ratecheck(&sc->kue_rx_notice)) {
printf("%s: %u usb errors on rx: %s\n",
sc->kue_dev.dv_xname, sc->kue_rx_errs,
usbd_errstr(status));
sc->kue_rx_errs = 0;
}
if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(sc->kue_ep[KUE_ENDPT_RX]);
goto done;
}
usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
DPRINTFN(10,("%s: %s: total_len=%d len=%d\n", sc->kue_dev.dv_xname,
__func__, total_len,
UGETW(mtod(c->kue_mbuf, u_int8_t *))));
if (total_len <= 1)
goto done;
m = c->kue_mbuf;
/* copy data to mbuf */
memcpy(mtod(m, char *), c->kue_buf, total_len);
/* No errors; receive the packet. */
total_len = UGETW(mtod(m, u_int8_t *));
m_adj(m, sizeof(u_int16_t));
if (total_len < sizeof(struct ether_header)) {
ifp->if_ierrors++;
goto done;
}
ifp->if_ipackets++;
m->m_pkthdr.len = m->m_len = total_len;
m->m_pkthdr.rcvif = ifp;
s = splnet();
/* XXX ugly */
if (kue_newbuf(sc, c, NULL) == ENOBUFS) {
ifp->if_ierrors++;
goto done1;
}
#if NBPFILTER > 0
/*
* Handle BPF listeners. Let the BPF user see the packet, but
* don't pass it up to the ether_input() layer unless it's
* a broadcast packet, multicast packet, matches our ethernet
* address or the interface is in promiscuous mode.
*/
if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
#endif
DPRINTFN(10,("%s: %s: deliver %d\n", sc->kue_dev.dv_xname,
__func__, m->m_len));
ether_input_mbuf(ifp, m);
done1:
splx(s);
done:
/* Setup new transfer. */
usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX],
c, c->kue_buf, KUE_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY,
USBD_NO_TIMEOUT, kue_rxeof);
usbd_transfer(c->kue_xfer);
DPRINTFN(10,("%s: %s: start rx\n", sc->kue_dev.dv_xname,
__func__));
}
Static void
cdce_init(void *xsc)
{
struct cdce_softc *sc = xsc;
struct ifnet *ifp = GET_IFP(sc);
struct ue_chain *c;
usbd_status err;
int i;
if (ifp->if_flags & IFF_RUNNING)
return;
CDCE_LOCK(sc);
cdce_reset(sc);
if (usb_ether_tx_list_init(sc, &sc->cdce_cdata,
sc->cdce_udev) == ENOBUFS) {
printf("%s: tx list init failed\n", USBDEVNAME(sc->cdce_dev));
CDCE_UNLOCK(sc);
return;
}
if (usb_ether_rx_list_init(sc, &sc->cdce_cdata,
sc->cdce_udev) == ENOBUFS) {
printf("%s: rx list init failed\n", USBDEVNAME(sc->cdce_dev));
CDCE_UNLOCK(sc);
return;
}
/* Maybe set multicast / broadcast here??? */
err = usbd_open_pipe(sc->cdce_data_iface, sc->cdce_bulkin_no,
USBD_EXCLUSIVE_USE, &sc->cdce_bulkin_pipe);
if (err) {
printf("%s: open rx pipe failed: %s\n", USBDEVNAME(sc->cdce_dev),
usbd_errstr(err));
CDCE_UNLOCK(sc);
return;
}
err = usbd_open_pipe(sc->cdce_data_iface, sc->cdce_bulkout_no,
USBD_EXCLUSIVE_USE, &sc->cdce_bulkout_pipe);
if (err) {
printf("%s: open tx pipe failed: %s\n", USBDEVNAME(sc->cdce_dev),
usbd_errstr(err));
CDCE_UNLOCK(sc);
return;
}
for (i = 0; i < UE_RX_LIST_CNT; i++) {
c = &sc->cdce_cdata.ue_rx_chain[i];
usbd_setup_xfer(c->ue_xfer, sc->cdce_bulkin_pipe, c,
mtod(c->ue_mbuf, char *), UE_BUFSZ, USBD_SHORT_XFER_OK,
USBD_NO_TIMEOUT, cdce_rxeof);
usbd_transfer(c->ue_xfer);
}
ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
CDCE_UNLOCK(sc);
return;
}
void
smsc_init(void *xsc)
{
struct smsc_softc *sc = xsc;
struct ifnet *ifp = &sc->sc_ac.ac_if;
struct smsc_chain *c;
usbd_status err;
int s, i;
s = splnet();
/* Cancel pending I/O */
smsc_stop(sc);
/* Reset the ethernet interface. */
smsc_reset(sc);
/* Init RX ring. */
if (smsc_rx_list_init(sc) == ENOBUFS) {
printf("%s: rx list init failed\n", sc->sc_dev.dv_xname);
splx(s);
return;
}
/* Init TX ring. */
if (smsc_tx_list_init(sc) == ENOBUFS) {
printf("%s: tx list init failed\n", sc->sc_dev.dv_xname);
splx(s);
return;
}
/* Program promiscuous mode and multicast filters. */
smsc_iff(sc);
/* Open RX and TX pipes. */
err = usbd_open_pipe(sc->sc_iface, sc->sc_ed[SMSC_ENDPT_RX],
USBD_EXCLUSIVE_USE, &sc->sc_ep[SMSC_ENDPT_RX]);
if (err) {
printf("%s: open rx pipe failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
splx(s);
return;
}
err = usbd_open_pipe(sc->sc_iface, sc->sc_ed[SMSC_ENDPT_TX],
USBD_EXCLUSIVE_USE, &sc->sc_ep[SMSC_ENDPT_TX]);
if (err) {
printf("%s: open tx pipe failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
splx(s);
return;
}
/* Start up the receive pipe. */
for (i = 0; i < SMSC_RX_LIST_CNT; i++) {
c = &sc->sc_cdata.rx_chain[i];
usbd_setup_xfer(c->sc_xfer, sc->sc_ep[SMSC_ENDPT_RX],
c, c->sc_buf, sc->sc_bufsz,
USBD_SHORT_XFER_OK | USBD_NO_COPY,
USBD_NO_TIMEOUT, smsc_rxeof);
usbd_transfer(c->sc_xfer);
}
/* TCP/UDP checksum offload engines. */
smsc_sethwcsum(sc);
/* Indicate we are up and running. */
ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
timeout_add_sec(&sc->sc_stat_ch, 1);
splx(s);
}
/*
* A frame has been uploaded: pass the resulting mbuf chain up to
* the higher level protocols.
*/
static void
kue_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
{
struct kue_chain *c = priv;
struct kue_softc *sc = c->kue_sc;
struct ifnet *ifp = GET_IFP(sc);
struct mbuf *m;
int total_len, pktlen;
int s;
DPRINTFN(10,("%s: %s: enter status=%d\n", device_xname(sc->kue_dev),
__func__, status));
if (sc->kue_dying)
return;
if (!(ifp->if_flags & IFF_RUNNING))
return;
if (status != USBD_NORMAL_COMPLETION) {
if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
return;
sc->kue_rx_errs++;
if (usbd_ratecheck(&sc->kue_rx_notice)) {
printf("%s: %u usb errors on rx: %s\n",
device_xname(sc->kue_dev), sc->kue_rx_errs,
usbd_errstr(status));
sc->kue_rx_errs = 0;
}
if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(sc->kue_ep[KUE_ENDPT_RX]);
goto done;
}
usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
DPRINTFN(10,("%s: %s: total_len=%d len=%d\n", device_xname(sc->kue_dev),
__func__, total_len,
le16dec(c->kue_buf)));
if (total_len <= 1)
goto done;
pktlen = le16dec(c->kue_buf);
if (pktlen > total_len - 2)
pktlen = total_len - 2;
if (pktlen < ETHER_MIN_LEN - ETHER_CRC_LEN ||
pktlen > MCLBYTES - ETHER_ALIGN) {
ifp->if_ierrors++;
goto done;
}
/* No errors; receive the packet. */
MGETHDR(m, M_DONTWAIT, MT_DATA);
if (m == NULL) {
ifp->if_ierrors++;
goto done;
}
if (pktlen > MHLEN - ETHER_ALIGN) {
MCLGET(m, M_DONTWAIT);
if ((m->m_flags & M_EXT) == 0) {
m_freem(m);
ifp->if_ierrors++;
goto done;
}
}
m->m_data += ETHER_ALIGN;
/* copy data to mbuf */
memcpy(mtod(m, uint8_t *), c->kue_buf + 2, pktlen);
ifp->if_ipackets++;
m->m_pkthdr.len = m->m_len = pktlen;
m->m_pkthdr.rcvif = ifp;
s = splnet();
/*
* Handle BPF listeners. Let the BPF user see the packet, but
* don't pass it up to the ether_input() layer unless it's
* a broadcast packet, multicast packet, matches our ethernet
* address or the interface is in promiscuous mode.
*/
bpf_mtap(ifp, m);
DPRINTFN(10,("%s: %s: deliver %d\n", device_xname(sc->kue_dev),
__func__, m->m_len));
(*ifp->if_input)(ifp, m);
splx(s);
done:
/* Setup new transfer. */
usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX],
c, c->kue_buf, KUE_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY,
USBD_NO_TIMEOUT, kue_rxeof);
usbd_transfer(c->kue_xfer);
DPRINTFN(10,("%s: %s: start rx\n", device_xname(sc->kue_dev),
__func__));
}
void
ucomstart(struct tty *tp)
{
struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(tp->t_dev)];
usbd_status err;
int s;
u_char *data;
int cnt;
if (sc == NULL || usbd_is_dying(sc->sc_uparent))
return;
s = spltty();
if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP)) {
DPRINTFN(4,("ucomstart: no go, state=0x%x\n", tp->t_state));
goto out;
}
if (sc->sc_tx_stopped)
goto out;
ttwakeupwr(tp);
if (tp->t_outq.c_cc == 0)
goto out;
/* Grab the first contiguous region of buffer space. */
data = tp->t_outq.c_cf;
cnt = ndqb(&tp->t_outq, 0);
if (cnt == 0) {
DPRINTF(("ucomstart: cnt==0\n"));
goto out;
}
SET(tp->t_state, TS_BUSY);
if (cnt > sc->sc_obufsize) {
DPRINTF(("ucomstart: big buffer %d chars\n", cnt));
cnt = sc->sc_obufsize;
}
if (sc->sc_methods->ucom_write != NULL)
sc->sc_methods->ucom_write(sc->sc_parent, sc->sc_portno,
sc->sc_obuf, data, &cnt);
else
memcpy(sc->sc_obuf, data, cnt);
DPRINTFN(4,("ucomstart: %d chars\n", cnt));
#ifdef DIAGNOSTIC
if (sc->sc_oxfer == NULL) {
printf("ucomstart: null oxfer\n");
goto out;
}
#endif
if (sc->sc_bulkout_pipe != NULL) {
usbd_setup_xfer(sc->sc_oxfer, sc->sc_bulkout_pipe,
(void *)sc, sc->sc_obuf, cnt,
USBD_NO_COPY, USBD_NO_TIMEOUT, ucomwritecb);
} else {
usbd_setup_xfer(sc->sc_oxfer, sc->sc_opipe,
(void *)sc, sc->sc_obuf, cnt,
USBD_NO_COPY, USBD_NO_TIMEOUT, ucomwritecb);
}
/* What can we do on error? */
err = usbd_transfer(sc->sc_oxfer);
#ifdef DIAGNOSTIC
if (err != USBD_IN_PROGRESS)
printf("ucomstart: err=%s\n", usbd_errstr(err));
#endif
out:
splx(s);
}
int
ugen_do_write(struct ugen_softc *sc, int endpt, struct uio *uio, int flag)
{
struct ugen_endpoint *sce = &sc->sc_endpoints[endpt][OUT];
u_int32_t n;
int flags, error = 0;
char buf[UGEN_BBSIZE];
struct usbd_xfer *xfer;
usbd_status err;
DPRINTFN(5, ("%s: ugenwrite: %d\n", sc->sc_dev.dv_xname, endpt));
if (usbd_is_dying(sc->sc_udev))
return (EIO);
if (endpt == USB_CONTROL_ENDPOINT)
return (ENODEV);
#ifdef DIAGNOSTIC
if (sce->edesc == NULL) {
printf("ugenwrite: no edesc\n");
return (EIO);
}
if (sce->pipeh == NULL) {
printf("ugenwrite: no pipe\n");
return (EIO);
}
#endif
flags = USBD_SYNCHRONOUS;
if (sce->timeout == 0)
flags |= USBD_CATCH;
switch (sce->edesc->bmAttributes & UE_XFERTYPE) {
case UE_BULK:
xfer = usbd_alloc_xfer(sc->sc_udev);
if (xfer == 0)
return (EIO);
while ((n = min(UGEN_BBSIZE, uio->uio_resid)) != 0) {
error = uiomove(buf, n, uio);
if (error)
break;
DPRINTFN(1, ("ugenwrite: transfer %d bytes\n", n));
usbd_setup_xfer(xfer, sce->pipeh, 0, buf, n,
flags, sce->timeout, NULL);
err = usbd_transfer(xfer);
if (err) {
usbd_clear_endpoint_stall(sce->pipeh);
if (err == USBD_INTERRUPTED)
error = EINTR;
else if (err == USBD_TIMEOUT)
error = ETIMEDOUT;
else
error = EIO;
break;
}
}
usbd_free_xfer(xfer);
break;
case UE_INTERRUPT:
xfer = usbd_alloc_xfer(sc->sc_udev);
if (xfer == 0)
return (EIO);
while ((n = min(UGETW(sce->edesc->wMaxPacketSize),
uio->uio_resid)) != 0) {
error = uiomove(buf, n, uio);
if (error)
break;
DPRINTFN(1, ("ugenwrite: transfer %d bytes\n", n));
usbd_setup_xfer(xfer, sce->pipeh, 0, buf, n,
flags, sce->timeout, NULL);
err = usbd_transfer(xfer);
if (err) {
usbd_clear_endpoint_stall(sce->pipeh);
if (err == USBD_INTERRUPTED)
error = EINTR;
else if (err == USBD_TIMEOUT)
error = ETIMEDOUT;
else
error = EIO;
break;
}
}
usbd_free_xfer(xfer);
break;
default:
return (ENXIO);
}
return (error);
}
int
ugen_do_read(struct ugen_softc *sc, int endpt, struct uio *uio, int flag)
{
struct ugen_endpoint *sce = &sc->sc_endpoints[endpt][IN];
u_int32_t n, tn;
char buf[UGEN_BBSIZE];
struct usbd_xfer *xfer;
usbd_status err;
int s;
int flags, error = 0;
u_char buffer[UGEN_CHUNK];
DPRINTFN(5, ("%s: ugenread: %d\n", sc->sc_dev.dv_xname, endpt));
if (usbd_is_dying(sc->sc_udev))
return (EIO);
if (endpt == USB_CONTROL_ENDPOINT)
return (ENODEV);
#ifdef DIAGNOSTIC
if (sce->edesc == NULL) {
printf("ugenread: no edesc\n");
return (EIO);
}
if (sce->pipeh == NULL) {
printf("ugenread: no pipe\n");
return (EIO);
}
#endif
switch (sce->edesc->bmAttributes & UE_XFERTYPE) {
case UE_INTERRUPT:
/* Block until activity occurred. */
s = splusb();
while (sce->q.c_cc == 0) {
if (flag & IO_NDELAY) {
splx(s);
return (EWOULDBLOCK);
}
sce->state |= UGEN_ASLP;
DPRINTFN(5, ("ugenread: sleep on %p\n", sce));
error = tsleep(sce, PZERO | PCATCH, "ugenri",
(sce->timeout * hz) / 1000);
sce->state &= ~UGEN_ASLP;
DPRINTFN(5, ("ugenread: woke, error=%d\n", error));
if (usbd_is_dying(sc->sc_udev))
error = EIO;
if (error == EWOULDBLOCK) { /* timeout, return 0 */
error = 0;
break;
}
if (error)
break;
}
splx(s);
/* Transfer as many chunks as possible. */
while (sce->q.c_cc > 0 && uio->uio_resid > 0 && !error) {
n = min(sce->q.c_cc, uio->uio_resid);
if (n > sizeof(buffer))
n = sizeof(buffer);
/* Remove a small chunk from the input queue. */
q_to_b(&sce->q, buffer, n);
DPRINTFN(5, ("ugenread: got %d chars\n", n));
/* Copy the data to the user process. */
error = uiomove(buffer, n, uio);
if (error)
break;
}
break;
case UE_BULK:
xfer = usbd_alloc_xfer(sc->sc_udev);
if (xfer == 0)
return (ENOMEM);
flags = USBD_SYNCHRONOUS;
if (sce->state & UGEN_SHORT_OK)
flags |= USBD_SHORT_XFER_OK;
if (sce->timeout == 0)
flags |= USBD_CATCH;
while ((n = min(UGEN_BBSIZE, uio->uio_resid)) != 0) {
DPRINTFN(1, ("ugenread: start transfer %d bytes\n",n));
usbd_setup_xfer(xfer, sce->pipeh, 0, buf, n,
flags, sce->timeout, NULL);
err = usbd_transfer(xfer);
if (err) {
usbd_clear_endpoint_stall(sce->pipeh);
if (err == USBD_INTERRUPTED)
error = EINTR;
else if (err == USBD_TIMEOUT)
error = ETIMEDOUT;
else
error = EIO;
break;
}
usbd_get_xfer_status(xfer, NULL, NULL, &tn, NULL);
DPRINTFN(1, ("ugenread: got %d bytes\n", tn));
error = uiomove(buf, tn, uio);
if (error || tn < n)
break;
}
usbd_free_xfer(xfer);
break;
case UE_ISOCHRONOUS:
s = splusb();
while (sce->cur == sce->fill) {
if (flag & IO_NDELAY) {
splx(s);
return (EWOULDBLOCK);
}
sce->state |= UGEN_ASLP;
DPRINTFN(5, ("ugenread: sleep on %p\n", sce));
error = tsleep(sce, PZERO | PCATCH, "ugenri",
(sce->timeout * hz) / 1000);
sce->state &= ~UGEN_ASLP;
DPRINTFN(5, ("ugenread: woke, error=%d\n", error));
if (usbd_is_dying(sc->sc_udev))
error = EIO;
if (error == EWOULDBLOCK) { /* timeout, return 0 */
error = 0;
break;
}
if (error)
break;
}
while (sce->cur != sce->fill && uio->uio_resid > 0 && !error) {
if(sce->fill > sce->cur)
n = min(sce->fill - sce->cur, uio->uio_resid);
else
n = min(sce->limit - sce->cur, uio->uio_resid);
DPRINTFN(5, ("ugenread: isoc got %d chars\n", n));
/* Copy the data to the user process. */
error = uiomove(sce->cur, n, uio);
if (error)
break;
sce->cur += n;
if(sce->cur >= sce->limit)
sce->cur = sce->ibuf;
}
splx(s);
break;
default:
return (ENXIO);
}
return (error);
}
int
ugenopen(dev_t dev, int flag, int mode, struct proc *p)
{
struct ugen_softc *sc;
int unit = UGENUNIT(dev);
int endpt = UGENENDPOINT(dev);
usb_endpoint_descriptor_t *edesc;
struct ugen_endpoint *sce;
int dir, isize;
usbd_status err;
struct usbd_xfer *xfer;
void *buf;
int i, j;
if (unit >= ugen_cd.cd_ndevs)
return (ENXIO);
sc = ugen_cd.cd_devs[unit];
if (sc == NULL)
return (ENXIO);
DPRINTFN(5, ("ugenopen: flag=%d, mode=%d, unit=%d endpt=%d\n",
flag, mode, unit, endpt));
if (sc == NULL || usbd_is_dying(sc->sc_udev))
return (ENXIO);
if (sc->sc_is_open[endpt])
return (EBUSY);
if (endpt == USB_CONTROL_ENDPOINT) {
sc->sc_is_open[USB_CONTROL_ENDPOINT] = 1;
return (0);
}
/* Make sure there are pipes for all directions. */
for (dir = OUT; dir <= IN; dir++) {
if (flag & (dir == OUT ? FWRITE : FREAD)) {
sce = &sc->sc_endpoints[endpt][dir];
if (sce == 0 || sce->edesc == 0)
return (ENXIO);
}
}
/* Actually open the pipes. */
/* XXX Should back out properly if it fails. */
for (dir = OUT; dir <= IN; dir++) {
if (!(flag & (dir == OUT ? FWRITE : FREAD)))
continue;
sce = &sc->sc_endpoints[endpt][dir];
sce->state = 0;
sce->timeout = USBD_NO_TIMEOUT;
DPRINTFN(5, ("ugenopen: sc=%p, endpt=%d, dir=%d, sce=%p\n",
sc, endpt, dir, sce));
edesc = sce->edesc;
switch (edesc->bmAttributes & UE_XFERTYPE) {
case UE_INTERRUPT:
if (dir == OUT) {
err = usbd_open_pipe(sce->iface,
edesc->bEndpointAddress, 0, &sce->pipeh);
if (err)
return (EIO);
break;
}
isize = UGETW(edesc->wMaxPacketSize);
if (isize == 0) /* shouldn't happen */
return (EINVAL);
sce->ibuf = malloc(isize, M_USBDEV, M_WAITOK);
DPRINTFN(5, ("ugenopen: intr endpt=%d,isize=%d\n",
endpt, isize));
clalloc(&sce->q, UGEN_IBSIZE, 0);
err = usbd_open_pipe_intr(sce->iface,
edesc->bEndpointAddress,
USBD_SHORT_XFER_OK, &sce->pipeh, sce,
sce->ibuf, isize, ugenintr,
USBD_DEFAULT_INTERVAL);
if (err) {
free(sce->ibuf, M_USBDEV, 0);
clfree(&sce->q);
return (EIO);
}
DPRINTFN(5, ("ugenopen: interrupt open done\n"));
break;
case UE_BULK:
err = usbd_open_pipe(sce->iface,
edesc->bEndpointAddress, 0, &sce->pipeh);
if (err)
return (EIO);
break;
case UE_ISOCHRONOUS:
if (dir == OUT)
return (EINVAL);
isize = UGETW(edesc->wMaxPacketSize);
if (isize == 0) /* shouldn't happen */
return (EINVAL);
sce->ibuf = malloc(isize * UGEN_NISOFRAMES,
M_USBDEV, M_WAITOK);
sce->cur = sce->fill = sce->ibuf;
sce->limit = sce->ibuf + isize * UGEN_NISOFRAMES;
DPRINTFN(5, ("ugenopen: isoc endpt=%d, isize=%d\n",
endpt, isize));
err = usbd_open_pipe(sce->iface,
edesc->bEndpointAddress, 0, &sce->pipeh);
if (err) {
free(sce->ibuf, M_USBDEV, 0);
return (EIO);
}
for(i = 0; i < UGEN_NISOREQS; ++i) {
sce->isoreqs[i].sce = sce;
xfer = usbd_alloc_xfer(sc->sc_udev);
if (xfer == 0)
goto bad;
sce->isoreqs[i].xfer = xfer;
buf = usbd_alloc_buffer
(xfer, isize * UGEN_NISORFRMS);
if (buf == 0) {
i++;
goto bad;
}
sce->isoreqs[i].dmabuf = buf;
for(j = 0; j < UGEN_NISORFRMS; ++j)
sce->isoreqs[i].sizes[j] = isize;
usbd_setup_isoc_xfer
(xfer, sce->pipeh, &sce->isoreqs[i],
sce->isoreqs[i].sizes,
UGEN_NISORFRMS, USBD_NO_COPY,
ugen_isoc_rintr);
(void)usbd_transfer(xfer);
}
DPRINTFN(5, ("ugenopen: isoc open done\n"));
break;
bad:
while (--i >= 0) /* implicit buffer free */
usbd_free_xfer(sce->isoreqs[i].xfer);
return (ENOMEM);
case UE_CONTROL:
sce->timeout = USBD_DEFAULT_TIMEOUT;
return (EINVAL);
}
}
sc->sc_is_open[endpt] = 1;
return (0);
}
Static void
ucomstart(struct tty *tp)
{
struct ucom_softc *sc;
struct cblock *cbp;
usbd_status err;
int s;
u_char *data;
int cnt;
USB_GET_SC(ucom, UCOMUNIT(tp->t_dev), sc);
DPRINTF(("ucomstart: sc = %p\n", sc));
if (sc->sc_dying)
return;
s = spltty();
if (tp->t_state & TS_TBLOCK) {
if (ISSET(sc->sc_mcr, UMCR_RTS) &&
ISSET(sc->sc_state, UCS_RTS_IFLOW)) {
DPRINTF(("ucomstart: clear RTS\n"));
(void)ucomctl(sc, UMCR_RTS, DMBIC);
}
} else {
if (!ISSET(sc->sc_mcr, UMCR_RTS) &&
tp->t_rawq.c_cc <= tp->t_ilowat &&
ISSET(sc->sc_state, UCS_RTS_IFLOW)) {
DPRINTF(("ucomstart: set RTS\n"));
(void)ucomctl(sc, UMCR_RTS, DMBIS);
}
}
if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP)) {
ttwwakeup(tp);
DPRINTF(("ucomstart: stopped\n"));
goto out;
}
if (tp->t_outq.c_cc <= tp->t_olowat) {
if (ISSET(tp->t_state, TS_SO_OLOWAT)) {
CLR(tp->t_state, TS_SO_OLOWAT);
wakeup(TSA_OLOWAT(tp));
}
selwakeup(&tp->t_wsel);
if (tp->t_outq.c_cc == 0) {
if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
CLR(tp->t_state, TS_SO_OCOMPLETE);
wakeup(TSA_OCOMPLETE(tp));
}
goto out;
}
}
/* Grab the first contiguous region of buffer space. */
data = tp->t_outq.c_cf;
cbp = (struct cblock *) ((intptr_t) tp->t_outq.c_cf & ~CROUND);
cnt = min((char *) (cbp+1) - tp->t_outq.c_cf, tp->t_outq.c_cc);
if (cnt == 0) {
DPRINTF(("ucomstart: cnt == 0\n"));
goto out;
}
SET(tp->t_state, TS_BUSY);
if (cnt > sc->sc_obufsize) {
DPRINTF(("ucomstart: big buffer %d chars\n", cnt));
cnt = sc->sc_obufsize;
}
if (sc->sc_callback->ucom_write != NULL)
sc->sc_callback->ucom_write(sc->sc_parent, sc->sc_portno,
sc->sc_obuf, data, &cnt);
else
memcpy(sc->sc_obuf, data, cnt);
DPRINTF(("ucomstart: %d chars\n", cnt));
usbd_setup_xfer(sc->sc_oxfer, sc->sc_bulkout_pipe,
(usbd_private_handle)sc, sc->sc_obuf, cnt,
USBD_NO_COPY, USBD_NO_TIMEOUT, ucomwritecb);
/* What can we do on error? */
err = usbd_transfer(sc->sc_oxfer);
if (err != USBD_IN_PROGRESS)
printf("ucomstart: err=%s\n", usbd_errstr(err));
ttwwakeup(tp);
out:
splx(s);
}
/*
* A frame has been uploaded: pass the resulting mbuf chain up to
* the higher level protocols.
*/
void
ugl_rxeof(struct usbd_xfer *xfer, void *priv, usbd_status status)
{
struct ugl_chain *c = priv;
struct ugl_softc *sc = c->ugl_sc;
struct ifnet *ifp = GET_IFP(sc);
struct mbuf *m;
int total_len = 0;
unsigned int packet_len, packet_count;
int s;
if (usbd_is_dying(sc->sc_udev))
return;
if (!(ifp->if_flags & IFF_RUNNING))
return;
if (status != USBD_NORMAL_COMPLETION) {
if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
return;
sc->sc_rx_errs++;
if (usbd_ratecheck(&sc->sc_rx_notice)) {
printf("%s: %u usb errors on rx: %s\n",
sc->sc_dev.dv_xname, sc->sc_rx_errs,
usbd_errstr(status));
sc->sc_rx_errs = 0;
}
if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(sc->sc_ep[UGL_ENDPT_RX]);
goto done;
}
usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
DPRINTFN(9,("%s: %s: enter status=%d length=%d\n",
sc->sc_dev.dv_xname, __func__, status, total_len));
if (total_len < offsetof(struct ugl_packet, pkt_data)) {
printf("%s: bad header (length=%d)\n",
sc->sc_dev.dv_xname, total_len);
goto done;
}
packet_count = UGETDW(c->ugl_buf->pkt_count);
if (packet_count != UGL_RX_FRAMES) {
printf("%s: bad packet count (%d)\n",
sc->sc_dev.dv_xname, packet_count);
if (packet_count == 0)
goto done;
}
packet_len = UGETDW(c->ugl_buf->pkt_length);
if (total_len < packet_len) {
printf("%s: bad packet size(%d), length=%d\n",
sc->sc_dev.dv_xname, packet_len, total_len);
if (packet_len == 0)
goto done;
}
m = c->ugl_mbuf;
memcpy(mtod(c->ugl_mbuf, char *), c->ugl_buf->pkt_data, packet_len);
ifp->if_ipackets++;
m->m_pkthdr.len = m->m_len = packet_len;
m->m_pkthdr.rcvif = ifp;
s = splnet();
/* XXX ugly */
if (ugl_newbuf(sc, c, NULL) == ENOBUFS) {
ifp->if_ierrors++;
goto done1;
}
#if NBPFILTER > 0
/*
* Handle BPF listeners. Let the BPF user see the packet, but
* don't pass it up to the ether_input() layer unless it's
* a broadcast packet, multicast packet, matches our ethernet
* address or the interface is in promiscuous mode.
*/
if (ifp->if_bpf) {
bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
}
#endif
DPRINTFN(10,("%s: %s: deliver %d\n", sc->sc_dev.dv_xname,
__func__, m->m_len));
ether_input_mbuf(ifp, m);
done1:
splx(s);
done:
/* Setup new transfer. */
usbd_setup_xfer(c->ugl_xfer, sc->sc_ep[UGL_ENDPT_RX],
c, c->ugl_buf, UGL_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY,
USBD_NO_TIMEOUT, ugl_rxeof);
usbd_transfer(c->ugl_xfer);
DPRINTFN(10,("%s: %s: start rx\n", sc->sc_dev.dv_xname,
__func__));
}
/*
* A frame has been received.
*/
void
wi_usb_rxeof(struct usbd_xfer *xfer, void *priv, usbd_status status)
{
struct wi_usb_chain *c = priv;
struct wi_usb_softc *sc = c->wi_usb_sc;
wi_usb_usbin *uin;
int total_len = 0;
u_int16_t rtype;
if (usbd_is_dying(sc->wi_usb_udev))
return;
DPRINTFN(10,("%s: %s: enter status=%d\n", sc->wi_usb_dev.dv_xname,
__func__, status));
if (status != USBD_NORMAL_COMPLETION) {
if (status == USBD_NOT_STARTED || status == USBD_IOERROR
|| status == USBD_CANCELLED) {
printf("%s: %u usb errors on rx: %s\n",
sc->wi_usb_dev.dv_xname, 1,
/* sc->wi_usb_rx_errs, */
usbd_errstr(status));
return;
}
#if 0
sc->wi_usb_rx_errs++;
if (usbd_ratecheck(&sc->wi_usb_rx_notice)) {
printf("%s: %u usb errors on rx: %s\n",
sc->wi_usb_dev.dv_xname, sc->wi_usb_rx_errs,
usbd_errstr(status));
sc->wi_usb_rx_errs = 0;
}
#endif
if (status == USBD_STALLED) {
sc->wi_usb_refcnt++;
usbd_clear_endpoint_stall_async(
sc->wi_usb_ep[WI_USB_ENDPT_RX]);
if (--sc->wi_usb_refcnt < 0)
usb_detach_wakeup(&sc->wi_usb_dev);
}
goto done;
}
usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
if (total_len < 6) /* short XXX */
goto done;
uin = (wi_usb_usbin *)(c->wi_usb_buf);
rtype = letoh16(uin->type);
#if 0
wi_dump_data(c->wi_usb_buf, total_len);
#endif
if (WI_USB_ISRXFRM(rtype)) {
wi_usb_rxfrm(sc, uin, total_len);
goto done;
}
if (WI_USB_ISTXFRM(rtype)) {
DPRINTFN(2,("%s: %s: txfrm type %x\n",
sc->wi_usb_dev.dv_xname, __func__, rtype));
wi_usb_txfrm(sc, uin, total_len);
goto done;
}
switch (rtype) {
case WI_USB_INFOFRM:
/* info packet, INFO_FID hmm */
DPRINTFN(10,("%s: %s: infofrm type %x\n",
sc->wi_usb_dev.dv_xname, __func__, rtype));
wi_usb_infofrm(c, total_len);
break;
case WI_USB_CMDRESP:
wi_usb_cmdresp(c);
break;
case WI_USB_WRIDRESP:
wi_usb_wridresp(c);
break;
case WI_USB_RRIDRESP:
wi_usb_rridresp(c);
break;
case WI_USB_WMEMRESP:
/* Not currently used */
DPRINTFN(2,("%s: %s: wmemresp type %x\n",
sc->wi_usb_dev.dv_xname, __func__, rtype));
break;
case WI_USB_RMEMRESP:
/* Not currently used */
DPRINTFN(2,("%s: %s: rmemresp type %x\n",
sc->wi_usb_dev.dv_xname, __func__, rtype));
break;
case WI_USB_BUFAVAIL:
printf("wi_usb: received USB_BUFAVAIL packet\n"); /* XXX */
break;
case WI_USB_ERROR:
printf("wi_usb: received USB_ERROR packet\n"); /* XXX */
break;
#if 0
default:
printf("wi_usb: received Unknown packet 0x%x len %x\n",
rtype, total_len);
wi_dump_data(c->wi_usb_buf, total_len);
#endif
}
done:
/* Setup new transfer. */
usbd_setup_xfer(c->wi_usb_xfer, sc->wi_usb_ep[WI_USB_ENDPT_RX],
c, c->wi_usb_buf, WI_USB_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY,
USBD_NO_TIMEOUT, wi_usb_rxeof);
sc->wi_usb_refcnt++;
usbd_transfer(c->wi_usb_xfer);
if (--sc->wi_usb_refcnt < 0)
usb_detach_wakeup(&sc->wi_usb_dev);
DPRINTFN(10,("%s: %s: start rx\n", sc->wi_usb_dev.dv_xname,
__func__));
}
int
wi_send_packet(struct wi_usb_softc *sc, int id)
{
struct wi_usb_chain *c;
struct wi_frame *wibuf;
int total_len, rnd_len;
int err;
c = &sc->wi_usb_tx_chain[0];
DPRINTFN(10,("%s: %s: id=%x\n",
sc->wi_usb_dev.dv_xname, __func__, id));
/* assemble packet from write_data buffer */
if (id == 0 || id == 1) {
/* tx_lock acquired before wi_start() */
wibuf = sc->wi_usb_txmem[id];
total_len = sizeof (struct wi_frame) +
letoh16(wibuf->wi_dat_len);
rnd_len = ROUNDUP64(total_len);
if ((total_len > sc->wi_usb_txmemsize[id]) ||
(rnd_len > WI_USB_BUFSZ )){
printf("invalid packet len: %x memsz %x max %x\n",
total_len, sc->wi_usb_txmemsize[id], WI_USB_BUFSZ);
err = EIO;
goto err_ret;
}
sc->txresp = WI_CMD_TX;
sc->txresperr = 0;
bcopy(wibuf, c->wi_usb_buf, total_len);
bzero(((char *)c->wi_usb_buf)+total_len,
rnd_len - total_len);
/* zero old packet for next TX */
bzero(wibuf, total_len);
total_len = rnd_len;
DPRINTFN(5,("%s: %s: id=%x len=%x\n",
sc->wi_usb_dev.dv_xname, __func__, id, total_len));
usbd_setup_xfer(c->wi_usb_xfer, sc->wi_usb_ep[WI_USB_ENDPT_TX],
c, c->wi_usb_buf, rnd_len,
USBD_FORCE_SHORT_XFER | USBD_NO_COPY,
WI_USB_TX_TIMEOUT, wi_usb_txeof_frm);
err = usbd_transfer(c->wi_usb_xfer);
if (err != USBD_IN_PROGRESS && err != USBD_NORMAL_COMPLETION) {
printf("%s: %s: error=%s\n",
sc->wi_usb_dev.dv_xname, __func__,
usbd_errstr(err));
/* Stop the interface from process context. */
wi_usb_stop(sc);
err = EIO;
} else {
err = 0;
}
DPRINTFN(5,("%s: %s: exit err=%x\n",
sc->wi_usb_dev.dv_xname, __func__, err));
err_ret:
return err;
}
printf("%s:%s: invalid packet id sent %x\n",
sc->wi_usb_dev.dv_xname, __func__, id);
return 0;
}
int
smsc_init(struct ifnet *ifp)
{
struct smsc_softc *sc = ifp->if_softc;
struct smsc_chain *c;
usbd_status err;
int s, i;
if (sc->sc_dying)
return EIO;
s = splnet();
/* Cancel pending I/O */
if (ifp->if_flags & IFF_RUNNING)
smsc_stop(ifp, 1);
/* Reset the ethernet interface. */
smsc_reset(sc);
/* Init RX ring. */
if (smsc_rx_list_init(sc) == ENOBUFS) {
aprint_error_dev(sc->sc_dev, "rx list init failed\n");
splx(s);
return EIO;
}
/* Init TX ring. */
if (smsc_tx_list_init(sc) == ENOBUFS) {
aprint_error_dev(sc->sc_dev, "tx list init failed\n");
splx(s);
return EIO;
}
/* Load the multicast filter. */
smsc_setmulti(sc);
/* TCP/UDP checksum offload engines. */
smsc_sethwcsum(sc);
/* Open RX and TX pipes. */
err = usbd_open_pipe(sc->sc_iface, sc->sc_ed[SMSC_ENDPT_RX],
USBD_EXCLUSIVE_USE, &sc->sc_ep[SMSC_ENDPT_RX]);
if (err) {
printf("%s: open rx pipe failed: %s\n",
device_xname(sc->sc_dev), usbd_errstr(err));
splx(s);
return EIO;
}
err = usbd_open_pipe(sc->sc_iface, sc->sc_ed[SMSC_ENDPT_TX],
USBD_EXCLUSIVE_USE, &sc->sc_ep[SMSC_ENDPT_TX]);
if (err) {
printf("%s: open tx pipe failed: %s\n",
device_xname(sc->sc_dev), usbd_errstr(err));
splx(s);
return EIO;
}
/* Start up the receive pipe. */
for (i = 0; i < SMSC_RX_LIST_CNT; i++) {
c = &sc->sc_cdata.rx_chain[i];
usbd_setup_xfer(c->sc_xfer, sc->sc_ep[SMSC_ENDPT_RX],
c, c->sc_buf, sc->sc_bufsz,
USBD_SHORT_XFER_OK | USBD_NO_COPY,
USBD_NO_TIMEOUT, smsc_rxeof);
usbd_transfer(c->sc_xfer);
}
/* Indicate we are up and running. */
ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
splx(s);
callout_reset(&sc->sc_stat_ch, hz, smsc_tick, sc);
return 0;
}
/*
* Reset the printer, then wait until it's selected and not busy.
*/
int
ulptopen(dev_t dev, int flag, int mode, struct proc *p)
{
u_char flags = ULPTFLAGS(dev);
struct ulpt_softc *sc;
usbd_status err;
int error;
if (ULPTUNIT(dev) >= ulpt_cd.cd_ndevs)
return (ENXIO);
sc = ulpt_cd.cd_devs[ULPTUNIT(dev)];
if (sc == NULL)
return (ENXIO);
if (sc == NULL || sc->sc_iface == NULL || usbd_is_dying(sc->sc_udev))
return (ENXIO);
if (sc->sc_state)
return (EBUSY);
sc->sc_state = ULPT_INIT;
sc->sc_flags = flags;
DPRINTF(("ulptopen: flags=0x%x\n", (unsigned)flags));
error = 0;
sc->sc_refcnt++;
if ((flags & ULPT_NOPRIME) == 0) {
ulpt_reset(sc);
if (usbd_is_dying(sc->sc_udev)) {
error = ENXIO;
sc->sc_state = 0;
goto done;
}
}
err = usbd_open_pipe(sc->sc_iface, sc->sc_out, 0, &sc->sc_out_pipe);
if (err) {
sc->sc_state = 0;
error = EIO;
goto done;
}
if (ulptusein && sc->sc_in != -1) {
DPRINTF(("ulpt_open: open input pipe\n"));
err = usbd_open_pipe(sc->sc_iface, sc->sc_in,0,&sc->sc_in_pipe);
if (err) {
error = EIO;
usbd_close_pipe(sc->sc_out_pipe);
sc->sc_out_pipe = NULL;
sc->sc_state = 0;
goto done;
}
sc->sc_in_xfer1 = usbd_alloc_xfer(sc->sc_udev);
sc->sc_in_xfer2 = usbd_alloc_xfer(sc->sc_udev);
if (sc->sc_in_xfer1 == NULL || sc->sc_in_xfer2 == NULL) {
error = ENOMEM;
if (sc->sc_in_xfer1 != NULL) {
usbd_free_xfer(sc->sc_in_xfer1);
sc->sc_in_xfer1 = NULL;
}
if (sc->sc_in_xfer2 != NULL) {
usbd_free_xfer(sc->sc_in_xfer2);
sc->sc_in_xfer2 = NULL;
}
usbd_close_pipe(sc->sc_out_pipe);
sc->sc_out_pipe = NULL;
usbd_close_pipe(sc->sc_in_pipe);
sc->sc_in_pipe = NULL;
sc->sc_state = 0;
goto done;
}
usbd_setup_xfer(sc->sc_in_xfer1, sc->sc_in_pipe, sc,
sc->sc_junk, sizeof sc->sc_junk, USBD_SHORT_XFER_OK,
USBD_NO_TIMEOUT, ulpt_input);
usbd_setup_xfer(sc->sc_in_xfer2, sc->sc_in_pipe, sc,
sc->sc_junk, sizeof sc->sc_junk, USBD_SHORT_XFER_OK,
USBD_NO_TIMEOUT, ulpt_input);
usbd_transfer(sc->sc_in_xfer1); /* ignore failed start */
}
sc->sc_state = ULPT_OPEN;
done:
if (--sc->sc_refcnt < 0)
usb_detach_wakeup(&sc->sc_dev);
DPRINTF(("ulptopen: done, error=%d\n", error));
return (error);
}
Static int
url_openpipes(struct url_softc *sc)
{
struct url_chain *c;
usbd_status err;
int i;
int error = 0;
if (sc->sc_dying)
return (EIO);
sc->sc_refcnt++;
/* Open RX pipe */
err = usbd_open_pipe(sc->sc_ctl_iface, sc->sc_bulkin_no,
USBD_EXCLUSIVE_USE, &sc->sc_pipe_rx);
if (err) {
printf("%s: open rx pipe failed: %s\n",
USBDEVNAME(sc->sc_dev), usbd_errstr(err));
error = EIO;
goto done;
}
/* Open TX pipe */
err = usbd_open_pipe(sc->sc_ctl_iface, sc->sc_bulkout_no,
USBD_EXCLUSIVE_USE, &sc->sc_pipe_tx);
if (err) {
printf("%s: open tx pipe failed: %s\n",
USBDEVNAME(sc->sc_dev), usbd_errstr(err));
error = EIO;
goto done;
}
#if 0
/* XXX: interrupt endpoint is not yet supported */
/* Open Interrupt pipe */
err = usbd_open_pipe_intr(sc->sc_ctl_iface, sc->sc_intrin_no,
USBD_EXCLUSIVE_USE, &sc->sc_pipe_intr, sc,
&sc->sc_cdata.url_ibuf, URL_INTR_PKGLEN,
url_intr, URL_INTR_INTERVAL);
if (err) {
printf("%s: open intr pipe failed: %s\n",
USBDEVNAME(sc->sc_dev), usbd_errstr(err));
error = EIO;
goto done;
}
#endif
/* Start up the receive pipe. */
for (i = 0; i < URL_RX_LIST_CNT; i++) {
c = &sc->sc_cdata.url_rx_chain[i];
usbd_setup_xfer(c->url_xfer, sc->sc_pipe_rx,
c, c->url_buf, URL_BUFSZ,
USBD_SHORT_XFER_OK | USBD_NO_COPY,
USBD_NO_TIMEOUT, url_rxeof);
(void)usbd_transfer(c->url_xfer);
DPRINTF(("%s: %s: start read\n", USBDEVNAME(sc->sc_dev),
__func__));
}
done:
if (--sc->sc_refcnt < 0)
usb_detach_wakeup(USBDEV(sc->sc_dev));
return (error);
}
Static void
cdce_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
{
struct ue_chain *c = priv;
struct cdce_softc *sc = c->ue_sc;
struct ifnet *ifp;
struct mbuf *m;
int total_len = 0;
CDCE_LOCK(sc);
ifp = GET_IFP(sc);
if (sc->cdce_dying || !(ifp->if_flags & IFF_RUNNING)) {
CDCE_UNLOCK(sc);
return;
}
if (status != USBD_NORMAL_COMPLETION) {
if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
CDCE_UNLOCK(sc);
return;
}
if (sc->cdce_rxeof_errors == 0)
printf("%s: usb error on rx: %s\n",
USBDEVNAME(sc->cdce_dev), usbd_errstr(status));
if (status == USBD_STALLED)
usbd_clear_endpoint_stall(sc->cdce_bulkin_pipe);
DELAY(sc->cdce_rxeof_errors * 10000);
sc->cdce_rxeof_errors++;
goto done;
}
sc->cdce_rxeof_errors = 0;
usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
if (sc->cdce_flags & CDCE_ZAURUS)
total_len -= 4; /* Strip off CRC added by Zaurus */
m = c->ue_mbuf;
if (total_len < sizeof(struct ether_header)) {
ifp->if_ierrors++;
goto done;
}
ifp->if_ipackets++;
m->m_pkthdr.rcvif = (struct ifnet *)&sc->q;
m->m_pkthdr.len = m->m_len = total_len;
/* Put the packet on the special USB input queue. */
usb_ether_input(m);
CDCE_UNLOCK(sc);
return;
done:
/* Setup new transfer. */
usbd_setup_xfer(c->ue_xfer, sc->cdce_bulkin_pipe, c,
mtod(c->ue_mbuf, char *),
UE_BUFSZ, USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT,
cdce_rxeof);
usbd_transfer(c->ue_xfer);
CDCE_UNLOCK(sc);
return;
}
Static void
url_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
{
struct url_chain *c = priv;
struct url_softc *sc = c->url_sc;
struct ifnet *ifp = GET_IFP(sc);
struct mbuf *m;
u_int32_t total_len;
url_rxhdr_t rxhdr;
int s;
DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev),__func__));
if (sc->sc_dying)
return;
if (status != USBD_NORMAL_COMPLETION) {
if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
return;
sc->sc_rx_errs++;
if (usbd_ratecheck(&sc->sc_rx_notice)) {
printf("%s: %u usb errors on rx: %s\n",
USBDEVNAME(sc->sc_dev), sc->sc_rx_errs,
usbd_errstr(status));
sc->sc_rx_errs = 0;
}
if (status == USBD_STALLED) {
sc->sc_refcnt++;
usbd_clear_endpoint_stall_async(sc->sc_pipe_rx);
if (--sc->sc_refcnt < 0)
usb_detach_wakeup(USBDEV(sc->sc_dev));
}
goto done;
}
usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
memcpy(mtod(c->url_mbuf, char *), c->url_buf, total_len);
if (total_len <= ETHER_CRC_LEN) {
ifp->if_ierrors++;
goto done;
}
memcpy(&rxhdr, c->url_buf + total_len - ETHER_CRC_LEN, sizeof(rxhdr));
DPRINTF(("%s: RX Status: %dbytes%s%s%s%s packets\n",
USBDEVNAME(sc->sc_dev),
UGETW(rxhdr) & URL_RXHDR_BYTEC_MASK,
UGETW(rxhdr) & URL_RXHDR_VALID_MASK ? ", Valid" : "",
UGETW(rxhdr) & URL_RXHDR_RUNTPKT_MASK ? ", Runt" : "",
UGETW(rxhdr) & URL_RXHDR_PHYPKT_MASK ? ", Physical match" : "",
UGETW(rxhdr) & URL_RXHDR_MCASTPKT_MASK ? ", Multicast" : ""));
if ((UGETW(rxhdr) & URL_RXHDR_VALID_MASK) == 0) {
ifp->if_ierrors++;
goto done;
}
ifp->if_ipackets++;
total_len -= ETHER_CRC_LEN;
m = c->url_mbuf;
m->m_pkthdr.len = m->m_len = total_len;
m->m_pkthdr.rcvif = ifp;
s = splnet();
if (url_newbuf(sc, c, NULL) == ENOBUFS) {
ifp->if_ierrors++;
goto done1;
}
#if NBPFILTER > 0
if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
#endif
DPRINTF(("%s: %s: deliver %d\n", USBDEVNAME(sc->sc_dev),
__func__, m->m_len));
IF_INPUT(ifp, m);
done1:
splx(s);
done:
/* Setup new transfer */
usbd_setup_xfer(xfer, sc->sc_pipe_rx, c, c->url_buf, URL_BUFSZ,
USBD_SHORT_XFER_OK | USBD_NO_COPY,
USBD_NO_TIMEOUT, url_rxeof);
sc->sc_refcnt++;
usbd_transfer(xfer);
if (--sc->sc_refcnt < 0)
usb_detach_wakeup(USBDEV(sc->sc_dev));
DPRINTF(("%s: %s: start rx\n", USBDEVNAME(sc->sc_dev), __func__));
}
Static int
udbp_setup_out_transfer(udbp_p sc)
{
void *priv = sc; /* XXX this should probably be some pointer to
* struct describing the transfer (mbuf?)
* See also below.
*/
int pktlen;
usbd_status err;
int s, s1;
struct mbuf *m;
s = splusb();
if (sc->flags & OUT_BUSY)
panic("out transfer already in use, we should add queuing");
sc->flags |= OUT_BUSY;
splx(s);
s1 = splimp(); /* Queueing happens at splnet */
IF_DEQUEUE(&sc->xmitq_hipri, m);
if (m == NULL) {
IF_DEQUEUE(&sc->xmitq, m);
}
splx(s1);
if (!m) {
sc->flags &= ~OUT_BUSY;
return (USBD_NORMAL_COMPLETION);
}
pktlen = m->m_pkthdr.len;
if (pktlen > sc->sc_bulkout_bufferlen) {
printf("%s: Packet too large, %d > %d\n",
USBDEVNAME(sc->sc_dev), pktlen,
sc->sc_bulkout_bufferlen);
return (USBD_IOERROR);
}
m_copydata(m, 0, pktlen, sc->sc_bulkout_buffer);
m_freem(m);
/* Initialise a USB transfer and then schedule it */
(void) usbd_setup_xfer( sc->sc_bulkout_xfer,
sc->sc_bulkout_pipe,
priv,
sc->sc_bulkout_buffer,
pktlen,
USBD_SHORT_XFER_OK,
UDBP_TIMEOUT,
udbp_out_transfer_cb);
err = usbd_transfer(sc->sc_bulkout_xfer);
if (err && err != USBD_IN_PROGRESS) {
DPRINTF(("%s: failed to setup out-transfer, %s\n",
USBDEVNAME(sc->sc_dev), usbd_errstr(err)));
return(err);
}
return (USBD_NORMAL_COMPLETION);
}
void
ueagle_loadpage(void *xsc)
{
struct ueagle_softc *sc = xsc;
struct usbd_xfer *xfer;
struct ueagle_block_info bi;
uint16_t pageno = sc->pageno;
uint16_t ovl = sc->ovl;
uint8_t pagecount, blockcount;
uint16_t blockaddr, blocksize;
uint32_t pageoffset;
uint8_t *p;
int i;
if (usbd_is_dying(sc->sc_udev))
return;
p = sc->dsp;
pagecount = *p++;
if (pageno >= pagecount) {
printf("%s: invalid page number %u requested\n",
sc->sc_dev.dv_xname, pageno);
return;
}
p += 4 * pageno;
pageoffset = UGETDW(p);
if (pageoffset == 0)
return;
p = sc->dsp + pageoffset;
blockcount = *p++;
DPRINTF(("%s: sending %u blocks for fw page %u\n",
sc->sc_dev.dv_xname, blockcount, pageno));
if ((xfer = usbd_alloc_xfer(sc->sc_udev)) == NULL) {
printf("%s: could not allocate xfer\n",
sc->sc_dev.dv_xname);
return;
}
USETW(bi.wHdr, UEAGLE_BLOCK_INFO_HDR);
USETW(bi.wOvl, ovl);
USETW(bi.wOvlOffset, ovl | 0x8000);
for (i = 0; i < blockcount; i++) {
blockaddr = UGETW(p); p += 2;
blocksize = UGETW(p); p += 2;
USETW(bi.wSize, blocksize);
USETW(bi.wAddress, blockaddr);
USETW(bi.wLast, (i == blockcount - 1) ? 1 : 0);
/* send block info through the IDMA pipe */
usbd_setup_xfer(xfer, sc->pipeh_idma, sc, &bi, sizeof bi,
USBD_SYNCHRONOUS, UEAGLE_IDMA_TIMEOUT, NULL);
if (usbd_transfer(xfer) != 0) {
printf("%s: could not transfer block info\n",
sc->sc_dev.dv_xname);
break;
}
/* send block data through the IDMA pipe */
usbd_setup_xfer(xfer, sc->pipeh_idma, sc, p, blocksize,
USBD_SYNCHRONOUS, UEAGLE_IDMA_TIMEOUT, NULL);
if (usbd_transfer(xfer) != 0) {
printf("%s: could not transfer block data\n",
sc->sc_dev.dv_xname);
break;
}
p += blocksize;
}
usbd_free_xfer(xfer);
}
