[BACK]Return to xmm7360.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / dev / pci

Annotation of src/sys/dev/pci/xmm7360.c, Revision 1.10

1.10    ! thorpej     1: /*     $NetBSD: xmm7360.c,v 1.9 2021/08/07 16:19:14 thorpej Exp $      */
1.8       andvar      2:
1.1       jdolecek    3: /*
                      4:  * Device driver for Intel XMM7360 LTE modems, eg. Fibocom L850-GL.
                      5:  * Written by James Wah
                      6:  * james@laird-wah.net
                      7:  *
                      8:  * Development of this driver was supported by genua GmbH
                      9:  *
1.8       andvar     10:  * Copyright (c) 2020 genua GmbH <info@genua.de>
                     11:  * Copyright (c) 2020 James Wah <james@laird-wah.net>
1.1       jdolecek   12:  *
1.2       jdolecek   13:  * The OpenBSD and NetBSD support was written by Jaromir Dolecek for
                     14:  * Moritz Systems Technology Company Sp. z o.o.
1.1       jdolecek   15:  *
                     16:  * Permission to use, copy, modify, and/or distribute this software for any
                     17:  * purpose with or without fee is hereby granted, provided that the above
                     18:  * copyright notice and this permission notice appear in all copies.
                     19:  *
                     20:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
                     21:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES ON
                     22:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
                     23:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGE
                     24:  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
                     25:  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
                     26:  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     27:  */
                     28:
                     29: #ifdef __linux__
                     30:
                     31: #include <linux/init.h>
                     32: #include <linux/interrupt.h>
                     33: #include <linux/kernel.h>
                     34: #include <linux/module.h>
                     35: #include <linux/pci.h>
                     36: #include <linux/delay.h>
                     37: #include <linux/uaccess.h>
                     38: #include <linux/cdev.h>
                     39: #include <linux/wait.h>
                     40: #include <linux/tty.h>
                     41: #include <linux/tty_flip.h>
                     42: #include <linux/poll.h>
                     43: #include <linux/skbuff.h>
                     44: #include <linux/netdevice.h>
                     45: #include <linux/if.h>
                     46: #include <linux/if_arp.h>
                     47: #include <net/rtnetlink.h>
                     48: #include <linux/hrtimer.h>
                     49: #include <linux/workqueue.h>
                     50:
                     51: MODULE_LICENSE("Dual BSD/GPL");
                     52:
                     53: static const struct pci_device_id xmm7360_ids[] = {
                     54:        { PCI_DEVICE(0x8086, 0x7360), },
                     55:        { 0, }
                     56: };
                     57: MODULE_DEVICE_TABLE(pci, xmm7360_ids);
                     58:
                     59: /* Actually this ioctl not used for xmm0/rpc device by python code */
                     60: #define XMM7360_IOCTL_GET_PAGE_SIZE _IOC(_IOC_READ, 'x', 0xc0, sizeof(u32))
                     61:
                     62: #define xmm7360_os_msleep(msec)                msleep(msec)
                     63:
                     64: #define __unused                       /* nothing */
                     65:
                     66: #endif
                     67:
                     68: #if defined(__OpenBSD__) || defined(__NetBSD__)
                     69:
                     70: #ifdef __OpenBSD__
                     71: #include "bpfilter.h"
                     72: #endif
                     73: #ifdef __NetBSD__
                     74: #include "opt_inet.h"
                     75: #include "opt_gateway.h"
                     76:
                     77: #include <sys/cdefs.h>
1.10    ! thorpej    78: __KERNEL_RCSID(0, "$NetBSD: xmm7360.c,v 1.9 2021/08/07 16:19:14 thorpej Exp $");
1.1       jdolecek   79: #endif
                     80:
                     81: #include <sys/param.h>
                     82: #include <sys/systm.h>
                     83: #include <sys/sockio.h>
                     84: #include <sys/mbuf.h>
                     85: #include <sys/kernel.h>
                     86: #include <sys/device.h>
                     87: #include <sys/socket.h>
                     88: #include <sys/mutex.h>
                     89: #include <sys/tty.h>
                     90: #include <sys/conf.h>
                     91: #include <sys/kthread.h>
                     92: #include <sys/poll.h>
                     93: #include <sys/fcntl.h>         /* for FREAD/FWRITE */
                     94: #include <sys/vnode.h>
                     95: #include <uvm/uvm_param.h>
                     96:
                     97: #include <dev/pci/pcireg.h>
                     98: #include <dev/pci/pcivar.h>
                     99: #include <dev/pci/pcidevs.h>
                    100:
                    101: #include <net/if.h>
                    102: #include <net/if_types.h>
                    103:
                    104: #include <netinet/in.h>
                    105: #include <netinet/ip.h>
                    106: #include <netinet/ip6.h>
                    107:
                    108: #ifdef __OpenBSD__
                    109: #include <netinet/if_ether.h>
                    110: #include <sys/timeout.h>
                    111: #include <machine/bus.h>
                    112: #endif
                    113:
                    114: #if NBPFILTER > 0 || defined(__NetBSD__)
                    115: #include <net/bpf.h>
                    116: #endif
                    117:
                    118: #ifdef __NetBSD__
                    119: #include "ioconf.h"
                    120: #include <sys/cpu.h>
                    121: #endif
                    122:
                    123: #ifdef INET
                    124: #include <netinet/in_var.h>
                    125: #endif
                    126: #ifdef INET6
                    127: #include <netinet6/in6_var.h>
                    128: #endif
                    129:
                    130: typedef uint8_t u8;
                    131: typedef uint16_t u16;
                    132: typedef uint32_t u32;
                    133: typedef bus_addr_t dma_addr_t;
                    134: typedef void * wait_queue_head_t;      /* just address for tsleep() */
                    135:
                    136: #define WWAN_BAR0      PCI_MAPREG_START
                    137: #define WWAN_BAR1      (PCI_MAPREG_START + 4)
                    138: #define WWAN_BAR2      (PCI_MAPREG_START + 8)
                    139:
                    140: #define BUG_ON(never_true)     KASSERT(!(never_true))
                    141: #define WARN_ON(x)             /* nothing */
                    142:
                    143: #ifdef __OpenBSD__
                    144: typedef struct mutex spinlock_t;
                    145: #define dev_err(devp, fmt, ...)                \
                    146:        printf("%s: " fmt, (devp)->dv_xname, ##__VA_ARGS__)
                    147: #define dev_info(devp, fmt, ...)       \
                    148:        printf("%s: " fmt, (devp)->dv_xname, ##__VA_ARGS__)
                    149: #define        kzalloc(size, flags)    malloc(size, M_DEVBUF, M_WAITOK | M_ZERO)
                    150: #define kfree(addr)            free(addr, M_DEVBUF, 0)
                    151: #define mutex_init(lock)       mtx_init(lock, IPL_TTY)
                    152: #define mutex_lock(lock)       mtx_enter(lock)
                    153: #define mutex_unlock(lock)     mtx_leave(lock)
                    154: /* In OpenBSD every mutex is spin mutex, and it must not be held on sleep */
                    155: #define spin_lock_irqsave(lock, flags)         mtx_enter(lock)
                    156: #define spin_unlock_irqrestore(lock, flags)    mtx_leave(lock)
                    157:
                    158: /* Compat defines for NetBSD API */
                    159: #define curlwp                 curproc
                    160: #define LINESW(tp)                             (linesw[(tp)->t_line])
                    161: #define selnotify(sel, band, note)             selwakeup(sel)
                    162: #define cfdata_t                               void *
                    163: #define device_lookup_private(cdp, unit)       \
                    164:        (unit < (*cdp).cd_ndevs) ? (*cdp).cd_devs[unit] : NULL
                    165: #define IFQ_SET_READY(ifq)                     /* nothing */
                    166: #define device_private(devt)                   (void *)devt;
                    167: #define if_deferred_start_init(ifp, arg)       /* nothing */
                    168: #define IF_OUTPUT_CONST                                /* nothing */
                    169: #define tty_lock()                             int s = spltty()
                    170: #define tty_unlock()                           splx(s)
                    171: #define tty_locked()                           /* nothing */
                    172: #define pmf_device_deregister(dev)             /* nothing */
                    173: #if NBPFILTER > 0
                    174: #define BPF_MTAP_OUT(ifp, m)                                           \
                    175:                 if (ifp->if_bpf) {                                     \
                    176:                         bpf_mtap_af(ifp->if_bpf, m->m_pkthdr.ph_family,        \
                    177:                            m, BPF_DIRECTION_OUT);                      \
                    178:                }
                    179: #else
                    180: #define BPF_MTAP_OUT(ifp, m)                   /* nothing */
                    181: #endif
                    182:
                    183: /* Copied from NetBSD <lib/libkern/libkern.h> */
                    184: #define __validate_container_of(PTR, TYPE, FIELD)                      \
                    185:     (0 * sizeof((PTR) - &((TYPE *)(((char *)(PTR)) -                   \
                    186:     offsetof(TYPE, FIELD)))->FIELD))
                    187: #define        container_of(PTR, TYPE, FIELD)                                  \
                    188:     ((TYPE *)(((char *)(PTR)) - offsetof(TYPE, FIELD))                 \
                    189:        + __validate_container_of(PTR, TYPE, FIELD))
                    190:
                    191: /* Copied from NetBSD <sys/cdefs.h> */
1.3       riastrad  192: #define __UNVOLATILE(a)                ((void *)(unsigned long)(volatile void *)(a))
1.1       jdolecek  193:
                    194: #if OpenBSD <= 201911
                    195: /* Backward compat with OpenBSD 6.6 */
                    196: #define klist_insert(klist, kn)                \
                    197:                SLIST_INSERT_HEAD(klist, kn, kn_selnext)
                    198: #define klist_remove(klist, kn)                \
                    199:                SLIST_REMOVE(klist, kn, knote, kn_selnext)
                    200: #define XMM_KQ_ISFD_INITIALIZER                .f_isfd = 1
                    201: #else
                    202: #define XMM_KQ_ISFD_INITIALIZER                .f_flags = FILTEROP_ISFD
                    203: #endif /* OpenBSD <= 201911 */
                    204:
                    205: #endif
                    206:
                    207: #ifdef __NetBSD__
                    208: typedef struct kmutex spinlock_t;
                    209: #define dev_err                        aprint_error_dev
                    210: #define dev_info               aprint_normal_dev
                    211: #define mutex                  kmutex
                    212: #define kzalloc(size, flags)   malloc(size, M_DEVBUF, M_WAITOK | M_ZERO)
                    213: #define kfree(addr)            free(addr, M_DEVBUF)
                    214: #define mutex_init(lock)       mutex_init(lock, MUTEX_DEFAULT, IPL_TTY)
                    215: #define mutex_lock(lock)       mutex_enter(lock)
                    216: #define mutex_unlock(lock)     mutex_exit(lock)
                    217: #define spin_lock_irqsave(lock, flags) mutex_enter(lock)
                    218: #define spin_unlock_irqrestore(lock, flags)    mutex_exit(lock)
                    219:
                    220: /* Compat defines with OpenBSD API */
                    221: #define caddr_t                        void *
                    222: #define proc                   lwp
                    223: #define LINESW(tp)             (*tp->t_linesw)
                    224: #define ttymalloc(speed)       tty_alloc()
                    225: #define ttyfree(tp)            tty_free(tp)
                    226: #define l_open(dev, tp, p)     l_open(dev, tp)
                    227: #define l_close(tp, flag, p)   l_close(tp, flag)
                    228: #define ttkqfilter(dev, kn)    ttykqfilter(dev, kn)
                    229: #define msleep(ident, lock, prio, wmesg, timo) \
                    230:                mtsleep(ident, prio, wmesg, timo, lock)
                    231: #define pci_mapreg_map(pa, reg, type, busfl, tp, hp, bp, szp, maxsize) \
                    232:        pci_mapreg_map(pa, reg, type, busfl, tp, hp, bp, szp)
                    233: #define pci_intr_establish(pc, ih, lvl, func, arg, name) \
                    234:        pci_intr_establish_xname(pc, ih, lvl, func, arg, name)
                    235: #define suser(l)                                       \
                    236:        kauth_authorize_device_tty(l->l_cred, KAUTH_DEVICE_TTY_OPEN, tp)
                    237: #define kthread_create(func, arg, lwpp, name)          \
                    238:        kthread_create(0, 0, NULL, func, arg, lwpp, "%s", name)
                    239: #define MUTEX_ASSERT_LOCKED(lock)      KASSERT(mutex_owned(lock))
                    240: #define MCLGETI(m, how, m0, sz)                MCLGET(m, how)
                    241: #define m_copyback(m, off, sz, buf, how)               \
                    242:                                        m_copyback(m, off, sz, buf)
                    243: #define ifq_deq_begin(ifq)             ({              \
                    244:                struct mbuf *m0;                        \
                    245:                IFQ_DEQUEUE(ifq, m0);                   \
                    246:                m0;                                     \
                    247: })
                    248: #define ifq_deq_rollback(ifq, m)       m_freem(m)
                    249: #define ifq_deq_commit(ifq, m)         /* nothing to do */
                    250: #define ifq_is_oactive(ifq)            true    /* always restart queue */
                    251: #define ifq_clr_oactive(ifq)           /* nothing to do */
                    252: #define ifq_empty(ifq)                 IFQ_IS_EMPTY(ifq)
                    253: #define ifq_purge(ifq)                 IF_PURGE(ifq)
                    254: #define if_enqueue(ifp, m)             ifq_enqueue(ifp, m)
                    255: #define if_ih_insert(ifp, func, arg)   (ifp)->_if_input = (func)
                    256: #define if_ih_remove(ifp, func, arg)   /* nothing to do */
                    257: #define if_hardmtu                     if_mtu
                    258: #define IF_OUTPUT_CONST                        const
                    259: #define si_note                                sel_klist
                    260: #define klist_insert(klist, kn)                \
                    261:                SLIST_INSERT_HEAD(klist, kn, kn_selnext)
                    262: #define klist_remove(klist, kn)                \
                    263:                SLIST_REMOVE(klist, kn, knote, kn_selnext)
1.10    ! thorpej   264: #define XMM_KQ_ISFD_INITIALIZER                .f_flags = FILTEROP_ISFD
1.1       jdolecek  265: #define tty_lock()                     mutex_spin_enter(&tty_lock)
                    266: #define tty_unlock()                   mutex_spin_exit(&tty_lock)
1.3       riastrad  267: #define tty_locked()                   KASSERT(mutex_owned(&tty_lock))
1.1       jdolecek  268: #define bpfattach(bpf, ifp, dlt, sz)   bpf_attach(ifp, dlt, sz)
                    269: #define NBPFILTER                      1
                    270: #define BPF_MTAP_OUT(ifp, m)           bpf_mtap(ifp, m, BPF_D_OUT)
                    271: #endif /* __NetBSD__ */
                    272:
                    273: #define __user                         /* nothing */
                    274: #define copy_from_user(kbuf, userbuf, sz)              \
                    275: ({                                                     \
                    276:        int __ret = 0;                                  \
                    277:        int error = copyin(userbuf, kbuf, sz);          \
                    278:        if (error != 0)                                 \
                    279:                return -error;                          \
                    280:        __ret;                                          \
                    281: })
                    282: #define copy_to_user(kbuf, userbuf, sz)                        \
                    283: ({                                                     \
                    284:        int __ret = 0;                                  \
                    285:        int error = copyout(userbuf, kbuf, sz);         \
                    286:        if (error != 0)                                 \
                    287:                return -error;                          \
                    288:        __ret;                                          \
                    289: })
1.6       jdolecek  290: #define xmm7360_os_msleep(msec)                                        \
                    291:        do {                                                    \
                    292:                KASSERT(!cold);                                 \
                    293:                tsleep(xmm, 0, "wwancsl", msec * hz / 1000);    \
                    294:        } while (0)
1.1       jdolecek  295:
                    296: static void *dma_alloc_coherent(struct device *, size_t, dma_addr_t *, int);
                    297: static void dma_free_coherent(struct device *, size_t, volatile void *, dma_addr_t);
                    298:
                    299: #ifndef PCI_PRODUCT_INTEL_XMM7360
                    300: #define PCI_PRODUCT_INTEL_XMM7360      0x7360
                    301: #endif
                    302:
                    303: #define init_waitqueue_head(wqp)       *(wqp) = (wqp)
                    304: #define wait_event_interruptible(wq, cond)                             \
                    305: ({                                                                     \
                    306:        int __ret = 1;                                                  \
                    307:        while (!(cond)) {                                               \
                    308:                KASSERT(!cold);                                         \
                    309:                int error = tsleep(wq, PCATCH, "xmmwq", 0);             \
                    310:                if (error) {                                            \
                    311:                        __ret = (cond) ? 1                              \
                    312:                            : ((error != ERESTART) ? -error : error);   \
                    313:                        break;                                          \
                    314:                }                                                       \
                    315:        }                                                               \
                    316:        __ret;                                                          \
                    317: })
                    318:
                    319: #define msecs_to_jiffies(msec)                                         \
                    320: ({                                                                     \
                    321:        KASSERT(hz < 1000);                                             \
                    322:        KASSERT(msec > (1000 / hz));                                    \
                    323:        msec * hz / 1000;                                               \
                    324: })
                    325:
                    326: #define wait_event_interruptible_timeout(wq, cond, jiffies)            \
                    327: ({                                                                     \
                    328:        int __ret = 1;                                                  \
                    329:        while (!(cond)) {                                               \
                    330:                if (cold) {                                             \
                    331:                        for (int loop = 0; loop < 10; loop++) {         \
                    332:                                delay(jiffies * 1000 * 1000 / hz / 10); \
                    333:                                if (cond)                               \
                    334:                                        break;                          \
                    335:                        }                                               \
                    336:                        __ret = (cond) ? 1 : 0;                         \
                    337:                        break;                                          \
                    338:                }                                                       \
                    339:                int error = tsleep(wq, PCATCH, "xmmwq", jiffies);       \
                    340:                if (error) {                                            \
                    341:                        __ret = (cond) ? 1                              \
                    342:                            : ((error != ERESTART) ? -error : error);   \
                    343:                        break;                                          \
                    344:                }                                                       \
                    345:        }                                                               \
                    346:        __ret;                                                          \
                    347: })
                    348:
                    349: #define GFP_KERNEL                     0
                    350:
                    351: #endif /* __OpenBSD__ || __NetBSD__ */
                    352:
                    353: /*
                    354:  * The XMM7360 communicates via DMA ring buffers. It has one
                    355:  * command ring, plus sixteen transfer descriptor (TD)
                    356:  * rings. The command ring is mainly used to configure and
                    357:  * deconfigure the TD rings.
                    358:  *
                    359:  * The 16 TD rings form 8 queue pairs (QP). For example, QP
                    360:  * 0 uses ring 0 for host->device, and ring 1 for
                    361:  * device->host.
                    362:  *
                    363:  * The known queue pair functions are as follows:
                    364:  *
                    365:  * 0:  Mux (Raw IP packets, amongst others)
                    366:  * 1:  RPC (funky command protocol based in part on ASN.1 BER)
                    367:  * 2:  AT trace? port; does not accept commands after init
                    368:  * 4:  AT command port
                    369:  * 7:  AT command port
                    370:  *
                    371:  */
                    372:
                    373: /* Command ring, which is used to configure the queue pairs */
                    374: struct cmd_ring_entry {
                    375:        dma_addr_t ptr;
                    376:        u16 len;
                    377:        u8 parm;
                    378:        u8 cmd;
                    379:        u32 extra;
                    380:        u32 unk, flags;
                    381: };
                    382:
                    383: #define CMD_RING_OPEN  1
                    384: #define CMD_RING_CLOSE 2
                    385: #define CMD_RING_FLUSH 3
                    386: #define CMD_WAKEUP     4
                    387:
                    388: #define CMD_FLAG_DONE  1
                    389: #define CMD_FLAG_READY 2
                    390:
                    391: /* Transfer descriptors used on the Tx and Rx rings of each queue pair */
                    392: struct td_ring_entry {
                    393:        dma_addr_t addr;
                    394:        u16 length;
                    395:        u16 flags;
                    396:        u32 unk;
                    397: };
                    398:
                    399: #define TD_FLAG_COMPLETE 0x200
                    400:
                    401: /* Root configuration object. This contains pointers to all of the control
                    402:  * structures that the modem will interact with.
                    403:  */
                    404: struct control {
                    405:        dma_addr_t status;
                    406:        dma_addr_t s_wptr, s_rptr;
                    407:        dma_addr_t c_wptr, c_rptr;
                    408:        dma_addr_t c_ring;
                    409:        u16 c_ring_size;
                    410:        u16 unk;
                    411: };
                    412:
                    413: struct status {
                    414:        u32 code;
                    415:        u32 mode;
                    416:        u32 asleep;
                    417:        u32 pad;
                    418: };
                    419:
                    420: #define CMD_RING_SIZE 0x80
                    421:
                    422: /* All of the control structures can be packed into one page of RAM. */
                    423: struct control_page {
                    424:        struct control ctl;
                    425:        // Status words - written by modem.
                    426:        volatile struct status status;
                    427:        // Slave ring write/read pointers.
                    428:        volatile u32 s_wptr[16], s_rptr[16];
                    429:        // Command ring write/read pointers.
                    430:        volatile u32 c_wptr, c_rptr;
                    431:        // Command ring entries.
                    432:        volatile struct cmd_ring_entry c_ring[CMD_RING_SIZE];
                    433: };
                    434:
                    435: #define BAR0_MODE      0x0c
                    436: #define BAR0_DOORBELL  0x04
                    437: #define BAR0_WAKEUP    0x14
                    438:
                    439: #define DOORBELL_TD    0
                    440: #define DOORBELL_CMD   1
                    441:
                    442: #define BAR2_STATUS    0x00
                    443: #define BAR2_MODE      0x18
                    444: #define BAR2_CONTROL   0x19
                    445: #define BAR2_CONTROLH  0x1a
                    446:
                    447: #define BAR2_BLANK0    0x1b
                    448: #define BAR2_BLANK1    0x1c
                    449: #define BAR2_BLANK2    0x1d
                    450: #define BAR2_BLANK3    0x1e
                    451:
                    452: #define XMM_MODEM_BOOTING      0xfeedb007
                    453: #define XMM_MODEM_READY                0x600df00d
                    454:
                    455: #define XMM_TAG_ACBH           0x41434248      // 'ACBH'
                    456: #define XMM_TAG_CMDH           0x434d4448      // 'CMDH'
                    457: #define XMM_TAG_ADBH           0x41444248      // 'ADBH'
                    458: #define XMM_TAG_ADTH           0x41445448      // 'ADTH'
                    459:
                    460: /* There are 16 TD rings: a Tx and Rx ring for each queue pair */
                    461: struct td_ring {
                    462:        u8 depth;
                    463:        u8 last_handled;
                    464:        u16 page_size;
                    465:
                    466:        struct td_ring_entry *tds;
                    467:        dma_addr_t tds_phys;
                    468:
                    469:        // One page of page_size per td
                    470:        void **pages;
                    471:        dma_addr_t *pages_phys;
                    472: };
                    473:
                    474: #define TD_MAX_PAGE_SIZE 16384
                    475:
                    476: struct queue_pair {
                    477:        struct xmm_dev *xmm;
                    478:        u8 depth;
                    479:        u16 page_size;
                    480:        int tty_index;
                    481:        int tty_needs_wake;
                    482:        struct device dev;
                    483:        int num;
                    484:        int open;
                    485:        struct mutex lock;
                    486:        unsigned char user_buf[TD_MAX_PAGE_SIZE];
                    487:        wait_queue_head_t wq;
                    488:
                    489: #ifdef __linux__
                    490:        struct cdev cdev;
                    491:        struct tty_port port;
                    492: #endif
                    493: #if defined(__OpenBSD__) || defined(__NetBSD__)
                    494:        struct selinfo selr, selw;
                    495: #endif
                    496: };
                    497:
                    498: #define XMM_QP_COUNT   8
                    499:
                    500: struct xmm_dev {
                    501:        struct device *dev;
                    502:
                    503:        volatile uint32_t *bar0, *bar2;
                    504:
                    505:        volatile struct control_page *cp;
                    506:        dma_addr_t cp_phys;
                    507:
                    508:        struct td_ring td_ring[2 * XMM_QP_COUNT];
                    509:
                    510:        struct queue_pair qp[XMM_QP_COUNT];
                    511:
                    512:        struct xmm_net *net;
                    513:        struct net_device *netdev;
                    514:
                    515:        int error;
                    516:        int card_num;
                    517:        int num_ttys;
                    518:        wait_queue_head_t wq;
                    519:
                    520: #ifdef __linux__
                    521:        struct pci_dev *pci_dev;
                    522:
                    523:        int irq;
                    524:
                    525:        struct work_struct init_work;   // XXX work not actually scheduled
                    526: #endif
                    527: };
                    528:
                    529: struct mux_bounds {
                    530:        uint32_t offset;
                    531:        uint32_t length;
                    532: };
                    533:
                    534: struct mux_first_header {
                    535:        uint32_t tag;
                    536:        uint16_t unknown;
                    537:        uint16_t sequence;
                    538:        uint16_t length;
                    539:        uint16_t extra;
                    540:        uint16_t next;
                    541:        uint16_t pad;
                    542: };
                    543:
                    544: struct mux_next_header {
                    545:        uint32_t tag;
                    546:        uint16_t length;
                    547:        uint16_t extra;
                    548:        uint16_t next;
                    549:        uint16_t pad;
                    550: };
                    551:
                    552: #define MUX_MAX_PACKETS        64
                    553:
                    554: struct mux_frame {
                    555:        int n_packets, n_bytes, max_size, sequence;
                    556:        uint16_t *last_tag_length, *last_tag_next;
                    557:        struct mux_bounds bounds[MUX_MAX_PACKETS];
                    558:        uint8_t data[TD_MAX_PAGE_SIZE];
                    559: };
                    560:
                    561: struct xmm_net {
                    562:        struct xmm_dev *xmm;
                    563:        struct queue_pair *qp;
                    564:        int channel;
                    565:
                    566: #ifdef __linux__
                    567:        struct sk_buff_head queue;
                    568:        struct hrtimer deadline;
                    569: #endif
                    570:        int queued_packets, queued_bytes;
                    571:
                    572:        int sequence;
                    573:        spinlock_t lock;
                    574:        struct mux_frame frame;
                    575: };
                    576:
                    577: static void xmm7360_os_handle_net_frame(struct xmm_dev *, const u8 *, size_t);
                    578: static void xmm7360_os_handle_net_dequeue(struct xmm_net *, struct mux_frame *);
                    579: static void xmm7360_os_handle_net_txwake(struct xmm_net *);
                    580: static void xmm7360_os_handle_tty_idata(struct queue_pair *, const u8 *, size_t);
                    581:
                    582: static void xmm7360_poll(struct xmm_dev *xmm)
                    583: {
                    584:        if (xmm->cp->status.code == 0xbadc0ded) {
                    585:                dev_err(xmm->dev, "crashed but dma up\n");
                    586:                xmm->error = -ENODEV;
                    587:        }
                    588:        if (xmm->bar2[BAR2_STATUS] != XMM_MODEM_READY) {
                    589:                dev_err(xmm->dev, "bad status %x\n",xmm->bar2[BAR2_STATUS]);
                    590:                xmm->error = -ENODEV;
                    591:        }
                    592: }
                    593:
                    594: static void xmm7360_ding(struct xmm_dev *xmm, int bell)
                    595: {
                    596:        if (xmm->cp->status.asleep)
                    597:                xmm->bar0[BAR0_WAKEUP] = 1;
                    598:        xmm->bar0[BAR0_DOORBELL] = bell;
                    599:        xmm7360_poll(xmm);
                    600: }
                    601:
                    602: static int xmm7360_cmd_ring_wait(struct xmm_dev *xmm)
                    603: {
                    604:        // Wait for all commands to complete
                    605:        // XXX locking?
                    606:        int ret = wait_event_interruptible_timeout(xmm->wq, (xmm->cp->c_rptr == xmm->cp->c_wptr) || xmm->error, msecs_to_jiffies(1000));
                    607:        if (ret == 0)
                    608:                return -ETIMEDOUT;
                    609:        if (ret < 0)
                    610:                return ret;
                    611:        return xmm->error;
                    612: }
                    613:
                    614: static int xmm7360_cmd_ring_execute(struct xmm_dev *xmm, u8 cmd, u8 parm, u16 len, dma_addr_t ptr, u32 extra)
                    615: {
                    616:        u8 wptr = xmm->cp->c_wptr;
                    617:        u8 new_wptr = (wptr + 1) % CMD_RING_SIZE;
                    618:        if (xmm->error)
                    619:                return xmm->error;
                    620:        if (new_wptr == xmm->cp->c_rptr)        // ring full
                    621:                return -EAGAIN;
                    622:
                    623:        xmm->cp->c_ring[wptr].ptr = ptr;
                    624:        xmm->cp->c_ring[wptr].cmd = cmd;
                    625:        xmm->cp->c_ring[wptr].parm = parm;
                    626:        xmm->cp->c_ring[wptr].len = len;
                    627:        xmm->cp->c_ring[wptr].extra = extra;
                    628:        xmm->cp->c_ring[wptr].unk = 0;
                    629:        xmm->cp->c_ring[wptr].flags = CMD_FLAG_READY;
                    630:
                    631:        xmm->cp->c_wptr = new_wptr;
                    632:
                    633:        xmm7360_ding(xmm, DOORBELL_CMD);
                    634:        return xmm7360_cmd_ring_wait(xmm);
                    635: }
                    636:
                    637: static int xmm7360_cmd_ring_init(struct xmm_dev *xmm) {
                    638:        int timeout;
                    639:        int ret;
                    640:
                    641:        xmm->cp = dma_alloc_coherent(xmm->dev, sizeof(struct control_page), &xmm->cp_phys, GFP_KERNEL);
                    642:        BUG_ON(xmm->cp == NULL);
                    643:
                    644:        xmm->cp->ctl.status = xmm->cp_phys + offsetof(struct control_page, status);
                    645:        xmm->cp->ctl.s_wptr = xmm->cp_phys + offsetof(struct control_page, s_wptr);
                    646:        xmm->cp->ctl.s_rptr = xmm->cp_phys + offsetof(struct control_page, s_rptr);
                    647:        xmm->cp->ctl.c_wptr = xmm->cp_phys + offsetof(struct control_page, c_wptr);
                    648:        xmm->cp->ctl.c_rptr = xmm->cp_phys + offsetof(struct control_page, c_rptr);
                    649:        xmm->cp->ctl.c_ring = xmm->cp_phys + offsetof(struct control_page, c_ring);
                    650:        xmm->cp->ctl.c_ring_size = CMD_RING_SIZE;
                    651:
                    652:        xmm->bar2[BAR2_CONTROL] = xmm->cp_phys;
                    653:        xmm->bar2[BAR2_CONTROLH] = xmm->cp_phys >> 32;
                    654:
                    655:        xmm->bar0[BAR0_MODE] = 1;
                    656:
                    657:        timeout = 100;
                    658:        while (xmm->bar2[BAR2_MODE] == 0 && --timeout)
                    659:                xmm7360_os_msleep(10);
                    660:
                    661:        if (!timeout)
                    662:                return -ETIMEDOUT;
                    663:
                    664:        xmm->bar2[BAR2_BLANK0] = 0;
                    665:        xmm->bar2[BAR2_BLANK1] = 0;
                    666:        xmm->bar2[BAR2_BLANK2] = 0;
                    667:        xmm->bar2[BAR2_BLANK3] = 0;
                    668:
                    669:        xmm->bar0[BAR0_MODE] = 2;       // enable intrs?
                    670:
                    671:        timeout = 100;
                    672:        while (xmm->bar2[BAR2_MODE] != 2 && --timeout)
                    673:                xmm7360_os_msleep(10);
                    674:
                    675:        if (!timeout)
                    676:                return -ETIMEDOUT;
                    677:
                    678:        // enable going to sleep when idle
                    679:        ret = xmm7360_cmd_ring_execute(xmm, CMD_WAKEUP, 0, 1, 0, 0);
                    680:        if (ret)
                    681:                return ret;
                    682:
                    683:        return 0;
                    684: }
                    685:
                    686: static void xmm7360_cmd_ring_free(struct xmm_dev *xmm) {
                    687:        if (xmm->bar0)
                    688:                xmm->bar0[BAR0_MODE] = 0;
                    689:        if (xmm->cp)
                    690:                dma_free_coherent(xmm->dev, sizeof(struct control_page), (volatile void *)xmm->cp, xmm->cp_phys);
                    691:        xmm->cp = NULL;
                    692:        return;
                    693: }
                    694:
                    695: static void xmm7360_td_ring_activate(struct xmm_dev *xmm, u8 ring_id)
                    696: {
                    697:        struct td_ring *ring = &xmm->td_ring[ring_id];
1.5       jdolecek  698:        int ret __diagused;
1.1       jdolecek  699:
                    700:        xmm->cp->s_rptr[ring_id] = xmm->cp->s_wptr[ring_id] = 0;
                    701:        ring->last_handled = 0;
                    702:        ret = xmm7360_cmd_ring_execute(xmm, CMD_RING_OPEN, ring_id, ring->depth, ring->tds_phys, 0x60);
                    703:        BUG_ON(ret);
                    704: }
                    705:
                    706: static void xmm7360_td_ring_create(struct xmm_dev *xmm, u8 ring_id, u8 depth, u16 page_size)
                    707: {
                    708:        struct td_ring *ring = &xmm->td_ring[ring_id];
                    709:        int i;
                    710:
                    711:        BUG_ON(ring->depth);
                    712:        BUG_ON(depth & (depth-1));
                    713:        BUG_ON(page_size > TD_MAX_PAGE_SIZE);
                    714:
                    715:        memset(ring, 0, sizeof(struct td_ring));
                    716:        ring->depth = depth;
                    717:        ring->page_size = page_size;
                    718:        ring->tds = dma_alloc_coherent(xmm->dev, sizeof(struct td_ring_entry)*depth, &ring->tds_phys, GFP_KERNEL);
                    719:
                    720:        ring->pages = kzalloc(sizeof(void*)*depth, GFP_KERNEL);
                    721:        ring->pages_phys = kzalloc(sizeof(dma_addr_t)*depth, GFP_KERNEL);
                    722:
                    723:        for (i=0; i<depth; i++) {
                    724:                ring->pages[i] = dma_alloc_coherent(xmm->dev, ring->page_size, &ring->pages_phys[i], GFP_KERNEL);
                    725:                ring->tds[i].addr = ring->pages_phys[i];
                    726:        }
                    727:
                    728:        xmm7360_td_ring_activate(xmm, ring_id);
                    729: }
                    730:
                    731: static void xmm7360_td_ring_deactivate(struct xmm_dev *xmm, u8 ring_id)
                    732: {
                    733:        xmm7360_cmd_ring_execute(xmm, CMD_RING_CLOSE, ring_id, 0, 0, 0);
                    734: }
                    735:
                    736: static void xmm7360_td_ring_destroy(struct xmm_dev *xmm, u8 ring_id)
                    737: {
                    738:        struct td_ring *ring = &xmm->td_ring[ring_id];
                    739:        int i, depth=ring->depth;
                    740:
                    741:        if (!depth) {
                    742:                WARN_ON(1);
                    743:                dev_err(xmm->dev, "Tried destroying empty ring!\n");
                    744:                return;
                    745:        }
                    746:
                    747:        xmm7360_td_ring_deactivate(xmm, ring_id);
                    748:
                    749:        for (i=0; i<depth; i++) {
                    750:                dma_free_coherent(xmm->dev, ring->page_size, ring->pages[i], ring->pages_phys[i]);
                    751:        }
                    752:
                    753:        kfree(ring->pages_phys);
                    754:        kfree(ring->pages);
                    755:
                    756:        dma_free_coherent(xmm->dev, sizeof(struct td_ring_entry)*depth, ring->tds, ring->tds_phys);
                    757:
                    758:        ring->depth = 0;
                    759: }
                    760:
                    761: static void xmm7360_td_ring_write(struct xmm_dev *xmm, u8 ring_id, const void *buf, int len)
                    762: {
                    763:        struct td_ring *ring = &xmm->td_ring[ring_id];
                    764:        u8 wptr = xmm->cp->s_wptr[ring_id];
                    765:
                    766:        BUG_ON(!ring->depth);
                    767:        BUG_ON(len > ring->page_size);
                    768:        BUG_ON(ring_id & 1);
                    769:
                    770:        memcpy(ring->pages[wptr], buf, len);
                    771:        ring->tds[wptr].length = len;
                    772:        ring->tds[wptr].flags = 0;
                    773:        ring->tds[wptr].unk = 0;
                    774:
                    775:        wptr = (wptr + 1) & (ring->depth - 1);
                    776:        BUG_ON(wptr == xmm->cp->s_rptr[ring_id]);
                    777:
                    778:        xmm->cp->s_wptr[ring_id] = wptr;
                    779: }
                    780:
                    781: static int xmm7360_td_ring_full(struct xmm_dev *xmm, u8 ring_id)
                    782: {
                    783:        struct td_ring *ring = &xmm->td_ring[ring_id];
                    784:        u8 wptr = xmm->cp->s_wptr[ring_id];
                    785:        wptr = (wptr + 1) & (ring->depth - 1);
                    786:        return wptr == xmm->cp->s_rptr[ring_id];
                    787: }
                    788:
                    789: static void xmm7360_td_ring_read(struct xmm_dev *xmm, u8 ring_id)
                    790: {
                    791:        struct td_ring *ring = &xmm->td_ring[ring_id];
                    792:        u8 wptr = xmm->cp->s_wptr[ring_id];
                    793:
                    794:        if (!ring->depth) {
                    795:                dev_err(xmm->dev, "read on disabled ring\n");
                    796:                WARN_ON(1);
                    797:                return;
                    798:        }
                    799:        if (!(ring_id & 1)) {
                    800:                dev_err(xmm->dev, "read on write ring\n");
                    801:                WARN_ON(1);
                    802:                return;
                    803:        }
                    804:
                    805:        ring->tds[wptr].length = ring->page_size;
                    806:        ring->tds[wptr].flags = 0;
                    807:        ring->tds[wptr].unk = 0;
                    808:
                    809:        wptr = (wptr + 1) & (ring->depth - 1);
                    810:        BUG_ON(wptr == xmm->cp->s_rptr[ring_id]);
                    811:
                    812:        xmm->cp->s_wptr[ring_id] = wptr;
                    813: }
                    814:
                    815: static struct queue_pair * xmm7360_init_qp(struct xmm_dev *xmm, int num, u8 depth, u16 page_size)
                    816: {
                    817:        struct queue_pair *qp = &xmm->qp[num];
                    818:
                    819:        qp->xmm = xmm;
                    820:        qp->num = num;
                    821:        qp->open = 0;
                    822:        qp->depth = depth;
                    823:        qp->page_size = page_size;
                    824:
                    825:        mutex_init(&qp->lock);
                    826:        init_waitqueue_head(&qp->wq);
                    827:        return qp;
                    828: }
                    829:
                    830: static void xmm7360_qp_arm(struct xmm_dev *xmm, struct queue_pair *qp)
                    831: {
                    832:        while (!xmm7360_td_ring_full(xmm, qp->num*2+1))
                    833:                xmm7360_td_ring_read(xmm, qp->num*2+1);
                    834:        xmm7360_ding(xmm, DOORBELL_TD);
                    835: }
                    836:
                    837: static int xmm7360_qp_start(struct queue_pair *qp)
                    838: {
                    839:        struct xmm_dev *xmm = qp->xmm;
                    840:        int ret;
                    841:
                    842:        mutex_lock(&qp->lock);
                    843:        if (qp->open) {
                    844:                ret = -EBUSY;
                    845:        } else {
                    846:                ret = 0;
                    847:                qp->open = 1;
                    848:        }
                    849:        mutex_unlock(&qp->lock);
                    850:
                    851:        if (ret == 0) {
                    852:                xmm7360_td_ring_create(xmm, qp->num*2, qp->depth, qp->page_size);
                    853:                xmm7360_td_ring_create(xmm, qp->num*2+1, qp->depth, qp->page_size);
                    854:                xmm7360_qp_arm(xmm, qp);
                    855:        }
                    856:
                    857:        return ret;
                    858: }
                    859:
                    860: static void xmm7360_qp_resume(struct queue_pair *qp)
                    861: {
                    862:        struct xmm_dev *xmm = qp->xmm;
                    863:
                    864:        BUG_ON(!qp->open);
                    865:        xmm7360_td_ring_activate(xmm, qp->num*2);
                    866:        xmm7360_td_ring_activate(xmm, qp->num*2+1);
                    867:        xmm7360_qp_arm(xmm, qp);
                    868: }
                    869:
                    870: static int xmm7360_qp_stop(struct queue_pair *qp)
                    871: {
                    872:        struct xmm_dev *xmm = qp->xmm;
                    873:        int ret = 0;
                    874:
                    875:        mutex_lock(&qp->lock);
                    876:        if (!qp->open) {
                    877:                ret = -ENODEV;
                    878:        } else {
                    879:                ret = 0;
                    880:                /* still holding qp->open to prevent concurrent access */
                    881:        }
                    882:        mutex_unlock(&qp->lock);
                    883:
                    884:        if (ret == 0) {
                    885:                xmm7360_td_ring_destroy(xmm, qp->num*2);
                    886:                xmm7360_td_ring_destroy(xmm, qp->num*2+1);
                    887:
                    888:                mutex_lock(&qp->lock);
                    889:                qp->open = 0;
                    890:                mutex_unlock(&qp->lock);
                    891:        }
                    892:
                    893:        return ret;
                    894: }
                    895:
                    896: static void xmm7360_qp_suspend(struct queue_pair *qp)
                    897: {
                    898:        struct xmm_dev *xmm = qp->xmm;
                    899:
                    900:        BUG_ON(!qp->open);
                    901:        xmm7360_td_ring_deactivate(xmm, qp->num*2);
                    902: }
                    903:
                    904: static int xmm7360_qp_can_write(struct queue_pair *qp)
                    905: {
                    906:        struct xmm_dev *xmm = qp->xmm;
                    907:        return !xmm7360_td_ring_full(xmm, qp->num*2);
                    908: }
                    909:
                    910: static ssize_t xmm7360_qp_write(struct queue_pair *qp, const char *buf, size_t size)
                    911: {
                    912:        struct xmm_dev *xmm = qp->xmm;
                    913:        int page_size = qp->xmm->td_ring[qp->num*2].page_size;
                    914:        if (xmm->error)
                    915:                return xmm->error;
                    916:        if (!xmm7360_qp_can_write(qp))
                    917:                return 0;
                    918:        if (size > page_size)
                    919:                size = page_size;
                    920:        xmm7360_td_ring_write(xmm, qp->num*2, buf, size);
                    921:        xmm7360_ding(xmm, DOORBELL_TD);
                    922:        return size;
                    923: }
                    924:
                    925: static ssize_t xmm7360_qp_write_user(struct queue_pair *qp, const char __user *buf, size_t size)
                    926: {
                    927:        int page_size = qp->xmm->td_ring[qp->num*2].page_size;
                    928:        int ret;
                    929:
                    930:        if (size > page_size)
                    931:                size = page_size;
                    932:
                    933:        ret = copy_from_user(qp->user_buf, buf, size);
                    934:        size = size - ret;
                    935:        if (!size)
                    936:                return 0;
                    937:        return xmm7360_qp_write(qp, qp->user_buf, size);
                    938: }
                    939:
                    940: static int xmm7360_qp_has_data(struct queue_pair *qp)
                    941: {
                    942:        struct xmm_dev *xmm = qp->xmm;
                    943:        struct td_ring *ring = &xmm->td_ring[qp->num*2+1];
                    944:
                    945:        return (xmm->cp->s_rptr[qp->num*2+1] != ring->last_handled);
                    946: }
                    947:
                    948: static ssize_t xmm7360_qp_read_user(struct queue_pair *qp, char __user *buf, size_t size)
                    949: {
                    950:        struct xmm_dev *xmm = qp->xmm;
                    951:        struct td_ring *ring = &xmm->td_ring[qp->num*2+1];
                    952:        int idx, nread, ret;
                    953:        // XXX locking?
                    954:        ret = wait_event_interruptible(qp->wq, xmm7360_qp_has_data(qp) || xmm->error);
                    955:        if (ret < 0)
                    956:                return ret;
                    957:        if (xmm->error)
                    958:                return xmm->error;
                    959:
                    960:        idx = ring->last_handled;
                    961:        nread = ring->tds[idx].length;
                    962:        if (nread > size)
                    963:                nread = size;
                    964:        ret = copy_to_user(buf, ring->pages[idx], nread);
                    965:        nread -= ret;
                    966:        if (nread == 0)
                    967:                return 0;
                    968:
                    969:        // XXX all data not fitting into buf+size is discarded
                    970:        xmm7360_td_ring_read(xmm, qp->num*2+1);
                    971:        xmm7360_ding(xmm, DOORBELL_TD);
                    972:        ring->last_handled = (idx + 1) & (ring->depth - 1);
                    973:
                    974:        return nread;
                    975: }
                    976:
                    977: static void xmm7360_tty_poll_qp(struct queue_pair *qp)
                    978: {
                    979:        struct xmm_dev *xmm = qp->xmm;
                    980:        struct td_ring *ring = &xmm->td_ring[qp->num*2+1];
                    981:        int idx, nread;
                    982:        while (xmm7360_qp_has_data(qp)) {
                    983:                idx = ring->last_handled;
                    984:                nread = ring->tds[idx].length;
                    985:                xmm7360_os_handle_tty_idata(qp, ring->pages[idx], nread);
                    986:
                    987:                xmm7360_td_ring_read(xmm, qp->num*2+1);
                    988:                xmm7360_ding(xmm, DOORBELL_TD);
                    989:                ring->last_handled = (idx + 1) & (ring->depth - 1);
                    990:        }
                    991: }
                    992:
                    993: #ifdef __linux__
                    994:
                    995: static void xmm7360_os_handle_tty_idata(struct queue_pair *qp, const u8 *data, size_t nread)
                    996: {
                    997:        tty_insert_flip_string(&qp->port, data, nread);
                    998:        tty_flip_buffer_push(&qp->port);
                    999: }
                   1000:
                   1001: int xmm7360_cdev_open (struct inode *inode, struct file *file)
                   1002: {
                   1003:        struct queue_pair *qp = container_of(inode->i_cdev, struct queue_pair, cdev);
                   1004:        file->private_data = qp;
                   1005:        return xmm7360_qp_start(qp);
                   1006: }
                   1007:
                   1008: int xmm7360_cdev_release (struct inode *inode, struct file *file)
                   1009: {
                   1010:        struct queue_pair *qp = file->private_data;
                   1011:        return xmm7360_qp_stop(qp);
                   1012: }
                   1013:
                   1014: ssize_t xmm7360_cdev_write (struct file *file, const char __user *buf, size_t size, loff_t *offset)
                   1015: {
                   1016:        struct queue_pair *qp = file->private_data;
                   1017:        int ret;
                   1018:
                   1019:        ret = xmm7360_qp_write_user(qp, buf, size);
                   1020:        if (ret < 0)
                   1021:                return ret;
                   1022:
                   1023:        *offset += ret;
                   1024:        return ret;
                   1025: }
                   1026:
                   1027: ssize_t xmm7360_cdev_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
                   1028: {
                   1029:        struct queue_pair *qp = file->private_data;
                   1030:        int ret;
                   1031:
                   1032:        ret = xmm7360_qp_read_user(qp, buf, size);
                   1033:        if (ret < 0)
                   1034:                return ret;
                   1035:
                   1036:        *offset += ret;
                   1037:        return ret;
                   1038: }
                   1039:
                   1040: static unsigned int xmm7360_cdev_poll(struct file *file, poll_table *wait)
                   1041: {
                   1042:        struct queue_pair *qp = file->private_data;
                   1043:        unsigned int mask = 0;
                   1044:
                   1045:        poll_wait(file, &qp->wq, wait);
                   1046:
                   1047:        if (qp->xmm->error)
                   1048:                return POLLHUP;
                   1049:
                   1050:        if (xmm7360_qp_has_data(qp))
                   1051:                mask |= POLLIN | POLLRDNORM;
                   1052:
                   1053:        if (xmm7360_qp_can_write(qp))
                   1054:                mask |= POLLOUT | POLLWRNORM;
                   1055:
                   1056:        return mask;
                   1057: }
                   1058:
                   1059: static long xmm7360_cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                   1060: {
                   1061:        struct queue_pair *qp = file->private_data;
                   1062:
                   1063:        u32 val;
                   1064:
                   1065:        switch (cmd) {
                   1066:                case XMM7360_IOCTL_GET_PAGE_SIZE:
                   1067:                        val = qp->xmm->td_ring[qp->num*2].page_size;
                   1068:                        if (copy_to_user((u32*)arg, &val, sizeof(u32)))
                   1069:                                return -EFAULT;
                   1070:                        return 0;
                   1071:        }
                   1072:
                   1073:        return -ENOTTY;
                   1074: }
                   1075:
                   1076: static struct file_operations xmm7360_fops = {
                   1077:        .read           = xmm7360_cdev_read,
                   1078:        .write          = xmm7360_cdev_write,
                   1079:        .poll           = xmm7360_cdev_poll,
                   1080:        .unlocked_ioctl = xmm7360_cdev_ioctl,
                   1081:        .open           = xmm7360_cdev_open,
                   1082:        .release        = xmm7360_cdev_release
                   1083: };
                   1084:
                   1085: #endif /* __linux__ */
                   1086:
                   1087: static void xmm7360_mux_frame_init(struct xmm_net *xn, struct mux_frame *frame, int sequence)
                   1088: {
                   1089:        frame->sequence = xn->sequence;
                   1090:        frame->max_size = xn->xmm->td_ring[0].page_size;
                   1091:        frame->n_packets = 0;
                   1092:        frame->n_bytes = 0;
                   1093:        frame->last_tag_next = NULL;
                   1094:        frame->last_tag_length = NULL;
                   1095: }
                   1096:
                   1097: static void xmm7360_mux_frame_add_tag(struct mux_frame *frame, uint32_t tag, uint16_t extra, void *data, int data_len)
                   1098: {
                   1099:        int total_length;
                   1100:        if (frame->n_bytes == 0)
                   1101:                total_length = sizeof(struct mux_first_header) + data_len;
                   1102:        else
                   1103:                total_length = sizeof(struct mux_next_header) + data_len;
                   1104:
                   1105:        while (frame->n_bytes & 3)
                   1106:                frame->n_bytes++;
                   1107:
                   1108:        BUG_ON(frame->n_bytes + total_length > frame->max_size);
                   1109:
                   1110:        if (frame->last_tag_next)
                   1111:                *frame->last_tag_next = frame->n_bytes;
                   1112:
                   1113:        if (frame->n_bytes == 0) {
                   1114:                struct mux_first_header *hdr = (struct mux_first_header *)frame->data;
                   1115:                memset(hdr, 0, sizeof(struct mux_first_header));
                   1116:                hdr->tag = htonl(tag);
                   1117:                hdr->sequence = frame->sequence;
                   1118:                hdr->length = total_length;
                   1119:                hdr->extra = extra;
                   1120:                frame->last_tag_length = &hdr->length;
                   1121:                frame->last_tag_next = &hdr->next;
                   1122:                frame->n_bytes += sizeof(struct mux_first_header);
                   1123:        } else {
                   1124:                struct mux_next_header *hdr = (struct mux_next_header *)(&frame->data[frame->n_bytes]);
                   1125:                memset(hdr, 0, sizeof(struct mux_next_header));
                   1126:                hdr->tag = htonl(tag);
                   1127:                hdr->length = total_length;
                   1128:                hdr->extra = extra;
                   1129:                frame->last_tag_length = &hdr->length;
                   1130:                frame->last_tag_next = &hdr->next;
                   1131:                frame->n_bytes += sizeof(struct mux_next_header);
                   1132:        }
                   1133:
                   1134:        if (data_len) {
                   1135:                memcpy(&frame->data[frame->n_bytes], data, data_len);
                   1136:                frame->n_bytes += data_len;
                   1137:        }
                   1138: }
                   1139:
                   1140: static void xmm7360_mux_frame_append_data(struct mux_frame *frame, const void *data, int data_len)
                   1141: {
                   1142:        BUG_ON(frame->n_bytes + data_len > frame->max_size);
                   1143:        BUG_ON(!frame->last_tag_length);
                   1144:
                   1145:        memcpy(&frame->data[frame->n_bytes], data, data_len);
                   1146:        *frame->last_tag_length += data_len;
                   1147:        frame->n_bytes += data_len;
                   1148: }
                   1149:
                   1150: static int xmm7360_mux_frame_append_packet(struct mux_frame *frame, const void *data, int data_len)
                   1151: {
                   1152:        int expected_adth_size = sizeof(struct mux_next_header) + 4 + (frame->n_packets+1)*sizeof(struct mux_bounds);
                   1153:        uint8_t pad[16];
                   1154:
                   1155:        if (frame->n_packets >= MUX_MAX_PACKETS)
                   1156:                return -1;
                   1157:
                   1158:        if (frame->n_bytes + data_len + 16 + expected_adth_size > frame->max_size)
                   1159:                return -1;
                   1160:
                   1161:        BUG_ON(!frame->last_tag_length);
                   1162:
                   1163:        frame->bounds[frame->n_packets].offset = frame->n_bytes;
                   1164:        frame->bounds[frame->n_packets].length = data_len + 16;
                   1165:        frame->n_packets++;
                   1166:
                   1167:        memset(pad, 0, sizeof(pad));
                   1168:        xmm7360_mux_frame_append_data(frame, pad, 16);
                   1169:        xmm7360_mux_frame_append_data(frame, data, data_len);
                   1170:        return 0;
                   1171: }
                   1172:
                   1173: static int xmm7360_mux_frame_push(struct xmm_dev *xmm, struct mux_frame *frame)
                   1174: {
                   1175:        struct mux_first_header *hdr = (void*)&frame->data[0];
                   1176:        int ret;
                   1177:        hdr->length = frame->n_bytes;
                   1178:
                   1179:        ret = xmm7360_qp_write(xmm->net->qp, frame->data, frame->n_bytes);
                   1180:        if (ret < 0)
                   1181:                return ret;
                   1182:        return 0;
                   1183: }
                   1184:
                   1185: static int xmm7360_mux_control(struct xmm_net *xn, u32 arg1, u32 arg2, u32 arg3, u32 arg4)
                   1186: {
                   1187:        struct mux_frame *frame = &xn->frame;
                   1188:        int ret;
                   1189:        uint32_t cmdh_args[] = {arg1, arg2, arg3, arg4};
                   1190:        unsigned long flags __unused;
                   1191:
                   1192:        spin_lock_irqsave(&xn->lock, flags);
                   1193:
                   1194:        xmm7360_mux_frame_init(xn, frame, 0);
                   1195:        xmm7360_mux_frame_add_tag(frame, XMM_TAG_ACBH, 0, NULL, 0);
                   1196:        xmm7360_mux_frame_add_tag(frame, XMM_TAG_CMDH, xn->channel, cmdh_args, sizeof(cmdh_args));
                   1197:        ret = xmm7360_mux_frame_push(xn->xmm, frame);
                   1198:
                   1199:        spin_unlock_irqrestore(&xn->lock, flags);
                   1200:
                   1201:        return ret;
                   1202: }
                   1203:
                   1204: static void xmm7360_net_flush(struct xmm_net *xn)
                   1205: {
                   1206:        struct mux_frame *frame = &xn->frame;
                   1207:        int ret;
                   1208:        u32 unknown = 0;
                   1209:
                   1210: #ifdef __linux__
                   1211:        /* Never called with empty queue */
                   1212:        BUG_ON(skb_queue_empty(&xn->queue));
                   1213: #endif
                   1214:        BUG_ON(!xmm7360_qp_can_write(xn->qp));
                   1215:
                   1216:        xmm7360_mux_frame_init(xn, frame, xn->sequence++);
                   1217:        xmm7360_mux_frame_add_tag(frame, XMM_TAG_ADBH, 0, NULL, 0);
                   1218:
                   1219:        xmm7360_os_handle_net_dequeue(xn, frame);
                   1220:        xn->queued_packets = xn->queued_bytes = 0;
                   1221:
                   1222:        xmm7360_mux_frame_add_tag(frame, XMM_TAG_ADTH, xn->channel, &unknown, sizeof(uint32_t));
                   1223:        xmm7360_mux_frame_append_data(frame, &frame->bounds[0], sizeof(struct mux_bounds)*frame->n_packets);
                   1224:
                   1225:        ret = xmm7360_mux_frame_push(xn->xmm, frame);
                   1226:        if (ret)
                   1227:                goto drop;
                   1228:
                   1229:        return;
                   1230:
                   1231: drop:
                   1232:        dev_err(xn->xmm->dev, "Failed to ship coalesced frame");
                   1233: }
                   1234:
                   1235: static int xmm7360_base_init(struct xmm_dev *xmm)
                   1236: {
                   1237:        int ret, i;
                   1238:        u32 status;
                   1239:
                   1240:        xmm->error = 0;
                   1241:        xmm->num_ttys = 0;
                   1242:
                   1243:        status = xmm->bar2[BAR2_STATUS];
                   1244:        if (status == XMM_MODEM_BOOTING) {
                   1245:                dev_info(xmm->dev, "modem still booting, waiting...\n");
                   1246:                for (i=0; i<100; i++) {
                   1247:                        status = xmm->bar2[BAR2_STATUS];
                   1248:                        if (status != XMM_MODEM_BOOTING)
                   1249:                                break;
                   1250:                        xmm7360_os_msleep(200);
                   1251:                }
                   1252:        }
                   1253:
                   1254:        if (status != XMM_MODEM_READY) {
                   1255:                dev_err(xmm->dev, "unknown modem status: 0x%08x\n", status);
                   1256:                return -EINVAL;
                   1257:        }
                   1258:
                   1259:        dev_info(xmm->dev, "modem is ready\n");
                   1260:
                   1261:        ret = xmm7360_cmd_ring_init(xmm);
                   1262:        if (ret) {
                   1263:                dev_err(xmm->dev, "Could not bring up command ring %d\n",
                   1264:                    ret);
                   1265:                return ret;
                   1266:        }
                   1267:
                   1268:        return 0;
                   1269: }
                   1270:
                   1271: static void xmm7360_net_mux_handle_frame(struct xmm_net *xn, u8 *data, int len)
                   1272: {
                   1273:        struct mux_first_header *first;
                   1274:        struct mux_next_header *adth;
                   1275:        int n_packets, i;
                   1276:        struct mux_bounds *bounds;
                   1277:
                   1278:        first = (void*)data;
                   1279:        if (ntohl(first->tag) == XMM_TAG_ACBH)
                   1280:                return;
                   1281:
                   1282:        if (ntohl(first->tag) != XMM_TAG_ADBH) {
                   1283:                dev_info(xn->xmm->dev, "Unexpected tag %x\n", first->tag);
                   1284:                return;
                   1285:        }
                   1286:
                   1287:        adth = (void*)(&data[first->next]);
                   1288:        if (ntohl(adth->tag) != XMM_TAG_ADTH) {
                   1289:                dev_err(xn->xmm->dev, "Unexpected tag %x, expected ADTH\n", adth->tag);
                   1290:                return;
                   1291:        }
                   1292:
                   1293:        n_packets = (adth->length - sizeof(struct mux_next_header) - 4) / sizeof(struct mux_bounds);
                   1294:
                   1295:        bounds = (void*)&data[first->next + sizeof(struct mux_next_header) + 4];
                   1296:
                   1297:        for (i=0; i<n_packets; i++) {
                   1298:                if (!bounds[i].length)
                   1299:                        continue;
                   1300:
                   1301:                xmm7360_os_handle_net_frame(xn->xmm,
                   1302:                    &data[bounds[i].offset], bounds[i].length);
                   1303:        }
                   1304: }
                   1305:
                   1306: static void xmm7360_net_poll(struct xmm_dev *xmm)
                   1307: {
                   1308:        struct queue_pair *qp;
                   1309:        struct td_ring *ring;
                   1310:        int idx, nread;
                   1311:        struct xmm_net *xn = xmm->net;
                   1312:        unsigned long flags __unused;
                   1313:
                   1314:        BUG_ON(!xn);
                   1315:
                   1316:        qp = xn->qp;
                   1317:        ring = &xmm->td_ring[qp->num*2+1];
                   1318:
                   1319:        spin_lock_irqsave(&xn->lock, flags);
                   1320:
                   1321:        if (xmm7360_qp_can_write(qp))
                   1322:                xmm7360_os_handle_net_txwake(xn);
                   1323:
                   1324:        while (xmm7360_qp_has_data(qp)) {
                   1325:                idx = ring->last_handled;
                   1326:                nread = ring->tds[idx].length;
                   1327:                xmm7360_net_mux_handle_frame(xn, ring->pages[idx], nread);
                   1328:
                   1329:                xmm7360_td_ring_read(xmm, qp->num*2+1);
                   1330:                xmm7360_ding(xmm, DOORBELL_TD);
                   1331:                ring->last_handled = (idx + 1) & (ring->depth - 1);
                   1332:        }
                   1333:
                   1334:        spin_unlock_irqrestore(&xn->lock, flags);
                   1335: }
                   1336:
                   1337: #ifdef __linux__
                   1338:
                   1339: static void xmm7360_net_uninit(struct net_device *dev)
                   1340: {
                   1341: }
                   1342:
                   1343: static int xmm7360_net_open(struct net_device *dev)
                   1344: {
                   1345:        struct xmm_net *xn = netdev_priv(dev);
                   1346:        xn->queued_packets = xn->queued_bytes = 0;
                   1347:        skb_queue_purge(&xn->queue);
                   1348:        netif_start_queue(dev);
                   1349:        return xmm7360_mux_control(xn, 1, 0, 0, 0);
                   1350: }
                   1351:
                   1352: static int xmm7360_net_close(struct net_device *dev)
                   1353: {
                   1354:        netif_stop_queue(dev);
                   1355:        return 0;
                   1356: }
                   1357:
                   1358: static int xmm7360_net_must_flush(struct xmm_net *xn, int new_packet_bytes)
                   1359: {
                   1360:        int frame_size;
                   1361:        if (xn->queued_packets >= MUX_MAX_PACKETS)
                   1362:                return 1;
                   1363:
                   1364:        frame_size = sizeof(struct mux_first_header) + xn->queued_bytes + sizeof(struct mux_next_header) + 4 + sizeof(struct mux_bounds)*xn->queued_packets;
                   1365:
                   1366:        frame_size += 16 + new_packet_bytes + sizeof(struct mux_bounds);
                   1367:
                   1368:        return frame_size > xn->frame.max_size;
                   1369: }
                   1370:
                   1371: static enum hrtimer_restart xmm7360_net_deadline_cb(struct hrtimer *t)
                   1372: {
                   1373:        struct xmm_net *xn = container_of(t, struct xmm_net, deadline);
                   1374:        unsigned long flags;
                   1375:        spin_lock_irqsave(&xn->lock, flags);
                   1376:        if (!skb_queue_empty(&xn->queue) && xmm7360_qp_can_write(xn->qp))
                   1377:                xmm7360_net_flush(xn);
                   1378:        spin_unlock_irqrestore(&xn->lock, flags);
                   1379:        return HRTIMER_NORESTART;
                   1380: }
                   1381:
                   1382: static netdev_tx_t xmm7360_net_xmit(struct sk_buff *skb, struct net_device *dev)
                   1383: {
                   1384:        struct xmm_net *xn = netdev_priv(dev);
                   1385:        ktime_t kt;
                   1386:        unsigned long flags;
                   1387:
                   1388:        if (netif_queue_stopped(dev))
                   1389:                return NETDEV_TX_BUSY;
                   1390:
                   1391:        skb_orphan(skb);
                   1392:
                   1393:        spin_lock_irqsave(&xn->lock, flags);
                   1394:        if (xmm7360_net_must_flush(xn, skb->len)) {
                   1395:                if (xmm7360_qp_can_write(xn->qp)) {
                   1396:                        xmm7360_net_flush(xn);
                   1397:                } else {
                   1398:                        netif_stop_queue(dev);
                   1399:                        spin_unlock_irqrestore(&xn->lock, flags);
                   1400:                        return NETDEV_TX_BUSY;
                   1401:                }
                   1402:        }
                   1403:
                   1404:        xn->queued_packets++;
                   1405:        xn->queued_bytes += 16 + skb->len;
                   1406:        skb_queue_tail(&xn->queue, skb);
                   1407:
                   1408:        spin_unlock_irqrestore(&xn->lock, flags);
                   1409:
                   1410:        if (!hrtimer_active(&xn->deadline)) {
                   1411:                kt = ktime_set(0, 100000);
                   1412:                hrtimer_start(&xn->deadline, kt, HRTIMER_MODE_REL);
                   1413:        }
                   1414:
                   1415:        return NETDEV_TX_OK;
                   1416: }
                   1417:
                   1418: static void xmm7360_os_handle_net_frame(struct xmm_dev *xmm, const u8 *buf, size_t sz)
                   1419: {
                   1420:        struct sk_buff *skb;
                   1421:        void *p;
                   1422:        u8 ip_version;
                   1423:
                   1424:        skb = dev_alloc_skb(sz + NET_IP_ALIGN);
                   1425:        if (!skb)
                   1426:                return;
                   1427:        skb_reserve(skb, NET_IP_ALIGN);
                   1428:        p = skb_put(skb, sz);
                   1429:        memcpy(p, buf, sz);
                   1430:
                   1431:        skb->dev = xmm->netdev;
                   1432:
                   1433:        ip_version = skb->data[0] >> 4;
                   1434:        if (ip_version == 4) {
                   1435:                skb->protocol = htons(ETH_P_IP);
                   1436:        } else if (ip_version == 6) {
                   1437:                skb->protocol = htons(ETH_P_IPV6);
                   1438:        } else {
                   1439:                kfree_skb(skb);
                   1440:                return;
                   1441:        }
                   1442:
                   1443:        netif_rx(skb);
                   1444: }
                   1445:
                   1446: static void xmm7360_os_handle_net_dequeue(struct xmm_net *xn, struct mux_frame *frame)
                   1447: {
                   1448:        struct sk_buff *skb;
                   1449:        int ret;
                   1450:
                   1451:        while ((skb = skb_dequeue(&xn->queue))) {
                   1452:                ret = xmm7360_mux_frame_append_packet(frame,
                   1453:                    skb->data, skb->len);
                   1454:                kfree_skb(skb);
                   1455:                if (ret) {
                   1456:                        /* No more space in the frame */
                   1457:                        break;
                   1458:                }
                   1459:        }
                   1460: }
                   1461:
                   1462: static void xmm7360_os_handle_net_txwake(struct xmm_net *xn)
                   1463: {
                   1464:        BUG_ON(!xmm7360_qp_can_write(xn->qp));
                   1465:
                   1466:        if (netif_queue_stopped(xn->xmm->netdev))
                   1467:                netif_wake_queue(xn->xmm->netdev);
                   1468: }
                   1469:
                   1470: static const struct net_device_ops xmm7360_netdev_ops = {
                   1471:        .ndo_uninit             = xmm7360_net_uninit,
                   1472:        .ndo_open               = xmm7360_net_open,
                   1473:        .ndo_stop               = xmm7360_net_close,
                   1474:        .ndo_start_xmit         = xmm7360_net_xmit,
                   1475: };
                   1476:
                   1477: static void xmm7360_net_setup(struct net_device *dev)
                   1478: {
                   1479:        struct xmm_net *xn = netdev_priv(dev);
                   1480:        spin_lock_init(&xn->lock);
                   1481:        hrtimer_init(&xn->deadline, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
                   1482:        xn->deadline.function = xmm7360_net_deadline_cb;
                   1483:        skb_queue_head_init(&xn->queue);
                   1484:
                   1485:        dev->netdev_ops = &xmm7360_netdev_ops;
                   1486:
                   1487:        dev->hard_header_len = 0;
                   1488:        dev->addr_len = 0;
                   1489:        dev->mtu = 1500;
                   1490:        dev->min_mtu = 1500;
                   1491:        dev->max_mtu = 1500;
                   1492:
                   1493:        dev->tx_queue_len = 1000;
                   1494:
                   1495:        dev->type = ARPHRD_NONE;
                   1496:        dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
                   1497: }
                   1498:
                   1499: static int xmm7360_create_net(struct xmm_dev *xmm, int num)
                   1500: {
                   1501:        struct net_device *netdev;
                   1502:        struct xmm_net *xn;
                   1503:        int ret;
                   1504:
                   1505:        netdev = alloc_netdev(sizeof(struct xmm_net), "wwan%d", NET_NAME_UNKNOWN, xmm7360_net_setup);
                   1506:
                   1507:        if (!netdev)
                   1508:                return -ENOMEM;
                   1509:
                   1510:        SET_NETDEV_DEV(netdev, xmm->dev);
                   1511:
                   1512:        xmm->netdev = netdev;
                   1513:
                   1514:        xn = netdev_priv(netdev);
                   1515:        xn->xmm = xmm;
                   1516:        xmm->net = xn;
                   1517:
                   1518:        rtnl_lock();
                   1519:        ret = register_netdevice(netdev);
                   1520:        rtnl_unlock();
                   1521:
                   1522:        xn->qp = xmm7360_init_qp(xmm, num, 128, TD_MAX_PAGE_SIZE);
                   1523:
                   1524:        if (!ret)
                   1525:                ret = xmm7360_qp_start(xn->qp);
                   1526:
                   1527:        if (ret < 0) {
                   1528:                free_netdev(netdev);
                   1529:                xmm->netdev = NULL;
                   1530:                xmm7360_qp_stop(xn->qp);
                   1531:        }
                   1532:
                   1533:        return ret;
                   1534: }
                   1535:
                   1536: static void xmm7360_destroy_net(struct xmm_dev *xmm)
                   1537: {
                   1538:        if (xmm->netdev) {
                   1539:                xmm7360_qp_stop(xmm->net->qp);
                   1540:                rtnl_lock();
                   1541:                unregister_netdevice(xmm->netdev);
                   1542:                rtnl_unlock();
                   1543:                free_netdev(xmm->netdev);
                   1544:                xmm->net = NULL;
                   1545:                xmm->netdev = NULL;
                   1546:        }
                   1547: }
                   1548:
                   1549: static irqreturn_t xmm7360_irq0(int irq, void *dev_id) {
                   1550:        struct xmm_dev *xmm = dev_id;
                   1551:        struct queue_pair *qp;
                   1552:        int id;
                   1553:
                   1554:        xmm7360_poll(xmm);
                   1555:        wake_up(&xmm->wq);
                   1556:        if (xmm->td_ring) {
                   1557:                if (xmm->net)
                   1558:                        xmm7360_net_poll(xmm);
                   1559:
                   1560:                for (id=1; id<XMM_QP_COUNT; id++) {
                   1561:                        qp = &xmm->qp[id];
                   1562:
                   1563:                        /* wake _cdev_read() */
                   1564:                        if (qp->open)
                   1565:                                wake_up(&qp->wq);
                   1566:
                   1567:                        /* tty tasks */
                   1568:                        if (qp->open && qp->port.ops) {
                   1569:                                xmm7360_tty_poll_qp(qp);
                   1570:                                if (qp->tty_needs_wake && xmm7360_qp_can_write(qp) && qp->port.tty) {
                   1571:                                        struct tty_ldisc *ldisc = tty_ldisc_ref(qp->port.tty);
                   1572:                                        if (ldisc) {
                   1573:                                                if (ldisc->ops->write_wakeup)
                   1574:                                                        ldisc->ops->write_wakeup(qp->port.tty);
                   1575:                                                tty_ldisc_deref(ldisc);
                   1576:                                        }
                   1577:                                        qp->tty_needs_wake = 0;
                   1578:                                }
                   1579:                        }
                   1580:                }
                   1581:        }
                   1582:
                   1583:        return IRQ_HANDLED;
                   1584: }
                   1585:
                   1586: static dev_t xmm_base;
                   1587:
                   1588: static struct tty_driver *xmm7360_tty_driver;
                   1589:
                   1590: static void xmm7360_dev_deinit(struct xmm_dev *xmm)
                   1591: {
                   1592:        int i;
                   1593:        xmm->error = -ENODEV;
                   1594:
                   1595:        cancel_work_sync(&xmm->init_work);
                   1596:
                   1597:        xmm7360_destroy_net(xmm);
                   1598:
                   1599:        for (i=0; i<XMM_QP_COUNT; i++) {
                   1600:                if (xmm->qp[i].xmm) {
                   1601:                        if (xmm->qp[i].cdev.owner) {
                   1602:                                cdev_del(&xmm->qp[i].cdev);
                   1603:                                device_unregister(&xmm->qp[i].dev);
                   1604:                        }
                   1605:                        if (xmm->qp[i].port.ops) {
                   1606:                                tty_unregister_device(xmm7360_tty_driver, xmm->qp[i].tty_index);
                   1607:                                tty_port_destroy(&xmm->qp[i].port);
                   1608:                        }
                   1609:                }
                   1610:                memset(&xmm->qp[i], 0, sizeof(struct queue_pair));
                   1611:        }
                   1612:        xmm7360_cmd_ring_free(xmm);
                   1613:
                   1614: }
                   1615:
                   1616: static void xmm7360_remove(struct pci_dev *dev)
                   1617: {
                   1618:        struct xmm_dev *xmm = pci_get_drvdata(dev);
                   1619:
                   1620:        xmm7360_dev_deinit(xmm);
                   1621:
                   1622:        if (xmm->irq)
                   1623:                free_irq(xmm->irq, xmm);
                   1624:        pci_free_irq_vectors(dev);
                   1625:        pci_release_region(dev, 0);
                   1626:        pci_release_region(dev, 2);
                   1627:        pci_disable_device(dev);
                   1628:        kfree(xmm);
                   1629: }
                   1630:
                   1631: static void xmm7360_cdev_dev_release(struct device *dev)
                   1632: {
                   1633: }
                   1634:
                   1635: static int xmm7360_tty_open(struct tty_struct *tty, struct file *filp)
                   1636: {
                   1637:        struct queue_pair *qp = tty->driver_data;
                   1638:        return tty_port_open(&qp->port, tty, filp);
                   1639: }
                   1640:
                   1641: static void xmm7360_tty_close(struct tty_struct *tty, struct file *filp)
                   1642: {
                   1643:        struct queue_pair *qp = tty->driver_data;
                   1644:        if (qp)
                   1645:                tty_port_close(&qp->port, tty, filp);
                   1646: }
                   1647:
                   1648: static int xmm7360_tty_write(struct tty_struct *tty, const unsigned char *buffer,
                   1649:                      int count)
                   1650: {
                   1651:        struct queue_pair *qp = tty->driver_data;
                   1652:        int written;
                   1653:        written = xmm7360_qp_write(qp, buffer, count);
                   1654:        if (written < count)
                   1655:                qp->tty_needs_wake = 1;
                   1656:        return written;
                   1657: }
                   1658:
                   1659: static int xmm7360_tty_write_room(struct tty_struct *tty)
                   1660: {
                   1661:        struct queue_pair *qp = tty->driver_data;
                   1662:        if (!xmm7360_qp_can_write(qp))
                   1663:                return 0;
                   1664:        else
                   1665:                return qp->xmm->td_ring[qp->num*2].page_size;
                   1666: }
                   1667:
                   1668: static int xmm7360_tty_install(struct tty_driver *driver, struct tty_struct *tty)
                   1669: {
                   1670:        struct queue_pair *qp;
                   1671:        int ret;
                   1672:
                   1673:        ret = tty_standard_install(driver, tty);
                   1674:        if (ret)
                   1675:                return ret;
                   1676:
                   1677:        tty->port = driver->ports[tty->index];
                   1678:        qp = container_of(tty->port, struct queue_pair, port);
                   1679:        tty->driver_data = qp;
                   1680:        return 0;
                   1681: }
                   1682:
                   1683:
                   1684: static int xmm7360_tty_port_activate(struct tty_port *tport, struct tty_struct *tty)
                   1685: {
                   1686:        struct queue_pair *qp = tty->driver_data;
                   1687:        return xmm7360_qp_start(qp);
                   1688: }
                   1689:
                   1690: static void xmm7360_tty_port_shutdown(struct tty_port *tport)
                   1691: {
                   1692:        struct queue_pair *qp = tport->tty->driver_data;
                   1693:        xmm7360_qp_stop(qp);
                   1694: }
                   1695:
                   1696:
                   1697: static const struct tty_port_operations xmm7360_tty_port_ops = {
                   1698:        .activate = xmm7360_tty_port_activate,
                   1699:        .shutdown = xmm7360_tty_port_shutdown,
                   1700: };
                   1701:
                   1702: static const struct tty_operations xmm7360_tty_ops = {
                   1703:        .open = xmm7360_tty_open,
                   1704:        .close = xmm7360_tty_close,
                   1705:        .write = xmm7360_tty_write,
                   1706:        .write_room = xmm7360_tty_write_room,
                   1707:        .install = xmm7360_tty_install,
                   1708: };
                   1709:
                   1710: static int xmm7360_create_tty(struct xmm_dev *xmm, int num)
                   1711: {
                   1712:        struct device *tty_dev;
                   1713:        struct queue_pair *qp = xmm7360_init_qp(xmm, num, 8, 4096);
                   1714:        int ret;
                   1715:        tty_port_init(&qp->port);
                   1716:        qp->port.low_latency = 1;
                   1717:        qp->port.ops = &xmm7360_tty_port_ops;
                   1718:        qp->tty_index = xmm->num_ttys++;
                   1719:        tty_dev = tty_port_register_device(&qp->port, xmm7360_tty_driver, qp->tty_index, xmm->dev);
                   1720:
                   1721:        if (IS_ERR(tty_dev)) {
                   1722:                qp->port.ops = NULL;    // prevent calling unregister
                   1723:                ret = PTR_ERR(tty_dev);
                   1724:                dev_err(xmm->dev, "Could not allocate tty?\n");
                   1725:                tty_port_destroy(&qp->port);
                   1726:                return ret;
                   1727:        }
                   1728:
                   1729:        return 0;
                   1730: }
                   1731:
                   1732: static int xmm7360_create_cdev(struct xmm_dev *xmm, int num, const char *name, int cardnum)
                   1733: {
                   1734:        struct queue_pair *qp = xmm7360_init_qp(xmm, num, 16, TD_MAX_PAGE_SIZE);
                   1735:        int ret;
                   1736:
                   1737:        cdev_init(&qp->cdev, &xmm7360_fops);
                   1738:        qp->cdev.owner = THIS_MODULE;
                   1739:        device_initialize(&qp->dev);
                   1740:        qp->dev.devt = MKDEV(MAJOR(xmm_base), num); // XXX multiple cards
                   1741:        qp->dev.parent = &xmm->pci_dev->dev;
                   1742:        qp->dev.release = xmm7360_cdev_dev_release;
                   1743:        dev_set_name(&qp->dev, name, cardnum);
                   1744:        dev_set_drvdata(&qp->dev, qp);
                   1745:        ret = cdev_device_add(&qp->cdev, &qp->dev);
                   1746:        if (ret) {
                   1747:                dev_err(xmm->dev, "cdev_device_add: %d\n", ret);
                   1748:                return ret;
                   1749:        }
                   1750:        return 0;
                   1751: }
                   1752:
                   1753: static int xmm7360_dev_init(struct xmm_dev *xmm)
                   1754: {
                   1755:        int ret;
                   1756:
                   1757:        ret = xmm7360_base_init(xmm);
                   1758:        if (ret)
                   1759:                return ret;
                   1760:
                   1761:        ret = xmm7360_create_cdev(xmm, 1, "xmm%d/rpc", xmm->card_num);
                   1762:        if (ret)
                   1763:                return ret;
                   1764:        ret = xmm7360_create_cdev(xmm, 3, "xmm%d/trace", xmm->card_num);
                   1765:        if (ret)
                   1766:                return ret;
                   1767:        ret = xmm7360_create_tty(xmm, 2);
                   1768:        if (ret)
                   1769:                return ret;
                   1770:        ret = xmm7360_create_tty(xmm, 4);
                   1771:        if (ret)
                   1772:                return ret;
                   1773:        ret = xmm7360_create_tty(xmm, 7);
                   1774:        if (ret)
                   1775:                return ret;
                   1776:        ret = xmm7360_create_net(xmm, 0);
                   1777:        if (ret)
                   1778:                return ret;
                   1779:
                   1780:        return 0;
                   1781: }
                   1782:
                   1783: void xmm7360_dev_init_work(struct work_struct *work)
                   1784: {
                   1785:        struct xmm_dev *xmm = container_of(work, struct xmm_dev, init_work);
                   1786:        xmm7360_dev_init(xmm);
                   1787: }
                   1788:
                   1789: static int xmm7360_probe(struct pci_dev *dev, const struct pci_device_id *id)
                   1790: {
                   1791:        struct xmm_dev *xmm = kzalloc(sizeof(struct xmm_dev), GFP_KERNEL);
                   1792:        int ret;
                   1793:
                   1794:        xmm->pci_dev = dev;
                   1795:        xmm->dev = &dev->dev;
                   1796:
                   1797:        if (!xmm) {
                   1798:                dev_err(&(dev->dev), "kzalloc\n");
                   1799:                return -ENOMEM;
                   1800:        }
                   1801:
                   1802:        ret = pci_enable_device(dev);
                   1803:        if (ret) {
                   1804:                dev_err(&(dev->dev), "pci_enable_device\n");
                   1805:                goto fail;
                   1806:        }
                   1807:        pci_set_master(dev);
                   1808:
                   1809:        ret = pci_set_dma_mask(dev, 0xffffffffffffffff);
                   1810:        if (ret) {
                   1811:                dev_err(xmm->dev, "Cannot set DMA mask\n");
                   1812:                goto fail;
                   1813:        }
                   1814:        dma_set_coherent_mask(xmm->dev, 0xffffffffffffffff);
                   1815:
                   1816:
                   1817:        ret = pci_request_region(dev, 0, "xmm0");
                   1818:        if (ret) {
                   1819:                dev_err(&(dev->dev), "pci_request_region(0)\n");
                   1820:                goto fail;
                   1821:        }
                   1822:        xmm->bar0 = pci_iomap(dev, 0, pci_resource_len(dev, 0));
                   1823:
                   1824:        ret = pci_request_region(dev, 2, "xmm2");
                   1825:        if (ret) {
                   1826:                dev_err(&(dev->dev), "pci_request_region(2)\n");
                   1827:                goto fail;
                   1828:        }
                   1829:        xmm->bar2 = pci_iomap(dev, 2, pci_resource_len(dev, 2));
                   1830:
                   1831:        ret = pci_alloc_irq_vectors(dev, 1, 1, PCI_IRQ_MSI | PCI_IRQ_MSIX);
                   1832:        if (ret < 0) {
                   1833:                dev_err(&(dev->dev), "pci_alloc_irq_vectors\n");
                   1834:                goto fail;
                   1835:        }
                   1836:
                   1837:        init_waitqueue_head(&xmm->wq);
                   1838:        INIT_WORK(&xmm->init_work, xmm7360_dev_init_work);
                   1839:
                   1840:        pci_set_drvdata(dev, xmm);
                   1841:
                   1842:        ret = xmm7360_dev_init(xmm);
                   1843:        if (ret)
                   1844:                goto fail;
                   1845:
                   1846:        xmm->irq = pci_irq_vector(dev, 0);
                   1847:        ret = request_irq(xmm->irq, xmm7360_irq0, 0, "xmm7360", xmm);
                   1848:        if (ret) {
                   1849:                dev_err(&(dev->dev), "request_irq\n");
                   1850:                goto fail;
                   1851:        }
                   1852:
                   1853:        return ret;
                   1854:
                   1855: fail:
                   1856:        xmm7360_dev_deinit(xmm);
                   1857:        xmm7360_remove(dev);
                   1858:        return ret;
                   1859: }
                   1860:
                   1861: static struct pci_driver xmm7360_driver = {
                   1862:        .name           = "xmm7360",
                   1863:        .id_table       = xmm7360_ids,
                   1864:        .probe          = xmm7360_probe,
                   1865:        .remove         = xmm7360_remove,
                   1866: };
                   1867:
                   1868: static int xmm7360_init(void)
                   1869: {
                   1870:        int ret;
                   1871:        ret = alloc_chrdev_region(&xmm_base, 0, 8, "xmm");
                   1872:        if (ret)
                   1873:                return ret;
                   1874:
                   1875:        xmm7360_tty_driver = alloc_tty_driver(8);
                   1876:        if (!xmm7360_tty_driver)
                   1877:                return -ENOMEM;
                   1878:
                   1879:        xmm7360_tty_driver->driver_name = "xmm7360";
                   1880:        xmm7360_tty_driver->name = "ttyXMM";
                   1881:        xmm7360_tty_driver->major = 0;
                   1882:        xmm7360_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
                   1883:        xmm7360_tty_driver->subtype = SERIAL_TYPE_NORMAL;
                   1884:        xmm7360_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
                   1885:        xmm7360_tty_driver->init_termios = tty_std_termios;
                   1886:        xmm7360_tty_driver->init_termios.c_cflag = B115200 | CS8 | CREAD | \
                   1887:                                                HUPCL | CLOCAL;
                   1888:        xmm7360_tty_driver->init_termios.c_lflag &= ~ECHO;
                   1889:        xmm7360_tty_driver->init_termios.c_ispeed = 115200;
                   1890:        xmm7360_tty_driver->init_termios.c_ospeed = 115200;
                   1891:        tty_set_operations(xmm7360_tty_driver, &xmm7360_tty_ops);
                   1892:
                   1893:        ret = tty_register_driver(xmm7360_tty_driver);
                   1894:        if (ret) {
                   1895:                pr_err("xmm7360: failed to register xmm7360_tty driver\n");
                   1896:                return ret;
                   1897:        }
                   1898:
                   1899:
                   1900:        ret = pci_register_driver(&xmm7360_driver);
                   1901:        if (ret)
                   1902:                return ret;
                   1903:
                   1904:        return 0;
                   1905: }
                   1906:
                   1907: static void xmm7360_exit(void)
                   1908: {
                   1909:        pci_unregister_driver(&xmm7360_driver);
                   1910:        unregister_chrdev_region(xmm_base, 8);
                   1911:        tty_unregister_driver(xmm7360_tty_driver);
                   1912:        put_tty_driver(xmm7360_tty_driver);
                   1913: }
                   1914:
                   1915: module_init(xmm7360_init);
                   1916: module_exit(xmm7360_exit);
                   1917:
                   1918: #endif /* __linux__ */
                   1919:
                   1920: #if defined(__OpenBSD__) || defined(__NetBSD__)
                   1921:
                   1922: /*
                   1923:  * RPC and trace devices behave as regular character device,
                   1924:  * other devices behave as terminal.
                   1925:  */
                   1926: #define DEVCUA(x)      (minor(x) & 0x80)
                   1927: #define DEVUNIT(x)     ((minor(x) & 0x70) >> 4)
                   1928: #define DEVFUNC_MASK   0x0f
                   1929: #define DEVFUNC(x)     (minor(x) & DEVFUNC_MASK)
                   1930: #define DEV_IS_TTY(x)  (DEVFUNC(x) == 2 || DEVFUNC(x) > 3)
                   1931:
                   1932: struct wwanc_softc {
                   1933: #ifdef __OpenBSD__
                   1934:        struct device           sc_devx;        /* gen. device info storage */
                   1935: #endif
                   1936:        struct device           *sc_dev;        /* generic device information */
                   1937:         pci_chipset_tag_t       sc_pc;
                   1938:         pcitag_t                sc_tag;
                   1939:        bus_dma_tag_t           sc_dmat;
                   1940:        pci_intr_handle_t       sc_pih;
                   1941:         void                    *sc_ih;         /* interrupt vectoring */
                   1942:
                   1943:        bus_space_tag_t         sc_bar0_tag;
                   1944:        bus_space_handle_t      sc_bar0_handle;
                   1945:        bus_size_t              sc_bar0_sz;
                   1946:        bus_space_tag_t         sc_bar2_tag;
                   1947:        bus_space_handle_t      sc_bar2_handle;
                   1948:        bus_size_t              sc_bar2_sz;
                   1949:
                   1950:        struct xmm_dev          sc_xmm;
                   1951:        struct tty              *sc_tty[XMM_QP_COUNT];
                   1952:        struct device           *sc_net;
                   1953:        struct selinfo          sc_selr, sc_selw;
                   1954:        bool                    sc_resume;
                   1955: };
                   1956:
                   1957: struct wwanc_attach_args {
                   1958:        enum wwanc_type {
                   1959:                WWMC_TYPE_RPC,
                   1960:                WWMC_TYPE_TRACE,
                   1961:                WWMC_TYPE_TTY,
                   1962:                WWMC_TYPE_NET
                   1963:        } aa_type;
                   1964: };
                   1965:
                   1966: static int     wwanc_match(struct device *, cfdata_t, void *);
                   1967: static void    wwanc_attach(struct device *, struct device *, void *);
                   1968: static int     wwanc_detach(struct device *, int);
                   1969:
                   1970: #ifdef __OpenBSD__
                   1971: static int     wwanc_activate(struct device *, int);
                   1972:
                   1973: struct cfattach wwanc_ca = {
                   1974:         sizeof(struct wwanc_softc), wwanc_match, wwanc_attach,
                   1975:         wwanc_detach, wwanc_activate
                   1976: };
                   1977:
                   1978: struct cfdriver wwanc_cd = {
                   1979:         NULL, "wwanc", DV_DULL
                   1980: };
                   1981: #endif
                   1982:
                   1983: #ifdef __NetBSD__
                   1984: CFATTACH_DECL3_NEW(wwanc, sizeof(struct wwanc_softc),
                   1985:    wwanc_match, wwanc_attach, wwanc_detach, NULL,
                   1986:    NULL, NULL, DVF_DETACH_SHUTDOWN);
                   1987:
                   1988: static bool wwanc_pmf_suspend(device_t, const pmf_qual_t *);
                   1989: static bool wwanc_pmf_resume(device_t, const pmf_qual_t *);
                   1990: #endif /* __NetBSD__ */
                   1991:
                   1992: static int
                   1993: wwanc_match(struct device *parent, cfdata_t match, void *aux)
                   1994: {
                   1995:        struct pci_attach_args *pa = aux;
                   1996:
                   1997:        return (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_INTEL &&
                   1998:                PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_INTEL_XMM7360);
                   1999: }
                   2000:
                   2001: static int xmm7360_dev_init(struct xmm_dev *xmm)
                   2002: {
                   2003:        int ret;
                   2004:        int depth, page_size;
                   2005:
                   2006:        ret = xmm7360_base_init(xmm);
                   2007:        if (ret)
                   2008:                return ret;
                   2009:
                   2010:        /* Initialize queue pairs for later use */
                   2011:        for (int num = 0; num < XMM_QP_COUNT; num++) {
                   2012:                switch (num) {
                   2013:                case 0: /* net */
                   2014:                        depth = 128;
                   2015:                        page_size = TD_MAX_PAGE_SIZE;
                   2016:                        break;
                   2017:                case 1: /* rpc */
                   2018:                case 3: /* trace */
                   2019:                        depth = 16;
                   2020:                        page_size = TD_MAX_PAGE_SIZE;
                   2021:                        break;
                   2022:                default: /* tty */
                   2023:                        depth = 8;
                   2024:                        page_size = 4096;
                   2025:                        break;
                   2026:                }
                   2027:
                   2028:                xmm7360_init_qp(xmm, num, depth, page_size);
                   2029:        }
                   2030:
                   2031:        return 0;
                   2032: }
                   2033:
                   2034: static void xmm7360_dev_deinit(struct xmm_dev *xmm)
                   2035: {
                   2036:        struct wwanc_softc *sc = device_private(xmm->dev);
                   2037:        bool devgone = false;
                   2038:        struct tty *tp;
                   2039:
                   2040:        xmm->error = -ENODEV;
                   2041:
                   2042:        /* network device should be gone by now */
                   2043:        KASSERT(sc->sc_net == NULL);
                   2044:        KASSERT(xmm->net == NULL);
                   2045:
                   2046:        /* free ttys */
                   2047:        for (int i=0; i<XMM_QP_COUNT; i++) {
                   2048:                tp = sc->sc_tty[i];
                   2049:                if (tp) {
                   2050:                        KASSERT(DEV_IS_TTY(i));
                   2051:                        if (!devgone) {
                   2052:                                vdevgone(major(tp->t_dev), 0, DEVFUNC_MASK,
                   2053:                                    VCHR);
                   2054:                                devgone = true;
                   2055:                        }
                   2056:                        ttyfree(tp);
                   2057:                        sc->sc_tty[i] = NULL;
                   2058:                }
                   2059:        }
                   2060:
                   2061:        xmm7360_cmd_ring_free(xmm);
                   2062: }
                   2063:
                   2064: static void
                   2065: wwanc_io_wakeup(struct queue_pair *qp, int flag)
                   2066: {
                   2067:         if (flag & FREAD) {
                   2068:                 selnotify(&qp->selr, POLLIN|POLLRDNORM, NOTE_SUBMIT);
                   2069:                 wakeup(qp->wq);
                   2070:         }
                   2071:         if (flag & FWRITE) {
                   2072:                 selnotify(&qp->selw, POLLOUT|POLLWRNORM, NOTE_SUBMIT);
                   2073:                 wakeup(qp->wq);
                   2074:         }
                   2075: }
                   2076:
                   2077: static int
                   2078: wwanc_intr(void *xsc)
                   2079: {
                   2080:        struct wwanc_softc *sc = xsc;
                   2081:        struct xmm_dev *xmm = &sc->sc_xmm;
                   2082:        struct queue_pair *qp;
                   2083:
                   2084:        xmm7360_poll(xmm);
                   2085:        wakeup(&xmm->wq);
                   2086:
                   2087:        if (xmm->net && xmm->net->qp->open && xmm7360_qp_has_data(xmm->net->qp))
                   2088:                xmm7360_net_poll(xmm);
                   2089:
                   2090:        for (int func = 1; func < XMM_QP_COUNT; func++) {
                   2091:                qp = &xmm->qp[func];
                   2092:                if (!qp->open)
                   2093:                        continue;
                   2094:
                   2095:                /* Check for input, wwancstart()/wwancwrite() does output */
                   2096:                if (xmm7360_qp_has_data(qp)) {
                   2097:                        if (DEV_IS_TTY(func)) {
                   2098:                                int s = spltty();
                   2099:                                xmm7360_tty_poll_qp(qp);
                   2100:                                splx(s);
                   2101:                        }
                   2102:                        wwanc_io_wakeup(qp, FREAD);
                   2103:                }
                   2104:
                   2105:                /* Wakeup/notify eventual writers */
                   2106:                if (xmm7360_qp_can_write(qp))
                   2107:                        wwanc_io_wakeup(qp, FWRITE);
                   2108:        }
                   2109:
                   2110:        return 1;
                   2111: }
                   2112:
                   2113: static int
                   2114: wwancprint(void *aux, const char *pnp)
                   2115: {
                   2116:        struct wwanc_attach_args *wa = aux;
                   2117:
                   2118:        if (pnp)
                   2119:                 printf("wwanc type %s at %s",
                   2120:                    (wa->aa_type == WWMC_TYPE_NET) ? "net" : "unk", pnp);
                   2121:        else
                   2122:                printf(" type %s",
                   2123:                    (wa->aa_type == WWMC_TYPE_NET) ? "net" : "unk");
                   2124:
                   2125:        return (UNCONF);
                   2126: }
                   2127:
                   2128: static void
                   2129: wwanc_attach_finish(struct device *self)
                   2130: {
                   2131:        struct wwanc_softc *sc = device_private(self);
                   2132:
                   2133:        if (xmm7360_dev_init(&sc->sc_xmm)) {
                   2134:                /* error already printed */
                   2135:                return;
                   2136:        }
                   2137:
                   2138:        /* Attach the network device */
                   2139:        struct wwanc_attach_args wa;
                   2140:        memset(&wa, 0, sizeof(wa));
                   2141:        wa.aa_type = WWMC_TYPE_NET;
1.9       thorpej  2142:        sc->sc_net = config_found(self, &wa, wwancprint, CFARGS_NONE);
1.1       jdolecek 2143: }
                   2144:
                   2145: static void
                   2146: wwanc_attach(struct device *parent, struct device *self, void *aux)
                   2147: {
                   2148:        struct wwanc_softc *sc = device_private(self);
                   2149:        struct pci_attach_args *pa = aux;
                   2150:        bus_space_tag_t memt;
                   2151:        bus_space_handle_t memh;
                   2152:        bus_size_t sz;
                   2153:        int error;
                   2154:        const char *intrstr;
                   2155: #ifdef __OpenBSD__
                   2156:        pci_intr_handle_t ih;
                   2157: #endif
                   2158: #ifdef __NetBSD__
                   2159:        pci_intr_handle_t *ih;
                   2160:        char intrbuf[PCI_INTRSTR_LEN];
                   2161: #endif
                   2162:
                   2163:        sc->sc_dev = self;
                   2164:        sc->sc_pc = pa->pa_pc;
                   2165:        sc->sc_tag = pa->pa_tag;
                   2166:        sc->sc_dmat = pa->pa_dmat;
                   2167:
                   2168:        /* map the register window, memory mapped 64-bit non-prefetchable */
                   2169:        error = pci_mapreg_map(pa, WWAN_BAR0,
                   2170:            PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_64BIT,
                   2171:            BUS_SPACE_MAP_LINEAR, &memt, &memh, NULL, &sz, 0);
                   2172:        if (error != 0) {
                   2173:                printf(": can't map mem space for BAR0 %d\n", error);
                   2174:                return;
                   2175:        }
                   2176:        sc->sc_bar0_tag = memt;
                   2177:        sc->sc_bar0_handle = memh;
                   2178:        sc->sc_bar0_sz = sz;
                   2179:
                   2180:        error = pci_mapreg_map(pa, WWAN_BAR2,
                   2181:            PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_64BIT,
                   2182:            BUS_SPACE_MAP_LINEAR, &memt, &memh, NULL, &sz, 0);
                   2183:        if (error != 0) {
                   2184:                bus_space_unmap(sc->sc_bar0_tag, sc->sc_bar0_handle,
                   2185:                    sc->sc_bar0_sz);
                   2186:                printf(": can't map mem space for BAR2\n");
                   2187:                return;
                   2188:        }
                   2189:        sc->sc_bar2_tag = memt;
                   2190:        sc->sc_bar2_handle = memh;
                   2191:        sc->sc_bar2_sz = sz;
                   2192:
                   2193:        /* Set xmm members needed for xmm7360_dev_init() */
                   2194:        sc->sc_xmm.dev = self;
                   2195:        sc->sc_xmm.bar0 = bus_space_vaddr(sc->sc_bar0_tag, sc->sc_bar0_handle);
                   2196:        sc->sc_xmm.bar2 = bus_space_vaddr(sc->sc_bar0_tag, sc->sc_bar2_handle);
                   2197:        init_waitqueue_head(&sc->sc_xmm.wq);
                   2198:
                   2199: #ifdef __OpenBSD__
                   2200:        if (pci_intr_map_msi(pa, &ih) && pci_intr_map(pa, &ih)) {
                   2201:                printf(": can't map interrupt\n");
                   2202:                goto fail;
                   2203:        }
                   2204:        sc->sc_pih = ih;
                   2205:        intrstr = pci_intr_string(sc->sc_pc, ih);
                   2206:        printf(": %s\n", intrstr);
                   2207: #endif
                   2208: #ifdef __NetBSD__
                   2209:        if (pci_intr_alloc(pa, &ih, NULL, 0)) {
                   2210:                printf(": can't map interrupt\n");
                   2211:                goto fail;
                   2212:        }
                   2213:        sc->sc_pih = ih[0];
                   2214:        intrstr = pci_intr_string(pa->pa_pc, ih[0], intrbuf, sizeof(intrbuf));
                   2215:        aprint_normal(": LTE modem\n");
                   2216:        aprint_normal_dev(sc->sc_dev, "interrupting at %s\n", intrstr);
                   2217: #endif
                   2218:
                   2219:        /* Device initialized, can establish the interrupt now */
                   2220:        sc->sc_ih = pci_intr_establish(sc->sc_pc, sc->sc_pih, IPL_NET,
                   2221:            wwanc_intr, sc, sc->sc_dev->dv_xname);
                   2222:        if (sc->sc_ih == NULL) {
                   2223:                printf("%s: can't establish interrupt\n", self->dv_xname);
                   2224:                return;
                   2225:        }
                   2226:
                   2227: #ifdef __NetBSD__
                   2228:        if (!pmf_device_register(self, wwanc_pmf_suspend, wwanc_pmf_resume))
                   2229:                aprint_error_dev(self, "couldn't establish power handler\n");
                   2230: #endif
                   2231:
                   2232:        /*
                   2233:         * Device initialization requires working interrupts, so need
                   2234:         * to postpone this until they are enabled.
                   2235:         */
                   2236:        config_mountroot(self, wwanc_attach_finish);
                   2237:        return;
                   2238:
                   2239: fail:
                   2240:        bus_space_unmap(sc->sc_bar0_tag, sc->sc_bar0_handle, sc->sc_bar0_sz);
                   2241:        sc->sc_bar0_tag = 0;
                   2242:        bus_space_unmap(sc->sc_bar2_tag, sc->sc_bar2_handle, sc->sc_bar2_sz);
                   2243:        sc->sc_bar2_tag = 0;
                   2244:        return;
                   2245: }
                   2246:
                   2247: static int
                   2248: wwanc_detach(struct device *self, int flags)
                   2249: {
                   2250:        int error;
                   2251:        struct wwanc_softc *sc = device_private(self);
                   2252:
                   2253:        if (sc->sc_ih) {
                   2254:                pci_intr_disestablish(sc->sc_pc, sc->sc_ih);
                   2255:                sc->sc_ih = NULL;
                   2256:        }
                   2257:
                   2258:        if (sc->sc_net) {
                   2259:                error = config_detach_children(self, flags);
                   2260:                if (error)
                   2261:                        return error;
                   2262:                sc->sc_net = NULL;
                   2263:        }
                   2264:
                   2265:        pmf_device_deregister(self);
                   2266:
                   2267:        xmm7360_dev_deinit(&sc->sc_xmm);
                   2268:
                   2269:        if (sc->sc_bar0_tag) {
                   2270:                bus_space_unmap(sc->sc_bar0_tag, sc->sc_bar0_handle,
                   2271:                    sc->sc_bar0_sz);
                   2272:                sc->sc_bar0_tag = 0;
                   2273:        }
                   2274:        sc->sc_xmm.bar0 = NULL;
                   2275:
                   2276:        if (sc->sc_bar2_tag) {
                   2277:                bus_space_unmap(sc->sc_bar2_tag, sc->sc_bar2_handle,
                   2278:                    sc->sc_bar2_sz);
                   2279:                sc->sc_bar2_tag = 0;
                   2280:        }
                   2281:        sc->sc_xmm.bar2 = NULL;
                   2282:
                   2283:        return 0;
                   2284: }
                   2285:
                   2286: static void
                   2287: wwanc_suspend(struct device *self)
                   2288: {
                   2289:        struct wwanc_softc *sc = device_private(self);
                   2290:        struct xmm_dev *xmm = &sc->sc_xmm;
                   2291:        struct queue_pair *qp;
                   2292:
                   2293:        KASSERT(!sc->sc_resume);
                   2294:        KASSERT(xmm->cp != NULL);
                   2295:
                   2296:        for (int i = 0; i < XMM_QP_COUNT; i++) {
                   2297:                qp = &xmm->qp[i];
                   2298:                if (qp->open)
                   2299:                        xmm7360_qp_suspend(qp);
                   2300:        }
                   2301:
                   2302:        xmm7360_cmd_ring_free(xmm);
                   2303:        KASSERT(xmm->cp == NULL);
                   2304: }
                   2305:
                   2306: static void
                   2307: wwanc_resume(struct device *self)
                   2308: {
                   2309:        struct wwanc_softc *sc = device_private(self);
                   2310:        struct xmm_dev *xmm = &sc->sc_xmm;
                   2311:        struct queue_pair *qp;
                   2312:
                   2313:        KASSERT(xmm->cp == NULL);
                   2314:
                   2315:        xmm7360_base_init(xmm);
                   2316:
                   2317:        for (int i = 0; i < XMM_QP_COUNT; i++) {
                   2318:                qp = &xmm->qp[i];
                   2319:                if (qp->open)
                   2320:                        xmm7360_qp_resume(qp);
                   2321:        }
                   2322: }
                   2323:
                   2324: #ifdef __OpenBSD__
                   2325:
                   2326: static void
                   2327: wwanc_defer_resume(void *xarg)
                   2328: {
                   2329:        struct device *self = xarg;
                   2330:        struct wwanc_softc *sc = device_private(self);
                   2331:
                   2332:        tsleep(&sc->sc_resume, 0, "wwancdr", 2 * hz);
                   2333:
                   2334:        wwanc_resume(self);
                   2335:
                   2336:        (void)config_activate_children(self, DVACT_RESUME);
                   2337:
                   2338:        sc->sc_resume = false;
                   2339:        kthread_exit(0);
                   2340: }
                   2341:
                   2342: static int
                   2343: wwanc_activate(struct device *self, int act)
                   2344: {
                   2345:        struct wwanc_softc *sc = device_private(self);
                   2346:
                   2347:        switch (act) {
                   2348:        case DVACT_QUIESCE:
                   2349:                (void)config_activate_children(self, act);
                   2350:                break;
                   2351:        case DVACT_SUSPEND:
                   2352:                if (sc->sc_resume) {
                   2353:                        /* Refuse to suspend if resume still ongoing */
                   2354:                        printf("%s: not suspending, resume still ongoing\n",
                   2355:                            self->dv_xname);
                   2356:                        return EBUSY;
                   2357:                }
                   2358:
                   2359:                (void)config_activate_children(self, act);
                   2360:                wwanc_suspend(self);
                   2361:                break;
                   2362:        case DVACT_RESUME:
                   2363:                /*
                   2364:                 * Modem reinitialization can take several seconds, defer
                   2365:                 * it via kernel thread to avoid blocking the resume.
                   2366:                 */
                   2367:                sc->sc_resume = true;
                   2368:                kthread_create(wwanc_defer_resume, self, NULL, "wwancres");
                   2369:                break;
                   2370:        default:
                   2371:                break;
                   2372:        }
                   2373:
                   2374:        return 0;
                   2375: }
                   2376:
                   2377: cdev_decl(wwanc);
                   2378: #endif /* __OpenBSD__ */
                   2379:
                   2380: #ifdef __NetBSD__
                   2381: static bool
                   2382: wwanc_pmf_suspend(device_t self, const pmf_qual_t *qual)
                   2383: {
                   2384:        wwanc_suspend(self);
                   2385:        return true;
                   2386: }
                   2387:
                   2388: static bool
                   2389: wwanc_pmf_resume(device_t self, const pmf_qual_t *qual)
                   2390: {
                   2391:        wwanc_resume(self);
                   2392:        return true;
                   2393: }
                   2394:
                   2395: static dev_type_open(wwancopen);
                   2396: static dev_type_close(wwancclose);
                   2397: static dev_type_read(wwancread);
                   2398: static dev_type_write(wwancwrite);
                   2399: static dev_type_ioctl(wwancioctl);
                   2400: static dev_type_poll(wwancpoll);
                   2401: static dev_type_kqfilter(wwanckqfilter);
                   2402: static dev_type_tty(wwanctty);
                   2403:
                   2404: const struct cdevsw wwanc_cdevsw = {
                   2405:        .d_open = wwancopen,
                   2406:        .d_close = wwancclose,
                   2407:        .d_read = wwancread,
                   2408:        .d_write = wwancwrite,
                   2409:        .d_ioctl = wwancioctl,
                   2410:        .d_stop = nullstop,
                   2411:        .d_tty = wwanctty,
                   2412:        .d_poll = wwancpoll,
                   2413:        .d_mmap = nommap,
                   2414:        .d_kqfilter = wwanckqfilter,
                   2415:        .d_discard = nodiscard,
                   2416:        .d_flag = D_TTY
                   2417: };
                   2418: #endif
                   2419:
                   2420: static int wwancparam(struct tty *, struct termios *);
                   2421: static void wwancstart(struct tty *);
                   2422:
                   2423: static void xmm7360_os_handle_tty_idata(struct queue_pair *qp, const u8 *data, size_t nread)
                   2424: {
                   2425:        struct xmm_dev *xmm = qp->xmm;
                   2426:        struct wwanc_softc *sc = device_private(xmm->dev);
                   2427:        int func = qp->num;
                   2428:        struct tty *tp = sc->sc_tty[func];
                   2429:
                   2430:        KASSERT(DEV_IS_TTY(func));
                   2431:        KASSERT(tp);
                   2432:
                   2433:        for (int i = 0; i < nread; i++)
                   2434:                LINESW(tp).l_rint(data[i], tp);
                   2435: }
                   2436:
                   2437: int
                   2438: wwancopen(dev_t dev, int flags, int mode, struct proc *p)
                   2439: {
                   2440:        int unit = DEVUNIT(dev);
                   2441:        struct wwanc_softc *sc = device_lookup_private(&wwanc_cd, unit);
                   2442:        struct tty *tp;
                   2443:        int func, error;
                   2444:
                   2445:        if (sc == NULL)
                   2446:                return ENXIO;
                   2447:
                   2448:        /* Only allow opening the rpc/trace/AT queue pairs */
                   2449:        func = DEVFUNC(dev);
                   2450:        if (func < 1 || func > 7)
                   2451:                return ENXIO;
                   2452:
                   2453:        if (DEV_IS_TTY(dev)) {
                   2454:                if (!sc->sc_tty[func]) {
                   2455:                        tp = sc->sc_tty[func] = ttymalloc(1000000);
                   2456:
                   2457:                        tp->t_oproc = wwancstart;
                   2458:                        tp->t_param = wwancparam;
                   2459:                        tp->t_dev = dev;
                   2460:                        tp->t_sc = (void *)sc;
                   2461:                } else
                   2462:                        tp = sc->sc_tty[func];
                   2463:
                   2464:                if (!ISSET(tp->t_state, TS_ISOPEN)) {
                   2465:                        ttychars(tp);
                   2466:                        tp->t_iflag = TTYDEF_IFLAG;
                   2467:                        tp->t_oflag = TTYDEF_OFLAG;
                   2468:                        tp->t_lflag = TTYDEF_LFLAG;
                   2469:                        tp->t_cflag = TTYDEF_CFLAG;
                   2470:                        tp->t_ispeed = tp->t_ospeed = B115200;
                   2471:                        SET(tp->t_cflag, CS8 | CREAD | HUPCL | CLOCAL);
                   2472:
                   2473:                        SET(tp->t_state, TS_CARR_ON);
                   2474:                } else if (suser(p) != 0) {
                   2475:                        return EBUSY;
                   2476:                }
                   2477:
                   2478:                error = LINESW(tp).l_open(dev, tp, p);
                   2479:                if (error)
                   2480:                        return error;
                   2481:        }
                   2482:
                   2483:        /* Initialize ring if qp not open yet */
                   2484:        xmm7360_qp_start(&sc->sc_xmm.qp[func]);
                   2485:
                   2486:        return 0;
                   2487: }
                   2488:
                   2489: int
                   2490: wwancread(dev_t dev, struct uio *uio, int flag)
                   2491: {
                   2492:        struct wwanc_softc *sc = device_lookup_private(&wwanc_cd, DEVUNIT(dev));
                   2493:        int func = DEVFUNC(dev);
                   2494:
                   2495:        KASSERT(sc != NULL);
                   2496:
                   2497:        if (DEV_IS_TTY(dev)) {
                   2498:                struct tty *tp = sc->sc_tty[func];
                   2499:
                   2500:                return (LINESW(tp).l_read(tp, uio, flag));
                   2501:        } else {
                   2502:                struct queue_pair *qp = &sc->sc_xmm.qp[func];
                   2503:                ssize_t ret;
                   2504:                char *buf;
                   2505:                size_t size, read = 0;
                   2506:
                   2507: #ifdef __OpenBSD__
                   2508:                KASSERT(uio->uio_segflg == UIO_USERSPACE);
                   2509: #endif
                   2510:
                   2511:                for (int i = 0; i < uio->uio_iovcnt; i++) {
                   2512:                        buf = uio->uio_iov[i].iov_base;
                   2513:                        size = uio->uio_iov[i].iov_len;
                   2514:
                   2515:                        while (size > 0) {
                   2516:                                ret = xmm7360_qp_read_user(qp, buf, size);
                   2517:                                if (ret < 0) {
                   2518:                                        /*
                   2519:                                         * This shadows -EPERM, but that is
                   2520:                                         * not returned by the call stack,
                   2521:                                         * so this condition is safe.
                   2522:                                         */
                   2523:                                        return (ret == ERESTART) ? ret : -ret;
                   2524:                                }
                   2525:
                   2526:                                KASSERT(ret > 0 && ret <= size);
                   2527:                                size -= ret;
                   2528:                                buf += ret;
                   2529:                                read += ret;
                   2530:
                   2531:                                /* Reader will re-try if they want more */
                   2532:                                goto out;
                   2533:                        }
                   2534:                }
                   2535:
                   2536: out:
                   2537:                uio->uio_resid -= read;
                   2538:                uio->uio_offset += read;
                   2539:
                   2540:                return 0;
                   2541:        }
                   2542: }
                   2543:
                   2544: int
                   2545: wwancwrite(dev_t dev, struct uio *uio, int flag)
                   2546: {
                   2547:        struct wwanc_softc *sc = device_lookup_private(&wwanc_cd, DEVUNIT(dev));
                   2548:        int func = DEVFUNC(dev);
                   2549:
                   2550:        if (DEV_IS_TTY(dev)) {
                   2551:                struct tty *tp = sc->sc_tty[func];
                   2552:
                   2553:                return (LINESW(tp).l_write(tp, uio, flag));
                   2554:        } else {
                   2555:                struct queue_pair *qp = &sc->sc_xmm.qp[func];
                   2556:                ssize_t ret;
                   2557:                const char *buf;
                   2558:                size_t size, wrote = 0;
                   2559:
                   2560: #ifdef __OpenBSD__
                   2561:                KASSERT(uio->uio_segflg == UIO_USERSPACE);
                   2562: #endif
                   2563:
                   2564:                for (int i = 0; i < uio->uio_iovcnt; i++) {
                   2565:                        buf = uio->uio_iov[i].iov_base;
                   2566:                        size = uio->uio_iov[i].iov_len;
                   2567:
                   2568:                        while (size > 0) {
                   2569:                                ret = xmm7360_qp_write_user(qp, buf, size);
                   2570:                                if (ret < 0) {
                   2571:                                        /*
                   2572:                                         * This shadows -EPERM, but that is
                   2573:                                         * not returned by the call stack,
                   2574:                                         * so this condition is safe.
                   2575:                                         */
                   2576:                                        return (ret == ERESTART) ? ret : -ret;
                   2577:                                }
                   2578:
                   2579:                                KASSERT(ret > 0 && ret <= size);
                   2580:                                size -= ret;
                   2581:                                buf += ret;
                   2582:                                wrote += ret;
                   2583:                        }
                   2584:                }
                   2585:
                   2586:                uio->uio_resid -= wrote;
                   2587:                uio->uio_offset += wrote;
                   2588:
                   2589:                return 0;
                   2590:        }
                   2591: }
                   2592:
                   2593: int
                   2594: wwancioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
                   2595: {
                   2596:        struct wwanc_softc *sc = device_lookup_private(&wwanc_cd, DEVUNIT(dev));
                   2597:        int error;
                   2598:
                   2599:        if (DEV_IS_TTY(dev)) {
                   2600:                struct tty *tp = sc->sc_tty[DEVFUNC(dev)];
                   2601:                KASSERT(tp);
                   2602:
                   2603:                error = LINESW(tp).l_ioctl(tp, cmd, data, flag, p);
                   2604:                if (error >= 0)
                   2605:                        return error;
                   2606:                error = ttioctl(tp, cmd, data, flag, p);
                   2607:                if (error >= 0)
                   2608:                        return error;
                   2609:        }
                   2610:
                   2611:        return ENOTTY;
                   2612: }
                   2613:
                   2614: int
                   2615: wwancclose(dev_t dev, int flag, int mode, struct proc *p)
                   2616: {
                   2617:        struct wwanc_softc *sc = device_lookup_private(&wwanc_cd, DEVUNIT(dev));
                   2618:        int func = DEVFUNC(dev);
                   2619:
                   2620:        if (DEV_IS_TTY(dev)) {
                   2621:                struct tty *tp = sc->sc_tty[func];
                   2622:                KASSERT(tp);
                   2623:
                   2624:                CLR(tp->t_state, TS_BUSY | TS_FLUSH);
                   2625:                LINESW(tp).l_close(tp, flag, p);
                   2626:                ttyclose(tp);
                   2627:        }
                   2628:
                   2629:        xmm7360_qp_stop(&sc->sc_xmm.qp[func]);
                   2630:
                   2631:        return 0;
                   2632: }
                   2633:
                   2634: struct tty *
                   2635: wwanctty(dev_t dev)
                   2636: {
                   2637:        struct wwanc_softc *sc = device_lookup_private(&wwanc_cd, DEVUNIT(dev));
                   2638:        struct tty *tp = sc->sc_tty[DEVFUNC(dev)];
                   2639:
                   2640:        KASSERT(DEV_IS_TTY(dev));
                   2641:        KASSERT(tp);
                   2642:
                   2643:        return tp;
                   2644: }
                   2645:
                   2646: static int
                   2647: wwancparam(struct tty *tp, struct termios *t)
                   2648: {
1.5       jdolecek 2649:        struct wwanc_softc *sc __diagused = (struct wwanc_softc *)tp->t_sc;
1.1       jdolecek 2650:        dev_t dev = tp->t_dev;
1.5       jdolecek 2651:        int func __diagused = DEVFUNC(dev);
1.1       jdolecek 2652:
                   2653:        KASSERT(DEV_IS_TTY(dev));
                   2654:        KASSERT(tp == sc->sc_tty[func]);
                   2655:        /* Can't assert tty_locked(), it's not taken when called via ttioctl()*/
                   2656:
                   2657:        /* Nothing to set on hardware side, just copy values */
                   2658:        tp->t_ispeed = t->c_ispeed;
                   2659:        tp->t_ospeed = t->c_ospeed;
                   2660:        tp->t_cflag = t->c_cflag;
                   2661:
                   2662:        return 0;
                   2663: }
                   2664:
                   2665: static void
                   2666: wwancstart(struct tty *tp)
                   2667: {
                   2668:        struct wwanc_softc *sc = (struct wwanc_softc *)tp->t_sc;
                   2669:        dev_t dev = tp->t_dev;
                   2670:        int func = DEVFUNC(dev);
                   2671:        struct queue_pair *qp = &sc->sc_xmm.qp[func];
                   2672:        int n, written;
                   2673:
                   2674:        KASSERT(DEV_IS_TTY(dev));
                   2675:        KASSERT(tp == sc->sc_tty[func]);
                   2676:        tty_locked();
                   2677:
                   2678:        if (ISSET(tp->t_state, TS_BUSY) || !xmm7360_qp_can_write(qp))
                   2679:                return;
                   2680:        if (tp->t_outq.c_cc == 0)
                   2681:                return;
                   2682:
                   2683:        /*
                   2684:         * If we can write, we can write full qb page_size amount of data.
                   2685:         * Once q_to_b() is called, the data must be trasmitted - q_to_b()
                   2686:         * removes them from the tty output queue. Partial write is not
                   2687:         * possible.
                   2688:         */
                   2689:        KASSERT(sizeof(qp->user_buf) >= qp->page_size);
                   2690:        SET(tp->t_state, TS_BUSY);
                   2691:        n = q_to_b(&tp->t_outq, qp->user_buf, qp->page_size);
                   2692:        KASSERT(n > 0);
                   2693:        KASSERT(n <= qp->page_size);
                   2694:        written = xmm7360_qp_write(qp, qp->user_buf, n);
                   2695:        CLR(tp->t_state, TS_BUSY);
                   2696:
                   2697:        if (written != n) {
                   2698:                dev_err(sc->sc_dev, "xmm7360_qp_write(%d) failed %d != %d\n",
                   2699:                    func, written, n);
                   2700:                /* nothing to recover, just return */
                   2701:        }
                   2702: }
                   2703:
                   2704: int
                   2705: wwancpoll(dev_t dev, int events, struct proc *p)
                   2706: {
                   2707:        struct wwanc_softc *sc = device_lookup_private(&wwanc_cd, DEVUNIT(dev));
                   2708:        int func = DEVFUNC(dev);
                   2709:        struct queue_pair *qp = &sc->sc_xmm.qp[func];
                   2710:        int mask = 0;
                   2711:
                   2712:        if (DEV_IS_TTY(dev)) {
                   2713: #ifdef __OpenBSD__
                   2714:                return ttpoll(dev, events, p);
                   2715: #endif
                   2716: #ifdef __NetBSD__
                   2717:                struct tty *tp = sc->sc_tty[func];
                   2718:
                   2719:                return LINESW(tp).l_poll(tp, events, p);
                   2720: #endif
                   2721:        }
                   2722:
                   2723:        KASSERT(!DEV_IS_TTY(dev));
                   2724:
                   2725:        if (qp->xmm->error) {
                   2726:                mask |= POLLHUP;
                   2727:                goto out;
                   2728:        }
                   2729:
                   2730:        if (xmm7360_qp_has_data(qp))
                   2731:                mask |= POLLIN | POLLRDNORM;
                   2732:
                   2733:        if (xmm7360_qp_can_write(qp))
                   2734:                mask |= POLLOUT | POLLWRNORM;
                   2735:
                   2736: out:
                   2737:        if ((mask & events) == 0) {
                   2738:                if (events & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND))
                   2739:                        selrecord(p, &sc->sc_selr);
                   2740:                 if (events & (POLLOUT | POLLWRNORM))
                   2741:                         selrecord(p, &sc->sc_selw);
                   2742:        }
                   2743:
                   2744:        return mask & events;
                   2745: }
                   2746:
                   2747: static void
                   2748: filt_wwancrdetach(struct knote *kn)
                   2749: {
                   2750:        struct queue_pair *qp = (struct queue_pair *)kn->kn_hook;
                   2751:
                   2752:        tty_lock();
                   2753:        klist_remove(&qp->selr.si_note, kn);
                   2754:        tty_unlock();
                   2755: }
                   2756:
                   2757: static int
                   2758: filt_wwancread(struct knote *kn, long hint)
                   2759: {
                   2760:        struct queue_pair *qp = (struct queue_pair *)kn->kn_hook;
                   2761:
                   2762:        kn->kn_data = 0;
                   2763:
                   2764:        if (!qp->open) {
                   2765:                kn->kn_flags |= EV_EOF;
                   2766:                return (1);
                   2767:        } else {
                   2768:                kn->kn_data = xmm7360_qp_has_data(qp) ? 1 : 0;
                   2769:        }
                   2770:
                   2771:        return (kn->kn_data > 0);
                   2772: }
                   2773:
                   2774: static void
                   2775: filt_wwancwdetach(struct knote *kn)
                   2776: {
                   2777:        struct queue_pair *qp = (struct queue_pair *)kn->kn_hook;
                   2778:
                   2779:        tty_lock();
                   2780:        klist_remove(&qp->selw.si_note, kn);
                   2781:        tty_unlock();
                   2782: }
                   2783:
                   2784: static int
                   2785: filt_wwancwrite(struct knote *kn, long hint)
                   2786: {
                   2787:        struct queue_pair *qp = (struct queue_pair *)kn->kn_hook;
                   2788:
                   2789:        kn->kn_data = 0;
                   2790:
                   2791:        if (qp->open) {
                   2792:                if (xmm7360_qp_can_write(qp))
                   2793:                        kn->kn_data = qp->page_size;
                   2794:        }
                   2795:
                   2796:        return (kn->kn_data > 0);
                   2797: }
                   2798:
                   2799: static const struct filterops wwancread_filtops = {
                   2800:        XMM_KQ_ISFD_INITIALIZER,
                   2801:        .f_attach       = NULL,
                   2802:        .f_detach       = filt_wwancrdetach,
                   2803:        .f_event        = filt_wwancread,
                   2804: };
                   2805:
                   2806: static const struct filterops wwancwrite_filtops = {
                   2807:        XMM_KQ_ISFD_INITIALIZER,
                   2808:        .f_attach       = NULL,
                   2809:        .f_detach       = filt_wwancwdetach,
                   2810:        .f_event        = filt_wwancwrite,
                   2811: };
                   2812:
                   2813: int
                   2814: wwanckqfilter(dev_t dev, struct knote *kn)
                   2815: {
                   2816:        struct wwanc_softc *sc = device_lookup_private(&wwanc_cd, DEVUNIT(dev));
                   2817:        int func = DEVFUNC(dev);
                   2818:        struct queue_pair *qp = &sc->sc_xmm.qp[func];
                   2819:        struct klist *klist;
                   2820:
                   2821:        if (DEV_IS_TTY(func))
                   2822:                return ttkqfilter(dev, kn);
                   2823:
                   2824:        KASSERT(!DEV_IS_TTY(func));
                   2825:
                   2826:        switch (kn->kn_filter) {
                   2827:        case EVFILT_READ:
                   2828:                klist = &qp->selr.si_note;
                   2829:                kn->kn_fop = &wwancread_filtops;
                   2830:                break;
                   2831:        case EVFILT_WRITE:
                   2832:                klist = &qp->selw.si_note;
                   2833:                kn->kn_fop = &wwancwrite_filtops;
                   2834:                break;
                   2835:        default:
                   2836:                return (EINVAL);
                   2837:        }
                   2838:
                   2839:        kn->kn_hook = (void *)qp;
                   2840:
                   2841:        tty_lock();
                   2842:        klist_insert(klist, kn);
                   2843:        tty_unlock();
                   2844:
                   2845:        return (0);
                   2846: }
                   2847:
                   2848: static void *
                   2849: dma_alloc_coherent(struct device *self, size_t sz, dma_addr_t *physp, int flags)
                   2850: {
                   2851:        struct wwanc_softc *sc = device_private(self);
                   2852:        bus_dma_segment_t seg;
                   2853:        int nsegs;
                   2854:        int error;
                   2855:        caddr_t kva;
                   2856:
                   2857:        error = bus_dmamem_alloc(sc->sc_dmat, sz, 0, 0, &seg, 1, &nsegs,
                   2858:            BUS_DMA_WAITOK);
                   2859:        if (error) {
                   2860:                panic("%s: bus_dmamem_alloc(%lu) failed %d\n",
                   2861:                    self->dv_xname, (unsigned long)sz, error);
                   2862:                /* NOTREACHED */
                   2863:        }
                   2864:
                   2865:        KASSERT(nsegs == 1);
                   2866:        KASSERT(seg.ds_len == round_page(sz));
                   2867:
                   2868:        error = bus_dmamem_map(sc->sc_dmat, &seg, nsegs, sz, &kva,
                   2869:            BUS_DMA_WAITOK | BUS_DMA_COHERENT);
                   2870:        if (error) {
                   2871:                panic("%s: bus_dmamem_alloc(%lu) failed %d\n",
                   2872:                    self->dv_xname, (unsigned long)sz, error);
                   2873:                /* NOTREACHED */
                   2874:        }
                   2875:
                   2876:        memset(kva, 0, sz);
                   2877:        *physp = seg.ds_addr;
                   2878:        return (void *)kva;
                   2879: }
                   2880:
                   2881: static void
                   2882: dma_free_coherent(struct device *self, size_t sz, volatile void *vaddr, dma_addr_t phys)
                   2883: {
                   2884:        struct wwanc_softc *sc = device_private(self);
                   2885:        bus_dma_segment_t seg;
                   2886:
                   2887:        sz = round_page(sz);
                   2888:
                   2889:        bus_dmamem_unmap(sc->sc_dmat, __UNVOLATILE(vaddr), sz);
                   2890:
                   2891:        /* this does't need the exact seg returned by bus_dmamem_alloc() */
                   2892:        memset(&seg, 0, sizeof(seg));
                   2893:        seg.ds_addr = phys;
                   2894:        seg.ds_len  = sz;
                   2895:        bus_dmamem_free(sc->sc_dmat, &seg, 1);
                   2896: }
                   2897:
                   2898: struct wwan_softc {
                   2899: #ifdef __OpenBSD__
                   2900:        struct device           sc_devx;        /* gen. device info storage */
                   2901: #endif
                   2902:        struct device           *sc_dev;        /* generic device */
                   2903:        struct wwanc_softc      *sc_parent;     /* parent device */
                   2904:        struct ifnet            sc_ifnet;       /* network-visible interface */
                   2905:        struct xmm_net          sc_xmm_net;
                   2906: };
                   2907:
                   2908: static void xmm7360_os_handle_net_frame(struct xmm_dev *xmm, const u8 *buf, size_t sz)
                   2909: {
                   2910:        struct wwanc_softc *sc = device_private(xmm->dev);
                   2911:        struct wwan_softc *sc_if = device_private(sc->sc_net);
                   2912:        struct ifnet *ifp = &sc_if->sc_ifnet;
                   2913:        struct mbuf *m;
                   2914:
                   2915:        KASSERT(sz <= MCLBYTES);
                   2916:
                   2917:        MGETHDR(m, M_DONTWAIT, MT_DATA);
                   2918:        if (!m)
                   2919:                return;
                   2920:        if (sz > MHLEN) {
                   2921:                MCLGETI(m, M_DONTWAIT, NULL, sz);
                   2922:                if ((m->m_flags & M_EXT) == 0) {
                   2923:                        m_freem(m);
                   2924:                        return;
                   2925:                }
                   2926:        }
                   2927:        m->m_len = m->m_pkthdr.len = sz;
                   2928:
                   2929:        /*
                   2930:         * No explicit alignment necessary - there is no ethernet header,
                   2931:         * so IP address is already aligned.
                   2932:         */
                   2933:        KASSERT(m->m_pkthdr.len == sz);
                   2934:        m_copyback(m, 0, sz, (const void *)buf, M_NOWAIT);
                   2935:
                   2936: #ifdef __OpenBSD__
                   2937:        struct mbuf_list ml = MBUF_LIST_INITIALIZER();
                   2938:        ml_enqueue(&ml, m);
                   2939:        if_input(ifp, &ml);
                   2940: #endif
                   2941: #ifdef __NetBSD__
                   2942:        if_percpuq_enqueue(ifp->if_percpuq, m);
                   2943: #endif
                   2944: }
                   2945:
                   2946: static void
                   2947: xmm7360_os_handle_net_dequeue(struct xmm_net *xn, struct mux_frame *frame)
                   2948: {
                   2949:        struct wwan_softc *sc_if =
                   2950:                container_of(xn, struct wwan_softc, sc_xmm_net);
                   2951:        struct ifnet *ifp = &sc_if->sc_ifnet;
                   2952:        struct mbuf *m;
                   2953:        int ret;
                   2954:
                   2955:        MUTEX_ASSERT_LOCKED(&xn->lock);
                   2956:
                   2957:        while ((m = ifq_deq_begin(&ifp->if_snd))) {
                   2958:                /*
                   2959:                 * xmm7360_mux_frame_append_packet() requires single linear
                   2960:                 * buffer, so try m_defrag(). Another option would be
                   2961:                 * using m_copydata() into an intermediate buffer.
                   2962:                 */
                   2963:                if (m->m_next) {
                   2964:                        if (m_defrag(m, M_DONTWAIT) != 0 || m->m_next) {
                   2965:                                /* Can't defrag, drop and continue */
                   2966:                                ifq_deq_commit(&ifp->if_snd, m);
                   2967:                                m_freem(m);
                   2968:                                continue;
                   2969:                        }
                   2970:                }
                   2971:
                   2972:                ret = xmm7360_mux_frame_append_packet(frame,
                   2973:                    mtod(m, void *), m->m_pkthdr.len);
                   2974:                if (ret) {
                   2975:                        /* No more space in the frame */
                   2976:                        ifq_deq_rollback(&ifp->if_snd, m);
                   2977:                        break;
                   2978:                }
                   2979:                ifq_deq_commit(&ifp->if_snd, m);
                   2980:
                   2981:                /* Send a copy of the frame to the BPF listener */
                   2982:                BPF_MTAP_OUT(ifp, m);
                   2983:
                   2984:                m_freem(m);
                   2985:        }
                   2986: }
                   2987:
                   2988: static void xmm7360_os_handle_net_txwake(struct xmm_net *xn)
                   2989: {
                   2990:        struct wwan_softc *sc_if =
                   2991:                container_of(xn, struct wwan_softc, sc_xmm_net);
                   2992:        struct ifnet *ifp = &sc_if->sc_ifnet;
                   2993:
                   2994:        MUTEX_ASSERT_LOCKED(&xn->lock);
                   2995:
                   2996:        KASSERT(xmm7360_qp_can_write(xn->qp));
                   2997:        if (ifq_is_oactive(&ifp->if_snd)) {
                   2998:                ifq_clr_oactive(&ifp->if_snd);
                   2999: #ifdef __OpenBSD__
                   3000:                ifq_restart(&ifp->if_snd);
                   3001: #endif
                   3002: #ifdef __NetBSD__
                   3003:                if_schedule_deferred_start(ifp);
                   3004: #endif
                   3005:        }
                   3006: }
                   3007:
                   3008: #ifdef __OpenBSD__
                   3009: /*
                   3010:  * Process received raw IPv4/IPv6 packet. There is no encapsulation.
                   3011:  */
                   3012: static int
                   3013: wwan_if_input(struct ifnet *ifp, struct mbuf *m, void *cookie)
                   3014: {
                   3015:        const uint8_t *data = mtod(m, uint8_t *);
                   3016:        void (*input)(struct ifnet *, struct mbuf *);
                   3017:        u8 ip_version;
                   3018:
                   3019:        ip_version = data[0] >> 4;
                   3020:
                   3021:        switch (ip_version) {
                   3022:        case IPVERSION:
                   3023:                input = ipv4_input;
                   3024:                break;
                   3025:        case (IPV6_VERSION >> 4):
                   3026:                input = ipv6_input;
                   3027:                break;
                   3028:        default:
                   3029:                /* Unknown protocol, just drop packet */
                   3030:                m_freem(m);
                   3031:                return 1;
                   3032:                /* NOTREACHED */
                   3033:        }
                   3034:
1.4       jdolecek 3035:        /* Needed for tcpdump(1) et.al */
                   3036:        m->m_pkthdr.ph_rtableid = ifp->if_rdomain;
                   3037:        m_adj(m, sizeof(u_int32_t));
                   3038:
1.1       jdolecek 3039:        (*input)(ifp, m);
                   3040:        return 1;
                   3041: }
                   3042: #endif /* __OpenBSD__ */
                   3043:
                   3044: #ifdef __NetBSD__
                   3045: static bool wwan_pmf_suspend(device_t, const pmf_qual_t *);
                   3046:
                   3047: /*
                   3048:  * Process received raw IPv4/IPv6 packet. There is no encapsulation.
                   3049:  */
                   3050: static void
                   3051: wwan_if_input(struct ifnet *ifp, struct mbuf *m)
                   3052: {
                   3053:        const uint8_t *data = mtod(m, uint8_t *);
                   3054:        pktqueue_t *pktq = NULL;
                   3055:        u8 ip_version;
                   3056:
                   3057:        KASSERT(!cpu_intr_p());
                   3058:        KASSERT((m->m_flags & M_PKTHDR) != 0);
                   3059:
                   3060:        if ((ifp->if_flags & IFF_UP) == 0) {
                   3061:                m_freem(m);
                   3062:                return;
                   3063:        }
                   3064:
                   3065:        if_statadd(ifp, if_ibytes, m->m_pkthdr.len);
                   3066:
                   3067:        /*
1.3       riastrad 3068:         * The interface can't receive packets for other host, so never
1.1       jdolecek 3069:         * really IFF_PROMISC even if bpf listener is attached.
                   3070:         */
                   3071:        if (pfil_run_hooks(ifp->if_pfil, &m, ifp, PFIL_IN) != 0)
                   3072:                return;
                   3073:        if (m == NULL)
                   3074:                return;
                   3075:
                   3076:        ip_version = data[0] >> 4;
                   3077:        switch (ip_version) {
                   3078: #ifdef INET
                   3079:        case IPVERSION:
                   3080: #ifdef GATEWAY
                   3081:                if (ipflow_fastforward(m))
                   3082:                        return;
                   3083: #endif
                   3084:                pktq = ip_pktq;
                   3085:                break;
                   3086: #endif /* INET */
                   3087: #ifdef INET6
                   3088:        case (IPV6_VERSION >> 4):
                   3089:                if (__predict_false(!in6_present)) {
                   3090:                        m_freem(m);
                   3091:                        return;
                   3092:                }
                   3093: #ifdef GATEWAY
                   3094:                if (ip6flow_fastforward(&m))
                   3095:                        return;
                   3096: #endif
                   3097:                pktq = ip6_pktq;
                   3098:                break;
                   3099: #endif /* INET6 */
                   3100:        default:
                   3101:                /* Unknown protocol, just drop packet */
                   3102:                m_freem(m);
                   3103:                return;
                   3104:                /* NOTREACHED */
                   3105:        }
                   3106:
                   3107:        KASSERT(pktq != NULL);
                   3108:
                   3109:        /* No errors.  Receive the packet. */
                   3110:        m_set_rcvif(m, ifp);
                   3111:
                   3112: #ifdef NET_MPSAFE
                   3113:        const u_int h = curcpu()->ci_index;
                   3114: #else
                   3115:        const uint32_t h = pktq_rps_hash(m);
                   3116: #endif
                   3117:        if (__predict_false(!pktq_enqueue(pktq, m, h))) {
                   3118:                m_freem(m);
                   3119:        }
                   3120: }
                   3121: #endif
                   3122:
                   3123: /*
                   3124:  * Transmit raw IPv4/IPv6 packet. No encapsulation necessary.
                   3125:  */
                   3126: static int
                   3127: wwan_if_output(struct ifnet *ifp, struct mbuf *m,
                   3128:     IF_OUTPUT_CONST struct sockaddr *dst, IF_OUTPUT_CONST struct rtentry *rt)
                   3129: {
                   3130:        // there is no ethernet frame, this means no bridge(4) handling
                   3131:        return (if_enqueue(ifp, m));
                   3132: }
                   3133:
                   3134: static int
                   3135: wwan_if_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
                   3136: {
                   3137:        struct wwan_softc *sc_if = ifp->if_softc;
                   3138:        int error = 0;
                   3139:        int s;
                   3140:
                   3141:        s = splnet();
                   3142:
                   3143:        switch (cmd) {
                   3144: #ifdef __NetBSD__
                   3145:        case SIOCINITIFADDR:
                   3146: #endif
                   3147: #ifdef __OpenBSD__
                   3148:        case SIOCAIFADDR:
                   3149:        case SIOCAIFADDR_IN6:
                   3150:        case SIOCSIFADDR:
                   3151: #endif
                   3152:                /* Make interface ready to run if address is assigned */
                   3153:                ifp->if_flags |= IFF_UP;
                   3154:                if (!(ifp->if_flags & IFF_RUNNING)) {
                   3155:                        ifp->if_flags |= IFF_RUNNING;
                   3156:                        xmm7360_mux_control(&sc_if->sc_xmm_net, 1, 0, 0, 0);
                   3157:                }
                   3158:                break;
                   3159:        case SIOCSIFFLAGS:
                   3160:        case SIOCADDMULTI:
                   3161:        case SIOCDELMULTI:
                   3162:                /* nothing special to do */
                   3163:                break;
                   3164:        case SIOCSIFMTU:
                   3165:                error = ENOTTY;
                   3166:                break;
                   3167:        default:
                   3168: #ifdef __NetBSD__
                   3169:                /*
                   3170:                 * Call common code for SIOCG* ioctls. In OpenBSD those ioctls
                   3171:                 * are handled in ifioctl(), and the if_ioctl is not called
                   3172:                 * for them at all.
                   3173:                 */
                   3174:                error = ifioctl_common(ifp, cmd, data);
                   3175:                if (error == ENETRESET)
                   3176:                        error = 0;
                   3177: #endif
                   3178: #ifdef __OpenBSD__
                   3179:                error = ENOTTY;
                   3180: #endif
                   3181:                break;
                   3182:        }
                   3183:
                   3184:        splx(s);
                   3185:
                   3186:        return error;
                   3187: }
                   3188:
                   3189: static void
                   3190: wwan_if_start(struct ifnet *ifp)
                   3191: {
                   3192:        struct wwan_softc *sc = ifp->if_softc;
                   3193:
                   3194:        mutex_lock(&sc->sc_xmm_net.lock);
                   3195:        while (!ifq_empty(&ifp->if_snd)) {
                   3196:                if (!xmm7360_qp_can_write(sc->sc_xmm_net.qp)) {
                   3197:                        break;
                   3198:                }
                   3199:                xmm7360_net_flush(&sc->sc_xmm_net);
                   3200:        }
                   3201:        mutex_unlock(&sc->sc_xmm_net.lock);
                   3202: }
                   3203:
                   3204: static int
                   3205: wwan_match(struct device *parent, cfdata_t match, void *aux)
                   3206: {
                   3207:        struct wwanc_attach_args *wa = aux;
                   3208:
                   3209:        return (wa->aa_type == WWMC_TYPE_NET);
                   3210: }
                   3211:
                   3212: static void
                   3213: wwan_attach(struct device *parent, struct device *self, void *aux)
                   3214: {
                   3215:        struct wwan_softc *sc_if = device_private(self);
                   3216:        struct ifnet *ifp = &sc_if->sc_ifnet;
                   3217:        struct xmm_dev *xmm;
                   3218:        struct xmm_net *xn;
                   3219:
                   3220:        sc_if->sc_dev = self;
                   3221:        sc_if->sc_parent = device_private(parent);
                   3222:        xmm = sc_if->sc_xmm_net.xmm = &sc_if->sc_parent->sc_xmm;
                   3223:        xn = &sc_if->sc_xmm_net;
                   3224:        mutex_init(&xn->lock);
                   3225:
                   3226:        /* QP already initialized in parent, just set pointers and start */
                   3227:        xn->qp = &xmm->qp[0];
                   3228:        xmm7360_qp_start(xn->qp);
                   3229:        xmm->net = xn;
                   3230:
                   3231:        ifp->if_softc = sc_if;
                   3232:        ifp->if_flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST \
                   3233:                | IFF_SIMPLEX;
                   3234:        ifp->if_ioctl = wwan_if_ioctl;
                   3235:        ifp->if_start = wwan_if_start;
                   3236:        ifp->if_mtu = 1500;
                   3237:        ifp->if_hardmtu = 1500;
                   3238:        ifp->if_type = IFT_OTHER;
                   3239:        IFQ_SET_MAXLEN(&ifp->if_snd, xn->qp->depth);
                   3240:        IFQ_SET_READY(&ifp->if_snd);
                   3241:        bcopy(sc_if->sc_dev->dv_xname, ifp->if_xname, IFNAMSIZ);
                   3242:
                   3243:        /* Call MI attach routines. */
                   3244:        if_attach(ifp);
                   3245:
                   3246:        /* Hook custom input and output processing, and dummy sadl */
                   3247:        ifp->if_output = wwan_if_output;
                   3248:        if_ih_insert(ifp, wwan_if_input, NULL);
                   3249:        if_deferred_start_init(ifp, NULL);
                   3250:        if_alloc_sadl(ifp);
                   3251: #if NBPFILTER > 0
1.4       jdolecek 3252: #ifdef __OpenBSD__
                   3253:        bpfattach(&ifp->if_bpf, ifp, DLT_LOOP, sizeof(u_int32_t));
                   3254: #endif
                   3255: #ifdef __NetBSD__
1.1       jdolecek 3256:        bpfattach(&ifp->if_bpf, ifp, DLT_RAW, 0);
                   3257: #endif
1.4       jdolecek 3258: #endif
1.1       jdolecek 3259:
                   3260:        printf("\n");
                   3261:
                   3262: #ifdef __NetBSD__
                   3263:        if (pmf_device_register(self, wwan_pmf_suspend, NULL))
                   3264:                pmf_class_network_register(self, ifp);
                   3265:        else
                   3266:                aprint_error_dev(self, "couldn't establish power handler\n");
                   3267: #endif
                   3268: }
                   3269:
                   3270: static int
                   3271: wwan_detach(struct device *self, int flags)
                   3272: {
                   3273:        struct wwan_softc *sc_if = device_private(self);
                   3274:        struct ifnet *ifp = &sc_if->sc_ifnet;
                   3275:
                   3276:        if (ifp->if_flags & (IFF_UP|IFF_RUNNING))
                   3277:                ifp->if_flags &= ~(IFF_UP|IFF_RUNNING);
                   3278:
                   3279:        pmf_device_deregister(self);
                   3280:
                   3281:        if_ih_remove(ifp, wwan_if_input, NULL);
                   3282:        if_detach(ifp);
                   3283:
                   3284:        xmm7360_qp_stop(sc_if->sc_xmm_net.qp);
                   3285:
                   3286:        sc_if->sc_xmm_net.xmm->net = NULL;
                   3287:
                   3288:        return 0;
                   3289: }
                   3290:
                   3291: static void
                   3292: wwan_suspend(struct device *self)
                   3293: {
                   3294:        struct wwan_softc *sc_if = device_private(self);
                   3295:        struct ifnet *ifp = &sc_if->sc_ifnet;
                   3296:
                   3297:        /*
                   3298:         * Interface is marked down on suspend, and needs to be reconfigured
                   3299:         * after resume.
                   3300:         */
                   3301:        if (ifp->if_flags & (IFF_UP|IFF_RUNNING))
                   3302:                ifp->if_flags &= ~(IFF_UP|IFF_RUNNING);
                   3303:
                   3304:        ifq_purge(&ifp->if_snd);
                   3305: }
                   3306:
                   3307: #ifdef __OpenBSD__
                   3308: static int
                   3309: wwan_activate(struct device *self, int act)
                   3310: {
                   3311:        switch (act) {
                   3312:        case DVACT_QUIESCE:
                   3313:        case DVACT_SUSPEND:
                   3314:                wwan_suspend(self);
                   3315:                break;
                   3316:        case DVACT_RESUME:
                   3317:                /* Nothing to do */
                   3318:                break;
                   3319:        }
                   3320:
                   3321:        return 0;
                   3322: }
                   3323:
                   3324: struct cfattach wwan_ca = {
                   3325:         sizeof(struct wwan_softc), wwan_match, wwan_attach,
                   3326:         wwan_detach, wwan_activate
                   3327: };
                   3328:
                   3329: struct cfdriver wwan_cd = {
                   3330:         NULL, "wwan", DV_IFNET
                   3331: };
                   3332: #endif /* __OpenBSD__ */
                   3333:
                   3334: #ifdef __NetBSD__
                   3335: static bool
                   3336: wwan_pmf_suspend(device_t self, const pmf_qual_t *qual)
                   3337: {
                   3338:        wwan_suspend(self);
                   3339:        return true;
                   3340: }
                   3341:
                   3342: CFATTACH_DECL3_NEW(wwan, sizeof(struct wwan_softc),
                   3343:    wwan_match, wwan_attach, wwan_detach, NULL,
                   3344:    NULL, NULL, DVF_DETACH_SHUTDOWN);
                   3345: #endif /* __NetBSD__ */
                   3346:
                   3347: #endif /* __OpenBSD__ || __NetBSD__ */

CVSweb <webmaster@jp.NetBSD.org>