/*      $NetBSD: if_umbreg.h,v 1.2 2020/03/21 06:54:32 skrll Exp $ */
/*      $OpenBSD: if_umb.h,v 1.4 2017/04/18 13:27:55 gerhard Exp $ */

/*
* Copyright (c) 2016 genua mbH
* All rights reserved.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

/*
* Mobile Broadband Interface Model
* http://www.usb.org/developers/docs/devclass_docs/MBIM-Compliance-1.0.pdf
*/
#ifndef _IF_UMBREG_H_
#define _IF_UMBREG_H_

struct umb_valdescr {
       int              val;
       char const      *descr;
};

static const char *
umb_val2descr(const struct umb_valdescr *vdp, int val)
{
       static char sval[32];

       while (vdp->descr != NULL) {
               if (vdp->val == val)
                       return vdp->descr;
               vdp++;
       }
       snprintf(sval, sizeof(sval), "#%d", val);
       return sval;
}

#define MBIM_REGSTATE_DESCRIPTIONS {                            \
       { MBIM_REGSTATE_UNKNOWN,        "unknown" },            \
       { MBIM_REGSTATE_DEREGISTERED,   "not registered" },     \
       { MBIM_REGSTATE_SEARCHING,      "searching" },          \
       { MBIM_REGSTATE_HOME,           "home network" },       \
       { MBIM_REGSTATE_ROAMING,        "roaming network" },    \
       { MBIM_REGSTATE_PARTNER,        "partner network" },    \
       { MBIM_REGSTATE_DENIED,         "access denied" },      \
       { 0, NULL } }

#define MBIM_DATACLASS_DESCRIPTIONS {                                   \
       { MBIM_DATACLASS_NONE,                          "none" },       \
       { MBIM_DATACLASS_GPRS,                          "GPRS" },       \
       { MBIM_DATACLASS_EDGE,                          "EDGE" },       \
       { MBIM_DATACLASS_UMTS,                          "UMTS" },       \
       { MBIM_DATACLASS_HSDPA,                         "HSDPA" },      \
       { MBIM_DATACLASS_HSUPA,                         "HSUPA" },      \
       { MBIM_DATACLASS_HSDPA|MBIM_DATACLASS_HSUPA,    "HSPA" },       \
       { MBIM_DATACLASS_LTE,                           "LTE" },        \
       { MBIM_DATACLASS_1XRTT,                         "CDMA2000" },   \
       { MBIM_DATACLASS_1XEVDO,                        "CDMA2000" },   \
       { MBIM_DATACLASS_1XEVDO_REV_A,                  "CDMA2000" },   \
       { MBIM_DATACLASS_1XEVDV,                        "CDMA2000" },   \
       { MBIM_DATACLASS_3XRTT,                         "CDMA2000" },   \
       { MBIM_DATACLASS_1XEVDO_REV_B,                  "CDMA2000" },   \
       { MBIM_DATACLASS_UMB,                           "CDMA2000" },   \
       { MBIM_DATACLASS_CUSTOM,                        "custom" },     \
       { 0, NULL } }

#define MBIM_1TO1_DESCRIPTION(m)        { (m), #m }
#define MBIM_MESSAGES_DESCRIPTIONS {                            \
       MBIM_1TO1_DESCRIPTION(MBIM_OPEN_MSG),                   \
       MBIM_1TO1_DESCRIPTION(MBIM_CLOSE_MSG),                  \
       MBIM_1TO1_DESCRIPTION(MBIM_COMMAND_MSG),                \
       MBIM_1TO1_DESCRIPTION(MBIM_HOST_ERROR_MSG),             \
       MBIM_1TO1_DESCRIPTION(MBIM_OPEN_DONE),                  \
       MBIM_1TO1_DESCRIPTION(MBIM_CLOSE_DONE),                 \
       MBIM_1TO1_DESCRIPTION(MBIM_COMMAND_DONE),               \
       MBIM_1TO1_DESCRIPTION(MBIM_FUNCTION_ERROR_MSG),         \
       MBIM_1TO1_DESCRIPTION(MBIM_INDICATE_STATUS_MSG),        \
       { 0, NULL } }

