Annotation of sys/dev/pci/if_san_common.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: if_san_common.c,v 1.11 2005/11/08 20:23:42 canacar Exp $ */
! 2:
! 3: /*-
! 4: * Copyright (c) 2001-2004 Sangoma Technologies (SAN)
! 5: * All rights reserved. www.sangoma.com
! 6: *
! 7: * This code is written by Alex Feldman <al.feldman@sangoma.com> for SAN.
! 8: *
! 9: * Redistribution and use in source and binary forms, with or without
! 10: * modification, are permitted provided that the following conditions
! 11: * are met:
! 12: * 1. Redistributions of source code must retain the above copyright
! 13: * notice, this list of conditions and the following disclaimer.
! 14: * 2. Redistributions in binary form must reproduce the above
! 15: * copyright notice, this list of conditions and the following disclaimer
! 16: * in the documentation and/or other materials provided with the
! 17: * distribution.
! 18: * 3. Neither the name of Sangoma Technologies nor the names of its
! 19: * contributors may be used to endorse or promote products derived
! 20: * from this software without specific prior written permission.
! 21: *
! 22: * THIS SOFTWARE IS PROVIDED BY SANGOMA TECHNOLOGIES AND CONTRIBUTORS
! 23: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 24: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 25: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
! 26: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 27: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 28: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 29: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 30: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 31: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
! 32: * THE POSSIBILITY OF SUCH DAMAGE.
! 33: */
! 34:
! 35:
! 36: # include <sys/types.h>
! 37: # include <sys/param.h>
! 38: # include <sys/systm.h>
! 39: # include <sys/syslog.h>
! 40: # include <sys/ioccom.h>
! 41: # include <sys/conf.h>
! 42: # include <sys/malloc.h>
! 43: # include <sys/errno.h>
! 44: # include <sys/exec.h>
! 45: # include <sys/mbuf.h>
! 46: # include <sys/proc.h>
! 47: # include <sys/socket.h>
! 48: # include <sys/kernel.h>
! 49: # include <sys/time.h>
! 50: # include <sys/timeout.h>
! 51:
! 52: # include <net/bpf.h>
! 53: # include <net/if_dl.h>
! 54: # include <net/if_types.h>
! 55: # include <net/if.h>
! 56: # include <net/netisr.h>
! 57: # include <net/route.h>
! 58: # include <net/if_media.h>
! 59: # include <net/ppp_defs.h>
! 60: # include <net/if_ppp.h>
! 61: # include <net/if_sppp.h>
! 62: # include <netinet/in_systm.h>
! 63: # include <netinet/in.h>
! 64: # include <netinet/in_var.h>
! 65: # include <netinet/udp.h>
! 66: # include <netinet/ip.h>
! 67:
! 68: # include <dev/pci/if_san_common.h>
! 69: # include <dev/pci/if_san_obsd.h>
! 70:
! 71: #ifdef _DEBUG_
! 72: #define STATIC
! 73: #else
! 74: #define STATIC static
! 75: #endif
! 76:
! 77: /* WAN link driver entry points */
! 78: #if 0
! 79: static int shutdown(sdla_t *card);
! 80: #endif
! 81:
! 82: /* Miscellaneous functions */
! 83: static int wan_ioctl(struct ifnet*, int, struct ifreq *);
! 84: static int sdla_isr(void *);
! 85:
! 86: static void release_hw(sdla_t *card);
! 87:
! 88: static int wan_ioctl_dump(sdla_t *, void *);
! 89: static int wan_ioctl_hwprobe(struct ifnet *, void *);
! 90:
! 91: /*
! 92: * Global Data
! 93: * Note: All data must be explicitly initialized!!!
! 94: */
! 95:
! 96: /* private data */
! 97: extern char *san_drvname;
! 98: LIST_HEAD(, sdla) wan_cardlist = LIST_HEAD_INITIALIZER(&wan_cardlist);
! 99:
! 100: #if 0
! 101: static san_detach(void)
! 102: {
! 103: wanpipe_common_t *common;
! 104: sdla_t *card, *tmp_card;
! 105: int err = 0;
! 106:
! 107: card = LIST_FIRST(&wan_cardlist);
! 108: while (card) {
! 109: if (card->disable_comm)
! 110: card->disable_comm(card);
! 111:
! 112: while ((common = LIST_FIRST(&card->dev_head))) {
! 113: LIST_REMOVE(common, next);
! 114: if (card->del_if) {
! 115: struct ifnet *ifp =
! 116: (struct ifnet*)&common->ifp;
! 117: log(LOG_INFO, "%s: Deleting interface...\n",
! 118: ifp->if_xname);
! 119: card->del_if(card, ifp);
! 120: }
! 121: }
! 122: log(LOG_INFO, "%s: Shutdown device\n", card->devname);
! 123: shutdown(card);
! 124: tmp_card = card;
! 125: card = LIST_NEXT(card, next);
! 126: LIST_REMOVE(tmp_card, next);
! 127: free(tmp_card, M_DEVBUF);
! 128: }
! 129:
! 130: log(LOG_INFO, "\n");
! 131: log(LOG_INFO, "%s: WANPIPE Generic Modules Unloaded.\n",
! 132: san_drvname);
! 133:
! 134: err = sdladrv_exit();
! 135: return err;
! 136: }
! 137: #endif
! 138:
! 139:
! 140: int
! 141: san_dev_attach(void *hw, u_int8_t *devname, int namelen)
! 142: {
! 143: sdla_t *card;
! 144: wanpipe_common_t *common = NULL;
! 145: int err = 0;
! 146:
! 147: card=malloc(sizeof(sdla_t), M_DEVBUF, M_NOWAIT);
! 148: if (!card) {
! 149: log(LOG_INFO, "%s: Failed allocate new card!\n",
! 150: san_drvname);
! 151: return (EINVAL);
! 152: }
! 153: bzero(card, sizeof(sdla_t));
! 154: card->magic = WANPIPE_MAGIC;
! 155: wanpipe_generic_name(card, card->devname, sizeof(card->devname));
! 156: strlcpy(devname, card->devname, namelen);
! 157: card->hw = hw;
! 158: LIST_INIT(&card->dev_head);
! 159:
! 160: sdla_getcfg(card->hw, SDLA_CARDTYPE, &card->type);
! 161: if (sdla_is_te1(card->hw))
! 162: sdla_te_defcfg(&card->fe_te.te_cfg);
! 163:
! 164: err = sdla_setup(card->hw);
! 165: if (err) {
! 166: log(LOG_INFO, "%s: Hardware setup Failed %d\n",
! 167: card->devname,err);
! 168: return (EINVAL);
! 169: }
! 170: err = sdla_intr_establish(card->hw, sdla_isr, (void*)card);
! 171: if (err) {
! 172: log(LOG_INFO, "%s: Failed set interrupt handler!\n",
! 173: card->devname);
! 174: sdla_down(card->hw);
! 175: return (EINVAL);
! 176: }
! 177:
! 178: switch (card->type) {
! 179: case SDLA_AFT:
! 180: #if defined(DEBUG_INIT)
! 181: log(LOG_INFO, "%s: Starting AFT Hardware Init.\n",
! 182: card->devname);
! 183: #endif
! 184: common = wan_xilinx_init(card);
! 185: break;
! 186: }
! 187: if (common == NULL) {
! 188: release_hw(card);
! 189: card->configured = 0;
! 190: return (EINVAL);
! 191: }
! 192: LIST_INSERT_HEAD(&card->dev_head, common, next);
! 193:
! 194: /* Reserve I/O region and schedule background task */
! 195: card->critical = 0;
! 196: card->state = WAN_DISCONNECTED;
! 197: card->ioctl = wan_ioctl;
! 198: return (0);
! 199: }
! 200:
! 201:
! 202: /*
! 203: * Shut down WAN link driver.
! 204: * o shut down adapter hardware
! 205: * o release system resources.
! 206: *
! 207: */
! 208: #if 0
! 209: static int
! 210: shutdown (sdla_t *card)
! 211: {
! 212: int err=0;
! 213:
! 214: if (card->state == WAN_UNCONFIGURED) {
! 215: return 0;
! 216: }
! 217: card->state = WAN_UNCONFIGURED;
! 218:
! 219: bit_set((u_int8_t*)&card->critical, PERI_CRIT);
! 220:
! 221: /* In case of piggibacking, make sure that
! 222: * we never try to shutdown both devices at the same
! 223: * time, because they depend on one another */
! 224:
! 225: card->state = WAN_UNCONFIGURED;
! 226:
! 227: /* Release Resources */
! 228: release_hw(card);
! 229:
! 230: /* only free the allocated I/O range if not an S514 adapter */
! 231: if (!card->configured) {
! 232: card->hw = NULL;
! 233: if (card->same_cpu) {
! 234: card->same_cpu->hw = NULL;
! 235: card->same_cpu->same_cpu = NULL;
! 236: card->same_cpu=NULL;
! 237: }
! 238: }
! 239:
! 240: bit_clear((u_int8_t*)&card->critical, PERI_CRIT);
! 241:
! 242: return err;
! 243: }
! 244: #endif
! 245:
! 246: static void
! 247: release_hw(sdla_t *card)
! 248: {
! 249: log(LOG_INFO, "%s: Master shutting down\n",card->devname);
! 250: sdla_down(card->hw);
! 251: sdla_intr_disestablish(card->hw);
! 252: card->configured = 0;
! 253: return;
! 254: }
! 255:
! 256:
! 257: /*
! 258: * Driver IOCTL Handlers
! 259: */
! 260:
! 261: static int
! 262: wan_ioctl(struct ifnet *ifp, int cmd, struct ifreq *ifr)
! 263: {
! 264: sdla_t *card;
! 265: wanpipe_common_t *common = WAN_IFP_TO_COMMON(ifp);
! 266: int err;
! 267:
! 268: SAN_ASSERT(common == NULL);
! 269: SAN_ASSERT(common->card == NULL);
! 270:
! 271: if ((err = suser(curproc, 0)) != 0)
! 272: return err;
! 273:
! 274: switch (cmd) {
! 275: case SIOC_WANPIPE_HWPROBE:
! 276: err = wan_ioctl_hwprobe(ifp, ifr->ifr_data);
! 277: break;
! 278:
! 279: case SIOC_WANPIPE_DUMP:
! 280: err = wan_ioctl_dump(card, ifr->ifr_data);
! 281: break;
! 282:
! 283: default:
! 284: err = ENOTTY;
! 285: break;
! 286: }
! 287: return err;
! 288: }
! 289:
! 290: static int
! 291: wan_ioctl_hwprobe(struct ifnet *ifp, void *u_def)
! 292: {
! 293: sdla_t *card = NULL;
! 294: wanpipe_common_t *common = WAN_IFP_TO_COMMON(ifp);
! 295: wanlite_def_t def;
! 296: unsigned char *str;
! 297: int err;
! 298:
! 299: SAN_ASSERT(common == NULL);
! 300: SAN_ASSERT(common->card == NULL);
! 301: card = common->card;
! 302: bzero(&def, sizeof(wanlite_def_t));
! 303: /* Get protocol type */
! 304: def.proto = common->protocol;
! 305:
! 306: /* Get hardware configuration */
! 307: err = sdla_get_hwprobe(card->hw, (void**)&str);
! 308: if (err)
! 309: return EINVAL;
! 310:
! 311: strlcpy(def.hwprobe, str, sizeof(def.hwprobe));
! 312: /* Get interface configuration */
! 313: if (IS_TE1(&card->fe_te.te_cfg)) {
! 314: if (IS_T1(&card->fe_te.te_cfg))
! 315: def.iface = IF_IFACE_T1;
! 316: else
! 317: def.iface = IF_IFACE_E1;
! 318:
! 319: bcopy(&card->fe_te.te_cfg, &def.te_cfg, sizeof(sdla_te_cfg_t));
! 320: }
! 321:
! 322: err = copyout(&def, u_def, sizeof(def));
! 323: if (err) {
! 324: log(LOG_INFO, "%s: Failed to copy to user space (%d)\n",
! 325: card->devname, __LINE__);
! 326: return ENOMEM;
! 327: }
! 328: return 0;
! 329: }
! 330:
! 331: static int
! 332: wan_ioctl_dump(sdla_t *card, void *u_dump)
! 333: {
! 334: sdla_dump_t dump;
! 335: void* data;
! 336: u_int32_t memory;
! 337: int err = 0;
! 338:
! 339: err = copyin(u_dump, &dump, sizeof(sdla_dump_t));
! 340: if (err)
! 341: return err;
! 342:
! 343: sdla_getcfg(card->hw, SDLA_MEMORY, &memory);
! 344: if (dump.magic != WANPIPE_MAGIC)
! 345: return EINVAL;
! 346:
! 347: if ((dump.offset + dump.length) > memory)
! 348: return EINVAL;
! 349:
! 350: data = malloc(dump.length, M_DEVBUF, M_NOWAIT);
! 351: if (data == NULL)
! 352: return ENOMEM;
! 353:
! 354: sdla_peek(card->hw, dump.offset, data, dump.length);
! 355: err = copyout(data, dump.ptr, dump.length);
! 356: if (err) {
! 357: log(LOG_INFO, "%s: Failed to copy to user space (%d)\n",
! 358: card->devname, __LINE__);
! 359: }
! 360: free(data, M_DEVBUF);
! 361: return err;
! 362: }
! 363:
! 364:
! 365: /*
! 366: * SDLA Interrupt Service Routine.
! 367: * o call protocol-specific interrupt service routine, if any.
! 368: */
! 369: int
! 370: sdla_isr(void *pcard)
! 371: {
! 372: sdla_t *card = (sdla_t*)pcard;
! 373:
! 374: if (card == NULL || card->magic != WANPIPE_MAGIC)
! 375: return 0;
! 376:
! 377: switch (card->type) {
! 378: case SDLA_AFT:
! 379: if (card->isr)
! 380: card->isr(card);
! 381: break;
! 382: }
! 383: return (1);
! 384: }
! 385:
! 386: struct mbuf*
! 387: wan_mbuf_alloc(int len)
! 388: {
! 389: struct mbuf *m;
! 390:
! 391: /* XXX handle len > MCLBYTES */
! 392: if (len <= 0 || len > MCLBYTES)
! 393: return (NULL);
! 394:
! 395: MGETHDR(m, M_DONTWAIT, MT_DATA);
! 396:
! 397: if (m == NULL || len <= MHLEN)
! 398: return (m);
! 399:
! 400: m->m_pkthdr.len = len;
! 401: m->m_len = len;
! 402: MCLGET(m, M_DONTWAIT);
! 403:
! 404: if ((m->m_flags & M_EXT) == 0) {
! 405: m_freem(m);
! 406: return (NULL);
! 407: }
! 408:
! 409: return (m);
! 410: }
! 411:
! 412: int
! 413: wan_mbuf_to_buffer(struct mbuf **m_org)
! 414: {
! 415: struct mbuf *m, *m0, *tmp;
! 416: char *buffer;
! 417: size_t len;
! 418:
! 419: if (m_org == NULL || *m_org == NULL)
! 420: return (EINVAL);
! 421:
! 422: m0 = *m_org;
! 423: #if 0
! 424: /* no need to copy if it is a single, properly aligned mbuf */
! 425: if (m0->m_next == NULL && (mtod(m0, u_int32_t) & 0x03) == 0)
! 426: return (0);
! 427: #endif
! 428: MGET(m, M_DONTWAIT, MT_DATA);
! 429:
! 430: if (m == NULL)
! 431: return (ENOMEM);
! 432:
! 433: MCLGET(m, M_DONTWAIT);
! 434:
! 435: if ((m->m_flags & M_EXT) == 0) {
! 436: m_freem(m);
! 437: return (ENOMEM);
! 438: }
! 439:
! 440: m->m_len = 0;
! 441:
! 442: /* XXX handle larger packets? */
! 443: len = MCLBYTES ;
! 444: buffer = mtod(m, caddr_t);
! 445:
! 446: len -= 16;
! 447: buffer += 16;
! 448:
! 449: /* make sure the buffer is aligned to a 4-byte boundary */
! 450: if (ADDR_MASK(buffer, 0x03)) {
! 451: unsigned int inc = 4 - ADDR_MASK(buffer, 0x03);
! 452: buffer += inc;
! 453: len -= inc;
! 454: }
! 455:
! 456: m->m_data = buffer;
! 457:
! 458: for (tmp = m0; tmp; tmp = tmp->m_next) {
! 459: if (tmp->m_len > len) {
! 460: m_freem(m);
! 461: return (EINVAL);
! 462: }
! 463: bcopy(mtod(tmp, caddr_t), buffer, tmp->m_len);
! 464: buffer += tmp->m_len;
! 465: m->m_len += tmp->m_len;
! 466: len -= tmp->m_len;
! 467: }
! 468:
! 469: m_freem(m0);
! 470: *m_org = m;
! 471:
! 472: return (0);
! 473: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_san_common.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci