src/add-ons/kernel/drivers/network/ipro1000/if_compat.c

   1 /* Intel PRO/1000 Family Driver
   2  * Copyright (C) 2004 Marcus Overhagen <marcus@overhagen.de>. All rights reserved.
   3  *
   4  * Permission to use, copy, modify and distribute this software and its
   5  * documentation for any purpose and without fee is hereby granted, provided
   6  * that the above copyright notice appear in all copies, and that both the
   7  * copyright notice and this permission notice appear in supporting documentation.
   8  *
   9  * Marcus Overhagen makes no representations about the suitability of this software
  10  * for any purpose. It is provided "as is" without express or implied warranty.
  11  *
  12  * MARCUS OVERHAGEN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  13  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL MARCUS
  14  * OVERHAGEN BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
  15  * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  17  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18  */
  19 #include "if_compat.h"
  20 #include "if_em.h"
  21 #include "device.h"
  22 #include "debug.h"
  23 #include "mempool.h"
  24
  25 #undef malloc
  26 #undef free
  27
  28 spinlock        mbuf_lock = 0;
  29
  30 struct mbuf *
  31 m_gethdr(int how, int type)
  32 {
  33         struct mbuf *m = mbuf_pool_get();
  34         if (!m)
  35                 return m;
  36         memset(m, 0, sizeof(m));
  37         m->m_flags = M_PKTHDR;
  38         return m;
  39 }
  40
  41 void
  42 m_clget(struct mbuf * m, int how)
  43 {
  44 //      TRACE("m_clget\n");
  45
  46         m->m_ext.ext_buf = chunk_pool_get();
  47         m->m_data = m->m_ext.ext_buf;
  48         if (m->m_ext.ext_buf)
  49                 m->m_flags |= M_EXT;
  50 }
  51
  52 void
  53 m_adj(struct mbuf *mp, int bytes)
  54 {
  55         mp->m_data = (char *)mp->m_data + bytes;
  56 }
  57
  58 void
  59 m_freem(struct mbuf *mp)
  60 {
  61         struct mbuf *m, *c;
  62 //      TRACE("m_freem\n");
  63
  64         for (m = mp; m; ) {
  65                 if (m->m_flags & M_EXT)
  66                         chunk_pool_put(m->m_ext.ext_buf);
  67                 c = m;
  68                 m = m->m_next;
  69                 mbuf_pool_put(c);
  70         }
  71 }
  72
  73 static void
  74 ether_input(struct ifnet *ifp, struct mbuf *m)
  75 {
  76 /*
  77         uint8 *buf;
  78         int len;
  79
  80         buf = mtod(m, uint8 *);
  81         len = m->m_len;
  82         TRACE("ether_input: received packet with %d bytes\n", len);
  83         TRACE("%02x %02x %02x %02x . %02x %02x %02x %02x . %02x %02x %02x %02x \n",
  84                 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5],
  85                 buf[6], buf[7], buf[8], buf[8], buf[10], buf[11]);
  86
  87         m_freem(m);
  88         return;
  89 */
  90
  91         IF_APPEND(&ifp->if_rcv, m);
  92         release_sem_etc(ifp->if_rcv_sem, 1, B_DO_NOT_RESCHEDULE);
  93 }
  94
  95 void
  96 ether_ifattach(struct ifnet *ifp, const uint8 *etheraddr)
  97 {
  98         ipro1000_device *dev = ifp->if_softc->dev;
  99
 100         INIT_DEBUGOUT("ether_ifattach");
 101
 102         TAILQ_INIT(&ifp->if_multiaddrs);
 103
 104         memcpy(dev->macaddr, etheraddr, 6);
 105
 106         ifp->if_input = ether_input;
 107
 108         ifp->if_rcv_sem = create_sem(0, "ifp->if_rcv_sem");
 109         set_sem_owner(ifp->if_rcv_sem, B_SYSTEM_TEAM);
 110
 111         INIT_DEBUGOUT("calling if_init...");
 112         ifp->if_init(ifp->if_softc);
 113         INIT_DEBUGOUT("done calling if_init!");
 114 }
 115
 116
 117 static struct ifmultiaddr *
 118 ether_find_multi(struct ifnet *ifp, const struct sockaddr *_address)
 119 {
 120         const struct sockaddr_dl *address = (const struct sockaddr_dl *)_address;
 121         struct ifmultiaddr *ifma;
 122
 123         TAILQ_FOREACH (ifma, &ifp->if_multiaddrs, ifma_link) {
 124                 if (memcmp(LLADDR(address),
 125                                 LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
 126                                 ETHER_ADDR_LEN) == 0)
 127                         return ifma;
 128         }
 129
 130         return NULL;
 131 }
 132
 133
 134 int
 135 ether_add_multi(struct ifnet *ifp, const struct sockaddr *address)
 136 {
 137         struct ifmultiaddr *addr = ether_find_multi(ifp, address);
 138
 139         if (addr != NULL) {
 140                 addr->ifma_refcount++;
 141                 return 0;
 142         }
 143
 144         addr = (struct ifmultiaddr *)malloc(sizeof(struct ifmultiaddr));
 145         if (addr == NULL)
 146                 return ENOBUFS;
 147
 148         memcpy(&addr->ifma_addr_storage, address, sizeof(struct sockaddr_dl));
 149         addr->ifma_addr = (struct sockaddr *)&addr->ifma_addr_storage;
 150
 151         addr->ifma_refcount = 1;
 152
 153         TAILQ_INSERT_HEAD(&ifp->if_multiaddrs, addr, ifma_link);
 154
 155         return ifp->if_ioctl(ifp, SIOCADDMULTI, NULL);
 156 }
 157
 158
 159 static void
 160 ether_delete_multi(struct ifnet *ifp, struct ifmultiaddr *ifma)
 161 {
 162         TAILQ_REMOVE(&ifp->if_multiaddrs, ifma, ifma_link);
 163         free(ifma);
 164 }
 165
 166
 167 int
 168 ether_rem_multi(struct ifnet *ifp, const struct sockaddr *address)
 169 {
 170         struct ifmultiaddr *addr = ether_find_multi(ifp, address);
 171         if (addr == NULL)
 172                 return EADDRNOTAVAIL;
 173
 174         addr->ifma_refcount--;
 175         if (addr->ifma_refcount == 0) {
 176                 ether_delete_multi(ifp, addr);
 177                 return ifp->if_ioctl(ifp, SIOCDELMULTI, NULL);
 178         }
 179
 180         return 0;
 181 }
 182
 183
 184 void
 185 ether_ifdetach(struct ifnet *ifp)
 186 {
 187         struct ifmultiaddr *ifma, *next;
 188
 189         INIT_DEBUGOUT("ether_ifdetach");
 190
 191         delete_sem(ifp->if_rcv_sem);
 192
 193         TAILQ_FOREACH_SAFE(ifma, &ifp->if_multiaddrs, ifma_link, next)
 194                 ether_delete_multi(ifp, ifma);
 195 }
 196
 197 struct mbuf *
 198 if_dequeue(struct if_queue *queue)
 199 {
 200         cpu_status s;
 201         struct mbuf *m;
 202
 203 //      TRACE("IF_DEQUEUE\n");
 204
 205         s = disable_interrupts();
 206         acquire_spinlock(&mbuf_lock);
 207
 208         m = (struct mbuf *) queue->ifq_head;
 209         if (m) {
 210                 queue->ifq_head = m->m_nextq;
 211                 if (!queue->ifq_head)
 212                         queue->ifq_tail = 0;
 213                 m->m_nextq = 0;
 214         }
 215
 216         release_spinlock(&mbuf_lock);
 217         restore_interrupts(s);
 218
 219         return m;
 220 }
 221
 222 void
 223 if_prepend(struct if_queue *queue, struct mbuf *mb)
 224 {
 225         cpu_status s;
 226 //      TRACE("IF_PREPEND\n");
 227
 228         s = disable_interrupts();
 229         acquire_spinlock(&mbuf_lock);
 230
 231         mb->m_nextq = (struct mbuf *) queue->ifq_head;
 232         queue->ifq_head = mb;
 233         if (!queue->ifq_tail)
 234                 queue->ifq_tail = mb;
 235
 236         release_spinlock(&mbuf_lock);
 237         restore_interrupts(s);
 238 }
 239
 240 void
 241 if_append(struct if_queue *queue, struct mbuf *mb)
 242 {
 243         cpu_status s;
 244 //      TRACE("IF_APPEND\n");
 245
 246         s = disable_interrupts();
 247         acquire_spinlock(&mbuf_lock);
 248
 249         mb->m_nextq = 0;
 250         if (!queue->ifq_tail) {
 251                 queue->ifq_tail = mb;
 252                 queue->ifq_head = mb;
 253         } else {
 254                 queue->ifq_tail->m_nextq = mb;
 255                 queue->ifq_tail = mb;
 256         }
 257
 258         release_spinlock(&mbuf_lock);
 259         restore_interrupts(s);
 260 }