Merge remote-tracking branch 'origin/master'

[unleashed/lotheac.git] / usr / src / uts / common / io / sundlpi.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 *  Common Sun DLPI routines.
 */

#include <sys/types.h>
#include <sys/sysmacros.h>
#include <sys/byteorder.h>
#include <sys/stream.h>
#include <sys/strsun.h>
#include <sys/dlpi.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunldi.h>
#include <sys/cmn_err.h>

void
dlbindack(
        queue_t         *wq,
        mblk_t          *mp,
        t_scalar_t      sap,
        const void      *addrp,
        t_uscalar_t     addrlen,
        t_uscalar_t     maxconind,
        t_uscalar_t     xidtest)
{
        union DL_primitives     *dlp;
        size_t                  size;

        size = sizeof (dl_bind_ack_t) + addrlen;
        if ((mp = mexchange(wq, mp, size, M_PCPROTO, DL_BIND_ACK)) == NULL)
                return;

        dlp = (union DL_primitives *)mp->b_rptr;
        dlp->bind_ack.dl_sap = sap;
        dlp->bind_ack.dl_addr_length = addrlen;
        dlp->bind_ack.dl_addr_offset = sizeof (dl_bind_ack_t);
        dlp->bind_ack.dl_max_conind = maxconind;
        dlp->bind_ack.dl_xidtest_flg = xidtest;
        if (addrlen != 0)
                bcopy(addrp, mp->b_rptr + sizeof (dl_bind_ack_t), addrlen);
        qreply(wq, mp);
}

void
dlokack(
        queue_t         *wq,
        mblk_t          *mp,
        t_uscalar_t     correct_primitive)
{
        union DL_primitives     *dlp;

        if ((mp = mexchange(wq, mp, sizeof (dl_ok_ack_t), M_PCPROTO,
            DL_OK_ACK)) == NULL)
                return;
        dlp = (union DL_primitives *)mp->b_rptr;
        dlp->ok_ack.dl_correct_primitive = correct_primitive;
        qreply(wq, mp);
}

void
dlerrorack(
        queue_t         *wq,
        mblk_t          *mp,
        t_uscalar_t     error_primitive,
        t_uscalar_t     error,
        t_uscalar_t     unix_errno)
{
        union DL_primitives     *dlp;

        if ((mp = mexchange(wq, mp, sizeof (dl_error_ack_t), M_PCPROTO,
            DL_ERROR_ACK)) == NULL)
                return;
        dlp = (union DL_primitives *)mp->b_rptr;
        dlp->error_ack.dl_error_primitive = error_primitive;
        dlp->error_ack.dl_errno = error;
        dlp->error_ack.dl_unix_errno = unix_errno;
        qreply(wq, mp);
}

void
dluderrorind(
        queue_t         *wq,
        mblk_t          *mp,
        const void      *addrp,
        t_uscalar_t     addrlen,
        t_uscalar_t     error,
        t_uscalar_t     unix_errno)
{
        union DL_primitives     *dlp;
        size_t                  size;

        size = sizeof (dl_uderror_ind_t) + addrlen;
        if ((mp = mexchange(wq, mp, size, M_PCPROTO, DL_UDERROR_IND)) == NULL)
                return;

        dlp = (union DL_primitives *)mp->b_rptr;
        dlp->uderror_ind.dl_dest_addr_length = addrlen;
        dlp->uderror_ind.dl_dest_addr_offset = sizeof (dl_uderror_ind_t);
        dlp->uderror_ind.dl_unix_errno = unix_errno;
        dlp->uderror_ind.dl_errno = error;
        if (addrlen != 0)
                bcopy(addrp, mp->b_rptr + sizeof (dl_uderror_ind_t), addrlen);
        qreply(wq, mp);
}

