Differential D48167 Diff 148359 sys/dev/usb/net/if_umbreg.h

Changeset View

Standalone View

sys/dev/usb/net/if_umbreg.h

This file was added.

				/* $OpenBSD: if_umb.h,v 1.4 2017/04/18 13:27:55 gerhard Exp $ */

				/*
				* Original copyright (c) 2016 genua mbH (OpenBSD version)
				*
				* 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.
				*
				* Copyright (c) 2022 ADISTA SAS (re-write for FreeBSD)
				*
				* Re-write for FreeBSD by Pierre Pronchery <pierre@defora.net>
				*
				* Redistribution and use in source and binary forms, with or without
				* modification, are permitted provided that the following conditions are met:
				*
				* - Redistributions of source code must retain the above copyright notice,
				* this list of conditions and the following disclaimer.
				* - Redistributions in binary form must reproduce the above copyright notice,
				* this list of conditions and the following disclaimer in the documentation
				* and/or other materials provided with the distribution.
				* - Neither the name of the copyright holder nor the names of its contributors
				* may be used to endorse or promote products derived from this software
				* without specific prior written permission.
				*
				* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
				* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
				* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
				* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
				* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
				* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
				* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
				* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
				* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
				* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
				* POSSIBILITY OF SUCH DAMAGE.
				*/

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

				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;

				uint16_t 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
				struct in_addr ipv4dns[UMB_MAX_DNSSRV];
				};

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

				#ifdef _KERNEL
				/*
				* UMB device
				*/
				enum {
				UMB_INTR_RX,
				UMB_BULK_RX,
				UMB_BULK_TX,
				UMB_N_TRANSFER,
				};

				struct umb_task {
				struct usb_proc_msg hdr;
				struct umb_softc *sc;
				};

				struct umb_softc {
				device_t sc_dev;
				struct ifnet *sc_if;
				#define GET_IFP(sc) ((sc)->sc_if)
				struct ifmedia sc_im;
				struct usb_device *sc_udev;
				struct usb_xfer *sc_xfer[UMB_N_TRANSFER];
				uint8_t sc_ifaces_index[2];

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

				#define UMBFLG_FCC_AUTH_REQUIRED 0x0001
				#define UMBFLG_NO_INET6 0x0002
				uint32_t sc_flags;
				int sc_cid;

				struct usb_process sc_taskqueue;
				struct umb_task sc_proc_attach_task[2];
				struct umb_task sc_proc_start_task[2];
				struct umb_task sc_proc_state_task[2];
				struct umb_task sc_proc_get_response_task[2];

				int sc_nresp;
				struct mtx sc_mutex;
				struct usb_callout sc_statechg_timer;
				char sc_dying;
				char sc_attached;

				uint8_t sc_ctrl_ifaceno;
				struct usb_interface *sc_data_iface;

				void *sc_resp_buf;
				void *sc_ctrl_msg;

				void *sc_rx_buf;
				uint32_t sc_rx_bufsz;
				unsigned sc_rx_nerr;
				struct ifqueue sc_rx_queue;

				void *sc_tx_buf;
				struct mbuf *sc_tx_m;
				uint32_t sc_tx_bufsz;
				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 */