#define MBIM_STATUS_DESCRIPTION(m)      { MBIM_STATUS_ ## m, #m }
#define MBIM_STATUS_DESCRIPTIONS {                                      \
       MBIM_STATUS_DESCRIPTION(SUCCESS),                               \
       MBIM_STATUS_DESCRIPTION(BUSY),                                  \
       MBIM_STATUS_DESCRIPTION(FAILURE),                               \
       MBIM_STATUS_DESCRIPTION(SIM_NOT_INSERTED),                      \
       MBIM_STATUS_DESCRIPTION(BAD_SIM),                               \
       MBIM_STATUS_DESCRIPTION(PIN_REQUIRED),                          \
       MBIM_STATUS_DESCRIPTION(PIN_DISABLED),                          \
       MBIM_STATUS_DESCRIPTION(NOT_REGISTERED),                        \
       MBIM_STATUS_DESCRIPTION(PROVIDERS_NOT_FOUND),                   \
       MBIM_STATUS_DESCRIPTION(NO_DEVICE_SUPPORT),                     \
       MBIM_STATUS_DESCRIPTION(PROVIDER_NOT_VISIBLE),                  \
       MBIM_STATUS_DESCRIPTION(DATA_CLASS_NOT_AVAILABLE),              \
       MBIM_STATUS_DESCRIPTION(PACKET_SERVICE_DETACHED),               \
       MBIM_STATUS_DESCRIPTION(MAX_ACTIVATED_CONTEXTS),                \
       MBIM_STATUS_DESCRIPTION(NOT_INITIALIZED),                       \
       MBIM_STATUS_DESCRIPTION(VOICE_CALL_IN_PROGRESS),                \
       MBIM_STATUS_DESCRIPTION(CONTEXT_NOT_ACTIVATED),                 \
       MBIM_STATUS_DESCRIPTION(SERVICE_NOT_ACTIVATED),                 \
       MBIM_STATUS_DESCRIPTION(INVALID_ACCESS_STRING),                 \
       MBIM_STATUS_DESCRIPTION(INVALID_USER_NAME_PWD),                 \
       MBIM_STATUS_DESCRIPTION(RADIO_POWER_OFF),                       \
       MBIM_STATUS_DESCRIPTION(INVALID_PARAMETERS),                    \
       MBIM_STATUS_DESCRIPTION(READ_FAILURE),                          \
       MBIM_STATUS_DESCRIPTION(WRITE_FAILURE),                         \
       MBIM_STATUS_DESCRIPTION(NO_PHONEBOOK),                          \
       MBIM_STATUS_DESCRIPTION(PARAMETER_TOO_LONG),                    \
       MBIM_STATUS_DESCRIPTION(STK_BUSY),                              \
       MBIM_STATUS_DESCRIPTION(OPERATION_NOT_ALLOWED),                 \
       MBIM_STATUS_DESCRIPTION(MEMORY_FAILURE),                        \
       MBIM_STATUS_DESCRIPTION(INVALID_MEMORY_INDEX),                  \
       MBIM_STATUS_DESCRIPTION(MEMORY_FULL),                           \
       MBIM_STATUS_DESCRIPTION(FILTER_NOT_SUPPORTED),                  \
       MBIM_STATUS_DESCRIPTION(DSS_INSTANCE_LIMIT),                    \
       MBIM_STATUS_DESCRIPTION(INVALID_DEVICE_SERVICE_OPERATION),      \
       MBIM_STATUS_DESCRIPTION(AUTH_INCORRECT_AUTN),                   \
       MBIM_STATUS_DESCRIPTION(AUTH_SYNC_FAILURE),                     \
       MBIM_STATUS_DESCRIPTION(AUTH_AMF_NOT_SET),                      \
       MBIM_STATUS_DESCRIPTION(CONTEXT_NOT_SUPPORTED),                 \
       MBIM_STATUS_DESCRIPTION(SMS_UNKNOWN_SMSC_ADDRESS),              \
       MBIM_STATUS_DESCRIPTION(SMS_NETWORK_TIMEOUT),                   \
       MBIM_STATUS_DESCRIPTION(SMS_LANG_NOT_SUPPORTED),                \
       MBIM_STATUS_DESCRIPTION(SMS_ENCODING_NOT_SUPPORTED),            \
       MBIM_STATUS_DESCRIPTION(SMS_FORMAT_NOT_SUPPORTED),              \
       { 0, NULL } }

#define MBIM_ERROR_DESCRIPTION(m)       { MBIM_ERROR_ ## m, #m }
#define MBIM_ERROR_DESCRIPTIONS {                                       \
       MBIM_ERROR_DESCRIPTION(TIMEOUT_FRAGMENT),                       \
       MBIM_ERROR_DESCRIPTION(FRAGMENT_OUT_OF_SEQUENCE),               \
       MBIM_ERROR_DESCRIPTION(LENGTH_MISMATCH),                        \
       MBIM_ERROR_DESCRIPTION(DUPLICATED_TID),                         \
       MBIM_ERROR_DESCRIPTION(NOT_OPENED),                             \
       MBIM_ERROR_DESCRIPTION(UNKNOWN),                                \
       MBIM_ERROR_DESCRIPTION(CANCEL),                                 \
       MBIM_ERROR_DESCRIPTION(MAX_TRANSFER),                           \
       { 0, NULL } }

#define MBIM_CID_DESCRIPTIONS {                                         \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_DEVICE_CAPS),                    \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_SUBSCRIBER_READY_STATUS),        \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_RADIO_STATE),                    \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_PIN),                            \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_PIN_LIST),                       \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_HOME_PROVIDER),                  \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_PREFERRED_PROVIDERS),            \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_VISIBLE_PROVIDERS),              \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_REGISTER_STATE),                 \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_PACKET_SERVICE),                 \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_SIGNAL_STATE),                   \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_CONNECT),                        \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_PROVISIONED_CONTEXTS),           \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_SERVICE_ACTIVATION),             \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_IP_CONFIGURATION),               \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_DEVICE_SERVICES),                \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_DEVICE_SERVICE_SUBSCRIBE_LIST),  \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_PACKET_STATISTICS),              \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_NETWORK_IDLE_HINT),              \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_EMERGENCY_MODE),                 \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_IP_PACKET_FILTERS),              \
       MBIM_1TO1_DESCRIPTION(MBIM_CID_MULTICARRIER_PROVIDERS),         \
       { 0, NULL } }

#define MBIM_SIMSTATE_DESCRIPTIONS {                                    \
       { MBIM_SIMSTATE_NOTINITIALIZED, "not initialized" },            \
       { MBIM_SIMSTATE_INITIALIZED, "initialized" },                   \
       { MBIM_SIMSTATE_NOTINSERTED, "not inserted" },                  \
       { MBIM_SIMSTATE_BADSIM, "bad type" },                           \
       { MBIM_SIMSTATE_FAILURE, "failed" },                            \
       { MBIM_SIMSTATE_NOTACTIVATED, "not activated" },                \
       { MBIM_SIMSTATE_LOCKED, "locked" },                             \
       { 0, NULL } }

#define MBIM_PINTYPE_DESCRIPTIONS {                                     \
       { MBIM_PIN_TYPE_NONE, "none" },                                 \
       { MBIM_PIN_TYPE_CUSTOM, "custom" },                             \
       { MBIM_PIN_TYPE_PIN1, "PIN1" },                                 \
       { MBIM_PIN_TYPE_PIN2, "PIN2" },                                 \
       { MBIM_PIN_TYPE_DEV_SIM_PIN, "device PIN" },                    \
       { MBIM_PIN_TYPE_DEV_FIRST_SIM_PIN, "device 1st PIN" },          \
       { MBIM_PIN_TYPE_NETWORK_PIN, "network PIN" },                   \
       { MBIM_PIN_TYPE_NETWORK_SUBSET_PIN, "network subset PIN" },     \
       { MBIM_PIN_TYPE_SERVICE_PROVIDER_PIN, "provider PIN" },         \
       { MBIM_PIN_TYPE_CORPORATE_PIN, "corporate PIN" },               \
       { MBIM_PIN_TYPE_SUBSIDY_LOCK, "subsidy lock" },                 \
       { MBIM_PIN_TYPE_PUK1, "PUK" },                                  \
       { MBIM_PIN_TYPE_PUK2, "PUK2" },                                 \
       { MBIM_PIN_TYPE_DEV_FIRST_SIM_PUK, "device 1st PUK" },          \
       { MBIM_PIN_TYPE_NETWORK_PUK, "network PUK" },                   \
       { MBIM_PIN_TYPE_NETWORK_SUBSET_PUK, "network subset PUK" },     \
       { MBIM_PIN_TYPE_SERVICE_PROVIDER_PUK, "provider PUK" },         \
       { MBIM_PIN_TYPE_CORPORATE_PUK, "corporate PUK" },               \
       { 0, NULL } }

#define MBIM_PKTSRV_STATE_DESCRIPTIONS {                                \
       { MBIM_PKTSERVICE_STATE_UNKNOWN, "unknown" },                   \
       { MBIM_PKTSERVICE_STATE_ATTACHING, "attaching" },               \
       { MBIM_PKTSERVICE_STATE_ATTACHED, "attached" },                 \
       { MBIM_PKTSERVICE_STATE_DETACHING, "detaching" },               \
       { MBIM_PKTSERVICE_STATE_DETACHED, "detached" },                 \
       { 0, NULL } }

#define MBIM_ACTIVATION_STATE_DESCRIPTIONS {                            \
       { MBIM_ACTIVATION_STATE_UNKNOWN, "unknown" },                   \
       { MBIM_ACTIVATION_STATE_ACTIVATED, "activated" },               \
       { MBIM_ACTIVATION_STATE_ACTIVATING, "activating" },             \
       { MBIM_ACTIVATION_STATE_DEACTIVATED, "deactivated" },           \
       { MBIM_ACTIVATION_STATE_DEACTIVATING, "deactivating" },         \
       { 0, NULL } }

/*
* Driver internal state
*/
enum umb_state {
       UMB_S_DOWN = 0,         /* interface down */
       UMB_S_OPEN,             /* MBIM device has been opened */
       UMB_S_CID,              /* QMI client id allocated */
       UMB_S_RADIO,            /* radio is on */
       UMB_S_SIMREADY,         /* SIM is ready */
       UMB_S_ATTACHED,         /* packet service is attached */
       UMB_S_CONNECTED,        /* connected to provider */
       UMB_S_UP,               /* have IP configuration */
};

#define UMB_INTERNAL_STATE_DESCRIPTIONS {       \
       { UMB_S_DOWN, "down" },                 \
       { UMB_S_OPEN, "open" },                 \
       { UMB_S_CID, "CID allocated" },         \
       { UMB_S_RADIO, "radio on" },            \
       { UMB_S_SIMREADY, "SIM is ready" },     \
       { UMB_S_ATTACHED, "attached" },         \
       { UMB_S_CONNECTED, "connected" },       \
       { UMB_S_UP, "up" },                     \
       { 0, NULL } }

/*
* UMB parameters (SIOC[GS]UMBPARAM ioctls)
*/
struct umb_parameter {
       int                     op;
       int                     is_puk;
       uint16_t                pin[MBIM_PIN_MAXLEN];
       int                     pinlen;

       char                    newpin[MBIM_PIN_MAXLEN];
       int                     newpinlen;

#define UMB_APN_MAXLEN          100
       uint16_t                apn[UMB_APN_MAXLEN];
       int                     apnlen;

#define UMB_USERNAME_MAXLEN     205
       uint16_t                username[UMB_USERNAME_MAXLEN];
       int                     usernamelen;

#define UMB_PASSWORD_MAXLEN     205
       uint16_t                password[UMB_PASSWORD_MAXLEN];
       int                     passwordlen;

       int                     roaming;
       uint32_t                preferredclasses;
};