void
dlphysaddrack(
        queue_t         *wq,
        mblk_t          *mp,
        const void      *addrp,
        t_uscalar_t     len)
{
        union DL_primitives     *dlp;
        size_t                  size;

        size = sizeof (dl_phys_addr_ack_t) + len;
        if ((mp = mexchange(wq, mp, size, M_PCPROTO, DL_PHYS_ADDR_ACK)) == NULL)
                return;
        dlp = (union DL_primitives *)mp->b_rptr;
        dlp->physaddr_ack.dl_addr_length = len;
        dlp->physaddr_ack.dl_addr_offset = sizeof (dl_phys_addr_ack_t);
        if (len != 0)
                bcopy(addrp, mp->b_rptr + sizeof (dl_phys_addr_ack_t), len);
        qreply(wq, mp);
}

void
dlcapabsetqid(dl_mid_t *idp, const queue_t *q)
{
#ifndef _LP64
        idp->mid[0] = (t_uscalar_t)q;
#else
        idp->mid[0] = (t_uscalar_t)BMASK_32((uint64_t)q);
        idp->mid[1] = (t_uscalar_t)BMASK_32(((uint64_t)q) >> 32);
#endif
}

boolean_t
dlcapabcheckqid(const dl_mid_t *idp, const queue_t *q)
{
#ifndef _LP64
        return ((queue_t *)(idp->mid[0]) == q);
#else
        return ((queue_t *)
            ((uint64_t)idp->mid[0] | ((uint64_t)idp->mid[1] << 32)) == q);
#endif
}

void
dlnotifyack(
        queue_t         *wq,
        mblk_t          *mp,
        uint32_t        notifications)
{
        union DL_primitives     *dlp;

        if ((mp = mexchange(wq, mp, sizeof (dl_notify_ack_t), M_PROTO,
            DL_NOTIFY_ACK)) == NULL)
                return;
        dlp = (union DL_primitives *)mp->b_rptr;
        dlp->notify_ack.dl_notifications = notifications;
        qreply(wq, mp);
}

static int
dl_op(ldi_handle_t lh, mblk_t **mpp, t_uscalar_t expprim, size_t minlen,
    dl_error_ack_t *dleap, timestruc_t *tvp)
{
        int             err;
        size_t          len;
        mblk_t          *mp = *mpp;
        t_uscalar_t     reqprim, ackprim, ackreqprim;
        union DL_primitives *dlp;

        reqprim = ((union DL_primitives *)mp->b_rptr)->dl_primitive;

        (void) ldi_putmsg(lh, mp);

        switch (err = ldi_getmsg(lh, &mp, tvp)) {
        case 0:
                break;
        case ETIME:
                cmn_err(CE_NOTE, "!dl_op: timed out waiting for %s to %s",
                    dl_primstr(reqprim), dl_primstr(expprim));
                return (ETIME);
        default:
                cmn_err(CE_NOTE, "!dl_op: ldi_getmsg() for %s failed: %d",
                    dl_primstr(expprim), err);
                return (err);
        }

        len = MBLKL(mp);
        if (len < sizeof (t_uscalar_t)) {
                cmn_err(CE_NOTE, "!dl_op: received runt DLPI message");
                freemsg(mp);
                return (EBADMSG);
        }

        dlp = (union DL_primitives *)mp->b_rptr;
        ackprim = dlp->dl_primitive;

        if (ackprim == expprim) {
                if (len < minlen)
                        goto runt;

                if (ackprim == DL_OK_ACK) {
                        if (dlp->ok_ack.dl_correct_primitive != reqprim) {
                                ackreqprim = dlp->ok_ack.dl_correct_primitive;
                                goto mixup;
                        }
                }
                *mpp = mp;
                return (0);
        }

        if (ackprim == DL_ERROR_ACK) {
                if (len < DL_ERROR_ACK_SIZE)
                        goto runt;

                if (dlp->error_ack.dl_error_primitive != reqprim) {
                        ackreqprim = dlp->error_ack.dl_error_primitive;
                        goto mixup;
                }

                /*
                 * Return a special error code (ENOTSUP) indicating that the
                 * caller has returned DL_ERROR_ACK.  Callers that want more
                 * details an pass a non-NULL dleap.
                 */
                if (dleap != NULL)
                        *dleap = dlp->error_ack;

                freemsg(mp);
                return (ENOTSUP);
        }

        cmn_err(CE_NOTE, "!dl_op: expected %s but received %s",
            dl_primstr(expprim), dl_primstr(ackprim));
        freemsg(mp);
        return (EBADMSG);
runt:
        cmn_err(CE_NOTE, "!dl_op: received runt %s", dl_primstr(ackprim));
        freemsg(mp);
        return (EBADMSG);
mixup:
        cmn_err(CE_NOTE, "!dl_op: received %s for %s instead of %s",
            dl_primstr(ackprim), dl_primstr(ackreqprim), dl_primstr(reqprim));
        freemsg(mp);
        return (EBADMSG);
}

