The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/firewire/if_fwe.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2002-2003
    3  *      Hidetoshi Shimokawa. All rights reserved.
    4  * 
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 3. All advertising materials mentioning features or use of this software
   14  *    must display the following acknowledgement:
   15  *
   16  *      This product includes software developed by Hidetoshi Shimokawa.
   17  *
   18  * 4. Neither the name of the author nor the names of its contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  * 
   22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   32  * SUCH DAMAGE.
   33  * 
   34  * $FreeBSD$
   35  */
   36 
   37 #ifdef HAVE_KERNEL_OPTION_HEADERS
   38 #include "opt_device_polling.h"
   39 #include "opt_inet.h"
   40 #endif
   41 
   42 #include <sys/param.h>
   43 #include <sys/kernel.h>
   44 #include <sys/malloc.h>
   45 #include <sys/mbuf.h>
   46 #include <sys/socket.h>
   47 #include <sys/sockio.h>
   48 #include <sys/sysctl.h>
   49 #include <sys/systm.h>
   50 #include <sys/module.h>
   51 #include <sys/bus.h>
   52 #include <machine/bus.h>
   53 
   54 #include <net/bpf.h>
   55 #include <net/ethernet.h>
   56 #include <net/if.h>
   57 #include <net/if_arp.h>
   58 #include <net/if_types.h>
   59 #ifdef __DragonFly__
   60 #include <net/vlan/if_vlan_var.h>
   61 #include <bus/firewire/firewire.h>
   62 #include <bus/firewire/firewirereg.h>
   63 #include "if_fwevar.h"
   64 #else
   65 #include <net/if_vlan_var.h>
   66 
   67 #include <dev/firewire/firewire.h>
   68 #include <dev/firewire/firewirereg.h>
   69 #include <dev/firewire/if_fwevar.h>
   70 #endif
   71 
   72 #define FWEDEBUG        if (fwedebug) if_printf
   73 #define TX_MAX_QUEUE    (FWMAXQUEUE - 1)
   74 
   75 /* network interface */
   76 static void fwe_start (struct ifnet *);
   77 static int fwe_ioctl (struct ifnet *, u_long, caddr_t);
   78 static void fwe_init (void *);
   79 
   80 static void fwe_output_callback (struct fw_xfer *);
   81 static void fwe_as_output (struct fwe_softc *, struct ifnet *);
   82 static void fwe_as_input (struct fw_xferq *);
   83 
   84 static int fwedebug = 0;
   85 static int stream_ch = 1;
   86 static int tx_speed = 2;
   87 static int rx_queue_len = FWMAXQUEUE;
   88 
   89 MALLOC_DEFINE(M_FWE, "if_fwe", "Ethernet over FireWire interface");
   90 SYSCTL_INT(_debug, OID_AUTO, if_fwe_debug, CTLFLAG_RW, &fwedebug, 0, "");
   91 SYSCTL_DECL(_hw_firewire);
   92 SYSCTL_NODE(_hw_firewire, OID_AUTO, fwe, CTLFLAG_RD, 0,
   93         "Ethernet emulation subsystem");
   94 SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, stream_ch, CTLFLAG_RW, &stream_ch, 0,
   95         "Stream channel to use");
   96 SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, tx_speed, CTLFLAG_RW, &tx_speed, 0,
   97         "Transmission speed");
   98 SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, rx_queue_len, CTLFLAG_RW, &rx_queue_len,
   99         0, "Length of the receive queue");
  100 
  101 TUNABLE_INT("hw.firewire.fwe.stream_ch", &stream_ch);
  102 TUNABLE_INT("hw.firewire.fwe.tx_speed", &tx_speed);
  103 TUNABLE_INT("hw.firewire.fwe.rx_queue_len", &rx_queue_len);
  104 
  105 #ifdef DEVICE_POLLING
  106 static poll_handler_t fwe_poll;
  107 
  108 static void
  109 fwe_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
  110 {
  111         struct fwe_softc *fwe;
  112         struct firewire_comm *fc;
  113 
  114         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
  115                 return;
  116 
  117         fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
  118         fc = fwe->fd.fc;
  119         fc->poll(fc, (cmd == POLL_AND_CHECK_STATUS)?0:1, count);
  120 }
  121 #endif /* DEVICE_POLLING */
  122 
  123 static void
  124 fwe_identify(driver_t *driver, device_t parent)
  125 {
  126         BUS_ADD_CHILD(parent, 0, "fwe", device_get_unit(parent));
  127 }
  128 
  129 static int
  130 fwe_probe(device_t dev)
  131 {
  132         device_t pa;
  133 
  134         pa = device_get_parent(dev);
  135         if(device_get_unit(dev) != device_get_unit(pa)){
  136                 return(ENXIO);
  137         }
  138 
  139         device_set_desc(dev, "Ethernet over FireWire");
  140         return (0);
  141 }
  142 
  143 static int
  144 fwe_attach(device_t dev)
  145 {
  146         struct fwe_softc *fwe;
  147         struct ifnet *ifp;
  148         int unit, s;
  149 #if defined(__DragonFly__) || __FreeBSD_version < 500000
  150         u_char *eaddr;
  151 #else
  152         u_char eaddr[6];
  153 #endif
  154         struct fw_eui64 *eui;
  155 
  156         fwe = ((struct fwe_softc *)device_get_softc(dev));
  157         unit = device_get_unit(dev);
  158 
  159         bzero(fwe, sizeof(struct fwe_softc));
  160         /* XXX */
  161         fwe->stream_ch = stream_ch;
  162         fwe->dma_ch = -1;
  163 
  164         fwe->fd.fc = device_get_ivars(dev);
  165         if (tx_speed < 0)
  166                 tx_speed = fwe->fd.fc->speed;
  167 
  168         fwe->fd.dev = dev;
  169         fwe->fd.post_explore = NULL;
  170         fwe->eth_softc.fwe = fwe;
  171 
  172         fwe->pkt_hdr.mode.stream.tcode = FWTCODE_STREAM;
  173         fwe->pkt_hdr.mode.stream.sy = 0;
  174         fwe->pkt_hdr.mode.stream.chtag = fwe->stream_ch;
  175 
  176         /* generate fake MAC address: first and last 3bytes from eui64 */
  177 #define LOCAL (0x02)
  178 #define GROUP (0x01)
  179 #if defined(__DragonFly__) || __FreeBSD_version < 500000
  180         eaddr = &IFP2ENADDR(fwe->eth_softc.ifp)[0];
  181 #endif
  182 
  183 
  184         eui = &fwe->fd.fc->eui;
  185         eaddr[0] = (FW_EUI64_BYTE(eui, 0) | LOCAL) & ~GROUP;
  186         eaddr[1] = FW_EUI64_BYTE(eui, 1);
  187         eaddr[2] = FW_EUI64_BYTE(eui, 2);
  188         eaddr[3] = FW_EUI64_BYTE(eui, 5);
  189         eaddr[4] = FW_EUI64_BYTE(eui, 6);
  190         eaddr[5] = FW_EUI64_BYTE(eui, 7);
  191         printf("if_fwe%d: Fake Ethernet address: "
  192                 "%02x:%02x:%02x:%02x:%02x:%02x\n", unit,
  193                 eaddr[0], eaddr[1], eaddr[2], eaddr[3], eaddr[4], eaddr[5]);
  194 
  195         /* fill the rest and attach interface */        
  196         ifp = fwe->eth_softc.ifp = if_alloc(IFT_ETHER);
  197         if (ifp == NULL) {
  198                 device_printf(dev, "can not if_alloc()\n");
  199                 return (ENOSPC);
  200         }
  201         ifp->if_softc = &fwe->eth_softc;
  202 
  203 #if __FreeBSD_version >= 501113 || defined(__DragonFly__)
  204         if_initname(ifp, device_get_name(dev), unit);
  205 #else
  206         ifp->if_unit = unit;
  207         ifp->if_name = "fwe";
  208 #endif
  209         ifp->if_init = fwe_init;
  210 #if defined(__DragonFly__) || __FreeBSD_version < 500000
  211         ifp->if_output = ether_output;
  212 #endif
  213         ifp->if_start = fwe_start;
  214         ifp->if_ioctl = fwe_ioctl;
  215         ifp->if_mtu = ETHERMTU;
  216         ifp->if_flags = (IFF_BROADCAST|IFF_SIMPLEX|IFF_MULTICAST|
  217             IFF_NEEDSGIANT);
  218         ifp->if_snd.ifq_maxlen = TX_MAX_QUEUE;
  219 
  220         s = splimp();
  221 #if defined(__DragonFly__) || __FreeBSD_version < 500000
  222         ether_ifattach(ifp, 1);
  223 #else
  224         ether_ifattach(ifp, eaddr);
  225 #endif
  226         splx(s);
  227 
  228         /* Tell the upper layer(s) we support long frames. */
  229         ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
  230 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
  231         ifp->if_capabilities |= IFCAP_VLAN_MTU & IFCAP_POLLING;
  232         ifp->if_capenable |= IFCAP_VLAN_MTU;
  233 #endif
  234 
  235 
  236         FWEDEBUG(ifp, "interface created\n");
  237         return 0;
  238 }
  239 
  240 static void
  241 fwe_stop(struct fwe_softc *fwe)
  242 {
  243         struct firewire_comm *fc;
  244         struct fw_xferq *xferq;
  245         struct ifnet *ifp = fwe->eth_softc.ifp;
  246         struct fw_xfer *xfer, *next;
  247         int i;
  248 
  249         fc = fwe->fd.fc;
  250 
  251         if (fwe->dma_ch >= 0) {
  252                 xferq = fc->ir[fwe->dma_ch];
  253 
  254                 if (xferq->flag & FWXFERQ_RUNNING)
  255                         fc->irx_disable(fc, fwe->dma_ch);
  256                 xferq->flag &= 
  257                         ~(FWXFERQ_MODEMASK | FWXFERQ_OPEN | FWXFERQ_STREAM |
  258                         FWXFERQ_EXTBUF | FWXFERQ_HANDLER | FWXFERQ_CHTAGMASK);
  259                 xferq->hand =  NULL;
  260 
  261                 for (i = 0; i < xferq->bnchunk; i ++)
  262                         m_freem(xferq->bulkxfer[i].mbuf);
  263                 free(xferq->bulkxfer, M_FWE);
  264 
  265                 for (xfer = STAILQ_FIRST(&fwe->xferlist); xfer != NULL;
  266                                         xfer = next) {
  267                         next = STAILQ_NEXT(xfer, link);
  268                         fw_xfer_free(xfer);
  269                 }
  270                 STAILQ_INIT(&fwe->xferlist);
  271 
  272                 xferq->bulkxfer =  NULL;
  273                 fwe->dma_ch = -1;
  274         }
  275 
  276 #if defined(__FreeBSD__)
  277         ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
  278 #else
  279         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
  280 #endif
  281 }
  282 
  283 static int
  284 fwe_detach(device_t dev)
  285 {
  286         struct fwe_softc *fwe;
  287         struct ifnet *ifp;
  288         int s;
  289 
  290         fwe = device_get_softc(dev);
  291         ifp = fwe->eth_softc.ifp;
  292 
  293 #ifdef DEVICE_POLLING
  294         if (ifp->if_capenable & IFCAP_POLLING)
  295                 ether_poll_deregister(ifp);
  296 #endif
  297         s = splimp();
  298 
  299         fwe_stop(fwe);
  300 #if defined(__DragonFly__) || __FreeBSD_version < 500000
  301         ether_ifdetach(ifp, 1);
  302 #else
  303         ether_ifdetach(ifp);
  304         if_free(ifp);
  305 #endif
  306 
  307         splx(s);
  308         return 0;
  309 }
  310 
  311 static void
  312 fwe_init(void *arg)
  313 {
  314         struct fwe_softc *fwe = ((struct fwe_eth_softc *)arg)->fwe;
  315         struct firewire_comm *fc;
  316         struct ifnet *ifp = fwe->eth_softc.ifp;
  317         struct fw_xferq *xferq;
  318         struct fw_xfer *xfer;
  319         struct mbuf *m;
  320         int i;
  321 
  322         FWEDEBUG(ifp, "initializing\n");
  323 
  324         /* XXX keep promiscoud mode */
  325         ifp->if_flags |= IFF_PROMISC;
  326 
  327         fc = fwe->fd.fc;
  328 #define START 0
  329         if (fwe->dma_ch < 0) {
  330                 for (i = START; i < fc->nisodma; i ++) {
  331                         xferq = fc->ir[i];
  332                         if ((xferq->flag & FWXFERQ_OPEN) == 0)
  333                                 goto found;
  334                 }
  335                 printf("no free dma channel\n");
  336                 return;
  337 found:
  338                 fwe->dma_ch = i;
  339                 fwe->stream_ch = stream_ch;
  340                 fwe->pkt_hdr.mode.stream.chtag = fwe->stream_ch;
  341                 /* allocate DMA channel and init packet mode */
  342                 xferq->flag |= FWXFERQ_OPEN | FWXFERQ_EXTBUF |
  343                                 FWXFERQ_HANDLER | FWXFERQ_STREAM;
  344                 xferq->flag &= ~0xff;
  345                 xferq->flag |= fwe->stream_ch & 0xff;
  346                 /* register fwe_input handler */
  347                 xferq->sc = (caddr_t) fwe;
  348                 xferq->hand = fwe_as_input;
  349                 xferq->bnchunk = rx_queue_len;
  350                 xferq->bnpacket = 1;
  351                 xferq->psize = MCLBYTES;
  352                 xferq->queued = 0;
  353                 xferq->buf = NULL;
  354                 xferq->bulkxfer = (struct fw_bulkxfer *) malloc(
  355                         sizeof(struct fw_bulkxfer) * xferq->bnchunk,
  356                                                         M_FWE, M_WAITOK);
  357                 if (xferq->bulkxfer == NULL) {
  358                         printf("if_fwe: malloc failed\n");
  359                         return;
  360                 }
  361                 STAILQ_INIT(&xferq->stvalid);
  362                 STAILQ_INIT(&xferq->stfree);
  363                 STAILQ_INIT(&xferq->stdma);
  364                 xferq->stproc = NULL;
  365                 for (i = 0; i < xferq->bnchunk; i ++) {
  366                         m =
  367 #if defined(__DragonFly__) || __FreeBSD_version < 500000
  368                                 m_getcl(M_WAIT, MT_DATA, M_PKTHDR);
  369 #else
  370                                 m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
  371 #endif
  372                         xferq->bulkxfer[i].mbuf = m;
  373                         if (m != NULL) {
  374                                 m->m_len = m->m_pkthdr.len = m->m_ext.ext_size;
  375                                 STAILQ_INSERT_TAIL(&xferq->stfree,
  376                                                 &xferq->bulkxfer[i], link);
  377                         } else
  378                                 printf("fwe_as_input: m_getcl failed\n");
  379                 }
  380                 STAILQ_INIT(&fwe->xferlist);
  381                 for (i = 0; i < TX_MAX_QUEUE; i++) {
  382                         xfer = fw_xfer_alloc(M_FWE);
  383                         if (xfer == NULL)
  384                                 break;
  385                         xfer->send.spd = tx_speed;
  386                         xfer->fc = fwe->fd.fc;
  387                         xfer->sc = (caddr_t)fwe;
  388                         xfer->hand = fwe_output_callback;
  389                         STAILQ_INSERT_TAIL(&fwe->xferlist, xfer, link);
  390                 }
  391         } else
  392                 xferq = fc->ir[fwe->dma_ch];
  393 
  394 
  395         /* start dma */
  396         if ((xferq->flag & FWXFERQ_RUNNING) == 0)
  397                 fc->irx_enable(fc, fwe->dma_ch);
  398 
  399 #if defined(__FreeBSD__)
  400         ifp->if_drv_flags |= IFF_DRV_RUNNING;
  401         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
  402 #else
  403         ifp->if_flags |= IFF_RUNNING;
  404         ifp->if_flags &= ~IFF_OACTIVE;
  405 #endif
  406 
  407 #if 0
  408         /* attempt to start output */
  409         fwe_start(ifp);
  410 #endif
  411 }
  412 
  413 
  414 static int
  415 fwe_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
  416 {
  417         struct fwe_softc *fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
  418         struct ifstat *ifs = NULL;
  419         int s, error, len;
  420 
  421         switch (cmd) {
  422                 case SIOCSIFFLAGS:
  423                         s = splimp();
  424                         if (ifp->if_flags & IFF_UP) {
  425 #if defined(__FreeBSD__)
  426                                 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
  427 #else
  428                                 if (!(ifp->if_flags & IFF_RUNNING))
  429 #endif
  430                                         fwe_init(&fwe->eth_softc);
  431                         } else {
  432 #if defined(__FreeBSD__)
  433                                 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
  434 #else
  435                                 if (ifp->if_flags & IFF_RUNNING)
  436 #endif
  437                                         fwe_stop(fwe);
  438                         }
  439                         /* XXX keep promiscoud mode */
  440                         ifp->if_flags |= IFF_PROMISC;
  441                         splx(s);
  442                         break;
  443                 case SIOCADDMULTI:
  444                 case SIOCDELMULTI:
  445                         break;
  446 
  447                 case SIOCGIFSTATUS:
  448                         s = splimp();
  449                         ifs = (struct ifstat *)data;
  450                         len = strlen(ifs->ascii);
  451                         if (len < sizeof(ifs->ascii))
  452                                 snprintf(ifs->ascii + len,
  453                                         sizeof(ifs->ascii) - len,
  454                                         "\tch %d dma %d\n",
  455                                                 fwe->stream_ch, fwe->dma_ch);
  456                         splx(s);
  457                         break;
  458                 case SIOCSIFCAP:
  459 #ifdef DEVICE_POLLING
  460                     {
  461                         struct ifreq *ifr = (struct ifreq *) data;
  462                         struct firewire_comm *fc = fc = fwe->fd.fc;
  463 
  464                         if (ifr->ifr_reqcap & IFCAP_POLLING &&
  465                             !(ifp->if_capenable & IFCAP_POLLING)) {
  466                                 error = ether_poll_register(fwe_poll, ifp);
  467                                 if (error)
  468                                         return(error);
  469                                 /* Disable interrupts */
  470                                 fc->set_intr(fc, 0);
  471                                 ifp->if_capenable |= IFCAP_POLLING;
  472                                 return (error);
  473                                 
  474                         }
  475                         if (!(ifr->ifr_reqcap & IFCAP_POLLING) &&
  476                             ifp->if_capenable & IFCAP_POLLING) {
  477                                 error = ether_poll_deregister(ifp);
  478                                 /* Enable interrupts. */
  479                                 fc->set_intr(fc, 1);
  480                                 ifp->if_capenable &= ~IFCAP_POLLING;
  481                                 return (error);
  482                         }
  483                     }
  484 #endif /* DEVICE_POLLING */
  485                         break;
  486 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
  487                 default:
  488 #else
  489                 case SIOCSIFADDR:
  490                 case SIOCGIFADDR:
  491                 case SIOCSIFMTU:
  492 #endif
  493                         s = splimp();
  494                         error = ether_ioctl(ifp, cmd, data);
  495                         splx(s);
  496                         return (error);
  497 #if defined(__DragonFly__) || __FreeBSD_version < 500000
  498                 default:
  499                         return (EINVAL);
  500 #endif
  501         }
  502 
  503         return (0);
  504 }
  505 
  506 static void
  507 fwe_output_callback(struct fw_xfer *xfer)
  508 {
  509         struct fwe_softc *fwe;
  510         struct ifnet *ifp;
  511         int s;
  512 
  513         fwe = (struct fwe_softc *)xfer->sc;
  514         ifp = fwe->eth_softc.ifp;
  515         /* XXX error check */
  516         FWEDEBUG(ifp, "resp = %d\n", xfer->resp);
  517         if (xfer->resp != 0)
  518                 ifp->if_oerrors ++;
  519                 
  520         m_freem(xfer->mbuf);
  521         fw_xfer_unload(xfer);
  522 
  523         s = splimp();
  524         STAILQ_INSERT_TAIL(&fwe->xferlist, xfer, link);
  525         splx(s);
  526 
  527         /* for queue full */
  528         if (ifp->if_snd.ifq_head != NULL)
  529                 fwe_start(ifp);
  530 }
  531 
  532 static void
  533 fwe_start(struct ifnet *ifp)
  534 {
  535         struct fwe_softc *fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
  536         int s;
  537 
  538         GIANT_REQUIRED;
  539 
  540         FWEDEBUG(ifp, "starting\n");
  541 
  542         if (fwe->dma_ch < 0) {
  543                 struct mbuf     *m = NULL;
  544 
  545                 FWEDEBUG(ifp, "not ready\n");
  546 
  547                 s = splimp();
  548                 do {
  549                         IF_DEQUEUE(&ifp->if_snd, m);
  550                         if (m != NULL)
  551                                 m_freem(m);
  552                         ifp->if_oerrors ++;
  553                 } while (m != NULL);
  554                 splx(s);
  555 
  556                 return;
  557         }
  558 
  559         s = splimp();
  560 #if defined(__FreeBSD__)
  561         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
  562 #else
  563         ifp->if_flags |= IFF_OACTIVE;
  564 #endif
  565 
  566         if (ifp->if_snd.ifq_len != 0)
  567                 fwe_as_output(fwe, ifp);
  568 
  569 #if defined(__FreeBSD__)
  570         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
  571 #else
  572         ifp->if_flags &= ~IFF_OACTIVE;
  573 #endif
  574         splx(s);
  575 }
  576 
  577 #define HDR_LEN 4
  578 #ifndef ETHER_ALIGN
  579 #define ETHER_ALIGN 2
  580 #endif
  581 /* Async. stream output */
  582 static void
  583 fwe_as_output(struct fwe_softc *fwe, struct ifnet *ifp)
  584 {
  585         struct mbuf *m;
  586         struct fw_xfer *xfer;
  587         struct fw_xferq *xferq;
  588         struct fw_pkt *fp;
  589         int i = 0;
  590 
  591         xfer = NULL;
  592         xferq = fwe->fd.fc->atq;
  593         while (xferq->queued < xferq->maxq - 1) {
  594                 xfer = STAILQ_FIRST(&fwe->xferlist);
  595                 if (xfer == NULL) {
  596                         printf("if_fwe: lack of xfer\n");
  597                         return;
  598                 }
  599                 IF_DEQUEUE(&ifp->if_snd, m);
  600                 if (m == NULL)
  601                         break;
  602                 STAILQ_REMOVE_HEAD(&fwe->xferlist, link);
  603 #if defined(__DragonFly__) || __FreeBSD_version < 500000
  604                 if (ifp->if_bpf != NULL)
  605                         bpf_mtap(ifp, m);
  606 #else
  607                 BPF_MTAP(ifp, m);
  608 #endif
  609 
  610                 /* keep ip packet alignment for alpha */
  611                 M_PREPEND(m, ETHER_ALIGN, M_DONTWAIT);
  612                 fp = &xfer->send.hdr;
  613                 *(uint32_t *)&xfer->send.hdr = *(int32_t *)&fwe->pkt_hdr;
  614                 fp->mode.stream.len = m->m_pkthdr.len;
  615                 xfer->mbuf = m;
  616                 xfer->send.pay_len = m->m_pkthdr.len;
  617 
  618                 if (fw_asyreq(fwe->fd.fc, -1, xfer) != 0) {
  619                         /* error */
  620                         ifp->if_oerrors ++;
  621                         /* XXX set error code */
  622                         fwe_output_callback(xfer);
  623                 } else {
  624                         ifp->if_opackets ++;
  625                         i++;
  626                 }
  627         }
  628 #if 0
  629         if (i > 1)
  630                 printf("%d queued\n", i);
  631 #endif
  632         if (i > 0)
  633                 xferq->start(fwe->fd.fc);
  634 }
  635 
  636 /* Async. stream output */
  637 static void
  638 fwe_as_input(struct fw_xferq *xferq)
  639 {
  640         struct mbuf *m, *m0;
  641         struct ifnet *ifp;
  642         struct fwe_softc *fwe;
  643         struct fw_bulkxfer *sxfer;
  644         struct fw_pkt *fp;
  645         u_char *c;
  646 #if defined(__DragonFly__) || __FreeBSD_version < 500000
  647         struct ether_header *eh;
  648 #endif
  649 
  650         fwe = (struct fwe_softc *)xferq->sc;
  651         ifp = fwe->eth_softc.ifp;
  652 
  653         while ((sxfer = STAILQ_FIRST(&xferq->stvalid)) != NULL) {
  654                 STAILQ_REMOVE_HEAD(&xferq->stvalid, link);
  655                 fp = mtod(sxfer->mbuf, struct fw_pkt *);
  656                 if (fwe->fd.fc->irx_post != NULL)
  657                         fwe->fd.fc->irx_post(fwe->fd.fc, fp->mode.ld);
  658                 m = sxfer->mbuf;
  659 
  660                 /* insert new rbuf */
  661                 sxfer->mbuf = m0 = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
  662                 if (m0 != NULL) {
  663                         m0->m_len = m0->m_pkthdr.len = m0->m_ext.ext_size;
  664                         STAILQ_INSERT_TAIL(&xferq->stfree, sxfer, link);
  665                 } else
  666                         printf("fwe_as_input: m_getcl failed\n");
  667 
  668                 if (sxfer->resp != 0 || fp->mode.stream.len <
  669                     ETHER_ALIGN + sizeof(struct ether_header)) {
  670                         m_freem(m);
  671                         ifp->if_ierrors ++;
  672                         continue;
  673                 }
  674 
  675                 m->m_data += HDR_LEN + ETHER_ALIGN;
  676                 c = mtod(m, char *);
  677 #if defined(__DragonFly__) || __FreeBSD_version < 500000
  678                 eh = (struct ether_header *)c;
  679                 m->m_data += sizeof(struct ether_header);
  680                 m->m_len = m->m_pkthdr.len = fp->mode.stream.len - ETHER_ALIGN
  681                     - sizeof(struct ether_header);
  682 #else
  683                 m->m_len = m->m_pkthdr.len = fp->mode.stream.len - ETHER_ALIGN;
  684 #endif
  685                 m->m_pkthdr.rcvif = ifp;
  686 #if 0
  687                 FWEDEBUG(ifp, "%02x %02x %02x %02x %02x %02x\n"
  688                          "%02x %02x %02x %02x %02x %02x\n"
  689                          "%02x %02x %02x %02x\n"
  690                          "%02x %02x %02x %02x\n"
  691                          "%02x %02x %02x %02x\n"
  692                          "%02x %02x %02x %02x\n",
  693                          c[0], c[1], c[2], c[3], c[4], c[5],
  694                          c[6], c[7], c[8], c[9], c[10], c[11],
  695                          c[12], c[13], c[14], c[15],
  696                          c[16], c[17], c[18], c[19],
  697                          c[20], c[21], c[22], c[23],
  698                          c[20], c[21], c[22], c[23]
  699                  );
  700 #endif
  701 #if defined(__DragonFly__) || __FreeBSD_version < 500000
  702                 ether_input(ifp, eh, m);
  703 #else
  704                 (*ifp->if_input)(ifp, m);
  705 #endif
  706                 ifp->if_ipackets ++;
  707         }
  708         if (STAILQ_FIRST(&xferq->stfree) != NULL)
  709                 fwe->fd.fc->irx_enable(fwe->fd.fc, fwe->dma_ch);
  710 }
  711 
  712 
  713 static devclass_t fwe_devclass;
  714 
  715 static device_method_t fwe_methods[] = {
  716         /* device interface */
  717         DEVMETHOD(device_identify,      fwe_identify),
  718         DEVMETHOD(device_probe,         fwe_probe),
  719         DEVMETHOD(device_attach,        fwe_attach),
  720         DEVMETHOD(device_detach,        fwe_detach),
  721         { 0, 0 }
  722 };
  723 
  724 static driver_t fwe_driver = {
  725         "fwe",
  726         fwe_methods,
  727         sizeof(struct fwe_softc),
  728 };
  729 
  730 
  731 #ifdef __DragonFly__
  732 DECLARE_DUMMY_MODULE(fwe);
  733 #endif
  734 DRIVER_MODULE(fwe, firewire, fwe_driver, fwe_devclass, 0, 0);
  735 MODULE_VERSION(fwe, 1);
  736 MODULE_DEPEND(fwe, firewire, 1, 1, 1);

Cache object: dcd2ea9afb38c5f234b7aa2ad3e7ec84


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.