/*
* UMB device status info (SIOCGUMBINFO ioctl)
*/
struct umb_info {
       enum umb_state          state;
       int                     enable_roaming;
#define UMB_PIN_REQUIRED        0
#define UMB_PIN_UNLOCKED        1
#define UMB_PUK_REQUIRED        2
       int                     pin_state;
       int                     pin_attempts_left;
       int                     activation;
       int                     sim_state;
       int                     regstate;
       int                     regmode;
       int                     nwerror;
       int                     packetstate;
       uint32_t                supportedclasses; /* what the hw supports */
       uint32_t                preferredclasses; /* what the user prefers */
       uint32_t                highestclass;   /* what the network offers */
       uint32_t                cellclass;
#define UMB_PROVIDERNAME_MAXLEN         20
       uint16_t                provider[UMB_PROVIDERNAME_MAXLEN];
#define UMB_PHONENR_MAXLEN              22
       uint16_t                pn[UMB_PHONENR_MAXLEN];
#define UMB_SUBSCRIBERID_MAXLEN         15
       uint16_t                sid[UMB_SUBSCRIBERID_MAXLEN];
#define UMB_ICCID_MAXLEN                20
       uint16_t                iccid[UMB_ICCID_MAXLEN];
#define UMB_ROAMINGTEXT_MAXLEN          63
       uint16_t                roamingtxt[UMB_ROAMINGTEXT_MAXLEN];

#define UMB_DEVID_MAXLEN                18
       uint16_t                devid[UMB_DEVID_MAXLEN];
#define UMB_FWINFO_MAXLEN               30
       uint16_t                fwinfo[UMB_FWINFO_MAXLEN];
#define UMB_HWINFO_MAXLEN               30
       uint16_t                hwinfo[UMB_HWINFO_MAXLEN];

       uint16_t                apn[UMB_APN_MAXLEN];
       int                     apnlen;

       uint16_t                username[UMB_USERNAME_MAXLEN];
       int                     usernamelen;

       uint16_t                password[UMB_PASSWORD_MAXLEN];
       int                     passwordlen;

#define UMB_VALUE_UNKNOWN       -999
       int                     rssi;
#define UMB_BER_EXCELLENT       0
#define UMB_BER_VERYGOOD        1
#define UMB_BER_GOOD            2
#define UMB_BER_OK              3
#define UMB_BER_MEDIUM          4
#define UMB_BER_BAD             5
#define UMB_BER_VERYBAD         6
#define UMB_BER_EXTREMELYBAD    7
       int                     ber;

       int                     hw_radio_on;
       int                     sw_radio_on;

       uint64_t                uplink_speed;
       uint64_t                downlink_speed;

#define UMB_MAX_DNSSRV                  2
       u_int32_t               ipv4dns[UMB_MAX_DNSSRV];
};

#if !defined(ifr_mtu)
#define ifr_mtu ifr_ifru.ifru_metric
#endif

#ifdef _KERNEL
/*
* UMB device
*/
struct umb_softc {
       device_t                 sc_dev;
       struct ifnet             sc_if;
#define GET_IFP(sc)     (&(sc)->sc_if)
       struct ifmedia           sc_im;
       krndsource_t             sc_rnd_source;
       struct usbd_device      *sc_udev;

       int                      sc_ver_maj;
       int                      sc_ver_min;
       int                      sc_ctrl_len;
       int                      sc_maxpktlen;
       int                      sc_maxsessions;

#define UMBFLG_FCC_AUTH_REQUIRED        0x0001
       uint32_t                 sc_flags;
       int                      sc_cid;

       struct usb_task          sc_umb_task;
       struct usb_task          sc_get_response_task;
       int                      sc_nresp;
       callout_t                sc_statechg_timer;
       char                     sc_dying;
       char                     sc_attached;

       uint8_t                  sc_ctrl_ifaceno;
       struct usbd_pipe        *sc_ctrl_pipe;
       usb_cdc_notification_t   sc_intr_msg;
       struct usbd_interface   *sc_data_iface;

       void                    *sc_resp_buf;
       void                    *sc_ctrl_msg;

       int                      sc_rx_ep;
       struct usbd_xfer        *sc_rx_xfer;
       char                    *sc_rx_buf;
       int                      sc_rx_bufsz;
       struct usbd_pipe        *sc_rx_pipe;
       unsigned                 sc_rx_nerr;

       int                      sc_tx_ep;
       struct usbd_xfer        *sc_tx_xfer;
       char                    *sc_tx_buf;
       int                      sc_tx_bufsz;
       struct usbd_pipe        *sc_tx_pipe;
       struct mbuf             *sc_tx_m;
       uint32_t                 sc_tx_seq;

       uint32_t                 sc_tid;

#define sc_state                sc_info.state
#define sc_roaming              sc_info.enable_roaming
       struct umb_info         sc_info;
};
#endif /* _KERNEL */

#endif /* _IF_UMBREG_H_ */

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.