/*
 * Send a DL_ATTACH_REQ for `ppa' over `lh' and wait for the response.
 *
 * Returns an errno; ENOTSUP indicates a DL_ERROR_ACK response (and the
 * caller can get the contents by passing a non-NULL `dleap').
 */
int
dl_attach(ldi_handle_t lh, int ppa, dl_error_ack_t *dleap)
{
        mblk_t  *mp;
        int     err;

        mp = mexchange(NULL, NULL, DL_ATTACH_REQ_SIZE, M_PROTO, DL_ATTACH_REQ);
        if (mp == NULL)
                return (ENOMEM);

        ((dl_attach_req_t *)mp->b_rptr)->dl_ppa = ppa;

        err = dl_op(lh, &mp, DL_OK_ACK, DL_OK_ACK_SIZE, dleap, NULL);
        if (err == 0)
                freemsg(mp);
        return (err);
}

/*
 * Send a DL_BIND_REQ for `sap' over `lh' and wait for the response.
 *
 * Returns an errno; ENOTSUP indicates a DL_ERROR_ACK response (and the
 * caller can get the contents by passing a non-NULL `dleap').
 */
int
dl_bind(ldi_handle_t lh, uint_t sap, dl_error_ack_t *dleap)
{
        dl_bind_req_t   *dlbrp;
        dl_bind_ack_t   *dlbap;
        mblk_t          *mp;
        int             err;

        mp = mexchange(NULL, NULL, DL_BIND_REQ_SIZE, M_PROTO, DL_BIND_REQ);
        if (mp == NULL)
                return (ENOMEM);

        dlbrp = (dl_bind_req_t *)mp->b_rptr;
        dlbrp->dl_sap = sap;
        dlbrp->dl_conn_mgmt = 0;
        dlbrp->dl_max_conind = 0;
        dlbrp->dl_xidtest_flg = 0;
        dlbrp->dl_service_mode = DL_CLDLS;

        err = dl_op(lh, &mp, DL_BIND_ACK, DL_BIND_ACK_SIZE, dleap, NULL);
        if (err == 0) {
                dlbap = (dl_bind_ack_t *)mp->b_rptr;
                if (dlbap->dl_sap != sap) {
                        cmn_err(CE_NOTE, "!dl_bind: DL_BIND_ACK: bad sap %u",
                            dlbap->dl_sap);
                        err = EPROTO;
                }
                freemsg(mp);
        }
        return (err);
}

/*
 * Send a DL_PHYS_ADDR_REQ over `lh' and wait for the response.  The caller
 * must set `*physlenp' to the size of `physaddr' (both of which must be
 * non-NULL); upon success they will be updated to contain the actual physical
 * address and length.
 *
 * Returns an errno; ENOTSUP indicates a DL_ERROR_ACK response (and the
 * caller can get the contents by passing a non-NULL `dleap').
 */
int
dl_phys_addr(ldi_handle_t lh, uchar_t *physaddr, size_t *physlenp,
    dl_error_ack_t *dleap)
{
        dl_phys_addr_ack_t *dlpap;
        mblk_t          *mp;
        int             err;
        t_uscalar_t     paddrlen, paddroff;
        timestruc_t     tv;

        mp = mexchange(NULL, NULL, DL_PHYS_ADDR_REQ_SIZE, M_PROTO,
            DL_PHYS_ADDR_REQ);
        if (mp == NULL)
                return (ENOMEM);

        ((dl_phys_addr_req_t *)mp->b_rptr)->dl_addr_type = DL_CURR_PHYS_ADDR;

        /*
         * In case some provider doesn't implement or NAK the
         * request, just wait for 15 seconds.
         */
        tv.tv_sec = 15;
        tv.tv_nsec = 0;

        err = dl_op(lh, &mp, DL_PHYS_ADDR_ACK, DL_PHYS_ADDR_ACK_SIZE, dleap,
            &tv);
        if (err == 0) {
                dlpap = (dl_phys_addr_ack_t *)mp->b_rptr;
                paddrlen = dlpap->dl_addr_length;
                paddroff = dlpap->dl_addr_offset;
                if (paddroff == 0 || paddrlen == 0 || paddrlen > *physlenp ||
                    !MBLKIN(mp, paddroff, paddrlen)) {
                        cmn_err(CE_NOTE, "!dl_phys_addr: DL_PHYS_ADDR_ACK: "
                            "bad length/offset %d/%d", paddrlen, paddroff);
                        err = EBADMSG;
                } else {
                        bcopy(mp->b_rptr + paddroff, physaddr, paddrlen);
                        *physlenp = paddrlen;
                }
                freemsg(mp);
        }
        return (err);
}

/*
 * Send a DL_INFO_REQ over `lh' and wait for the response.  The caller must
 * pass a non-NULL `dliap', which upon success will contain the dl_info_ack_t
 * from the provider.  The caller may optionally get the provider's physical
 * address by passing a non-NULL `physaddr' and setting `*physlenp' to its
 * size; upon success they will be updated to contain the actual physical
 * address and its length.
 *
 * Returns an errno; ENOTSUP indicates a DL_ERROR_ACK response (and the
 * caller can get the contents by passing a non-NULL `dleap').
 */
int
dl_info(ldi_handle_t lh, dl_info_ack_t *dliap, uchar_t *physaddr,
    size_t *physlenp, dl_error_ack_t *dleap)
{
        mblk_t  *mp;
        int     err;
        int     addrlen, addroff;

        mp = mexchange(NULL, NULL, DL_INFO_REQ_SIZE, M_PCPROTO, DL_INFO_REQ);
        if (mp == NULL)
                return (ENOMEM);

        err = dl_op(lh, &mp, DL_INFO_ACK, DL_INFO_ACK_SIZE, dleap, NULL);
        if (err != 0)
                return (err);

        *dliap = *(dl_info_ack_t *)mp->b_rptr;
        if (physaddr != NULL) {
                addrlen = dliap->dl_addr_length - ABS(dliap->dl_sap_length);
                addroff = dliap->dl_addr_offset;
                if (addroff == 0 || addrlen <= 0 || addrlen > *physlenp ||
                    !MBLKIN(mp, addroff, dliap->dl_addr_length)) {
                        cmn_err(CE_NOTE, "!dl_info: DL_INFO_ACK: "
                            "bad length/offset %d/%d", addrlen, addroff);
                        freemsg(mp);
                        return (EBADMSG);
                }

                if (dliap->dl_sap_length > 0)
                        addroff += dliap->dl_sap_length;
                bcopy(mp->b_rptr + addroff, physaddr, addrlen);
                *physlenp = addrlen;
        }
        freemsg(mp);
        return (err);
}

/*
 * Send a DL_NOTIFY_REQ over `lh' and wait for the response.  The caller
 * should set `notesp' to the set of notifications they wish to enable;
 * upon success it will contain the notifications enabled by the provider.
 *
 * Returns an errno; ENOTSUP indicates a DL_ERROR_ACK response (and the
 * caller can get the contents by passing a non-NULL `dleap').
 */
int
dl_notify(ldi_handle_t lh, uint32_t *notesp, dl_error_ack_t *dleap)
{
        mblk_t  *mp;
        int     err;

        mp = mexchange(NULL, NULL, DL_NOTIFY_REQ_SIZE, M_PROTO, DL_NOTIFY_REQ);
        if (mp == NULL)
                return (ENOMEM);

        ((dl_notify_req_t *)mp->b_rptr)->dl_notifications = *notesp;

        err = dl_op(lh, &mp, DL_NOTIFY_ACK, DL_NOTIFY_ACK_SIZE, dleap, NULL);
        if (err == 0) {
                *notesp = ((dl_notify_ack_t *)mp->b_rptr)->dl_notifications;
                freemsg(mp);
        }
        return (err);
}

const char *
dl_primstr(t_uscalar_t prim)
{
        switch (prim) {
        case DL_INFO_REQ:               return ("DL_INFO_REQ");
        case DL_INFO_ACK:               return ("DL_INFO_ACK");
        case DL_ATTACH_REQ:             return ("DL_ATTACH_REQ");
        case DL_DETACH_REQ:             return ("DL_DETACH_REQ");
        case DL_BIND_REQ:               return ("DL_BIND_REQ");
        case DL_BIND_ACK:               return ("DL_BIND_ACK");
        case DL_UNBIND_REQ:             return ("DL_UNBIND_REQ");
        case DL_OK_ACK:                 return ("DL_OK_ACK");
        case DL_ERROR_ACK:              return ("DL_ERROR_ACK");
        case DL_ENABMULTI_REQ:          return ("DL_ENABMULTI_REQ");
        case DL_DISABMULTI_REQ:         return ("DL_DISABMULTI_REQ");
        case DL_PROMISCON_REQ:          return ("DL_PROMISCON_REQ");
        case DL_PROMISCOFF_REQ:         return ("DL_PROMISCOFF_REQ");
        case DL_UNITDATA_REQ:           return ("DL_UNITDATA_REQ");
        case DL_UNITDATA_IND:           return ("DL_UNITDATA_IND");
        case DL_UDERROR_IND:            return ("DL_UDERROR_IND");
        case DL_PHYS_ADDR_REQ:          return ("DL_PHYS_ADDR_REQ");
        case DL_PHYS_ADDR_ACK:          return ("DL_PHYS_ADDR_ACK");
        case DL_SET_PHYS_ADDR_REQ:      return ("DL_SET_PHYS_ADDR_REQ");
        case DL_NOTIFY_REQ:             return ("DL_NOTIFY_REQ");
        case DL_NOTIFY_ACK:             return ("DL_NOTIFY_ACK");
        case DL_NOTIFY_IND:             return ("DL_NOTIFY_IND");
        case DL_NOTIFY_CONF:            return ("DL_NOTIFY_CONF");
        case DL_CAPABILITY_REQ:         return ("DL_CAPABILITY_REQ");
        case DL_CAPABILITY_ACK:         return ("DL_CAPABILITY_ACK");
        case DL_CONTROL_REQ:            return ("DL_CONTROL_REQ");
        case DL_CONTROL_ACK:            return ("DL_CONTROL_ACK");
        case DL_PASSIVE_REQ:            return ("DL_PASSIVE_REQ");
        case DL_INTR_MODE_REQ:          return ("DL_INTR_MODE_REQ");
        case DL_UDQOS_REQ:              return ("DL_UDQOS_REQ");
        default:                        return ("<unknown primitive>");
        }
}

const char *
dl_errstr(t_uscalar_t err)
{
        switch (err) {
        case DL_ACCESS:                 return ("DL_ACCESS");
        case DL_BADADDR:                return ("DL_BADADDR");
        case DL_BADCORR:                return ("DL_BADCORR");
        case DL_BADDATA:                return ("DL_BADDATA");
        case DL_BADPPA:                 return ("DL_BADPPA");
        case DL_BADPRIM:                return ("DL_BADPRIM");
        case DL_BADQOSPARAM:            return ("DL_BADQOSPARAM");
        case DL_BADQOSTYPE:             return ("DL_BADQOSTYPE");
        case DL_BADSAP:                 return ("DL_BADSAP");
        case DL_BADTOKEN:               return ("DL_BADTOKEN");
        case DL_BOUND:                  return ("DL_BOUND");
        case DL_INITFAILED:             return ("DL_INITFAILED");
        case DL_NOADDR:                 return ("DL_NOADDR");
        case DL_NOTINIT:                return ("DL_NOTINIT");
        case DL_OUTSTATE:               return ("DL_OUTSTATE");
        case DL_SYSERR:                 return ("DL_SYSERR");
        case DL_UNSUPPORTED:            return ("DL_UNSUPPORTED");
        case DL_UNDELIVERABLE:          return ("DL_UNDELIVERABLE");
        case DL_NOTSUPPORTED:           return ("DL_NOTSUPPORTED ");
        case DL_TOOMANY:                return ("DL_TOOMANY");
        case DL_NOTENAB:                return ("DL_NOTENAB");
        case DL_BUSY:                   return ("DL_BUSY");
        case DL_NOAUTO:                 return ("DL_NOAUTO");
        case DL_NOXIDAUTO:              return ("DL_NOXIDAUTO");
        case DL_NOTESTAUTO:             return ("DL_NOTESTAUTO");
        case DL_XIDAUTO:                return ("DL_XIDAUTO");
        case DL_TESTAUTO:               return ("DL_TESTAUTO");
        case DL_PENDING:                return ("DL_PENDING");
        default:                        return ("<unknown error>");
        }
}

const char *
dl_mactypestr(t_uscalar_t mactype)
{
        switch (mactype) {
        case DL_CSMACD:         return ("CSMA/CD");
        case DL_TPB:            return ("Token Bus");
        case DL_TPR:            return ("Token Ring");
        case DL_METRO:          return ("Metro Net");
        case DL_ETHER:          return ("Ethernet");
        case DL_HDLC:           return ("HDLC");
        case DL_CHAR:           return ("Sync Character");
        case DL_CTCA:           return ("CTCA");
        case DL_FDDI:           return ("FDDI");
        case DL_FRAME:          return ("Frame Relay (LAPF)");
        case DL_MPFRAME:        return ("MP Frame Relay");
        case DL_ASYNC:          return ("Async Character");
        case DL_IPX25:          return ("X.25 (Classic IP)");
        case DL_LOOP:           return ("Software Loopback");
        case DL_FC:             return ("Fiber Channel");
        case DL_ATM:            return ("ATM");
        case DL_IPATM:          return ("ATM (Classic IP)");
        case DL_X25:            return ("X.25 (LAPB)");
        case DL_ISDN:           return ("ISDN");
        case DL_HIPPI:          return ("HIPPI");
        case DL_100VG:          return ("100BaseVG Ethernet");
        case DL_100VGTPR:       return ("100BaseVG Token Ring");
        case DL_ETH_CSMA:       return ("Ethernet/IEEE 802.3");
        case DL_100BT:          return ("100BaseT");
        case DL_IB:             return ("Infiniband");
        case DL_IPV4:           return ("IPv4 Tunnel");
        case DL_IPV6:           return ("IPv6 Tunnel");
        case DL_WIFI:           return ("IEEE 802.11");
        case DL_IPNET:          return ("IPNET");
        default:                return ("<unknown mactype>");
        }
}