File: | dev/usb/if_umb.c |
Warning: | line 1304, column 2 Value stored to 'tid' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: if_umb.c,v 1.56 2023/10/24 09:13:22 jmatthew Exp $ */ |
2 | |
3 | /* |
4 | * Copyright (c) 2016 genua mbH |
5 | * All rights reserved. |
6 | * |
7 | * Permission to use, copy, modify, and distribute this software for any |
8 | * purpose with or without fee is hereby granted, provided that the above |
9 | * copyright notice and this permission notice appear in all copies. |
10 | * |
11 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
12 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
13 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
14 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
15 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
16 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
17 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
18 | */ |
19 | |
20 | /* |
21 | * Mobile Broadband Interface Model specification: |
22 | * https://www.usb.org/sites/default/files/MBIM10Errata1_073013.zip |
23 | * Compliance testing guide |
24 | * https://www.usb.org/sites/default/files/MBIM-Compliance-1.0.pdf |
25 | */ |
26 | |
27 | #include "bpfilter.h" |
28 | #include "kstat.h" |
29 | |
30 | #include <sys/param.h> |
31 | #include <sys/mbuf.h> |
32 | #include <sys/socket.h> |
33 | #include <sys/systm.h> |
34 | #include <sys/syslog.h> |
35 | #include <sys/kstat.h> |
36 | |
37 | #if NBPFILTER1 > 0 |
38 | #include <net/bpf.h> |
39 | #endif |
40 | #include <net/if.h> |
41 | #include <net/if_var.h> |
42 | #include <net/if_types.h> |
43 | #include <net/route.h> |
44 | |
45 | #include <netinet/in.h> |
46 | #include <netinet/in_var.h> |
47 | #include <netinet/ip.h> |
48 | |
49 | #ifdef INET61 |
50 | #include <netinet/ip6.h> |
51 | #include <netinet6/in6_var.h> |
52 | #include <netinet6/ip6_var.h> |
53 | #include <netinet6/in6_ifattach.h> |
54 | #include <netinet6/nd6.h> |
55 | #endif |
56 | |
57 | #include <machine/bus.h> |
58 | |
59 | #include <dev/usb/usb.h> |
60 | #include <dev/usb/usbdi.h> |
61 | #include <dev/usb/usbdivar.h> |
62 | #include <dev/usb/usbdi_util.h> |
63 | #include <dev/usb/usbdevs.h> |
64 | #include <dev/usb/usbcdc.h> |
65 | |
66 | #include <dev/usb/mbim.h> |
67 | #include <dev/usb/if_umb.h> |
68 | |
69 | #ifdef UMB_DEBUG |
70 | #define DPRINTF(x...)do { } while (0) \ |
71 | do { if (umb_debug) log(LOG_DEBUG7, x); } while (0) |
72 | |
73 | #define DPRINTFN(n, x...)do { } while (0) \ |
74 | do { if (umb_debug >= (n)) log(LOG_DEBUG7, x); } while (0) |
75 | |
76 | #define DDUMPN(n, b, l)do { } while (0) \ |
77 | do { \ |
78 | if (umb_debug >= (n)) \ |
79 | umb_dump((b), (l)); \ |
80 | } while (0) |
81 | |
82 | int umb_debug = 0; |
83 | char *umb_uuid2str(uint8_t [MBIM_UUID_LEN16]); |
84 | void umb_dump(void *, int); |
85 | |
86 | #else |
87 | #define DPRINTF(x...)do { } while (0) do { } while (0) |
88 | #define DPRINTFN(n, x...)do { } while (0) do { } while (0) |
89 | #define DDUMPN(n, b, l)do { } while (0) do { } while (0) |
90 | #endif |
91 | |
92 | #define DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname) (((struct umb_softc *)(sc))->sc_dev.dv_xname) |
93 | |
94 | /* |
95 | * State change timeout |
96 | */ |
97 | #define UMB_STATE_CHANGE_TIMEOUT30 30 |
98 | |
99 | /* |
100 | * State change flags |
101 | */ |
102 | #define UMB_NS_DONT_DROP0x0001 0x0001 /* do not drop below current state */ |
103 | #define UMB_NS_DONT_RAISE0x0002 0x0002 /* do not raise below current state */ |
104 | |
105 | /* |
106 | * Diagnostic macros |
107 | */ |
108 | const struct umb_valdescr umb_regstates[] = MBIM_REGSTATE_DESCRIPTIONS{ { 0, "unknown" }, { 1, "not registered" }, { 2, "searching" }, { 3, "home network" }, { 4, "roaming network" }, { 5, "partner network" }, { 6, "access denied" }, { 0, ((void *)0) } }; |
109 | const struct umb_valdescr umb_dataclasses[] = MBIM_DATACLASS_DESCRIPTIONS{ { 0x00000000, "none" }, { 0x00000001, "GPRS" }, { 0x00000002 , "EDGE" }, { 0x00000004, "UMTS" }, { 0x00000008, "HSDPA" }, { 0x00000010, "HSUPA" }, { 0x00000008|0x00000010, "HSPA" }, { 0x00000020 , "LTE" }, { 0x00010000, "CDMA2000" }, { 0x00020000, "CDMA2000" }, { 0x00040000, "CDMA2000" }, { 0x00080000, "CDMA2000" }, { 0x00100000, "CDMA2000" }, { 0x00200000, "CDMA2000" }, { 0x00400000 , "CDMA2000" }, { 0x80000000, "custom" }, { 0, ((void *)0) } }; |
110 | const struct umb_valdescr umb_simstate[] = MBIM_SIMSTATE_DESCRIPTIONS{ { 0, "not initialized" }, { 1, "initialized" }, { 2, "not inserted" }, { 3, "bad type" }, { 4, "failed" }, { 5, "not activated" } , { 6, "locked" }, { 0, ((void *)0) } }; |
111 | const struct umb_valdescr umb_messages[] = MBIM_MESSAGES_DESCRIPTIONS{ { (1U), "MBIM_OPEN_MSG" }, { (2U), "MBIM_CLOSE_MSG" }, { (3U ), "MBIM_COMMAND_MSG" }, { (4U), "MBIM_HOST_ERROR_MSG" }, { ( 0x80000001U), "MBIM_OPEN_DONE" }, { (0x80000002U), "MBIM_CLOSE_DONE" }, { (0x80000003U), "MBIM_COMMAND_DONE" }, { (0x80000004U), "MBIM_FUNCTION_ERROR_MSG" }, { (0x80000007U), "MBIM_INDICATE_STATUS_MSG" }, { 0, ((void *)0) } }; |
112 | const struct umb_valdescr umb_status[] = MBIM_STATUS_DESCRIPTIONS{ { 0, "SUCCESS" }, { 1, "BUSY" }, { 2, "FAILURE" }, { 3, "SIM_NOT_INSERTED" }, { 4, "BAD_SIM" }, { 5, "PIN_REQUIRED" }, { 6, "PIN_DISABLED" }, { 7, "NOT_REGISTERED" }, { 8, "PROVIDERS_NOT_FOUND" }, { 9 , "NO_DEVICE_SUPPORT" }, { 10, "PROVIDER_NOT_VISIBLE" }, { 11 , "DATA_CLASS_NOT_AVAILABLE" }, { 12, "PACKET_SERVICE_DETACHED" }, { 13, "MAX_ACTIVATED_CONTEXTS" }, { 14, "NOT_INITIALIZED" }, { 15, "VOICE_CALL_IN_PROGRESS" }, { 16, "CONTEXT_NOT_ACTIVATED" }, { 17, "SERVICE_NOT_ACTIVATED" }, { 18, "INVALID_ACCESS_STRING" }, { 19, "INVALID_USER_NAME_PWD" }, { 20, "RADIO_POWER_OFF" } , { 21, "INVALID_PARAMETERS" }, { 22, "READ_FAILURE" }, { 23, "WRITE_FAILURE" }, { 25, "NO_PHONEBOOK" }, { 26, "PARAMETER_TOO_LONG" }, { 27, "STK_BUSY" }, { 28, "OPERATION_NOT_ALLOWED" }, { 29 , "MEMORY_FAILURE" }, { 30, "INVALID_MEMORY_INDEX" }, { 31, "MEMORY_FULL" }, { 32, "FILTER_NOT_SUPPORTED" }, { 33, "DSS_INSTANCE_LIMIT" }, { 34, "INVALID_DEVICE_SERVICE_OPERATION" }, { 35, "AUTH_INCORRECT_AUTN" }, { 36, "AUTH_SYNC_FAILURE" }, { 37, "AUTH_AMF_NOT_SET" }, { 38, "CONTEXT_NOT_SUPPORTED" }, { 100, "SMS_UNKNOWN_SMSC_ADDRESS" }, { 101, "SMS_NETWORK_TIMEOUT" }, { 102, "SMS_LANG_NOT_SUPPORTED" }, { 103, "SMS_ENCODING_NOT_SUPPORTED" }, { 104, "SMS_FORMAT_NOT_SUPPORTED" }, { 0, ((void *)0) } }; |
113 | const struct umb_valdescr umb_cids[] = MBIM_CID_DESCRIPTIONS{ { (1), "MBIM_CID_DEVICE_CAPS" }, { (2), "MBIM_CID_SUBSCRIBER_READY_STATUS" }, { (3), "MBIM_CID_RADIO_STATE" }, { (4), "MBIM_CID_PIN" }, { (5), "MBIM_CID_PIN_LIST" }, { (6), "MBIM_CID_HOME_PROVIDER" }, { (7), "MBIM_CID_PREFERRED_PROVIDERS" }, { (8), "MBIM_CID_VISIBLE_PROVIDERS" }, { (9), "MBIM_CID_REGISTER_STATE" }, { (10), "MBIM_CID_PACKET_SERVICE" }, { (11), "MBIM_CID_SIGNAL_STATE" }, { (12), "MBIM_CID_CONNECT" }, { (13), "MBIM_CID_PROVISIONED_CONTEXTS" }, { (14), "MBIM_CID_SERVICE_ACTIVATION" }, { (15), "MBIM_CID_IP_CONFIGURATION" }, { (16), "MBIM_CID_DEVICE_SERVICES" }, { (19), "MBIM_CID_DEVICE_SERVICE_SUBSCRIBE_LIST" }, { (20 ), "MBIM_CID_PACKET_STATISTICS" }, { (21), "MBIM_CID_NETWORK_IDLE_HINT" }, { (22), "MBIM_CID_EMERGENCY_MODE" }, { (23), "MBIM_CID_IP_PACKET_FILTERS" }, { (24), "MBIM_CID_MULTICARRIER_PROVIDERS" }, { 0, ((void * )0) } }; |
114 | const struct umb_valdescr umb_pktstate[] = MBIM_PKTSRV_STATE_DESCRIPTIONS{ { 0, "unknown" }, { 1, "attaching" }, { 2, "attached" }, { 3 , "detaching" }, { 4, "detached" }, { 0, ((void *)0) } }; |
115 | const struct umb_valdescr umb_actstate[] = MBIM_ACTIVATION_STATE_DESCRIPTIONS{ { 0, "unknown" }, { 1, "activated" }, { 2, "activating" }, { 3, "deactivated" }, { 4, "deactivating" }, { 0, ((void *)0) } }; |
116 | const struct umb_valdescr umb_error[] = MBIM_ERROR_DESCRIPTIONS{ { 1, "TIMEOUT_FRAGMENT" }, { 2, "FRAGMENT_OUT_OF_SEQUENCE" } , { 3, "LENGTH_MISMATCH" }, { 4, "DUPLICATED_TID" }, { 5, "NOT_OPENED" }, { 6, "UNKNOWN" }, { 7, "CANCEL" }, { 8, "MAX_TRANSFER" }, { 0, ((void *)0) } }; |
117 | const struct umb_valdescr umb_pintype[] = MBIM_PINTYPE_DESCRIPTIONS{ { 0, "none" }, { 1, "custom" }, { 2, "PIN1" }, { 3, "PIN2" } , { 4, "device PIN" }, { 5, "device 1st PIN" }, { 6, "network PIN" }, { 7, "network subset PIN" }, { 8, "provider PIN" }, { 9, "corporate PIN" }, { 10, "subsidy lock" }, { 11, "PUK" }, { 12, "PUK2" }, { 13 , "device 1st PUK" }, { 14, "network PUK" }, { 15, "network subset PUK" }, { 16, "provider PUK" }, { 17, "corporate PUK" }, { 0, ((void *)0) } }; |
118 | const struct umb_valdescr umb_istate[] = 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, ((void *)0) } }; |
119 | |
120 | #define umb_regstate(c)umb_val2descr(umb_regstates, (c)) umb_val2descr(umb_regstates, (c)) |
121 | #define umb_dataclass(c)umb_val2descr(umb_dataclasses, (c)) umb_val2descr(umb_dataclasses, (c)) |
122 | #define umb_simstate(s)umb_val2descr(umb_simstate, (s)) umb_val2descr(umb_simstate, (s)) |
123 | #define umb_request2str(m)umb_val2descr(umb_messages, (m)) umb_val2descr(umb_messages, (m)) |
124 | #define umb_status2str(s)umb_val2descr(umb_status, (s)) umb_val2descr(umb_status, (s)) |
125 | #define umb_cid2str(c)umb_val2descr(umb_cids, (c)) umb_val2descr(umb_cids, (c)) |
126 | #define umb_packet_state(s)umb_val2descr(umb_pktstate, (s)) umb_val2descr(umb_pktstate, (s)) |
127 | #define umb_activation(s)umb_val2descr(umb_actstate, (s)) umb_val2descr(umb_actstate, (s)) |
128 | #define umb_error2str(e)umb_val2descr(umb_error, (e)) umb_val2descr(umb_error, (e)) |
129 | #define umb_pin_type(t)umb_val2descr(umb_pintype, (t)) umb_val2descr(umb_pintype, (t)) |
130 | #define umb_istate(s)umb_val2descr(umb_istate, (s)) umb_val2descr(umb_istate, (s)) |
131 | |
132 | int umb_match(struct device *, void *, void *); |
133 | void umb_attach(struct device *, struct device *, void *); |
134 | int umb_detach(struct device *, int); |
135 | void umb_ncm_setup(struct umb_softc *); |
136 | void umb_ncm_setup_format(struct umb_softc *); |
137 | int umb_alloc_xfers(struct umb_softc *); |
138 | void umb_free_xfers(struct umb_softc *); |
139 | int umb_alloc_bulkpipes(struct umb_softc *); |
140 | void umb_close_bulkpipes(struct umb_softc *); |
141 | int umb_ioctl(struct ifnet *, u_long, caddr_t); |
142 | int umb_output(struct ifnet *, struct mbuf *, struct sockaddr *, |
143 | struct rtentry *); |
144 | void umb_start(struct ifnet *); |
145 | void umb_rtrequest(struct ifnet *, int, struct rtentry *); |
146 | void umb_watchdog(struct ifnet *); |
147 | void umb_statechg_timeout(void *); |
148 | |
149 | void umb_newstate(struct umb_softc *, enum umb_state, int); |
150 | void umb_state_task(void *); |
151 | void umb_up(struct umb_softc *); |
152 | void umb_down(struct umb_softc *, int); |
153 | |
154 | void umb_get_response_task(void *); |
155 | |
156 | void umb_decode_response(struct umb_softc *, void *, int); |
157 | void umb_handle_indicate_status_msg(struct umb_softc *, void *, |
158 | int); |
159 | void umb_handle_opendone_msg(struct umb_softc *, void *, int); |
160 | void umb_handle_closedone_msg(struct umb_softc *, void *, int); |
161 | int umb_decode_register_state(struct umb_softc *, void *, int); |
162 | int umb_decode_devices_caps(struct umb_softc *, void *, int); |
163 | int umb_decode_subscriber_status(struct umb_softc *, void *, int); |
164 | int umb_decode_radio_state(struct umb_softc *, void *, int); |
165 | int umb_decode_pin(struct umb_softc *, void *, int); |
166 | int umb_decode_packet_service(struct umb_softc *, void *, int); |
167 | int umb_decode_signal_state(struct umb_softc *, void *, int); |
168 | int umb_decode_connect_info(struct umb_softc *, void *, int); |
169 | void umb_clear_addr(struct umb_softc *); |
170 | int umb_add_inet_config(struct umb_softc *, struct in_addr, u_int, |
171 | struct in_addr); |
172 | int umb_add_inet6_config(struct umb_softc *, struct in6_addr *, |
173 | u_int, struct in6_addr *); |
174 | void umb_send_inet_proposal(struct umb_softc *, int); |
175 | int umb_decode_ip_configuration(struct umb_softc *, void *, int); |
176 | void umb_rx(struct umb_softc *); |
177 | void umb_rxeof(struct usbd_xfer *, void *, usbd_status); |
178 | int umb_encap(struct umb_softc *, int); |
179 | void umb_txeof(struct usbd_xfer *, void *, usbd_status); |
180 | void umb_decap(struct umb_softc *, struct usbd_xfer *); |
181 | |
182 | usbd_status umb_send_encap_command(struct umb_softc *, void *, int); |
183 | int umb_get_encap_response(struct umb_softc *, void *, int *); |
184 | void umb_ctrl_msg(struct umb_softc *, uint32_t, void *, int); |
185 | |
186 | void umb_open(struct umb_softc *); |
187 | void umb_close(struct umb_softc *); |
188 | |
189 | int umb_setpin(struct umb_softc *, int, int, void *, int, void *, |
190 | int); |
191 | void umb_setdataclass(struct umb_softc *); |
192 | void umb_radio(struct umb_softc *, int); |
193 | void umb_allocate_cid(struct umb_softc *); |
194 | void umb_send_fcc_auth(struct umb_softc *); |
195 | void umb_packet_service(struct umb_softc *, int); |
196 | void umb_connect(struct umb_softc *); |
197 | void umb_disconnect(struct umb_softc *); |
198 | void umb_send_connect(struct umb_softc *, int); |
199 | |
200 | void umb_qry_ipconfig(struct umb_softc *); |
201 | void umb_cmd(struct umb_softc *, int, int, void *, int); |
202 | void umb_cmd1(struct umb_softc *, int, int, void *, int, uint8_t *); |
203 | void umb_command_done(struct umb_softc *, void *, int); |
204 | void umb_decode_cid(struct umb_softc *, uint32_t, void *, int); |
205 | void umb_decode_qmi(struct umb_softc *, uint8_t *, int); |
206 | |
207 | void umb_intr(struct usbd_xfer *, void *, usbd_status); |
208 | |
209 | #if NKSTAT1 > 0 |
210 | void umb_kstat_attach(struct umb_softc *); |
211 | void umb_kstat_detach(struct umb_softc *); |
212 | |
213 | struct umb_kstat_signal { |
214 | struct kstat_kv rssi; |
215 | struct kstat_kv error_rate; |
216 | struct kstat_kv reports; |
217 | }; |
218 | #endif |
219 | |
220 | int umb_xfer_tout = USBD_DEFAULT_TIMEOUT5000; |
221 | |
222 | uint8_t umb_uuid_basic_connect[] = MBIM_UUID_BASIC_CONNECT{ 0xa2, 0x89, 0xcc, 0x33, 0xbc, 0xbb, 0x8b, 0x4f, 0xb6, 0xb0, 0x13, 0x3e, 0xc2, 0xaa, 0xe6, 0xdf }; |
223 | uint8_t umb_uuid_context_internet[] = MBIM_UUID_CONTEXT_INTERNET{ 0x7e, 0x5e, 0x2a, 0x7e, 0x4e, 0x6f, 0x72, 0x72, 0x73, 0x6b, 0x65, 0x6e, 0x7e, 0x5e, 0x2a, 0x7e }; |
224 | uint8_t umb_uuid_qmi_mbim[] = MBIM_UUID_QMI_MBIM{ 0xd1, 0xa3, 0x0b, 0xc2, 0xf9, 0x7a, 0x6e, 0x43, 0xbf, 0x65, 0xc7, 0xe2, 0x4f, 0xb0, 0xf0, 0xd3 }; |
225 | uint32_t umb_session_id = 0; |
226 | |
227 | struct cfdriver umb_cd = { |
228 | NULL((void *)0), "umb", DV_IFNET |
229 | }; |
230 | |
231 | const struct cfattach umb_ca = { |
232 | sizeof (struct umb_softc), |
233 | umb_match, |
234 | umb_attach, |
235 | umb_detach, |
236 | NULL((void *)0), |
237 | }; |
238 | |
239 | int umb_delay = 4000; |
240 | |
241 | struct umb_quirk { |
242 | struct usb_devno dev; |
243 | u_int32_t umb_flags; |
244 | int umb_confno; |
245 | int umb_match; |
246 | }; |
247 | const struct umb_quirk umb_quirks[] = { |
248 | { { USB_VENDOR_DELL0x413c, USB_PRODUCT_DELL_DW5821E0x81d7 }, |
249 | 0, |
250 | 2, |
251 | UMATCH_VENDOR_PRODUCT13 |
252 | }, |
253 | |
254 | { { USB_VENDOR_HUAWEI0x12d1, USB_PRODUCT_HUAWEI_ME906S0x15c1 }, |
255 | UMBFLG_NDP_AT_END0x0004, |
256 | 3, |
257 | UMATCH_VENDOR_PRODUCT13 |
258 | }, |
259 | |
260 | { { USB_VENDOR_SIERRA0x1199, USB_PRODUCT_SIERRA_EM74550x9079 }, |
261 | UMBFLG_FCC_AUTH_REQUIRED0x0001, |
262 | 0, |
263 | 0 |
264 | }, |
265 | |
266 | { { USB_VENDOR_SIMCOM0x1e0e, USB_PRODUCT_SIMCOM_SIM76000x9003 }, |
267 | 0, |
268 | 1, |
269 | UMATCH_VENDOR_PRODUCT13 |
270 | }, |
271 | }; |
272 | |
273 | #define umb_lookup(vid, pid)((const struct umb_quirk *)usbd_match_device((const struct usb_devno *)(umb_quirks), sizeof (umb_quirks) / sizeof ((umb_quirks)[0 ]), sizeof ((umb_quirks)[0]), (vid), (pid))) \ |
274 | ((const struct umb_quirk *)usb_lookup(umb_quirks, vid, pid)usbd_match_device((const struct usb_devno *)(umb_quirks), sizeof (umb_quirks) / sizeof ((umb_quirks)[0]), sizeof ((umb_quirks )[0]), (vid), (pid))) |
275 | |
276 | uint8_t umb_qmi_alloc_cid[] = { |
277 | 0x01, |
278 | 0x0f, 0x00, /* len */ |
279 | 0x00, /* QMUX flags */ |
280 | 0x00, /* service "ctl" */ |
281 | 0x00, /* CID */ |
282 | 0x00, /* QMI flags */ |
283 | 0x01, /* transaction */ |
284 | 0x22, 0x00, /* msg "Allocate CID" */ |
285 | 0x04, 0x00, /* TLV len */ |
286 | 0x01, 0x01, 0x00, 0x02 /* TLV */ |
287 | }; |
288 | |
289 | uint8_t umb_qmi_fcc_auth[] = { |
290 | 0x01, |
291 | 0x0c, 0x00, /* len */ |
292 | 0x00, /* QMUX flags */ |
293 | 0x02, /* service "dms" */ |
294 | #define UMB_QMI_CID_OFFS5 5 |
295 | 0x00, /* CID (filled in later) */ |
296 | 0x00, /* QMI flags */ |
297 | 0x01, 0x00, /* transaction */ |
298 | 0x5f, 0x55, /* msg "Send FCC Authentication" */ |
299 | 0x00, 0x00 /* TLV len */ |
300 | }; |
301 | |
302 | int |
303 | umb_match(struct device *parent, void *match, void *aux) |
304 | { |
305 | struct usb_attach_arg *uaa = aux; |
306 | const struct umb_quirk *quirk; |
307 | usb_interface_descriptor_t *id; |
308 | |
309 | quirk = umb_lookup(uaa->vendor, uaa->product)((const struct umb_quirk *)usbd_match_device((const struct usb_devno *)(umb_quirks), sizeof (umb_quirks) / sizeof ((umb_quirks)[0 ]), sizeof ((umb_quirks)[0]), (uaa->vendor), (uaa->product ))); |
310 | if (quirk != NULL((void *)0) && quirk->umb_match) |
311 | return (quirk->umb_match); |
312 | if (!uaa->iface) |
313 | return UMATCH_NONE0; |
314 | if ((id = usbd_get_interface_descriptor(uaa->iface)) == NULL((void *)0)) |
315 | return UMATCH_NONE0; |
316 | |
317 | /* |
318 | * If this function implements NCM, check if alternate setting |
319 | * 1 implements MBIM. |
320 | */ |
321 | if (id->bInterfaceClass == UICLASS_CDC0x02 && |
322 | id->bInterfaceSubClass == |
323 | UISUBCLASS_NETWORK_CONTROL_MODEL13) |
324 | id = usbd_find_idesc(uaa->device->cdesc, uaa->iface->index, 1); |
325 | if (id == NULL((void *)0)) |
326 | return UMATCH_NONE0; |
327 | |
328 | if (id->bInterfaceClass == UICLASS_CDC0x02 && |
329 | id->bInterfaceSubClass == |
330 | UISUBCLASS_MOBILE_BROADBAND_INTERFACE_MODEL14 && |
331 | id->bInterfaceProtocol == 0) |
332 | return UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO5; |
333 | |
334 | return UMATCH_NONE0; |
335 | } |
336 | |
337 | void |
338 | umb_attach(struct device *parent, struct device *self, void *aux) |
339 | { |
340 | struct umb_softc *sc = (struct umb_softc *)self; |
341 | struct usb_attach_arg *uaa = aux; |
342 | const struct umb_quirk *quirk; |
343 | usbd_status status; |
344 | struct usbd_desc_iter iter; |
345 | const usb_descriptor_t *desc; |
346 | int v; |
347 | struct usb_cdc_union_descriptor *ud; |
348 | struct mbim_descriptor *md; |
349 | int i; |
350 | int ctrl_ep; |
351 | usb_interface_descriptor_t *id; |
352 | usb_config_descriptor_t *cd; |
353 | usb_endpoint_descriptor_t *ed; |
354 | usb_interface_assoc_descriptor_t *ad; |
355 | int current_ifaceno = -1; |
356 | int data_ifaceno = -1; |
357 | int altnum; |
358 | int s; |
359 | struct ifnet *ifp; |
360 | |
361 | sc->sc_udev = uaa->device; |
362 | sc->sc_ctrl_ifaceno = uaa->ifaceno; |
363 | ml_init(&sc->sc_tx_ml); |
364 | |
365 | quirk = umb_lookup(uaa->vendor, uaa->product)((const struct umb_quirk *)usbd_match_device((const struct usb_devno *)(umb_quirks), sizeof (umb_quirks) / sizeof ((umb_quirks)[0 ]), sizeof ((umb_quirks)[0]), (uaa->vendor), (uaa->product ))); |
366 | if (quirk != NULL((void *)0) && quirk->umb_flags) { |
367 | DPRINTF("%s: setting flags 0x%x from quirk\n", DEVNAM(sc),do { } while (0) |
368 | quirk->umb_flags)do { } while (0); |
369 | sc->sc_flags |= quirk->umb_flags; |
370 | } |
371 | |
372 | /* |
373 | * Normally, MBIM devices are detected by their interface class and |
374 | * subclass. But for some models that have multiple configurations, it |
375 | * is better to match by vendor and product id so that we can select |
376 | * the desired configuration ourselves, e.g. to override a class-based |
377 | * match to another driver. |
378 | */ |
379 | if (uaa->configno < 0) { |
380 | if (quirk == NULL((void *)0)) { |
381 | printf("%s: unknown configuration for vid/pid match\n", |
382 | DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
383 | goto fail; |
384 | } |
385 | uaa->configno = quirk->umb_confno; |
386 | DPRINTF("%s: switching to config #%d\n", DEVNAM(sc),do { } while (0) |
387 | uaa->configno)do { } while (0); |
388 | status = usbd_set_config_no(sc->sc_udev, uaa->configno, 1); |
389 | if (status) { |
390 | printf("%s: failed to switch to config #%d: %s\n", |
391 | DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), uaa->configno, usbd_errstr(status)); |
392 | goto fail; |
393 | } |
394 | usbd_delay_ms(sc->sc_udev, 200); |
395 | |
396 | /* |
397 | * Need to do some manual setup that usbd_probe_and_attach() |
398 | * would do for us otherwise. |
399 | */ |
400 | uaa->nifaces = uaa->device->cdesc->bNumInterfaces; |
401 | for (i = 0; i < uaa->nifaces; i++) { |
402 | if (usbd_iface_claimed(sc->sc_udev, i)) |
403 | continue; |
404 | id = usbd_get_interface_descriptor(&uaa->device->ifaces[i]); |
405 | if (id != NULL((void *)0) && id->bInterfaceClass == UICLASS_CDC0x02 && |
406 | id->bInterfaceSubClass == |
407 | UISUBCLASS_MOBILE_BROADBAND_INTERFACE_MODEL14) { |
408 | uaa->iface = &uaa->device->ifaces[i]; |
409 | uaa->ifaceno = uaa->iface->idesc->bInterfaceNumber; |
410 | sc->sc_ctrl_ifaceno = uaa->ifaceno; |
411 | break; |
412 | } |
413 | } |
414 | } |
415 | |
416 | /* |
417 | * Some MBIM hardware does not provide the mandatory CDC Union |
418 | * Descriptor, so we also look at matching Interface |
419 | * Association Descriptors to find out the MBIM Data Interface |
420 | * number. |
421 | */ |
422 | sc->sc_ver_maj = sc->sc_ver_min = -1; |
423 | sc->sc_maxpktlen = MBIM_MAXSEGSZ_MINVAL(2 * 1024); |
424 | usbd_desc_iter_init(sc->sc_udev, &iter); |
425 | while ((desc = usbd_desc_iter_next(&iter))) { |
426 | if (desc->bDescriptorType == UDESC_IFACE_ASSOC0x0B) { |
427 | ad = (usb_interface_assoc_descriptor_t *)desc; |
428 | if (ad->bFirstInterface == uaa->ifaceno && |
429 | ad->bInterfaceCount > 1) |
430 | data_ifaceno = uaa->ifaceno + 1; |
431 | continue; |
432 | } |
433 | if (desc->bDescriptorType == UDESC_INTERFACE0x04) { |
434 | id = (usb_interface_descriptor_t *)desc; |
435 | current_ifaceno = id->bInterfaceNumber; |
436 | continue; |
437 | } |
438 | if (current_ifaceno != uaa->ifaceno) |
439 | continue; |
440 | if (desc->bDescriptorType != UDESC_CS_INTERFACE0x24) |
441 | continue; |
442 | switch (desc->bDescriptorSubtype) { |
443 | case UDESCSUB_CDC_UNION6: |
444 | ud = (struct usb_cdc_union_descriptor *)desc; |
445 | data_ifaceno = ud->bSlaveInterface[0]; |
446 | break; |
447 | case UDESCSUB_MBIM27: |
448 | md = (struct mbim_descriptor *)desc; |
449 | v = UGETW(md->bcdMBIMVersion)(*(u_int16_t *)(md->bcdMBIMVersion)); |
450 | sc->sc_ver_maj = MBIM_VER_MAJOR(v)(((v) >> 8) & 0x0f); |
451 | sc->sc_ver_min = MBIM_VER_MINOR(v)((v) & 0x0f); |
452 | sc->sc_ctrl_len = UGETW(md->wMaxControlMessage)(*(u_int16_t *)(md->wMaxControlMessage)); |
453 | /* Never trust a USB device! Could try to exploit us */ |
454 | if (sc->sc_ctrl_len < MBIM_CTRLMSG_MINLEN64 || |
455 | sc->sc_ctrl_len > MBIM_CTRLMSG_MAXLEN(4 * 1204)) { |
456 | DPRINTF("%s: control message len %d out of "do { } while (0) |
457 | "bounds [%d .. %d]\n", DEVNAM(sc),do { } while (0) |
458 | sc->sc_ctrl_len, MBIM_CTRLMSG_MINLEN,do { } while (0) |
459 | MBIM_CTRLMSG_MAXLEN)do { } while (0); |
460 | /* cont. anyway */ |
461 | } |
462 | sc->sc_maxpktlen = UGETW(md->wMaxSegmentSize)(*(u_int16_t *)(md->wMaxSegmentSize)); |
463 | DPRINTFN(2, "%s: ctrl_len=%d, maxpktlen=%d, cap=0x%x\n",do { } while (0) |
464 | DEVNAM(sc), sc->sc_ctrl_len, sc->sc_maxpktlen,do { } while (0) |
465 | md->bmNetworkCapabilities)do { } while (0); |
466 | break; |
467 | default: |
468 | break; |
469 | } |
470 | } |
471 | if (sc->sc_ver_maj < 0) { |
472 | printf("%s: missing MBIM descriptor\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
473 | goto fail; |
474 | } |
475 | if (sc->sc_flags & UMBFLG_FCC_AUTH_REQUIRED0x0001) |
476 | sc->sc_cid = -1; |
477 | |
478 | for (i = 0; i < uaa->nifaces; i++) { |
479 | if (usbd_iface_claimed(sc->sc_udev, i)) |
480 | continue; |
481 | id = usbd_get_interface_descriptor(&sc->sc_udev->ifaces[i]); |
482 | if (id != NULL((void *)0) && id->bInterfaceNumber == data_ifaceno) { |
483 | sc->sc_data_iface = &sc->sc_udev->ifaces[i]; |
484 | usbd_claim_iface(sc->sc_udev, i); |
485 | } |
486 | } |
487 | if (sc->sc_data_iface == NULL((void *)0)) { |
488 | printf("%s: no data interface found\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
489 | goto fail; |
490 | } |
491 | |
492 | /* |
493 | * If this is a combined NCM/MBIM function, switch to |
494 | * alternate setting one to enable MBIM. |
495 | */ |
496 | id = usbd_get_interface_descriptor(uaa->iface); |
497 | if (id->bInterfaceClass == UICLASS_CDC0x02 && |
498 | id->bInterfaceSubClass == |
499 | UISUBCLASS_NETWORK_CONTROL_MODEL13) |
500 | usbd_set_interface(uaa->iface, 1); |
501 | |
502 | id = usbd_get_interface_descriptor(uaa->iface); |
503 | ctrl_ep = -1; |
504 | for (i = 0; i < id->bNumEndpoints && ctrl_ep == -1; i++) { |
505 | ed = usbd_interface2endpoint_descriptor(uaa->iface, i); |
506 | if (ed == NULL((void *)0)) |
507 | break; |
508 | if (UE_GET_XFERTYPE(ed->bmAttributes)((ed->bmAttributes) & 0x03) == UE_INTERRUPT0x03 && |
509 | UE_GET_DIR(ed->bEndpointAddress)((ed->bEndpointAddress) & 0x80) == UE_DIR_IN0x80) |
510 | ctrl_ep = ed->bEndpointAddress; |
511 | } |
512 | if (ctrl_ep == -1) { |
513 | printf("%s: missing interrupt endpoint\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
514 | goto fail; |
515 | } |
516 | |
517 | /* |
518 | * For the MBIM Data Interface, select the appropriate |
519 | * alternate setting by looking for a matching descriptor that |
520 | * has two endpoints. |
521 | */ |
522 | cd = usbd_get_config_descriptor(sc->sc_udev); |
523 | altnum = usbd_get_no_alts(cd, data_ifaceno); |
524 | for (i = 0; i < altnum; i++) { |
525 | id = usbd_find_idesc(cd, sc->sc_data_iface->index, i); |
526 | if (id == NULL((void *)0)) |
527 | continue; |
528 | if (id->bInterfaceClass == UICLASS_CDC_DATA0x0a && |
529 | id->bInterfaceSubClass == UISUBCLASS_DATA0 && |
530 | id->bInterfaceProtocol == UIPROTO_DATA_MBIM0x02 && |
531 | id->bNumEndpoints == 2) |
532 | break; |
533 | } |
534 | if (i == altnum || id == NULL((void *)0)) { |
535 | printf("%s: missing alt setting for interface #%d\n", |
536 | DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), data_ifaceno); |
537 | goto fail; |
538 | } |
539 | status = usbd_set_interface(sc->sc_data_iface, i); |
540 | if (status) { |
541 | printf("%s: select alt setting %d for interface #%d " |
542 | "failed: %s\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), i, data_ifaceno, |
543 | usbd_errstr(status)); |
544 | goto fail; |
545 | } |
546 | |
547 | id = usbd_get_interface_descriptor(sc->sc_data_iface); |
548 | sc->sc_rx_ep = sc->sc_tx_ep = -1; |
549 | for (i = 0; i < id->bNumEndpoints; i++) { |
550 | if ((ed = usbd_interface2endpoint_descriptor(sc->sc_data_iface, |
551 | i)) == NULL((void *)0)) |
552 | break; |
553 | if (UE_GET_XFERTYPE(ed->bmAttributes)((ed->bmAttributes) & 0x03) == UE_BULK0x02 && |
554 | UE_GET_DIR(ed->bEndpointAddress)((ed->bEndpointAddress) & 0x80) == UE_DIR_IN0x80) |
555 | sc->sc_rx_ep = ed->bEndpointAddress; |
556 | else if (UE_GET_XFERTYPE(ed->bmAttributes)((ed->bmAttributes) & 0x03) == UE_BULK0x02 && |
557 | UE_GET_DIR(ed->bEndpointAddress)((ed->bEndpointAddress) & 0x80) == UE_DIR_OUT0x00) |
558 | sc->sc_tx_ep = ed->bEndpointAddress; |
559 | } |
560 | if (sc->sc_rx_ep == -1 || sc->sc_tx_ep == -1) { |
561 | printf("%s: missing bulk endpoints\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
562 | goto fail; |
563 | } |
564 | |
565 | DPRINTFN(2, "%s: ctrl-ifno#%d: ep-ctrl=%d, data-ifno#%d: ep-rx=%d, "do { } while (0) |
566 | "ep-tx=%d\n", DEVNAM(sc), sc->sc_ctrl_ifaceno,do { } while (0) |
567 | UE_GET_ADDR(ctrl_ep), data_ifaceno,do { } while (0) |
568 | UE_GET_ADDR(sc->sc_rx_ep), UE_GET_ADDR(sc->sc_tx_ep))do { } while (0); |
569 | |
570 | usb_init_task(&sc->sc_umb_task, umb_state_task, sc,((&sc->sc_umb_task)->fun = (umb_state_task), (& sc->sc_umb_task)->arg = (sc), (&sc->sc_umb_task) ->type = (0), (&sc->sc_umb_task)->state = 0x0) |
571 | USB_TASK_TYPE_GENERIC)((&sc->sc_umb_task)->fun = (umb_state_task), (& sc->sc_umb_task)->arg = (sc), (&sc->sc_umb_task) ->type = (0), (&sc->sc_umb_task)->state = 0x0); |
572 | usb_init_task(&sc->sc_get_response_task, umb_get_response_task, sc,((&sc->sc_get_response_task)->fun = (umb_get_response_task ), (&sc->sc_get_response_task)->arg = (sc), (&sc ->sc_get_response_task)->type = (0), (&sc->sc_get_response_task )->state = 0x0) |
573 | USB_TASK_TYPE_GENERIC)((&sc->sc_get_response_task)->fun = (umb_get_response_task ), (&sc->sc_get_response_task)->arg = (sc), (&sc ->sc_get_response_task)->type = (0), (&sc->sc_get_response_task )->state = 0x0); |
574 | timeout_set(&sc->sc_statechg_timer, umb_statechg_timeout, sc); |
575 | |
576 | if (usbd_open_pipe_intr(uaa->iface, ctrl_ep, USBD_SHORT_XFER_OK0x04, |
577 | &sc->sc_ctrl_pipe, sc, &sc->sc_intr_msg, sizeof (sc->sc_intr_msg), |
578 | umb_intr, USBD_DEFAULT_INTERVAL(-1))) { |
579 | printf("%s: failed to open control pipe\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
580 | goto fail; |
581 | } |
582 | sc->sc_resp_buf = malloc(sc->sc_ctrl_len, M_USBDEV102, M_NOWAIT0x0002); |
583 | if (sc->sc_resp_buf == NULL((void *)0)) { |
584 | printf("%s: allocation of resp buffer failed\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
585 | goto fail; |
586 | } |
587 | sc->sc_ctrl_msg = malloc(sc->sc_ctrl_len, M_USBDEV102, M_NOWAIT0x0002); |
588 | if (sc->sc_ctrl_msg == NULL((void *)0)) { |
589 | printf("%s: allocation of ctrl msg buffer failed\n", |
590 | DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
591 | goto fail; |
592 | } |
593 | |
594 | sc->sc_info.regstate = MBIM_REGSTATE_UNKNOWN0; |
595 | sc->sc_info.pin_attempts_left = UMB_VALUE_UNKNOWN-999; |
596 | sc->sc_info.rssi = UMB_VALUE_UNKNOWN-999; |
597 | sc->sc_info.ber = UMB_VALUE_UNKNOWN-999; |
598 | |
599 | /* Default to 16 bit NTB format. */ |
600 | sc->sc_ncm_format = NCM_FORMAT_NTB160x00; |
601 | umb_ncm_setup(sc); |
602 | umb_ncm_setup_format(sc); |
603 | if (sc->sc_ncm_supported_formats == 0) |
604 | goto fail; |
605 | DPRINTFN(2, "%s: rx/tx size %d/%d\n", DEVNAM(sc),do { } while (0) |
606 | sc->sc_rx_bufsz, sc->sc_tx_bufsz)do { } while (0); |
607 | |
608 | s = splnet()splraise(0x4); |
609 | ifp = GET_IFP(sc)(&(sc)->sc_if); |
610 | ifp->if_flags = IFF_SIMPLEX0x800 | IFF_MULTICAST0x8000 | IFF_POINTOPOINT0x10; |
611 | ifp->if_ioctl = umb_ioctl; |
612 | ifp->if_start = umb_start; |
613 | ifp->if_rtrequest = umb_rtrequest; |
614 | |
615 | ifp->if_watchdog = umb_watchdog; |
616 | strlcpy(ifp->if_xname, DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), IFNAMSIZ16); |
617 | ifp->if_link_stateif_data.ifi_link_state = LINK_STATE_DOWN2; |
618 | |
619 | ifp->if_typeif_data.ifi_type = IFT_MBIM0xfa; |
620 | ifp->if_priority = IF_WWAN_DEFAULT_PRIORITY6; |
621 | ifp->if_addrlenif_data.ifi_addrlen = 0; |
622 | ifp->if_hdrlenif_data.ifi_hdrlen = sizeof (struct ncm_header16) + |
623 | sizeof (struct ncm_pointer16); |
624 | ifp->if_mtuif_data.ifi_mtu = 1500; /* use a common default */ |
625 | ifp->if_hardmtu = sc->sc_maxpktlen; |
626 | ifp->if_bpf_mtap = p2p_bpf_mtap; |
627 | ifp->if_input = p2p_input; |
628 | ifp->if_output = umb_output; |
629 | if_attach(ifp); |
630 | if_alloc_sadl(ifp); |
631 | ifp->if_softc = sc; |
632 | #if NBPFILTER1 > 0 |
633 | bpfattach(&ifp->if_bpf, ifp, DLT_LOOP12, sizeof(uint32_t)); |
634 | #endif |
635 | |
636 | #if NKSTAT1 > 0 |
637 | umb_kstat_attach(sc); |
638 | #endif |
639 | |
640 | /* |
641 | * Open the device now so that we are able to query device information. |
642 | * XXX maybe close when done? |
643 | */ |
644 | umb_open(sc); |
645 | splx(s)spllower(s); |
646 | |
647 | DPRINTF("%s: vers %d.%d\n", DEVNAM(sc), sc->sc_ver_maj, sc->sc_ver_min)do { } while (0); |
648 | return; |
649 | |
650 | fail: |
651 | usbd_deactivate(sc->sc_udev); |
652 | return; |
653 | } |
654 | |
655 | int |
656 | umb_detach(struct device *self, int flags) |
657 | { |
658 | struct umb_softc *sc = (struct umb_softc *)self; |
659 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
660 | int s; |
661 | |
662 | s = splnet()splraise(0x4); |
663 | if (ifp->if_flags & IFF_RUNNING0x40) |
664 | umb_down(sc, 1); |
665 | umb_close(sc); |
666 | |
667 | #if NKSTAT1 > 0 |
668 | umb_kstat_detach(sc); |
669 | #endif |
670 | |
671 | usb_rem_wait_task(sc->sc_udev, &sc->sc_get_response_task); |
672 | if (timeout_initialized(&sc->sc_statechg_timer)((&sc->sc_statechg_timer)->to_flags & 0x04)) |
673 | timeout_del(&sc->sc_statechg_timer); |
674 | sc->sc_nresp = 0; |
675 | usb_rem_wait_task(sc->sc_udev, &sc->sc_umb_task); |
676 | if (sc->sc_ctrl_pipe) { |
677 | usbd_close_pipe(sc->sc_ctrl_pipe); |
678 | sc->sc_ctrl_pipe = NULL((void *)0); |
679 | } |
680 | if (sc->sc_ctrl_msg) { |
681 | free(sc->sc_ctrl_msg, M_USBDEV102, sc->sc_ctrl_len); |
682 | sc->sc_ctrl_msg = NULL((void *)0); |
683 | } |
684 | if (sc->sc_resp_buf) { |
685 | free(sc->sc_resp_buf, M_USBDEV102, sc->sc_ctrl_len); |
686 | sc->sc_resp_buf = NULL((void *)0); |
687 | } |
688 | if (ifp->if_softc != NULL((void *)0)) { |
689 | if_detach(ifp); |
690 | } |
691 | |
692 | splx(s)spllower(s); |
693 | return 0; |
694 | } |
695 | |
696 | void |
697 | umb_ncm_setup(struct umb_softc *sc) |
698 | { |
699 | usb_device_request_t req; |
700 | struct ncm_ntb_parameters np; |
701 | |
702 | /* Query NTB transfer sizes */ |
703 | req.bmRequestType = UT_READ_CLASS_INTERFACE(0x80 | 0x20 | 0x01); |
704 | req.bRequest = NCM_GET_NTB_PARAMETERS0x80; |
705 | USETW(req.wValue, 0)(*(u_int16_t *)(req.wValue) = (0)); |
706 | USETW(req.wIndex, sc->sc_ctrl_ifaceno)(*(u_int16_t *)(req.wIndex) = (sc->sc_ctrl_ifaceno)); |
707 | USETW(req.wLength, sizeof (np))(*(u_int16_t *)(req.wLength) = (sizeof (np))); |
708 | if (usbd_do_request(sc->sc_udev, &req, &np) == USBD_NORMAL_COMPLETION && |
709 | UGETW(np.wLength)(*(u_int16_t *)(np.wLength)) == sizeof (np)) { |
710 | sc->sc_rx_bufsz = UGETDW(np.dwNtbInMaxSize)(*(u_int32_t *)(np.dwNtbInMaxSize)); |
711 | sc->sc_tx_bufsz = UGETDW(np.dwNtbOutMaxSize)(*(u_int32_t *)(np.dwNtbOutMaxSize)); |
712 | sc->sc_maxdgram = UGETW(np.wNtbOutMaxDatagrams)(*(u_int16_t *)(np.wNtbOutMaxDatagrams)); |
713 | sc->sc_align = UGETW(np.wNdpOutAlignment)(*(u_int16_t *)(np.wNdpOutAlignment)); |
714 | sc->sc_ndp_div = UGETW(np.wNdpOutDivisor)(*(u_int16_t *)(np.wNdpOutDivisor)); |
715 | sc->sc_ndp_remainder = UGETW(np.wNdpOutPayloadRemainder)(*(u_int16_t *)(np.wNdpOutPayloadRemainder)); |
716 | /* Validate values */ |
717 | if (!powerof2(sc->sc_align)((((sc->sc_align)-1)&(sc->sc_align))==0) || sc->sc_align == 0 || |
718 | sc->sc_align >= sc->sc_tx_bufsz) |
719 | sc->sc_align = sizeof (uint32_t); |
720 | if (!powerof2(sc->sc_ndp_div)((((sc->sc_ndp_div)-1)&(sc->sc_ndp_div))==0) || sc->sc_ndp_div == 0 || |
721 | sc->sc_ndp_div >= sc->sc_tx_bufsz) |
722 | sc->sc_ndp_div = sizeof (uint32_t); |
723 | if (sc->sc_ndp_remainder >= sc->sc_ndp_div) |
724 | sc->sc_ndp_remainder = 0; |
725 | DPRINTF("%s: NCM align=%d div=%d rem=%d\n", DEVNAM(sc),do { } while (0) |
726 | sc->sc_align, sc->sc_ndp_div, sc->sc_ndp_remainder)do { } while (0); |
727 | sc->sc_ncm_supported_formats = UGETW(np.bmNtbFormatsSupported)(*(u_int16_t *)(np.bmNtbFormatsSupported)); |
728 | } else { |
729 | sc->sc_rx_bufsz = sc->sc_tx_bufsz = 8 * 1024; |
730 | sc->sc_maxdgram = 0; |
731 | sc->sc_align = sc->sc_ndp_div = sizeof (uint32_t); |
732 | sc->sc_ndp_remainder = 0; |
733 | DPRINTF("%s: align=default div=default rem=default\n",do { } while (0) |
734 | DEVNAM(sc))do { } while (0); |
735 | sc->sc_ncm_supported_formats = NCM_FORMAT_NTB16_MASK(1U << 0x00); |
736 | } |
737 | } |
738 | |
739 | void |
740 | umb_ncm_setup_format(struct umb_softc *sc) |
741 | { |
742 | usb_device_request_t req; |
743 | uWord wFmt; |
744 | uint16_t fmt; |
745 | |
746 | assertwaitok(); |
747 | if (sc->sc_ncm_supported_formats == 0) |
748 | goto fail; |
749 | |
750 | /* NCM_GET_NTB_FORMAT is not allowed for 16-bit only devices. */ |
751 | if (sc->sc_ncm_supported_formats == NCM_FORMAT_NTB16_MASK(1U << 0x00)) { |
752 | DPRINTF("%s: Only NTB16 format supported.\n", DEVNAM(sc))do { } while (0); |
753 | sc->sc_ncm_format = NCM_FORMAT_NTB160x00; |
754 | return; |
755 | } |
756 | |
757 | /* Query NTB FORMAT (16 vs. 32 bit) */ |
758 | req.bmRequestType = UT_READ_CLASS_INTERFACE(0x80 | 0x20 | 0x01); |
759 | req.bRequest = NCM_GET_NTB_FORMAT0x83; |
760 | USETW(req.wValue, 0)(*(u_int16_t *)(req.wValue) = (0)); |
761 | USETW(req.wIndex, sc->sc_ctrl_ifaceno)(*(u_int16_t *)(req.wIndex) = (sc->sc_ctrl_ifaceno)); |
762 | USETW(req.wLength, sizeof (wFmt))(*(u_int16_t *)(req.wLength) = (sizeof (wFmt))); |
763 | if (usbd_do_request(sc->sc_udev, &req, wFmt) != USBD_NORMAL_COMPLETION) |
764 | goto fail; |
765 | fmt = UGETW(wFmt)(*(u_int16_t *)(wFmt)); |
766 | if ((sc->sc_ncm_supported_formats & (1UL << fmt)) == 0) |
767 | goto fail; |
768 | if (fmt != NCM_FORMAT_NTB160x00 && fmt != NCM_FORMAT_NTB320x01) |
769 | goto fail; |
770 | sc->sc_ncm_format = fmt; |
771 | |
772 | DPRINTF("%s: Using NCM format %d, supported=0x%x\n",do { } while (0) |
773 | DEVNAM(sc), sc->sc_ncm_format, sc->sc_ncm_supported_formats)do { } while (0); |
774 | return; |
775 | |
776 | fail: |
777 | DPRINTF("%s: Cannot setup NCM format\n", DEVNAM(sc))do { } while (0); |
778 | sc->sc_ncm_supported_formats = 0; |
779 | } |
780 | |
781 | int |
782 | umb_alloc_xfers(struct umb_softc *sc) |
783 | { |
784 | if (!sc->sc_rx_xfer) { |
785 | if ((sc->sc_rx_xfer = usbd_alloc_xfer(sc->sc_udev)) != NULL((void *)0)) |
786 | sc->sc_rx_buf = usbd_alloc_buffer(sc->sc_rx_xfer, |
787 | sc->sc_rx_bufsz); |
788 | } |
789 | if (!sc->sc_tx_xfer) { |
790 | if ((sc->sc_tx_xfer = usbd_alloc_xfer(sc->sc_udev)) != NULL((void *)0)) |
791 | sc->sc_tx_buf = usbd_alloc_buffer(sc->sc_tx_xfer, |
792 | sc->sc_tx_bufsz); |
793 | } |
794 | return (sc->sc_rx_buf && sc->sc_tx_buf) ? 1 : 0; |
795 | } |
796 | |
797 | void |
798 | umb_free_xfers(struct umb_softc *sc) |
799 | { |
800 | if (sc->sc_rx_xfer) { |
801 | /* implicit usbd_free_buffer() */ |
802 | usbd_free_xfer(sc->sc_rx_xfer); |
803 | sc->sc_rx_xfer = NULL((void *)0); |
804 | sc->sc_rx_buf = NULL((void *)0); |
805 | } |
806 | if (sc->sc_tx_xfer) { |
807 | usbd_free_xfer(sc->sc_tx_xfer); |
808 | sc->sc_tx_xfer = NULL((void *)0); |
809 | sc->sc_tx_buf = NULL((void *)0); |
810 | } |
811 | ml_purge(&sc->sc_tx_ml); |
812 | } |
813 | |
814 | int |
815 | umb_alloc_bulkpipes(struct umb_softc *sc) |
816 | { |
817 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
818 | |
819 | if (!(ifp->if_flags & IFF_RUNNING0x40)) { |
820 | if (usbd_open_pipe(sc->sc_data_iface, sc->sc_rx_ep, |
821 | USBD_EXCLUSIVE_USE0x01, &sc->sc_rx_pipe)) |
822 | return 0; |
823 | if (usbd_open_pipe(sc->sc_data_iface, sc->sc_tx_ep, |
824 | USBD_EXCLUSIVE_USE0x01, &sc->sc_tx_pipe)) |
825 | return 0; |
826 | |
827 | ifp->if_flags |= IFF_RUNNING0x40; |
828 | ifq_clr_oactive(&ifp->if_snd); |
829 | umb_rx(sc); |
830 | } |
831 | return 1; |
832 | } |
833 | |
834 | void |
835 | umb_close_bulkpipes(struct umb_softc *sc) |
836 | { |
837 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
838 | |
839 | ifp->if_flags &= ~IFF_RUNNING0x40; |
840 | ifq_clr_oactive(&ifp->if_snd); |
841 | ifp->if_timer = 0; |
842 | if (sc->sc_rx_pipe) { |
843 | usbd_close_pipe(sc->sc_rx_pipe); |
844 | sc->sc_rx_pipe = NULL((void *)0); |
845 | } |
846 | if (sc->sc_tx_pipe) { |
847 | usbd_close_pipe(sc->sc_tx_pipe); |
848 | sc->sc_tx_pipe = NULL((void *)0); |
849 | } |
850 | } |
851 | |
852 | int |
853 | umb_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) |
854 | { |
855 | struct proc *p = curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc; |
856 | struct umb_softc *sc = ifp->if_softc; |
857 | struct ifreq *ifr = (struct ifreq *)data; |
858 | int s, error = 0; |
859 | struct umb_parameter mp; |
860 | |
861 | if (usbd_is_dying(sc->sc_udev)) |
862 | return ENXIO6; |
863 | |
864 | s = splnet()splraise(0x4); |
865 | switch (cmd) { |
866 | case SIOCSIFFLAGS((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff ) << 16) | ((('i')) << 8) | ((16))): |
867 | usb_add_task(sc->sc_udev, &sc->sc_umb_task); |
868 | break; |
869 | case SIOCGUMBINFO(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof (struct ifreq) & 0x1fff) << 16) | ((('i')) << 8) | ((190))): |
870 | error = copyout(&sc->sc_info, ifr->ifr_dataifr_ifru.ifru_data, |
871 | sizeof (sc->sc_info)); |
872 | break; |
873 | case SIOCSUMBPARAM((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff ) << 16) | ((('i')) << 8) | ((191))): |
874 | if ((error = suser(p)) != 0) |
875 | break; |
876 | if ((error = copyin(ifr->ifr_dataifr_ifru.ifru_data, &mp, sizeof (mp))) != 0) |
877 | break; |
878 | |
879 | if ((error = umb_setpin(sc, mp.op, mp.is_puk, mp.pin, mp.pinlen, |
880 | mp.newpin, mp.newpinlen)) != 0) |
881 | break; |
882 | |
883 | if (mp.apnlen < 0 || mp.apnlen > sizeof (sc->sc_info.apn)) { |
884 | error = EINVAL22; |
885 | break; |
886 | } |
887 | sc->sc_roamingsc_info.enable_roaming = mp.roaming ? 1 : 0; |
888 | memset(sc->sc_info.apn, 0, sizeof (sc->sc_info.apn))__builtin_memset((sc->sc_info.apn), (0), (sizeof (sc->sc_info .apn))); |
889 | memcpy(sc->sc_info.apn, mp.apn, mp.apnlen)__builtin_memcpy((sc->sc_info.apn), (mp.apn), (mp.apnlen)); |
890 | sc->sc_info.apnlen = mp.apnlen; |
891 | sc->sc_info.preferredclasses = mp.preferredclasses; |
892 | umb_setdataclass(sc); |
893 | break; |
894 | case SIOCGUMBPARAM(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof (struct ifreq) & 0x1fff) << 16) | ((('i')) << 8) | ((192))): |
895 | memset(&mp, 0, sizeof (mp))__builtin_memset((&mp), (0), (sizeof (mp))); |
896 | memcpy(mp.apn, sc->sc_info.apn, sc->sc_info.apnlen)__builtin_memcpy((mp.apn), (sc->sc_info.apn), (sc->sc_info .apnlen)); |
897 | mp.apnlen = sc->sc_info.apnlen; |
898 | mp.roaming = sc->sc_roamingsc_info.enable_roaming; |
899 | mp.preferredclasses = sc->sc_info.preferredclasses; |
900 | error = copyout(&mp, ifr->ifr_dataifr_ifru.ifru_data, sizeof (mp)); |
901 | break; |
902 | case SIOCSIFMTU((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff ) << 16) | ((('i')) << 8) | ((127))): |
903 | /* Does this include the NCM headers and tail? */ |
904 | if (ifr->ifr_mtuifr_ifru.ifru_metric > ifp->if_hardmtu) { |
905 | error = EINVAL22; |
906 | break; |
907 | } |
908 | ifp->if_mtuif_data.ifi_mtu = ifr->ifr_mtuifr_ifru.ifru_metric; |
909 | break; |
910 | case SIOCSIFADDR((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff ) << 16) | ((('i')) << 8) | ((12))): |
911 | case SIOCAIFADDR((unsigned long)0x80000000 | ((sizeof(struct ifaliasreq) & 0x1fff) << 16) | ((('i')) << 8) | ((26))): |
912 | case SIOCSIFDSTADDR((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff ) << 16) | ((('i')) << 8) | ((14))): |
913 | case SIOCADDMULTI((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff ) << 16) | ((('i')) << 8) | ((49))): |
914 | case SIOCDELMULTI((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff ) << 16) | ((('i')) << 8) | ((50))): |
915 | break; |
916 | default: |
917 | error = ENOTTY25; |
918 | break; |
919 | } |
920 | splx(s)spllower(s); |
921 | return error; |
922 | } |
923 | |
924 | int |
925 | umb_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst, |
926 | struct rtentry *rtp) |
927 | { |
928 | if ((ifp->if_flags & (IFF_UP0x1|IFF_RUNNING0x40)) != (IFF_UP0x1|IFF_RUNNING0x40)) { |
929 | m_freem(m); |
930 | return ENETDOWN50; |
931 | } |
932 | m->m_pkthdrM_dat.MH.MH_pkthdr.ph_family = dst->sa_family; |
933 | return if_enqueue(ifp, m); |
934 | } |
935 | |
936 | static inline int |
937 | umb_align(size_t bufsz, int offs, int alignment, int remainder) |
938 | { |
939 | size_t m = alignment - 1; |
940 | int align; |
941 | |
942 | align = (((size_t)offs + m) & ~m) - alignment + remainder; |
943 | if (align < offs) |
944 | align += alignment; |
945 | if (align > bufsz) |
946 | align = bufsz; |
947 | return align - offs; |
948 | } |
949 | |
950 | static inline int |
951 | umb_padding(void *buf, size_t bufsz, int offs, int alignment, int remainder) |
952 | { |
953 | int nb; |
954 | |
955 | nb = umb_align(bufsz, offs, alignment, remainder); |
956 | if (nb > 0) |
957 | memset(buf + offs, 0, nb)__builtin_memset((buf + offs), (0), (nb)); |
958 | return nb; |
959 | } |
960 | |
961 | void |
962 | umb_start(struct ifnet *ifp) |
963 | { |
964 | struct umb_softc *sc = ifp->if_softc; |
965 | struct mbuf *m = NULL((void *)0); |
966 | int ndgram = 0; |
967 | int offs, len, mlen; |
968 | int maxoverhead; |
969 | |
970 | if (usbd_is_dying(sc->sc_udev) || |
971 | !(ifp->if_flags & IFF_RUNNING0x40) || |
972 | ifq_is_oactive(&ifp->if_snd)) |
973 | return; |
974 | |
975 | KASSERT(ml_empty(&sc->sc_tx_ml))((((&sc->sc_tx_ml)->ml_len == 0)) ? (void)0 : __assert ("diagnostic ", "/usr/src/sys/dev/usb/if_umb.c", 975, "ml_empty(&sc->sc_tx_ml)" )); |
976 | |
977 | switch (sc->sc_ncm_format) { |
978 | case NCM_FORMAT_NTB160x00: |
979 | offs = sizeof (struct ncm_header16); |
980 | offs += umb_align(sc->sc_tx_bufsz, offs, sc->sc_align, 0); |
981 | offs += sizeof (struct ncm_pointer16); |
982 | maxoverhead = sizeof (struct ncm_pointer16_dgram); |
983 | break; |
984 | case NCM_FORMAT_NTB320x01: |
985 | offs = sizeof (struct ncm_header32); |
986 | offs += umb_align(sc->sc_tx_bufsz, offs, sc->sc_align, 0); |
987 | offs += sizeof (struct ncm_pointer32); |
988 | maxoverhead = sizeof (struct ncm_pointer32_dgram); |
989 | break; |
990 | } |
991 | |
992 | /* |
993 | * Overhead for per packet alignment plus packet pointer. Note |
994 | * that 'struct ncm_pointer{16,32}' already includes space for |
995 | * the terminating zero pointer. |
996 | */ |
997 | maxoverhead += sc->sc_ndp_div - 1; |
998 | |
999 | len = 0; |
1000 | while (1) { |
1001 | m = ifq_deq_begin(&ifp->if_snd); |
1002 | if (m == NULL((void *)0)) |
1003 | break; |
1004 | |
1005 | /* |
1006 | * Check if mbuf plus required NCM pointer still fits into |
1007 | * xfer buffers. Assume maximal padding. |
1008 | */ |
1009 | mlen = maxoverhead + m->m_pkthdrM_dat.MH.MH_pkthdr.len; |
1010 | if ((sc->sc_maxdgram != 0 && ndgram >= sc->sc_maxdgram) || |
1011 | (offs + len + mlen > sc->sc_tx_bufsz)) { |
1012 | ifq_deq_rollback(&ifp->if_snd, m); |
1013 | break; |
1014 | } |
1015 | ifq_deq_commit(&ifp->if_snd, m); |
1016 | |
1017 | ndgram++; |
1018 | len += mlen; |
1019 | ml_enqueue(&sc->sc_tx_ml, m); |
1020 | |
1021 | #if NBPFILTER1 > 0 |
1022 | if (ifp->if_bpf) |
1023 | bpf_mtap_af(ifp->if_bpf, m->m_pkthdrM_dat.MH.MH_pkthdr.ph_family, m, |
1024 | BPF_DIRECTION_OUT(1 << 1)); |
1025 | #endif |
1026 | } |
1027 | if (ml_empty(&sc->sc_tx_ml)((&sc->sc_tx_ml)->ml_len == 0)) |
1028 | return; |
1029 | if (umb_encap(sc, ndgram)) { |
1030 | ifq_set_oactive(&ifp->if_snd); |
1031 | ifp->if_timer = (2 * umb_xfer_tout) / 1000; |
1032 | } |
1033 | } |
1034 | |
1035 | void |
1036 | umb_rtrequest(struct ifnet *ifp, int req, struct rtentry *rt) |
1037 | { |
1038 | struct umb_softc *sc = ifp->if_softc; |
1039 | |
1040 | if (req == RTM_PROPOSAL0x13) { |
1041 | KERNEL_LOCK()_kernel_lock(); |
1042 | umb_send_inet_proposal(sc, AF_INET2); |
1043 | #ifdef INET61 |
1044 | umb_send_inet_proposal(sc, AF_INET624); |
1045 | #endif |
1046 | KERNEL_UNLOCK()_kernel_unlock(); |
1047 | return; |
1048 | } |
1049 | |
1050 | p2p_rtrequest(ifp, req, rt); |
1051 | } |
1052 | |
1053 | |
1054 | void |
1055 | umb_watchdog(struct ifnet *ifp) |
1056 | { |
1057 | struct umb_softc *sc = ifp->if_softc; |
1058 | |
1059 | if (usbd_is_dying(sc->sc_udev)) |
1060 | return; |
1061 | |
1062 | ifp->if_oerrorsif_data.ifi_oerrors++; |
1063 | printf("%s: watchdog timeout\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
1064 | usbd_abort_pipe(sc->sc_tx_pipe); |
1065 | return; |
1066 | } |
1067 | |
1068 | void |
1069 | umb_statechg_timeout(void *arg) |
1070 | { |
1071 | struct umb_softc *sc = arg; |
1072 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
1073 | |
1074 | if (sc->sc_info.regstate != MBIM_REGSTATE_ROAMING4 || sc->sc_roamingsc_info.enable_roaming) |
1075 | if (ifp->if_flags & IFF_DEBUG0x4) |
1076 | log(LOG_DEBUG7, "%s: state change timeout\n", |
1077 | DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
1078 | usb_add_task(sc->sc_udev, &sc->sc_umb_task); |
1079 | } |
1080 | |
1081 | void |
1082 | umb_newstate(struct umb_softc *sc, enum umb_state newstate, int flags) |
1083 | { |
1084 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
1085 | |
1086 | if (newstate == sc->sc_statesc_info.state) |
1087 | return; |
1088 | if (((flags & UMB_NS_DONT_DROP0x0001) && newstate < sc->sc_statesc_info.state) || |
1089 | ((flags & UMB_NS_DONT_RAISE0x0002) && newstate > sc->sc_statesc_info.state)) |
1090 | return; |
1091 | if (ifp->if_flags & IFF_DEBUG0x4) |
1092 | log(LOG_DEBUG7, "%s: state going %s from '%s' to '%s'\n", |
1093 | DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), newstate > sc->sc_statesc_info.state ? "up" : "down", |
1094 | umb_istate(sc->sc_state)umb_val2descr(umb_istate, (sc->sc_info.state)), umb_istate(newstate)umb_val2descr(umb_istate, (newstate))); |
1095 | sc->sc_statesc_info.state = newstate; |
1096 | usb_add_task(sc->sc_udev, &sc->sc_umb_task); |
1097 | } |
1098 | |
1099 | void |
1100 | umb_state_task(void *arg) |
1101 | { |
1102 | struct umb_softc *sc = arg; |
1103 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
1104 | int s; |
1105 | int state; |
1106 | |
1107 | if (sc->sc_info.regstate == MBIM_REGSTATE_ROAMING4 && !sc->sc_roamingsc_info.enable_roaming) { |
1108 | /* |
1109 | * Query the registration state until we're with the home |
1110 | * network again. |
1111 | */ |
1112 | umb_cmd(sc, MBIM_CID_REGISTER_STATE9, MBIM_CMDOP_QRY0, NULL((void *)0), 0); |
1113 | return; |
1114 | } |
1115 | |
1116 | s = splnet()splraise(0x4); |
1117 | if (ifp->if_flags & IFF_UP0x1) |
1118 | umb_up(sc); |
1119 | else |
1120 | umb_down(sc, 0); |
1121 | |
1122 | state = sc->sc_statesc_info.state == UMB_S_UP ? LINK_STATE_UP4 : LINK_STATE_DOWN2; |
1123 | if (ifp->if_link_stateif_data.ifi_link_state != state) { |
1124 | if (ifp->if_flags & IFF_DEBUG0x4) |
1125 | log(LOG_DEBUG7, "%s: link state changed from %s to %s\n", |
1126 | DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), |
1127 | LINK_STATE_IS_UP(ifp->if_link_state)((ifp->if_data.ifi_link_state) >= 4 || (ifp->if_data .ifi_link_state) == 0) |
1128 | ? "up" : "down", |
1129 | LINK_STATE_IS_UP(state)((state) >= 4 || (state) == 0) ? "up" : "down"); |
1130 | ifp->if_link_stateif_data.ifi_link_state = state; |
1131 | if_link_state_change(ifp); |
1132 | } |
1133 | splx(s)spllower(s); |
1134 | } |
1135 | |
1136 | void |
1137 | umb_up(struct umb_softc *sc) |
1138 | { |
1139 | splassert(IPL_NET)do { if (splassert_ctl > 0) { splassert_check(0x4, __func__ ); } } while (0); |
1140 | |
1141 | switch (sc->sc_statesc_info.state) { |
1142 | case UMB_S_DOWN: |
1143 | DPRINTF("%s: init: opening ...\n", DEVNAM(sc))do { } while (0); |
1144 | umb_open(sc); |
1145 | break; |
1146 | case UMB_S_OPEN: |
1147 | if (sc->sc_flags & UMBFLG_FCC_AUTH_REQUIRED0x0001) { |
1148 | if (sc->sc_cid == -1) { |
1149 | DPRINTF("%s: init: allocating CID ...\n",do { } while (0) |
1150 | DEVNAM(sc))do { } while (0); |
1151 | umb_allocate_cid(sc); |
1152 | break; |
1153 | } else |
1154 | umb_newstate(sc, UMB_S_CID, UMB_NS_DONT_DROP0x0001); |
1155 | } else { |
1156 | DPRINTF("%s: init: turning radio on ...\n", DEVNAM(sc))do { } while (0); |
1157 | umb_radio(sc, 1); |
1158 | break; |
1159 | } |
1160 | /*FALLTHROUGH*/ |
1161 | case UMB_S_CID: |
1162 | DPRINTF("%s: init: sending FCC auth ...\n", DEVNAM(sc))do { } while (0); |
1163 | umb_send_fcc_auth(sc); |
1164 | break; |
1165 | case UMB_S_RADIO: |
1166 | DPRINTF("%s: init: checking SIM state ...\n", DEVNAM(sc))do { } while (0); |
1167 | umb_cmd(sc, MBIM_CID_SUBSCRIBER_READY_STATUS2, MBIM_CMDOP_QRY0, |
1168 | NULL((void *)0), 0); |
1169 | break; |
1170 | case UMB_S_SIMREADY: |
1171 | DPRINTF("%s: init: attaching ...\n", DEVNAM(sc))do { } while (0); |
1172 | umb_packet_service(sc, 1); |
1173 | break; |
1174 | case UMB_S_ATTACHED: |
1175 | sc->sc_tx_seq = 0; |
1176 | if (!umb_alloc_xfers(sc)) { |
1177 | umb_free_xfers(sc); |
1178 | printf("%s: allocation of xfers failed\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
1179 | break; |
1180 | } |
1181 | DPRINTF("%s: init: connecting ...\n", DEVNAM(sc))do { } while (0); |
1182 | umb_connect(sc); |
1183 | break; |
1184 | case UMB_S_CONNECTED: |
1185 | DPRINTF("%s: init: getting IP config ...\n", DEVNAM(sc))do { } while (0); |
1186 | umb_qry_ipconfig(sc); |
1187 | break; |
1188 | case UMB_S_UP: |
1189 | DPRINTF("%s: init: reached state UP\n", DEVNAM(sc))do { } while (0); |
1190 | if (!umb_alloc_bulkpipes(sc)) { |
1191 | printf("%s: opening bulk pipes failed\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
1192 | umb_down(sc, 1); |
1193 | } |
1194 | break; |
1195 | } |
1196 | if (sc->sc_statesc_info.state < UMB_S_UP) |
1197 | timeout_add_sec(&sc->sc_statechg_timer, |
1198 | UMB_STATE_CHANGE_TIMEOUT30); |
1199 | else |
1200 | timeout_del(&sc->sc_statechg_timer); |
1201 | return; |
1202 | } |
1203 | |
1204 | void |
1205 | umb_down(struct umb_softc *sc, int force) |
1206 | { |
1207 | splassert(IPL_NET)do { if (splassert_ctl > 0) { splassert_check(0x4, __func__ ); } } while (0); |
1208 | |
1209 | umb_close_bulkpipes(sc); |
1210 | if (sc->sc_statesc_info.state < UMB_S_CONNECTED) |
1211 | umb_free_xfers(sc); |
1212 | |
1213 | switch (sc->sc_statesc_info.state) { |
1214 | case UMB_S_UP: |
1215 | umb_clear_addr(sc); |
1216 | /*FALLTHROUGH*/ |
1217 | case UMB_S_CONNECTED: |
1218 | DPRINTF("%s: stop: disconnecting ...\n", DEVNAM(sc))do { } while (0); |
1219 | umb_disconnect(sc); |
1220 | if (!force) |
1221 | break; |
1222 | /*FALLTHROUGH*/ |
1223 | case UMB_S_ATTACHED: |
1224 | DPRINTF("%s: stop: detaching ...\n", DEVNAM(sc))do { } while (0); |
1225 | umb_packet_service(sc, 0); |
1226 | if (!force) |
1227 | break; |
1228 | /*FALLTHROUGH*/ |
1229 | case UMB_S_SIMREADY: |
1230 | case UMB_S_RADIO: |
1231 | DPRINTF("%s: stop: turning radio off ...\n", DEVNAM(sc))do { } while (0); |
1232 | umb_radio(sc, 0); |
1233 | if (!force) |
1234 | break; |
1235 | /*FALLTHROUGH*/ |
1236 | case UMB_S_CID: |
1237 | case UMB_S_OPEN: |
1238 | case UMB_S_DOWN: |
1239 | /* Do not close the device */ |
1240 | DPRINTF("%s: stop: reached state DOWN\n", DEVNAM(sc))do { } while (0); |
1241 | break; |
1242 | } |
1243 | if (force) |
1244 | sc->sc_statesc_info.state = UMB_S_OPEN; |
1245 | |
1246 | if (sc->sc_statesc_info.state > UMB_S_OPEN) |
1247 | timeout_add_sec(&sc->sc_statechg_timer, |
1248 | UMB_STATE_CHANGE_TIMEOUT30); |
1249 | else |
1250 | timeout_del(&sc->sc_statechg_timer); |
1251 | } |
1252 | |
1253 | void |
1254 | umb_get_response_task(void *arg) |
1255 | { |
1256 | struct umb_softc *sc = arg; |
1257 | int len; |
1258 | int s; |
1259 | |
1260 | /* |
1261 | * Function is required to send on RESPONSE_AVAILABLE notification for |
1262 | * each encapsulated response that is to be processed by the host. |
1263 | * But of course, we can receive multiple notifications before the |
1264 | * response task is run. |
1265 | */ |
1266 | s = splusb()splraise(0x2); |
1267 | while (sc->sc_nresp > 0) { |
1268 | --sc->sc_nresp; |
1269 | len = sc->sc_ctrl_len; |
1270 | if (umb_get_encap_response(sc, sc->sc_resp_buf, &len)) |
1271 | umb_decode_response(sc, sc->sc_resp_buf, len); |
1272 | } |
1273 | splx(s)spllower(s); |
1274 | } |
1275 | |
1276 | void |
1277 | umb_decode_response(struct umb_softc *sc, void *response, int len) |
1278 | { |
1279 | struct mbim_msghdr *hdr = response; |
1280 | struct mbim_fragmented_msg_hdr *fraghdr; |
1281 | uint32_t type; |
1282 | uint32_t tid; |
1283 | |
1284 | DPRINTFN(3, "%s: got response: len %d\n", DEVNAM(sc), len)do { } while (0); |
1285 | DDUMPN(4, response, len)do { } while (0); |
1286 | |
1287 | if (len < sizeof (*hdr) || letoh32(hdr->len)((__uint32_t)(hdr->len)) != len) { |
1288 | /* |
1289 | * We should probably cancel a transaction, but since the |
1290 | * message is too short, we cannot decode the transaction |
1291 | * id (tid) and hence don't know, whom to cancel. Must wait |
1292 | * for the timeout. |
1293 | */ |
1294 | DPRINTF("%s: received short response (len %d)\n",do { } while (0) |
1295 | DEVNAM(sc), len)do { } while (0); |
1296 | return; |
1297 | } |
1298 | |
1299 | /* |
1300 | * XXX FIXME: if message is fragmented, store it until last frag |
1301 | * is received and then re-assemble all fragments. |
1302 | */ |
1303 | type = letoh32(hdr->type)((__uint32_t)(hdr->type)); |
1304 | tid = letoh32(hdr->tid)((__uint32_t)(hdr->tid)); |
Value stored to 'tid' is never read | |
1305 | switch (type) { |
1306 | case MBIM_INDICATE_STATUS_MSG0x80000007U: |
1307 | case MBIM_COMMAND_DONE0x80000003U: |
1308 | fraghdr = response; |
1309 | if (letoh32(fraghdr->frag.nfrag)((__uint32_t)(fraghdr->frag.nfrag)) != 1) { |
1310 | DPRINTF("%s: discarding fragmented messages\n",do { } while (0) |
1311 | DEVNAM(sc))do { } while (0); |
1312 | return; |
1313 | } |
1314 | break; |
1315 | default: |
1316 | break; |
1317 | } |
1318 | |
1319 | DPRINTF("%s: <- rcv %s (tid %u)\n", DEVNAM(sc), umb_request2str(type),do { } while (0) |
1320 | tid)do { } while (0); |
1321 | switch (type) { |
1322 | case MBIM_FUNCTION_ERROR_MSG0x80000004U: |
1323 | case MBIM_HOST_ERROR_MSG4U: |
1324 | { |
1325 | struct mbim_f2h_hosterr *e; |
1326 | int err; |
1327 | |
1328 | if (len >= sizeof (*e)) { |
1329 | e = response; |
1330 | err = letoh32(e->err)((__uint32_t)(e->err)); |
1331 | |
1332 | DPRINTF("%s: %s message, error %s (tid %u)\n",do { } while (0) |
1333 | DEVNAM(sc), umb_request2str(type),do { } while (0) |
1334 | umb_error2str(err), tid)do { } while (0); |
1335 | if (err == MBIM_ERROR_NOT_OPENED5) |
1336 | umb_newstate(sc, UMB_S_DOWN, 0); |
1337 | } |
1338 | break; |
1339 | } |
1340 | case MBIM_INDICATE_STATUS_MSG0x80000007U: |
1341 | umb_handle_indicate_status_msg(sc, response, len); |
1342 | break; |
1343 | case MBIM_OPEN_DONE0x80000001U: |
1344 | umb_handle_opendone_msg(sc, response, len); |
1345 | break; |
1346 | case MBIM_CLOSE_DONE0x80000002U: |
1347 | umb_handle_closedone_msg(sc, response, len); |
1348 | break; |
1349 | case MBIM_COMMAND_DONE0x80000003U: |
1350 | umb_command_done(sc, response, len); |
1351 | break; |
1352 | default: |
1353 | DPRINTF("%s: discard message %s\n", DEVNAM(sc),do { } while (0) |
1354 | umb_request2str(type))do { } while (0); |
1355 | break; |
1356 | } |
1357 | } |
1358 | |
1359 | void |
1360 | umb_handle_indicate_status_msg(struct umb_softc *sc, void *data, int len) |
1361 | { |
1362 | struct mbim_f2h_indicate_status *m = data; |
1363 | uint32_t infolen; |
1364 | uint32_t cid; |
1365 | |
1366 | if (len < sizeof (*m)) { |
1367 | DPRINTF("%s: discard short %s message\n", DEVNAM(sc),do { } while (0) |
1368 | umb_request2str(letoh32(m->hdr.type)))do { } while (0); |
1369 | return; |
1370 | } |
1371 | if (memcmp(m->devid, umb_uuid_basic_connect, sizeof (m->devid))__builtin_memcmp((m->devid), (umb_uuid_basic_connect), (sizeof (m->devid)))) { |
1372 | DPRINTF("%s: discard %s message for other UUID '%s'\n",do { } while (0) |
1373 | DEVNAM(sc), umb_request2str(letoh32(m->hdr.type)),do { } while (0) |
1374 | umb_uuid2str(m->devid))do { } while (0); |
1375 | return; |
1376 | } |
1377 | infolen = letoh32(m->infolen)((__uint32_t)(m->infolen)); |
1378 | if (len < sizeof (*m) + infolen) { |
1379 | DPRINTF("%s: discard truncated %s message (want %d, got %d)\n",do { } while (0) |
1380 | DEVNAM(sc), umb_request2str(letoh32(m->hdr.type)),do { } while (0) |
1381 | (int)sizeof (*m) + infolen, len)do { } while (0); |
1382 | return; |
1383 | } |
1384 | |
1385 | cid = letoh32(m->cid)((__uint32_t)(m->cid)); |
1386 | DPRINTF("%s: indicate %s status\n", DEVNAM(sc), umb_cid2str(cid))do { } while (0); |
1387 | umb_decode_cid(sc, cid, m->info, infolen); |
1388 | } |
1389 | |
1390 | void |
1391 | umb_handle_opendone_msg(struct umb_softc *sc, void *data, int len) |
1392 | { |
1393 | struct mbim_f2h_openclosedone *resp = data; |
1394 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
1395 | uint32_t status; |
1396 | |
1397 | status = letoh32(resp->status)((__uint32_t)(resp->status)); |
1398 | if (status == MBIM_STATUS_SUCCESS0) { |
1399 | if (sc->sc_maxsessions == 0) { |
1400 | umb_cmd(sc, MBIM_CID_DEVICE_CAPS1, MBIM_CMDOP_QRY0, NULL((void *)0), |
1401 | 0); |
1402 | umb_cmd(sc, MBIM_CID_PIN4, MBIM_CMDOP_QRY0, NULL((void *)0), 0); |
1403 | umb_cmd(sc, MBIM_CID_REGISTER_STATE9, MBIM_CMDOP_QRY0, |
1404 | NULL((void *)0), 0); |
1405 | } |
1406 | umb_newstate(sc, UMB_S_OPEN, UMB_NS_DONT_DROP0x0001); |
1407 | } else if (ifp->if_flags & IFF_DEBUG0x4) |
1408 | log(LOG_ERR3, "%s: open error: %s\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), |
1409 | umb_status2str(status)umb_val2descr(umb_status, (status))); |
1410 | return; |
1411 | } |
1412 | |
1413 | void |
1414 | umb_handle_closedone_msg(struct umb_softc *sc, void *data, int len) |
1415 | { |
1416 | struct mbim_f2h_openclosedone *resp = data; |
1417 | uint32_t status; |
1418 | |
1419 | status = letoh32(resp->status)((__uint32_t)(resp->status)); |
1420 | if (status == MBIM_STATUS_SUCCESS0) |
1421 | umb_newstate(sc, UMB_S_DOWN, 0); |
1422 | else |
1423 | DPRINTF("%s: close error: %s\n", DEVNAM(sc),do { } while (0) |
1424 | umb_status2str(status))do { } while (0); |
1425 | return; |
1426 | } |
1427 | |
1428 | static inline void |
1429 | umb_getinfobuf(void *in, int inlen, uint32_t offs, uint32_t sz, |
1430 | void *out, size_t outlen) |
1431 | { |
1432 | offs = letoh32(offs)((__uint32_t)(offs)); |
1433 | sz = letoh32(sz)((__uint32_t)(sz)); |
1434 | if (inlen >= offs + sz) { |
1435 | memset(out, 0, outlen)__builtin_memset((out), (0), (outlen)); |
1436 | memcpy(out, in + offs, MIN(sz, outlen))__builtin_memcpy((out), (in + offs), ((((sz)<(outlen))?(sz ):(outlen)))); |
1437 | } |
1438 | } |
1439 | |
1440 | static inline int |
1441 | umb_addstr(void *buf, size_t bufsz, int *offs, void *str, int slen, |
1442 | uint32_t *offsmember, uint32_t *sizemember) |
1443 | { |
1444 | if (*offs + slen > bufsz) |
1445 | return 0; |
1446 | |
1447 | *sizemember = htole32((uint32_t)slen)((__uint32_t)((uint32_t)slen)); |
1448 | if (slen && str) { |
1449 | *offsmember = htole32((uint32_t)*offs)((__uint32_t)((uint32_t)*offs)); |
1450 | memcpy(buf + *offs, str, slen)__builtin_memcpy((buf + *offs), (str), (slen)); |
1451 | *offs += slen; |
1452 | *offs += umb_padding(buf, bufsz, *offs, sizeof (uint32_t), 0); |
1453 | } else |
1454 | *offsmember = htole32(0)((__uint32_t)(0)); |
1455 | return 1; |
1456 | } |
1457 | |
1458 | int |
1459 | umb_decode_register_state(struct umb_softc *sc, void *data, int len) |
1460 | { |
1461 | struct mbim_cid_registration_state_info *rs = data; |
1462 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
1463 | |
1464 | if (len < sizeof (*rs)) |
1465 | return 0; |
1466 | sc->sc_info.nwerror = letoh32(rs->nwerror)((__uint32_t)(rs->nwerror)); |
1467 | sc->sc_info.regstate = letoh32(rs->regstate)((__uint32_t)(rs->regstate)); |
1468 | sc->sc_info.regmode = letoh32(rs->regmode)((__uint32_t)(rs->regmode)); |
1469 | sc->sc_info.cellclass = letoh32(rs->curcellclass)((__uint32_t)(rs->curcellclass)); |
1470 | |
1471 | umb_getinfobuf(data, len, rs->provname_offs, rs->provname_size, |
1472 | sc->sc_info.provider, sizeof (sc->sc_info.provider)); |
1473 | umb_getinfobuf(data, len, rs->provid_offs, rs->provid_size, |
1474 | sc->sc_info.providerid, sizeof (sc->sc_info.providerid)); |
1475 | umb_getinfobuf(data, len, rs->roamingtxt_offs, rs->roamingtxt_size, |
1476 | sc->sc_info.roamingtxt, sizeof (sc->sc_info.roamingtxt)); |
1477 | |
1478 | DPRINTFN(2, "%s: %s, availclass 0x%x, class 0x%x, regmode %d\n",do { } while (0) |
1479 | DEVNAM(sc), umb_regstate(sc->sc_info.regstate),do { } while (0) |
1480 | letoh32(rs->availclasses), sc->sc_info.cellclass,do { } while (0) |
1481 | sc->sc_info.regmode)do { } while (0); |
1482 | |
1483 | if (sc->sc_info.regstate == MBIM_REGSTATE_ROAMING4 && |
1484 | !sc->sc_roamingsc_info.enable_roaming && |
1485 | sc->sc_info.activation == MBIM_ACTIVATION_STATE_ACTIVATED1) { |
1486 | if (ifp->if_flags & IFF_DEBUG0x4) |
1487 | log(LOG_INFO6, |
1488 | "%s: disconnecting from roaming network\n", |
1489 | DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
1490 | umb_disconnect(sc); |
1491 | } |
1492 | return 1; |
1493 | } |
1494 | |
1495 | int |
1496 | umb_decode_devices_caps(struct umb_softc *sc, void *data, int len) |
1497 | { |
1498 | struct mbim_cid_device_caps *dc = data; |
1499 | |
1500 | if (len < sizeof (*dc)) |
1501 | return 0; |
1502 | sc->sc_maxsessions = letoh32(dc->max_sessions)((__uint32_t)(dc->max_sessions)); |
1503 | sc->sc_info.supportedclasses = letoh32(dc->dataclass)((__uint32_t)(dc->dataclass)); |
1504 | umb_getinfobuf(data, len, dc->devid_offs, dc->devid_size, |
1505 | sc->sc_info.devid, sizeof (sc->sc_info.devid)); |
1506 | umb_getinfobuf(data, len, dc->fwinfo_offs, dc->fwinfo_size, |
1507 | sc->sc_info.fwinfo, sizeof (sc->sc_info.fwinfo)); |
1508 | umb_getinfobuf(data, len, dc->hwinfo_offs, dc->hwinfo_size, |
1509 | sc->sc_info.hwinfo, sizeof (sc->sc_info.hwinfo)); |
1510 | DPRINTFN(2, "%s: max sessions %d, supported classes 0x%x\n",do { } while (0) |
1511 | DEVNAM(sc), sc->sc_maxsessions, sc->sc_info.supportedclasses)do { } while (0); |
1512 | return 1; |
1513 | } |
1514 | |
1515 | int |
1516 | umb_decode_subscriber_status(struct umb_softc *sc, void *data, int len) |
1517 | { |
1518 | struct mbim_cid_subscriber_ready_info *si = data; |
1519 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
1520 | int npn; |
1521 | |
1522 | if (len < sizeof (*si)) |
1523 | return 0; |
1524 | sc->sc_info.sim_state = letoh32(si->ready)((__uint32_t)(si->ready)); |
1525 | |
1526 | umb_getinfobuf(data, len, si->sid_offs, si->sid_size, |
1527 | sc->sc_info.sid, sizeof (sc->sc_info.sid)); |
1528 | umb_getinfobuf(data, len, si->icc_offs, si->icc_size, |
1529 | sc->sc_info.iccid, sizeof (sc->sc_info.iccid)); |
1530 | |
1531 | npn = letoh32(si->no_pn)((__uint32_t)(si->no_pn)); |
1532 | if (npn > 0) |
1533 | umb_getinfobuf(data, len, si->pn[0].offs, si->pn[0].size, |
1534 | sc->sc_info.pn, sizeof (sc->sc_info.pn)); |
1535 | else |
1536 | memset(sc->sc_info.pn, 0, sizeof (sc->sc_info.pn))__builtin_memset((sc->sc_info.pn), (0), (sizeof (sc->sc_info .pn))); |
1537 | |
1538 | if (sc->sc_info.sim_state == MBIM_SIMSTATE_LOCKED6) |
1539 | sc->sc_info.pin_state = UMB_PUK_REQUIRED2; |
1540 | if (ifp->if_flags & IFF_DEBUG0x4) |
1541 | log(LOG_INFO6, "%s: SIM %s\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), |
1542 | umb_simstate(sc->sc_info.sim_state)umb_val2descr(umb_simstate, (sc->sc_info.sim_state))); |
1543 | if (sc->sc_info.sim_state == MBIM_SIMSTATE_INITIALIZED1) |
1544 | umb_newstate(sc, UMB_S_SIMREADY, UMB_NS_DONT_DROP0x0001); |
1545 | return 1; |
1546 | } |
1547 | |
1548 | int |
1549 | umb_decode_radio_state(struct umb_softc *sc, void *data, int len) |
1550 | { |
1551 | struct mbim_cid_radio_state_info *rs = data; |
1552 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
1553 | |
1554 | if (len < sizeof (*rs)) |
1555 | return 0; |
1556 | |
1557 | sc->sc_info.hw_radio_on = |
1558 | (letoh32(rs->hw_state)((__uint32_t)(rs->hw_state)) == MBIM_RADIO_STATE_ON1) ? 1 : 0; |
1559 | sc->sc_info.sw_radio_on = |
1560 | (letoh32(rs->sw_state)((__uint32_t)(rs->sw_state)) == MBIM_RADIO_STATE_ON1) ? 1 : 0; |
1561 | if (!sc->sc_info.hw_radio_on) { |
1562 | printf("%s: radio is disabled by hardware switch\n", |
1563 | DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
1564 | /* |
1565 | * XXX do we need a time to poll the state of the rfkill switch |
1566 | * or will the device send an unsolicited notification |
1567 | * in case the state changes? |
1568 | */ |
1569 | umb_newstate(sc, UMB_S_OPEN, 0); |
1570 | } else if (!sc->sc_info.sw_radio_on) { |
1571 | if (ifp->if_flags & IFF_DEBUG0x4) |
1572 | log(LOG_INFO6, "%s: radio is off\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
1573 | umb_newstate(sc, UMB_S_OPEN, 0); |
1574 | } else |
1575 | umb_newstate(sc, UMB_S_RADIO, UMB_NS_DONT_DROP0x0001); |
1576 | return 1; |
1577 | } |
1578 | |
1579 | int |
1580 | umb_decode_pin(struct umb_softc *sc, void *data, int len) |
1581 | { |
1582 | struct mbim_cid_pin_info *pi = data; |
1583 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
1584 | uint32_t attempts_left; |
1585 | |
1586 | if (len < sizeof (*pi)) |
1587 | return 0; |
1588 | |
1589 | attempts_left = letoh32(pi->remaining_attempts)((__uint32_t)(pi->remaining_attempts)); |
1590 | if (attempts_left != 0xffffffff) |
1591 | sc->sc_info.pin_attempts_left = attempts_left; |
1592 | |
1593 | switch (letoh32(pi->state)((__uint32_t)(pi->state))) { |
1594 | case MBIM_PIN_STATE_UNLOCKED0: |
1595 | sc->sc_info.pin_state = UMB_PIN_UNLOCKED1; |
1596 | break; |
1597 | case MBIM_PIN_STATE_LOCKED1: |
1598 | switch (letoh32(pi->type)((__uint32_t)(pi->type))) { |
1599 | case MBIM_PIN_TYPE_PIN12: |
1600 | sc->sc_info.pin_state = UMB_PIN_REQUIRED0; |
1601 | break; |
1602 | case MBIM_PIN_TYPE_PUK111: |
1603 | sc->sc_info.pin_state = UMB_PUK_REQUIRED2; |
1604 | break; |
1605 | case MBIM_PIN_TYPE_PIN23: |
1606 | case MBIM_PIN_TYPE_PUK212: |
1607 | /* Assume that PIN1 was accepted */ |
1608 | sc->sc_info.pin_state = UMB_PIN_UNLOCKED1; |
1609 | break; |
1610 | } |
1611 | break; |
1612 | } |
1613 | if (ifp->if_flags & IFF_DEBUG0x4) |
1614 | log(LOG_INFO6, "%s: %s state %s (%d attempts left)\n", |
1615 | DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), umb_pin_type(letoh32(pi->type))umb_val2descr(umb_pintype, (((__uint32_t)(pi->type)))), |
1616 | (letoh32(pi->state)((__uint32_t)(pi->state)) == MBIM_PIN_STATE_UNLOCKED0) ? |
1617 | "unlocked" : "locked", |
1618 | letoh32(pi->remaining_attempts)((__uint32_t)(pi->remaining_attempts))); |
1619 | |
1620 | /* |
1621 | * In case the PIN was set after IFF_UP, retrigger the state machine |
1622 | */ |
1623 | usb_add_task(sc->sc_udev, &sc->sc_umb_task); |
1624 | return 1; |
1625 | } |
1626 | |
1627 | int |
1628 | umb_decode_packet_service(struct umb_softc *sc, void *data, int len) |
1629 | { |
1630 | struct mbim_cid_packet_service_info *psi = data; |
1631 | int state, highestclass; |
1632 | uint64_t up_speed, down_speed; |
1633 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
1634 | |
1635 | if (len < sizeof (*psi)) |
1636 | return 0; |
1637 | |
1638 | sc->sc_info.nwerror = letoh32(psi->nwerror)((__uint32_t)(psi->nwerror)); |
1639 | state = letoh32(psi->state)((__uint32_t)(psi->state)); |
1640 | highestclass = letoh32(psi->highest_dataclass)((__uint32_t)(psi->highest_dataclass)); |
1641 | up_speed = letoh64(psi->uplink_speed)((__uint64_t)(psi->uplink_speed)); |
1642 | down_speed = letoh64(psi->downlink_speed)((__uint64_t)(psi->downlink_speed)); |
1643 | if (sc->sc_info.packetstate != state || |
1644 | sc->sc_info.uplink_speed != up_speed || |
1645 | sc->sc_info.downlink_speed != down_speed) { |
1646 | if (ifp->if_flags & IFF_DEBUG0x4) { |
1647 | log(LOG_INFO6, "%s: packet service ", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
1648 | if (sc->sc_info.packetstate != state) |
1649 | addlog("changed from %s to ", |
1650 | umb_packet_state(sc->sc_info.packetstate)umb_val2descr(umb_pktstate, (sc->sc_info.packetstate))); |
1651 | addlog("%s, class %s, speed: %llu up / %llu down\n", |
1652 | umb_packet_state(state)umb_val2descr(umb_pktstate, (state)), |
1653 | umb_dataclass(highestclass)umb_val2descr(umb_dataclasses, (highestclass)), up_speed, down_speed); |
1654 | } |
1655 | } |
1656 | sc->sc_info.packetstate = state; |
1657 | sc->sc_info.highestclass = highestclass; |
1658 | sc->sc_info.uplink_speed = up_speed; |
1659 | sc->sc_info.downlink_speed = down_speed; |
1660 | |
1661 | if (sc->sc_info.regmode == MBIM_REGMODE_AUTOMATIC1) { |
1662 | /* |
1663 | * For devices using automatic registration mode, just proceed, |
1664 | * once registration has completed. |
1665 | */ |
1666 | if (ifp->if_flags & IFF_UP0x1) { |
1667 | switch (sc->sc_info.regstate) { |
1668 | case MBIM_REGSTATE_HOME3: |
1669 | case MBIM_REGSTATE_ROAMING4: |
1670 | case MBIM_REGSTATE_PARTNER5: |
1671 | umb_newstate(sc, UMB_S_ATTACHED, |
1672 | UMB_NS_DONT_DROP0x0001); |
1673 | break; |
1674 | default: |
1675 | break; |
1676 | } |
1677 | } else |
1678 | umb_newstate(sc, UMB_S_SIMREADY, UMB_NS_DONT_RAISE0x0002); |
1679 | } else switch (sc->sc_info.packetstate) { |
1680 | case MBIM_PKTSERVICE_STATE_ATTACHED2: |
1681 | umb_newstate(sc, UMB_S_ATTACHED, UMB_NS_DONT_DROP0x0001); |
1682 | break; |
1683 | case MBIM_PKTSERVICE_STATE_DETACHED4: |
1684 | umb_newstate(sc, UMB_S_SIMREADY, UMB_NS_DONT_RAISE0x0002); |
1685 | break; |
1686 | } |
1687 | return 1; |
1688 | } |
1689 | |
1690 | int |
1691 | umb_decode_signal_state(struct umb_softc *sc, void *data, int len) |
1692 | { |
1693 | struct mbim_cid_signal_state *ss = data; |
1694 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
1695 | int rssi; |
1696 | #if NKSTAT1 > 0 |
1697 | struct kstat *ks; |
1698 | #endif |
1699 | |
1700 | if (len < sizeof (*ss)) |
1701 | return 0; |
1702 | |
1703 | if (letoh32(ss->rssi)((__uint32_t)(ss->rssi)) == 99) |
1704 | rssi = UMB_VALUE_UNKNOWN-999; |
1705 | else { |
1706 | rssi = -113 + 2 * letoh32(ss->rssi)((__uint32_t)(ss->rssi)); |
1707 | if ((ifp->if_flags & IFF_DEBUG0x4) && sc->sc_info.rssi != rssi && |
1708 | sc->sc_statesc_info.state >= UMB_S_CONNECTED) |
1709 | log(LOG_INFO6, "%s: rssi %d dBm\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), rssi); |
1710 | } |
1711 | sc->sc_info.rssi = rssi; |
1712 | sc->sc_info.ber = letoh32(ss->err_rate)((__uint32_t)(ss->err_rate)); |
1713 | if (sc->sc_info.ber == 99) |
1714 | sc->sc_info.ber = UMB_VALUE_UNKNOWN-999; |
1715 | |
1716 | #if NKSTAT1 > 0 |
1717 | ks = sc->sc_kstat_signal; |
1718 | if (ks != NULL((void *)0)) { |
1719 | struct umb_kstat_signal *uks = ks->ks_data; |
1720 | |
1721 | rw_enter_write(&sc->sc_kstat_lock); |
1722 | kstat_kv_u64(&uks->reports)(&uks->reports)->kv_v.v_u64++; |
1723 | |
1724 | if (sc->sc_info.rssi == UMB_VALUE_UNKNOWN-999) |
1725 | uks->rssi.kv_type = KSTAT_KV_T_NULL; |
1726 | else { |
1727 | uks->rssi.kv_type = KSTAT_KV_T_INT32; |
1728 | kstat_kv_s32(&uks->rssi)(&uks->rssi)->kv_v.v_s32 = sc->sc_info.rssi; |
1729 | } |
1730 | |
1731 | if (sc->sc_info.ber == UMB_VALUE_UNKNOWN-999) |
1732 | uks->error_rate.kv_type = KSTAT_KV_T_NULL; |
1733 | else { |
1734 | uks->error_rate.kv_type = KSTAT_KV_T_INT32; |
1735 | kstat_kv_s32(&uks->error_rate)(&uks->error_rate)->kv_v.v_s32 = sc->sc_info.ber; |
1736 | } |
1737 | |
1738 | ks->ks_interval.tv_sec = letoh32(ss->ss_intvl)((__uint32_t)(ss->ss_intvl)); |
1739 | getnanouptime(&ks->ks_updated); |
1740 | rw_exit_write(&sc->sc_kstat_lock); |
1741 | } |
1742 | #endif |
1743 | |
1744 | return 1; |
1745 | } |
1746 | |
1747 | int |
1748 | umb_decode_connect_info(struct umb_softc *sc, void *data, int len) |
1749 | { |
1750 | struct mbim_cid_connect_info *ci = data; |
1751 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
1752 | int act; |
1753 | |
1754 | if (len < sizeof (*ci)) |
1755 | return 0; |
1756 | |
1757 | if (letoh32(ci->sessionid)((__uint32_t)(ci->sessionid)) != umb_session_id) { |
1758 | DPRINTF("%s: discard connection info for session %u\n",do { } while (0) |
1759 | DEVNAM(sc), letoh32(ci->sessionid))do { } while (0); |
1760 | return 1; |
1761 | } |
1762 | if (memcmp(ci->context, umb_uuid_context_internet,__builtin_memcmp((ci->context), (umb_uuid_context_internet ), (sizeof (ci->context))) |
1763 | sizeof (ci->context))__builtin_memcmp((ci->context), (umb_uuid_context_internet ), (sizeof (ci->context)))) { |
1764 | DPRINTF("%s: discard connection info for other context\n",do { } while (0) |
1765 | DEVNAM(sc))do { } while (0); |
1766 | return 1; |
1767 | } |
1768 | act = letoh32(ci->activation)((__uint32_t)(ci->activation)); |
1769 | if (sc->sc_info.activation != act) { |
1770 | if (ifp->if_flags & IFF_DEBUG0x4) |
1771 | log(LOG_INFO6, "%s: connection %s\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), |
1772 | umb_activation(act)umb_val2descr(umb_actstate, (act))); |
1773 | |
1774 | sc->sc_info.activation = act; |
1775 | sc->sc_info.nwerror = letoh32(ci->nwerror)((__uint32_t)(ci->nwerror)); |
1776 | |
1777 | if (sc->sc_info.activation == MBIM_ACTIVATION_STATE_ACTIVATED1) |
1778 | umb_newstate(sc, UMB_S_CONNECTED, UMB_NS_DONT_DROP0x0001); |
1779 | else if (sc->sc_info.activation == |
1780 | MBIM_ACTIVATION_STATE_DEACTIVATED3) |
1781 | umb_newstate(sc, UMB_S_ATTACHED, 0); |
1782 | /* else: other states are purely transitional */ |
1783 | } |
1784 | return 1; |
1785 | } |
1786 | |
1787 | void |
1788 | umb_clear_addr(struct umb_softc *sc) |
1789 | { |
1790 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
1791 | |
1792 | memset(sc->sc_info.ipv4dns, 0, sizeof (sc->sc_info.ipv4dns))__builtin_memset((sc->sc_info.ipv4dns), (0), (sizeof (sc-> sc_info.ipv4dns))); |
1793 | memset(sc->sc_info.ipv6dns, 0, sizeof (sc->sc_info.ipv6dns))__builtin_memset((sc->sc_info.ipv6dns), (0), (sizeof (sc-> sc_info.ipv6dns))); |
1794 | umb_send_inet_proposal(sc, AF_INET2); |
1795 | #ifdef INET61 |
1796 | umb_send_inet_proposal(sc, AF_INET624); |
1797 | #endif |
1798 | NET_LOCK()do { rw_enter_write(&netlock); } while (0); |
1799 | in_ifdetach(ifp); |
1800 | #ifdef INET61 |
1801 | in6_ifdetach(ifp); |
1802 | #endif |
1803 | NET_UNLOCK()do { rw_exit_write(&netlock); } while (0); |
1804 | } |
1805 | |
1806 | int |
1807 | umb_add_inet_config(struct umb_softc *sc, struct in_addr ip, u_int prefixlen, |
1808 | struct in_addr gw) |
1809 | { |
1810 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
1811 | struct in_aliasreq ifra; |
1812 | struct sockaddr_in *sin, default_sin; |
1813 | struct rt_addrinfo info; |
1814 | struct rtentry *rt; |
1815 | int rv; |
1816 | |
1817 | memset(&ifra, 0, sizeof (ifra))__builtin_memset((&ifra), (0), (sizeof (ifra))); |
1818 | rv = in_ioctl(SIOCDIFADDR((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff ) << 16) | ((('i')) << 8) | ((25))), (caddr_t)&ifra, ifp, 1); |
1819 | if (rv != 0 && rv != EADDRNOTAVAIL49) { |
1820 | printf("%s: unable to delete IPv4 address, error %d\n", |
1821 | DEVNAM(ifp->if_softc)(((struct umb_softc *)(ifp->if_softc))->sc_dev.dv_xname ), rv); |
1822 | return rv; |
1823 | } |
1824 | |
1825 | memset(&ifra, 0, sizeof (ifra))__builtin_memset((&ifra), (0), (sizeof (ifra))); |
1826 | sin = &ifra.ifra_addrifra_ifrau.ifrau_addr; |
1827 | sin->sin_family = AF_INET2; |
1828 | sin->sin_len = sizeof (*sin); |
1829 | sin->sin_addr = ip; |
1830 | |
1831 | sin = &ifra.ifra_dstaddr; |
1832 | sin->sin_family = AF_INET2; |
1833 | sin->sin_len = sizeof (*sin); |
1834 | sin->sin_addr = gw; |
1835 | |
1836 | sin = &ifra.ifra_mask; |
1837 | sin->sin_family = AF_INET2; |
1838 | sin->sin_len = sizeof (*sin); |
1839 | in_len2mask(&sin->sin_addr, prefixlen); |
1840 | |
1841 | rv = in_ioctl(SIOCAIFADDR((unsigned long)0x80000000 | ((sizeof(struct ifaliasreq) & 0x1fff) << 16) | ((('i')) << 8) | ((26))), (caddr_t)&ifra, ifp, 1); |
1842 | if (rv != 0) { |
1843 | printf("%s: unable to set IPv4 address, error %d\n", |
1844 | DEVNAM(ifp->if_softc)(((struct umb_softc *)(ifp->if_softc))->sc_dev.dv_xname ), rv); |
1845 | return rv; |
1846 | } |
1847 | |
1848 | memset(&default_sin, 0, sizeof(default_sin))__builtin_memset((&default_sin), (0), (sizeof(default_sin ))); |
1849 | default_sin.sin_family = AF_INET2; |
1850 | default_sin.sin_len = sizeof (default_sin); |
1851 | |
1852 | memset(&info, 0, sizeof(info))__builtin_memset((&info), (0), (sizeof(info))); |
1853 | NET_LOCK()do { rw_enter_write(&netlock); } while (0); |
1854 | info.rti_flags = RTF_GATEWAY0x2 /* maybe | RTF_STATIC */; |
1855 | info.rti_ifa = ifa_ifwithaddr(sintosa(&ifra.ifra_addrifra_ifrau.ifrau_addr), |
1856 | ifp->if_rdomainif_data.ifi_rdomain); |
1857 | info.rti_info[RTAX_DST0] = sintosa(&default_sin); |
1858 | info.rti_info[RTAX_NETMASK2] = sintosa(&default_sin); |
1859 | info.rti_info[RTAX_GATEWAY1] = sintosa(&ifra.ifra_dstaddr); |
1860 | |
1861 | rv = rtrequest(RTM_ADD0x1, &info, 0, &rt, ifp->if_rdomainif_data.ifi_rdomain); |
1862 | if (rv) { |
1863 | printf("%s: unable to set IPv4 default route, " |
1864 | "error %d\n", DEVNAM(ifp->if_softc)(((struct umb_softc *)(ifp->if_softc))->sc_dev.dv_xname ), rv); |
1865 | rtm_miss(RTM_MISS0x7, &info, 0, RTP_NONE0, 0, rv, |
1866 | ifp->if_rdomainif_data.ifi_rdomain); |
1867 | } else { |
1868 | /* Inform listeners of the new route */ |
1869 | rtm_send(rt, RTM_ADD0x1, rv, ifp->if_rdomainif_data.ifi_rdomain); |
1870 | rtfree(rt); |
1871 | } |
1872 | NET_UNLOCK()do { rw_exit_write(&netlock); } while (0); |
1873 | |
1874 | if (ifp->if_flags & IFF_DEBUG0x4) { |
1875 | char str[3][INET_ADDRSTRLEN16]; |
1876 | log(LOG_INFO6, "%s: IPv4 addr %s, mask %s, gateway %s\n", |
1877 | DEVNAM(ifp->if_softc)(((struct umb_softc *)(ifp->if_softc))->sc_dev.dv_xname ), |
1878 | sockaddr_ntop(sintosa(&ifra.ifra_addrifra_ifrau.ifrau_addr), str[0], |
1879 | sizeof(str[0])), |
1880 | sockaddr_ntop(sintosa(&ifra.ifra_mask), str[1], |
1881 | sizeof(str[1])), |
1882 | sockaddr_ntop(sintosa(&ifra.ifra_dstaddr), str[2], |
1883 | sizeof(str[2]))); |
1884 | } |
1885 | return 0; |
1886 | } |
1887 | |
1888 | #ifdef INET61 |
1889 | int |
1890 | umb_add_inet6_config(struct umb_softc *sc, struct in6_addr *ip, u_int prefixlen, |
1891 | struct in6_addr *gw) |
1892 | { |
1893 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
1894 | struct in6_aliasreq ifra; |
1895 | struct sockaddr_in6 *sin6, default_sin6; |
1896 | struct rt_addrinfo info; |
1897 | struct rtentry *rt; |
1898 | int rv; |
1899 | |
1900 | memset(&ifra, 0, sizeof (ifra))__builtin_memset((&ifra), (0), (sizeof (ifra))); |
1901 | sin6 = &ifra.ifra_addrifra_ifrau.ifrau_addr; |
1902 | sin6->sin6_family = AF_INET624; |
1903 | sin6->sin6_len = sizeof (*sin6); |
1904 | memcpy(&sin6->sin6_addr, ip, sizeof (sin6->sin6_addr))__builtin_memcpy((&sin6->sin6_addr), (ip), (sizeof (sin6 ->sin6_addr))); |
1905 | |
1906 | sin6 = &ifra.ifra_dstaddr; |
1907 | sin6->sin6_family = AF_INET624; |
1908 | sin6->sin6_len = sizeof (*sin6); |
1909 | memcpy(&sin6->sin6_addr, gw, sizeof (sin6->sin6_addr))__builtin_memcpy((&sin6->sin6_addr), (gw), (sizeof (sin6 ->sin6_addr))); |
1910 | |
1911 | /* XXX: in6_update_ifa() accepts only 128 bits for P2P interfaces. */ |
1912 | prefixlen = 128; |
1913 | |
1914 | sin6 = &ifra.ifra_prefixmask; |
1915 | sin6->sin6_family = AF_INET624; |
1916 | sin6->sin6_len = sizeof (*sin6); |
1917 | in6_prefixlen2mask(&sin6->sin6_addr, prefixlen); |
1918 | |
1919 | ifra.ifra_lifetime.ia6t_vltime = ND6_INFINITE_LIFETIME0xffffffff; |
1920 | ifra.ifra_lifetime.ia6t_pltime = ND6_INFINITE_LIFETIME0xffffffff; |
1921 | |
1922 | rv = in6_ioctl(SIOCAIFADDR_IN6((unsigned long)0x80000000 | ((sizeof(struct in6_aliasreq) & 0x1fff) << 16) | ((('i')) << 8) | ((26))), (caddr_t)&ifra, ifp, 1); |
1923 | if (rv != 0) { |
1924 | printf("%s: unable to set IPv6 address, error %d\n", |
1925 | DEVNAM(ifp->if_softc)(((struct umb_softc *)(ifp->if_softc))->sc_dev.dv_xname ), rv); |
1926 | return rv; |
1927 | } |
1928 | |
1929 | memset(&default_sin6, 0, sizeof(default_sin6))__builtin_memset((&default_sin6), (0), (sizeof(default_sin6 ))); |
1930 | default_sin6.sin6_family = AF_INET624; |
1931 | default_sin6.sin6_len = sizeof (default_sin6); |
1932 | |
1933 | memset(&info, 0, sizeof(info))__builtin_memset((&info), (0), (sizeof(info))); |
1934 | NET_LOCK()do { rw_enter_write(&netlock); } while (0); |
1935 | info.rti_flags = RTF_GATEWAY0x2 /* maybe | RTF_STATIC */; |
1936 | info.rti_ifa = ifa_ifwithaddr(sin6tosa(&ifra.ifra_addrifra_ifrau.ifrau_addr), |
1937 | ifp->if_rdomainif_data.ifi_rdomain); |
1938 | info.rti_info[RTAX_DST0] = sin6tosa(&default_sin6); |
1939 | info.rti_info[RTAX_NETMASK2] = sin6tosa(&default_sin6); |
1940 | info.rti_info[RTAX_GATEWAY1] = sin6tosa(&ifra.ifra_dstaddr); |
1941 | |
1942 | rv = rtrequest(RTM_ADD0x1, &info, 0, &rt, ifp->if_rdomainif_data.ifi_rdomain); |
1943 | if (rv) { |
1944 | printf("%s: unable to set IPv6 default route, " |
1945 | "error %d\n", DEVNAM(ifp->if_softc)(((struct umb_softc *)(ifp->if_softc))->sc_dev.dv_xname ), rv); |
1946 | rtm_miss(RTM_MISS0x7, &info, 0, RTP_NONE0, 0, rv, |
1947 | ifp->if_rdomainif_data.ifi_rdomain); |
1948 | } else { |
1949 | /* Inform listeners of the new route */ |
1950 | rtm_send(rt, RTM_ADD0x1, rv, ifp->if_rdomainif_data.ifi_rdomain); |
1951 | rtfree(rt); |
1952 | } |
1953 | NET_UNLOCK()do { rw_exit_write(&netlock); } while (0); |
1954 | |
1955 | if (ifp->if_flags & IFF_DEBUG0x4) { |
1956 | char str[3][INET6_ADDRSTRLEN46]; |
1957 | log(LOG_INFO6, "%s: IPv6 addr %s, mask %s, gateway %s\n", |
1958 | DEVNAM(ifp->if_softc)(((struct umb_softc *)(ifp->if_softc))->sc_dev.dv_xname ), |
1959 | sockaddr_ntop(sin6tosa(&ifra.ifra_addrifra_ifrau.ifrau_addr), str[0], |
1960 | sizeof(str[0])), |
1961 | sockaddr_ntop(sin6tosa(&ifra.ifra_prefixmask), str[1], |
1962 | sizeof(str[1])), |
1963 | sockaddr_ntop(sin6tosa(&ifra.ifra_dstaddr), str[2], |
1964 | sizeof(str[2]))); |
1965 | } |
1966 | return 0; |
1967 | } |
1968 | #endif |
1969 | |
1970 | void |
1971 | umb_send_inet_proposal(struct umb_softc *sc, int af) |
1972 | { |
1973 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
1974 | struct sockaddr_rtdns rtdns; |
1975 | struct rt_addrinfo info; |
1976 | int i, flag = 0; |
1977 | size_t sz = 0; |
1978 | |
1979 | memset(&rtdns, 0, sizeof(rtdns))__builtin_memset((&rtdns), (0), (sizeof(rtdns))); |
1980 | memset(&info, 0, sizeof(info))__builtin_memset((&info), (0), (sizeof(info))); |
1981 | |
1982 | for (i = 0; i < UMB_MAX_DNSSRV2; i++) { |
1983 | if (af == AF_INET2) { |
1984 | sz = sizeof (sc->sc_info.ipv4dns[i]); |
1985 | if (sc->sc_info.ipv4dns[i].s_addr == INADDR_ANY((u_int32_t) (__uint32_t)(__builtin_constant_p((u_int32_t)(0x00000000 )) ? (__uint32_t)(((__uint32_t)((u_int32_t)(0x00000000)) & 0xff) << 24 | ((__uint32_t)((u_int32_t)(0x00000000)) & 0xff00) << 8 | ((__uint32_t)((u_int32_t)(0x00000000)) & 0xff0000) >> 8 | ((__uint32_t)((u_int32_t)(0x00000000) ) & 0xff000000) >> 24) : __swap32md((u_int32_t)(0x00000000 ))))) |
1986 | break; |
1987 | memcpy(rtdns.sr_dns + i * sz, &sc->sc_info.ipv4dns[i],__builtin_memcpy((rtdns.sr_dns + i * sz), (&sc->sc_info .ipv4dns[i]), (sz)) |
1988 | sz)__builtin_memcpy((rtdns.sr_dns + i * sz), (&sc->sc_info .ipv4dns[i]), (sz)); |
1989 | flag = RTF_UP0x1; |
1990 | #ifdef INET61 |
1991 | } else if (af == AF_INET624) { |
1992 | sz = sizeof (sc->sc_info.ipv6dns[i]); |
1993 | if (IN6_ARE_ADDR_EQUAL(&sc->sc_info.ipv6dns[i],(__builtin_memcmp((&(&sc->sc_info.ipv6dns[i])-> __u6_addr.__u6_addr8[0]), (&(&in6addr_any)->__u6_addr .__u6_addr8[0]), (sizeof(struct in6_addr))) == 0) |
1994 | &in6addr_any)(__builtin_memcmp((&(&sc->sc_info.ipv6dns[i])-> __u6_addr.__u6_addr8[0]), (&(&in6addr_any)->__u6_addr .__u6_addr8[0]), (sizeof(struct in6_addr))) == 0)) |
1995 | break; |
1996 | memcpy(rtdns.sr_dns + i * sz, &sc->sc_info.ipv6dns[i],__builtin_memcpy((rtdns.sr_dns + i * sz), (&sc->sc_info .ipv6dns[i]), (sz)) |
1997 | sz)__builtin_memcpy((rtdns.sr_dns + i * sz), (&sc->sc_info .ipv6dns[i]), (sz)); |
1998 | flag = RTF_UP0x1; |
1999 | #endif |
2000 | } |
2001 | } |
2002 | rtdns.sr_family = af; |
2003 | rtdns.sr_len = 2 + i * sz; |
2004 | info.rti_info[RTAX_DNS12] = srtdnstosa(&rtdns); |
2005 | |
2006 | rtm_proposal(ifp, &info, flag, RTP_PROPOSAL_UMB60); |
2007 | } |
2008 | |
2009 | int |
2010 | umb_decode_ip_configuration(struct umb_softc *sc, void *data, int len) |
2011 | { |
2012 | struct mbim_cid_ip_configuration_info *ic = data; |
2013 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
2014 | int s; |
2015 | uint32_t avail_v4; |
2016 | uint32_t val; |
2017 | int n, i; |
2018 | int off; |
2019 | struct mbim_cid_ipv4_element ipv4elem; |
2020 | struct in_addr addr, gw; |
2021 | int state = -1; |
2022 | int rv; |
2023 | int hasmtu = 0; |
2024 | #ifdef INET61 |
2025 | uint32_t avail_v6; |
2026 | struct mbim_cid_ipv6_element ipv6elem; |
2027 | struct in6_addr addr6, gw6; |
2028 | #endif |
2029 | |
2030 | if (len < sizeof (*ic)) |
2031 | return 0; |
2032 | if (letoh32(ic->sessionid)((__uint32_t)(ic->sessionid)) != umb_session_id) { |
2033 | DPRINTF("%s: ignore IP configuration for session id %d\n",do { } while (0) |
2034 | DEVNAM(sc), letoh32(ic->sessionid))do { } while (0); |
2035 | return 0; |
2036 | } |
2037 | s = splnet()splraise(0x4); |
2038 | |
2039 | memset(sc->sc_info.ipv4dns, 0, sizeof (sc->sc_info.ipv4dns))__builtin_memset((sc->sc_info.ipv4dns), (0), (sizeof (sc-> sc_info.ipv4dns))); |
2040 | memset(sc->sc_info.ipv6dns, 0, sizeof (sc->sc_info.ipv6dns))__builtin_memset((sc->sc_info.ipv6dns), (0), (sizeof (sc-> sc_info.ipv6dns))); |
2041 | |
2042 | /* |
2043 | * IPv4 configuration |
2044 | */ |
2045 | avail_v4 = letoh32(ic->ipv4_available)((__uint32_t)(ic->ipv4_available)); |
2046 | if ((avail_v4 & (MBIM_IPCONF_HAS_ADDRINFO0x0001 | MBIM_IPCONF_HAS_GWINFO0x0002)) == |
2047 | (MBIM_IPCONF_HAS_ADDRINFO0x0001 | MBIM_IPCONF_HAS_GWINFO0x0002)) { |
2048 | n = letoh32(ic->ipv4_naddr)((__uint32_t)(ic->ipv4_naddr)); |
2049 | off = letoh32(ic->ipv4_addroffs)((__uint32_t)(ic->ipv4_addroffs)); |
2050 | |
2051 | if (n == 0 || off + sizeof (ipv4elem) > len) |
2052 | goto tryv6; |
2053 | if (n != 1 && ifp->if_flags & IFF_DEBUG0x4) |
2054 | log(LOG_INFO6, "%s: more than one IPv4 addr: %d\n", |
2055 | DEVNAM(ifp->if_softc)(((struct umb_softc *)(ifp->if_softc))->sc_dev.dv_xname ), n); |
2056 | |
2057 | /* Only pick the first one */ |
2058 | memcpy(&ipv4elem, data + off, sizeof (ipv4elem))__builtin_memcpy((&ipv4elem), (data + off), (sizeof (ipv4elem ))); |
2059 | ipv4elem.prefixlen = letoh32(ipv4elem.prefixlen)((__uint32_t)(ipv4elem.prefixlen)); |
2060 | addr.s_addr = ipv4elem.addr; |
2061 | |
2062 | off = letoh32(ic->ipv4_gwoffs)((__uint32_t)(ic->ipv4_gwoffs)); |
2063 | if (off + sizeof (gw) > len) |
2064 | goto done; |
2065 | memcpy(&gw, data + off, sizeof(gw))__builtin_memcpy((&gw), (data + off), (sizeof(gw))); |
2066 | |
2067 | rv = umb_add_inet_config(sc, addr, ipv4elem.prefixlen, gw); |
2068 | if (rv == 0) |
2069 | state = UMB_S_UP; |
2070 | |
2071 | } |
2072 | |
2073 | memset(sc->sc_info.ipv4dns, 0, sizeof (sc->sc_info.ipv4dns))__builtin_memset((sc->sc_info.ipv4dns), (0), (sizeof (sc-> sc_info.ipv4dns))); |
2074 | if (avail_v4 & MBIM_IPCONF_HAS_DNSINFO0x0004) { |
2075 | n = letoh32(ic->ipv4_ndnssrv)((__uint32_t)(ic->ipv4_ndnssrv)); |
2076 | off = letoh32(ic->ipv4_dnssrvoffs)((__uint32_t)(ic->ipv4_dnssrvoffs)); |
2077 | i = 0; |
2078 | while (n-- > 0) { |
2079 | if (off + sizeof (addr) > len) |
2080 | break; |
2081 | memcpy(&addr, data + off, sizeof(addr))__builtin_memcpy((&addr), (data + off), (sizeof(addr))); |
2082 | if (i < UMB_MAX_DNSSRV2) |
2083 | sc->sc_info.ipv4dns[i++] = addr; |
2084 | off += sizeof(addr); |
2085 | if (ifp->if_flags & IFF_DEBUG0x4) { |
2086 | char str[INET_ADDRSTRLEN16]; |
2087 | log(LOG_INFO6, "%s: IPv4 nameserver %s\n", |
2088 | DEVNAM(ifp->if_softc)(((struct umb_softc *)(ifp->if_softc))->sc_dev.dv_xname ), inet_ntop(AF_INET2, |
2089 | &addr, str, sizeof(str))); |
2090 | } |
2091 | } |
2092 | umb_send_inet_proposal(sc, AF_INET2); |
2093 | } |
2094 | if ((avail_v4 & MBIM_IPCONF_HAS_MTUINFO0x0008)) { |
2095 | val = letoh32(ic->ipv4_mtu)((__uint32_t)(ic->ipv4_mtu)); |
2096 | if (ifp->if_hardmtu != val && val <= sc->sc_maxpktlen) { |
2097 | hasmtu = 1; |
2098 | ifp->if_hardmtu = val; |
2099 | if (ifp->if_mtuif_data.ifi_mtu > val) |
2100 | ifp->if_mtuif_data.ifi_mtu = val; |
2101 | } |
2102 | } |
2103 | |
2104 | tryv6:; |
2105 | #ifdef INET61 |
2106 | /* |
2107 | * IPv6 configuration |
2108 | */ |
2109 | avail_v6 = letoh32(ic->ipv6_available)((__uint32_t)(ic->ipv6_available)); |
2110 | if (avail_v6 == 0) { |
2111 | if (ifp->if_flags & IFF_DEBUG0x4) |
2112 | log(LOG_INFO6, "%s: ISP or WWAN module offers no IPv6 " |
2113 | "support\n", DEVNAM(ifp->if_softc)(((struct umb_softc *)(ifp->if_softc))->sc_dev.dv_xname )); |
2114 | goto done; |
2115 | } |
2116 | |
2117 | if ((avail_v6 & (MBIM_IPCONF_HAS_ADDRINFO0x0001 | MBIM_IPCONF_HAS_GWINFO0x0002)) == |
2118 | (MBIM_IPCONF_HAS_ADDRINFO0x0001 | MBIM_IPCONF_HAS_GWINFO0x0002)) { |
2119 | n = letoh32(ic->ipv6_naddr)((__uint32_t)(ic->ipv6_naddr)); |
2120 | off = letoh32(ic->ipv6_addroffs)((__uint32_t)(ic->ipv6_addroffs)); |
2121 | |
2122 | if (n == 0 || off + sizeof (ipv6elem) > len) |
2123 | goto done; |
2124 | if (n != 1 && ifp->if_flags & IFF_DEBUG0x4) |
2125 | log(LOG_INFO6, "%s: more than one IPv6 addr: %d\n", |
2126 | DEVNAM(ifp->if_softc)(((struct umb_softc *)(ifp->if_softc))->sc_dev.dv_xname ), n); |
2127 | |
2128 | /* Only pick the first one */ |
2129 | memcpy(&ipv6elem, data + off, sizeof (ipv6elem))__builtin_memcpy((&ipv6elem), (data + off), (sizeof (ipv6elem ))); |
2130 | memcpy(&addr6, ipv6elem.addr, sizeof (addr6))__builtin_memcpy((&addr6), (ipv6elem.addr), (sizeof (addr6 ))); |
2131 | |
2132 | off = letoh32(ic->ipv6_gwoffs)((__uint32_t)(ic->ipv6_gwoffs)); |
2133 | if (off + sizeof (gw6) > len) |
2134 | goto done; |
2135 | memcpy(&gw6, data + off, sizeof (gw6))__builtin_memcpy((&gw6), (data + off), (sizeof (gw6))); |
2136 | |
2137 | rv = umb_add_inet6_config(sc, &addr6, ipv6elem.prefixlen, &gw6); |
2138 | if (rv == 0) |
2139 | state = UMB_S_UP; |
2140 | } |
2141 | |
2142 | if (avail_v6 & MBIM_IPCONF_HAS_DNSINFO0x0004) { |
2143 | n = letoh32(ic->ipv6_ndnssrv)((__uint32_t)(ic->ipv6_ndnssrv)); |
2144 | off = letoh32(ic->ipv6_dnssrvoffs)((__uint32_t)(ic->ipv6_dnssrvoffs)); |
2145 | i = 0; |
2146 | while (n-- > 0) { |
2147 | if (off + sizeof (addr6) > len) |
2148 | break; |
2149 | memcpy(&addr6, data + off, sizeof(addr6))__builtin_memcpy((&addr6), (data + off), (sizeof(addr6))); |
2150 | if (i < UMB_MAX_DNSSRV2) |
2151 | sc->sc_info.ipv6dns[i++] = addr6; |
2152 | off += sizeof(addr6); |
2153 | if (ifp->if_flags & IFF_DEBUG0x4) { |
2154 | char str[INET6_ADDRSTRLEN46]; |
2155 | log(LOG_INFO6, "%s: IPv6 nameserver %s\n", |
2156 | DEVNAM(ifp->if_softc)(((struct umb_softc *)(ifp->if_softc))->sc_dev.dv_xname ), inet_ntop(AF_INET624, |
2157 | &addr6, str, sizeof(str))); |
2158 | } |
2159 | } |
2160 | umb_send_inet_proposal(sc, AF_INET624); |
2161 | } |
2162 | |
2163 | if ((avail_v6 & MBIM_IPCONF_HAS_MTUINFO0x0008)) { |
2164 | val = letoh32(ic->ipv6_mtu)((__uint32_t)(ic->ipv6_mtu)); |
2165 | if (ifp->if_hardmtu != val && val <= sc->sc_maxpktlen) { |
2166 | hasmtu = 1; |
2167 | ifp->if_hardmtu = val; |
2168 | if (ifp->if_mtuif_data.ifi_mtu > val) |
2169 | ifp->if_mtuif_data.ifi_mtu = val; |
2170 | } |
2171 | } |
2172 | #endif |
2173 | |
2174 | done: |
2175 | if (hasmtu && (ifp->if_flags & IFF_DEBUG0x4)) |
2176 | log(LOG_INFO6, "%s: MTU %d\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), ifp->if_hardmtu); |
2177 | |
2178 | if (state != -1) |
2179 | umb_newstate(sc, state, 0); |
2180 | |
2181 | splx(s)spllower(s); |
2182 | return 1; |
2183 | } |
2184 | |
2185 | void |
2186 | umb_rx(struct umb_softc *sc) |
2187 | { |
2188 | usbd_setup_xfer(sc->sc_rx_xfer, sc->sc_rx_pipe, sc, sc->sc_rx_buf, |
2189 | sc->sc_rx_bufsz, USBD_SHORT_XFER_OK0x04 | USBD_NO_COPY0x01, |
2190 | USBD_NO_TIMEOUT0, umb_rxeof); |
2191 | usbd_transfer(sc->sc_rx_xfer); |
2192 | } |
2193 | |
2194 | void |
2195 | umb_rxeof(struct usbd_xfer *xfer, void *priv, usbd_status status) |
2196 | { |
2197 | struct umb_softc *sc = priv; |
2198 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
2199 | |
2200 | if (usbd_is_dying(sc->sc_udev) || !(ifp->if_flags & IFF_RUNNING0x40)) |
2201 | return; |
2202 | |
2203 | if (status != USBD_NORMAL_COMPLETION) { |
2204 | if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) |
2205 | return; |
2206 | DPRINTF("%s: rx error: %s\n", DEVNAM(sc), usbd_errstr(status))do { } while (0); |
2207 | if (status == USBD_STALLED) |
2208 | usbd_clear_endpoint_stall_async(sc->sc_rx_pipe); |
2209 | if (++sc->sc_rx_nerr > 100) { |
2210 | log(LOG_ERR3, "%s: too many rx errors, disabling\n", |
2211 | DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
2212 | usbd_deactivate(sc->sc_udev); |
2213 | } |
2214 | } else { |
2215 | sc->sc_rx_nerr = 0; |
2216 | umb_decap(sc, xfer); |
2217 | } |
2218 | |
2219 | umb_rx(sc); |
2220 | return; |
2221 | } |
2222 | |
2223 | int |
2224 | umb_encap(struct umb_softc *sc, int ndgram) |
2225 | { |
2226 | struct ncm_header16 *hdr16 = NULL((void *)0); |
2227 | struct ncm_header32 *hdr32 = NULL((void *)0); |
2228 | struct ncm_pointer16 *ptr16 = NULL((void *)0); |
2229 | struct ncm_pointer32 *ptr32 = NULL((void *)0); |
2230 | struct ncm_pointer16_dgram *dgram16 = NULL((void *)0); |
2231 | struct ncm_pointer32_dgram *dgram32 = NULL((void *)0); |
2232 | int offs = 0, plen = 0; |
2233 | int dgoffs = 0, poffs; |
2234 | struct mbuf *m; |
2235 | usbd_status err; |
2236 | |
2237 | /* All size constraints have been validated by the caller! */ |
2238 | |
2239 | /* NCM Header */ |
2240 | switch (sc->sc_ncm_format) { |
2241 | case NCM_FORMAT_NTB160x00: |
2242 | hdr16 = sc->sc_tx_buf; |
2243 | USETDW(hdr16->dwSignature, NCM_HDR16_SIG)(*(u_int32_t *)(hdr16->dwSignature) = (0x484d434e)); |
2244 | USETW(hdr16->wHeaderLength, sizeof (*hdr16))(*(u_int16_t *)(hdr16->wHeaderLength) = (sizeof (*hdr16))); |
2245 | USETW(hdr16->wSequence, sc->sc_tx_seq)(*(u_int16_t *)(hdr16->wSequence) = (sc->sc_tx_seq)); |
2246 | USETW(hdr16->wBlockLength, 0)(*(u_int16_t *)(hdr16->wBlockLength) = (0)); |
2247 | offs = sizeof (*hdr16); |
2248 | break; |
2249 | case NCM_FORMAT_NTB320x01: |
2250 | hdr32 = sc->sc_tx_buf; |
2251 | USETDW(hdr32->dwSignature, NCM_HDR32_SIG)(*(u_int32_t *)(hdr32->dwSignature) = (0x686d636e)); |
2252 | USETW(hdr32->wHeaderLength, sizeof (*hdr32))(*(u_int16_t *)(hdr32->wHeaderLength) = (sizeof (*hdr32))); |
2253 | USETW(hdr32->wSequence, sc->sc_tx_seq)(*(u_int16_t *)(hdr32->wSequence) = (sc->sc_tx_seq)); |
2254 | USETDW(hdr32->dwBlockLength, 0)(*(u_int32_t *)(hdr32->dwBlockLength) = (0)); |
2255 | offs = sizeof (*hdr32); |
2256 | break; |
2257 | } |
2258 | offs += umb_padding(sc->sc_tx_buf, sc->sc_tx_bufsz, offs, |
2259 | sc->sc_align, 0); |
2260 | |
2261 | if (sc->sc_flags & UMBFLG_NDP_AT_END0x0004) { |
2262 | dgoffs = offs; |
2263 | |
2264 | /* |
2265 | * Calculate space needed for datagrams. |
2266 | * |
2267 | * XXX cannot use ml_len(&sc->sc_tx_ml), since it ignores |
2268 | * the padding requirements. |
2269 | */ |
2270 | poffs = dgoffs; |
2271 | MBUF_LIST_FOREACH(&sc->sc_tx_ml, m)for ((m) = ((&sc->sc_tx_ml)->ml_head); (m) != ((void *)0); (m) = ((m)->m_hdr.mh_nextpkt)) { |
2272 | poffs += umb_padding(sc->sc_tx_buf, sc->sc_tx_bufsz, |
2273 | poffs, sc->sc_ndp_div, sc->sc_ndp_remainder); |
2274 | poffs += m->m_pkthdrM_dat.MH.MH_pkthdr.len; |
2275 | } |
2276 | poffs += umb_padding(sc->sc_tx_buf, sc->sc_tx_bufsz, |
2277 | poffs, sc->sc_ndp_div, sc->sc_ndp_remainder); |
2278 | } else |
2279 | poffs = offs; |
2280 | |
2281 | /* NCM Pointer */ |
2282 | switch (sc->sc_ncm_format) { |
2283 | case NCM_FORMAT_NTB160x00: |
2284 | USETW(hdr16->wNdpIndex, poffs)(*(u_int16_t *)(hdr16->wNdpIndex) = (poffs)); |
2285 | ptr16 = (struct ncm_pointer16 *)(sc->sc_tx_buf + poffs); |
2286 | plen = sizeof(*ptr16) + ndgram * sizeof(*dgram16); |
2287 | USETDW(ptr16->dwSignature, MBIM_NCM_NTH16_SIG(umb_session_id))(*(u_int32_t *)(ptr16->dwSignature) = (((((umb_session_id) & 0xff) << 24) | 0x00535049))); |
2288 | USETW(ptr16->wLength, plen)(*(u_int16_t *)(ptr16->wLength) = (plen)); |
2289 | USETW(ptr16->wNextNdpIndex, 0)(*(u_int16_t *)(ptr16->wNextNdpIndex) = (0)); |
2290 | dgram16 = ptr16->dgram; |
2291 | break; |
2292 | case NCM_FORMAT_NTB320x01: |
2293 | USETDW(hdr32->dwNdpIndex, poffs)(*(u_int32_t *)(hdr32->dwNdpIndex) = (poffs)); |
2294 | ptr32 = (struct ncm_pointer32 *)(sc->sc_tx_buf + poffs); |
2295 | plen = sizeof(*ptr32) + ndgram * sizeof(*dgram32); |
2296 | USETDW(ptr32->dwSignature, MBIM_NCM_NTH32_SIG(umb_session_id))(*(u_int32_t *)(ptr32->dwSignature) = (((((umb_session_id) & 0xff) << 24) | 0x00737069))); |
2297 | USETW(ptr32->wLength, plen)(*(u_int16_t *)(ptr32->wLength) = (plen)); |
2298 | USETW(ptr32->wReserved6, 0)(*(u_int16_t *)(ptr32->wReserved6) = (0)); |
2299 | USETDW(ptr32->dwNextNdpIndex, 0)(*(u_int32_t *)(ptr32->dwNextNdpIndex) = (0)); |
2300 | USETDW(ptr32->dwReserved12, 0)(*(u_int32_t *)(ptr32->dwReserved12) = (0)); |
2301 | dgram32 = ptr32->dgram; |
2302 | break; |
2303 | } |
2304 | |
2305 | if (!(sc->sc_flags & UMBFLG_NDP_AT_END0x0004)) |
2306 | dgoffs = offs + plen; |
2307 | |
2308 | /* Encap mbufs to NCM dgrams */ |
2309 | sc->sc_tx_seq++; |
2310 | while ((m = ml_dequeue(&sc->sc_tx_ml)) != NULL((void *)0)) { |
2311 | dgoffs += umb_padding(sc->sc_tx_buf, sc->sc_tx_bufsz, dgoffs, |
2312 | sc->sc_ndp_div, sc->sc_ndp_remainder); |
2313 | switch (sc->sc_ncm_format) { |
2314 | case NCM_FORMAT_NTB160x00: |
2315 | USETW(dgram16->wDatagramIndex, dgoffs)(*(u_int16_t *)(dgram16->wDatagramIndex) = (dgoffs)); |
2316 | USETW(dgram16->wDatagramLen, m->m_pkthdr.len)(*(u_int16_t *)(dgram16->wDatagramLen) = (m->M_dat.MH.MH_pkthdr .len)); |
2317 | dgram16++; |
2318 | break; |
2319 | case NCM_FORMAT_NTB320x01: |
2320 | USETDW(dgram32->dwDatagramIndex, dgoffs)(*(u_int32_t *)(dgram32->dwDatagramIndex) = (dgoffs)); |
2321 | USETDW(dgram32->dwDatagramLen, m->m_pkthdr.len)(*(u_int32_t *)(dgram32->dwDatagramLen) = (m->M_dat.MH. MH_pkthdr.len)); |
2322 | dgram32++; |
2323 | break; |
2324 | } |
2325 | m_copydata(m, 0, m->m_pkthdrM_dat.MH.MH_pkthdr.len, sc->sc_tx_buf + dgoffs); |
2326 | dgoffs += m->m_pkthdrM_dat.MH.MH_pkthdr.len; |
2327 | m_freem(m); |
2328 | } |
2329 | |
2330 | if (sc->sc_flags & UMBFLG_NDP_AT_END0x0004) |
2331 | offs = poffs + plen; |
2332 | else |
2333 | offs = dgoffs; |
2334 | |
2335 | /* Terminating pointer and datagram size */ |
2336 | switch (sc->sc_ncm_format) { |
2337 | case NCM_FORMAT_NTB160x00: |
2338 | USETW(dgram16->wDatagramIndex, 0)(*(u_int16_t *)(dgram16->wDatagramIndex) = (0)); |
2339 | USETW(dgram16->wDatagramLen, 0)(*(u_int16_t *)(dgram16->wDatagramLen) = (0)); |
2340 | USETW(hdr16->wBlockLength, offs)(*(u_int16_t *)(hdr16->wBlockLength) = (offs)); |
2341 | KASSERT(dgram16 - ptr16->dgram == ndgram)((dgram16 - ptr16->dgram == ndgram) ? (void)0 : __assert("diagnostic " , "/usr/src/sys/dev/usb/if_umb.c", 2341, "dgram16 - ptr16->dgram == ndgram" )); |
2342 | break; |
2343 | case NCM_FORMAT_NTB320x01: |
2344 | USETDW(dgram32->dwDatagramIndex, 0)(*(u_int32_t *)(dgram32->dwDatagramIndex) = (0)); |
2345 | USETDW(dgram32->dwDatagramLen, 0)(*(u_int32_t *)(dgram32->dwDatagramLen) = (0)); |
2346 | USETDW(hdr32->dwBlockLength, offs)(*(u_int32_t *)(hdr32->dwBlockLength) = (offs)); |
2347 | KASSERT(dgram32 - ptr32->dgram == ndgram)((dgram32 - ptr32->dgram == ndgram) ? (void)0 : __assert("diagnostic " , "/usr/src/sys/dev/usb/if_umb.c", 2347, "dgram32 - ptr32->dgram == ndgram" )); |
2348 | break; |
2349 | } |
2350 | |
2351 | DPRINTFN(3, "%s: encap %d bytes\n", DEVNAM(sc), offs)do { } while (0); |
2352 | DDUMPN(5, sc->sc_tx_buf, offs)do { } while (0); |
2353 | KASSERT(offs <= sc->sc_tx_bufsz)((offs <= sc->sc_tx_bufsz) ? (void)0 : __assert("diagnostic " , "/usr/src/sys/dev/usb/if_umb.c", 2353, "offs <= sc->sc_tx_bufsz" )); |
2354 | |
2355 | usbd_setup_xfer(sc->sc_tx_xfer, sc->sc_tx_pipe, sc, sc->sc_tx_buf, offs, |
2356 | USBD_FORCE_SHORT_XFER0x08 | USBD_NO_COPY0x01, umb_xfer_tout, umb_txeof); |
2357 | err = usbd_transfer(sc->sc_tx_xfer); |
2358 | if (err != USBD_IN_PROGRESS) { |
2359 | DPRINTF("%s: start tx error: %s\n", DEVNAM(sc),do { } while (0) |
2360 | usbd_errstr(err))do { } while (0); |
2361 | ml_purge(&sc->sc_tx_ml); |
2362 | return 0; |
2363 | } |
2364 | return 1; |
2365 | } |
2366 | |
2367 | void |
2368 | umb_txeof(struct usbd_xfer *xfer, void *priv, usbd_status status) |
2369 | { |
2370 | struct umb_softc *sc = priv; |
2371 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
2372 | int s; |
2373 | |
2374 | s = splnet()splraise(0x4); |
2375 | ml_purge(&sc->sc_tx_ml); |
2376 | ifq_clr_oactive(&ifp->if_snd); |
2377 | ifp->if_timer = 0; |
2378 | |
2379 | if (status != USBD_NORMAL_COMPLETION) { |
2380 | if (status != USBD_NOT_STARTED && status != USBD_CANCELLED) { |
2381 | ifp->if_oerrorsif_data.ifi_oerrors++; |
2382 | DPRINTF("%s: tx error: %s\n", DEVNAM(sc),do { } while (0) |
2383 | usbd_errstr(status))do { } while (0); |
2384 | if (status == USBD_STALLED) |
2385 | usbd_clear_endpoint_stall_async(sc->sc_tx_pipe); |
2386 | } |
2387 | } |
2388 | if (ifq_empty(&ifp->if_snd)(({ typeof((&ifp->if_snd)->ifq_len) __tmp = *(volatile typeof((&ifp->if_snd)->ifq_len) *)&((&ifp-> if_snd)->ifq_len); membar_datadep_consumer(); __tmp; }) == 0) == 0) |
2389 | umb_start(ifp); |
2390 | |
2391 | splx(s)spllower(s); |
2392 | } |
2393 | |
2394 | void |
2395 | umb_decap(struct umb_softc *sc, struct usbd_xfer *xfer) |
2396 | { |
2397 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
2398 | int s; |
2399 | void *buf; |
2400 | uint32_t len; |
2401 | char *dp; |
2402 | struct ncm_header16 *hdr16; |
2403 | struct ncm_header32 *hdr32; |
2404 | struct ncm_pointer16 *ptr16; |
2405 | struct ncm_pointer16_dgram *dgram16; |
2406 | struct ncm_pointer32_dgram *dgram32; |
2407 | uint32_t hsig, psig; |
2408 | int blen; |
2409 | int ptrlen, ptroff, dgentryoff; |
2410 | uint32_t doff, dlen; |
2411 | struct mbuf_list ml = MBUF_LIST_INITIALIZER(){ ((void *)0), ((void *)0), 0 }; |
2412 | struct mbuf *m; |
2413 | |
2414 | usbd_get_xfer_status(xfer, NULL((void *)0), &buf, &len, NULL((void *)0)); |
2415 | DPRINTFN(4, "%s: recv %d bytes\n", DEVNAM(sc), len)do { } while (0); |
2416 | DDUMPN(5, buf, len)do { } while (0); |
2417 | s = splnet()splraise(0x4); |
2418 | if (len < sizeof (*hdr16)) |
2419 | goto toosmall; |
2420 | |
2421 | hdr16 = (struct ncm_header16 *)buf; |
2422 | hsig = UGETDW(hdr16->dwSignature)(*(u_int32_t *)(hdr16->dwSignature)); |
2423 | |
2424 | switch (hsig) { |
2425 | case NCM_HDR16_SIG0x484d434e: |
2426 | blen = UGETW(hdr16->wBlockLength)(*(u_int16_t *)(hdr16->wBlockLength)); |
2427 | ptroff = UGETW(hdr16->wNdpIndex)(*(u_int16_t *)(hdr16->wNdpIndex)); |
2428 | if (UGETW(hdr16->wHeaderLength)(*(u_int16_t *)(hdr16->wHeaderLength)) != sizeof (*hdr16)) { |
2429 | DPRINTF("%s: bad header len %d for NTH16 (exp %zu)\n",do { } while (0) |
2430 | DEVNAM(sc), UGETW(hdr16->wHeaderLength),do { } while (0) |
2431 | sizeof (*hdr16))do { } while (0); |
2432 | goto fail; |
2433 | } |
2434 | break; |
2435 | case NCM_HDR32_SIG0x686d636e: |
2436 | if (len < sizeof (*hdr32)) |
2437 | goto toosmall; |
2438 | hdr32 = (struct ncm_header32 *)hdr16; |
2439 | blen = UGETDW(hdr32->dwBlockLength)(*(u_int32_t *)(hdr32->dwBlockLength)); |
2440 | ptroff = UGETDW(hdr32->dwNdpIndex)(*(u_int32_t *)(hdr32->dwNdpIndex)); |
2441 | if (UGETW(hdr32->wHeaderLength)(*(u_int16_t *)(hdr32->wHeaderLength)) != sizeof (*hdr32)) { |
2442 | DPRINTF("%s: bad header len %d for NTH32 (exp %zu)\n",do { } while (0) |
2443 | DEVNAM(sc), UGETW(hdr32->wHeaderLength),do { } while (0) |
2444 | sizeof (*hdr32))do { } while (0); |
2445 | goto fail; |
2446 | } |
2447 | break; |
2448 | default: |
2449 | DPRINTF("%s: unsupported NCM header signature (0x%08x)\n",do { } while (0) |
2450 | DEVNAM(sc), hsig)do { } while (0); |
2451 | goto fail; |
2452 | } |
2453 | if (blen != 0 && len < blen) { |
2454 | DPRINTF("%s: bad NTB len (%d) for %d bytes of data\n",do { } while (0) |
2455 | DEVNAM(sc), blen, len)do { } while (0); |
2456 | goto fail; |
2457 | } |
2458 | |
2459 | ptr16 = (struct ncm_pointer16 *)(buf + ptroff); |
2460 | psig = UGETDW(ptr16->dwSignature)(*(u_int32_t *)(ptr16->dwSignature)); |
2461 | ptrlen = UGETW(ptr16->wLength)(*(u_int16_t *)(ptr16->wLength)); |
2462 | if (len < ptrlen + ptroff) |
2463 | goto toosmall; |
2464 | if (!MBIM_NCM_NTH16_ISISG(psig)(((psig) & 0x00ffffff) == 0x00535049) && !MBIM_NCM_NTH32_ISISG(psig)(((psig) & 0x00ffffff) == 0x00737069)) { |
2465 | DPRINTF("%s: unsupported NCM pointer signature (0x%08x)\n",do { } while (0) |
2466 | DEVNAM(sc), psig)do { } while (0); |
2467 | goto fail; |
2468 | } |
2469 | |
2470 | switch (hsig) { |
2471 | case NCM_HDR16_SIG0x484d434e: |
2472 | dgentryoff = offsetof(struct ncm_pointer16, dgram)__builtin_offsetof(struct ncm_pointer16, dgram); |
2473 | break; |
2474 | case NCM_HDR32_SIG0x686d636e: |
2475 | dgentryoff = offsetof(struct ncm_pointer32, dgram)__builtin_offsetof(struct ncm_pointer32, dgram); |
2476 | break; |
2477 | default: |
2478 | goto fail; |
2479 | } |
2480 | |
2481 | while (dgentryoff < ptrlen) { |
2482 | switch (hsig) { |
2483 | case NCM_HDR16_SIG0x484d434e: |
2484 | if (ptroff + dgentryoff < sizeof (*dgram16)) |
2485 | goto done; |
2486 | dgram16 = (struct ncm_pointer16_dgram *) |
2487 | (buf + ptroff + dgentryoff); |
2488 | dgentryoff += sizeof (*dgram16); |
2489 | dlen = UGETW(dgram16->wDatagramLen)(*(u_int16_t *)(dgram16->wDatagramLen)); |
2490 | doff = UGETW(dgram16->wDatagramIndex)(*(u_int16_t *)(dgram16->wDatagramIndex)); |
2491 | break; |
2492 | case NCM_HDR32_SIG0x686d636e: |
2493 | if (ptroff + dgentryoff < sizeof (*dgram32)) |
2494 | goto done; |
2495 | dgram32 = (struct ncm_pointer32_dgram *) |
2496 | (buf + ptroff + dgentryoff); |
2497 | dgentryoff += sizeof (*dgram32); |
2498 | dlen = UGETDW(dgram32->dwDatagramLen)(*(u_int32_t *)(dgram32->dwDatagramLen)); |
2499 | doff = UGETDW(dgram32->dwDatagramIndex)(*(u_int32_t *)(dgram32->dwDatagramIndex)); |
2500 | break; |
2501 | default: |
2502 | ifp->if_ierrorsif_data.ifi_ierrors++; |
2503 | goto done; |
2504 | } |
2505 | |
2506 | /* Terminating zero entry */ |
2507 | if (dlen == 0 || doff == 0) |
2508 | break; |
2509 | if (len < dlen + doff) { |
2510 | /* Skip giant datagram but continue processing */ |
2511 | DPRINTF("%s: datagram too large (%d @ off %d)\n",do { } while (0) |
2512 | DEVNAM(sc), dlen, doff)do { } while (0); |
2513 | continue; |
2514 | } |
2515 | |
2516 | dp = buf + doff; |
2517 | DPRINTFN(3, "%s: decap %d bytes\n", DEVNAM(sc), dlen)do { } while (0); |
2518 | m = m_devget(dp, dlen, sizeof(uint32_t)); |
2519 | if (m == NULL((void *)0)) { |
2520 | ifp->if_iqdropsif_data.ifi_iqdrops++; |
2521 | continue; |
2522 | } |
2523 | switch (*dp & 0xf0) { |
2524 | case 4 << 4: |
2525 | m->m_pkthdrM_dat.MH.MH_pkthdr.ph_family = AF_INET2; |
2526 | break; |
2527 | case 6 << 4: |
2528 | m->m_pkthdrM_dat.MH.MH_pkthdr.ph_family = AF_INET624; |
2529 | break; |
2530 | } |
2531 | ml_enqueue(&ml, m); |
2532 | } |
2533 | done: |
2534 | if_input(ifp, &ml); |
2535 | splx(s)spllower(s); |
2536 | return; |
2537 | toosmall: |
2538 | DPRINTF("%s: packet too small (%d)\n", DEVNAM(sc), len)do { } while (0); |
2539 | fail: |
2540 | ifp->if_ierrorsif_data.ifi_ierrors++; |
2541 | splx(s)spllower(s); |
2542 | } |
2543 | |
2544 | usbd_status |
2545 | umb_send_encap_command(struct umb_softc *sc, void *data, int len) |
2546 | { |
2547 | struct usbd_xfer *xfer; |
2548 | usb_device_request_t req; |
2549 | char *buf; |
2550 | |
2551 | if (len > sc->sc_ctrl_len) |
2552 | return USBD_INVAL; |
2553 | |
2554 | if ((xfer = usbd_alloc_xfer(sc->sc_udev)) == NULL((void *)0)) |
2555 | return USBD_NOMEM; |
2556 | if ((buf = usbd_alloc_buffer(xfer, len)) == NULL((void *)0)) { |
2557 | usbd_free_xfer(xfer); |
2558 | return USBD_NOMEM; |
2559 | } |
2560 | memcpy(buf, data, len)__builtin_memcpy((buf), (data), (len)); |
2561 | |
2562 | /* XXX FIXME: if (total len > sc->sc_ctrl_len) => must fragment */ |
2563 | req.bmRequestType = UT_WRITE_CLASS_INTERFACE(0x00 | 0x20 | 0x01); |
2564 | req.bRequest = UCDC_SEND_ENCAPSULATED_COMMAND0x00; |
2565 | USETW(req.wValue, 0)(*(u_int16_t *)(req.wValue) = (0)); |
2566 | USETW(req.wIndex, sc->sc_ctrl_ifaceno)(*(u_int16_t *)(req.wIndex) = (sc->sc_ctrl_ifaceno)); |
2567 | USETW(req.wLength, len)(*(u_int16_t *)(req.wLength) = (len)); |
2568 | DELAY(umb_delay)(*delay_func)(umb_delay); |
2569 | return usbd_request_async(xfer, &req, NULL((void *)0), NULL((void *)0)); |
2570 | } |
2571 | |
2572 | int |
2573 | umb_get_encap_response(struct umb_softc *sc, void *buf, int *len) |
2574 | { |
2575 | usb_device_request_t req; |
2576 | usbd_status err; |
2577 | |
2578 | req.bmRequestType = UT_READ_CLASS_INTERFACE(0x80 | 0x20 | 0x01); |
2579 | req.bRequest = UCDC_GET_ENCAPSULATED_RESPONSE0x01; |
2580 | USETW(req.wValue, 0)(*(u_int16_t *)(req.wValue) = (0)); |
2581 | USETW(req.wIndex, sc->sc_ctrl_ifaceno)(*(u_int16_t *)(req.wIndex) = (sc->sc_ctrl_ifaceno)); |
2582 | USETW(req.wLength, *len)(*(u_int16_t *)(req.wLength) = (*len)); |
2583 | /* XXX FIXME: re-assemble fragments */ |
2584 | |
2585 | DELAY(umb_delay)(*delay_func)(umb_delay); |
2586 | err = usbd_do_request_flags(sc->sc_udev, &req, buf, USBD_SHORT_XFER_OK0x04, |
2587 | len, umb_xfer_tout); |
2588 | if (err == USBD_NORMAL_COMPLETION) |
2589 | return 1; |
2590 | DPRINTF("%s: ctrl recv: %s\n", DEVNAM(sc), usbd_errstr(err))do { } while (0); |
2591 | return 0; |
2592 | } |
2593 | |
2594 | void |
2595 | umb_ctrl_msg(struct umb_softc *sc, uint32_t req, void *data, int len) |
2596 | { |
2597 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
2598 | uint32_t tid; |
2599 | struct mbim_msghdr *hdr = data; |
2600 | usbd_status err; |
2601 | int s; |
2602 | |
2603 | assertwaitok(); |
2604 | if (usbd_is_dying(sc->sc_udev)) |
2605 | return; |
2606 | if (len < sizeof (*hdr)) |
2607 | return; |
2608 | tid = ++sc->sc_tid; |
2609 | |
2610 | hdr->type = htole32(req)((__uint32_t)(req)); |
2611 | hdr->len = htole32(len)((__uint32_t)(len)); |
2612 | hdr->tid = htole32(tid)((__uint32_t)(tid)); |
2613 | |
2614 | #ifdef UMB_DEBUG |
2615 | if (umb_debug) { |
2616 | const char *op, *str; |
2617 | if (req == MBIM_COMMAND_MSG3U) { |
2618 | struct mbim_h2f_cmd *c = data; |
2619 | if (letoh32(c->op)((__uint32_t)(c->op)) == MBIM_CMDOP_SET1) |
2620 | op = "set"; |
2621 | else |
2622 | op = "qry"; |
2623 | str = umb_cid2str(letoh32(c->cid))umb_val2descr(umb_cids, (((__uint32_t)(c->cid)))); |
2624 | } else { |
2625 | op = "snd"; |
2626 | str = umb_request2str(req)umb_val2descr(umb_messages, (req)); |
2627 | } |
2628 | DPRINTF("%s: -> %s %s (tid %u)\n", DEVNAM(sc), op, str, tid)do { } while (0); |
2629 | } |
2630 | #endif |
2631 | s = splusb()splraise(0x2); |
2632 | err = umb_send_encap_command(sc, data, len); |
2633 | splx(s)spllower(s); |
2634 | if (err != USBD_NORMAL_COMPLETION) { |
2635 | if (ifp->if_flags & IFF_DEBUG0x4) |
2636 | log(LOG_ERR3, "%s: send %s msg (tid %u) failed: %s\n", |
2637 | DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), umb_request2str(req)umb_val2descr(umb_messages, (req)), tid, |
2638 | usbd_errstr(err)); |
2639 | |
2640 | /* will affect other transactions, too */ |
2641 | usbd_abort_pipe(sc->sc_udev->default_pipe); |
2642 | } else { |
2643 | DPRINTFN(2, "%s: sent %s (tid %u)\n", DEVNAM(sc),do { } while (0) |
2644 | umb_request2str(req), tid)do { } while (0); |
2645 | DDUMPN(3, data, len)do { } while (0); |
2646 | } |
2647 | return; |
2648 | } |
2649 | |
2650 | void |
2651 | umb_open(struct umb_softc *sc) |
2652 | { |
2653 | struct mbim_h2f_openmsg msg; |
2654 | |
2655 | memset(&msg, 0, sizeof (msg))__builtin_memset((&msg), (0), (sizeof (msg))); |
2656 | msg.maxlen = htole32(sc->sc_ctrl_len)((__uint32_t)(sc->sc_ctrl_len)); |
2657 | umb_ctrl_msg(sc, MBIM_OPEN_MSG1U, &msg, sizeof (msg)); |
2658 | return; |
2659 | } |
2660 | |
2661 | void |
2662 | umb_close(struct umb_softc *sc) |
2663 | { |
2664 | struct mbim_h2f_closemsg msg; |
2665 | |
2666 | memset(&msg, 0, sizeof (msg))__builtin_memset((&msg), (0), (sizeof (msg))); |
2667 | umb_ctrl_msg(sc, MBIM_CLOSE_MSG2U, &msg, sizeof (msg)); |
2668 | } |
2669 | |
2670 | int |
2671 | umb_setpin(struct umb_softc *sc, int op, int is_puk, void *pin, int pinlen, |
2672 | void *newpin, int newpinlen) |
2673 | { |
2674 | struct mbim_cid_pin cp; |
2675 | int off; |
2676 | |
2677 | if (pinlen == 0) |
2678 | return 0; |
2679 | if (pinlen < 0 || pinlen > MBIM_PIN_MAXLEN32 || |
2680 | newpinlen < 0 || newpinlen > MBIM_PIN_MAXLEN32 || |
2681 | op < 0 || op > MBIM_PIN_OP_CHANGE3 || |
2682 | (is_puk && op != MBIM_PIN_OP_ENTER0)) |
2683 | return EINVAL22; |
2684 | |
2685 | memset(&cp, 0, sizeof (cp))__builtin_memset((&cp), (0), (sizeof (cp))); |
2686 | cp.type = htole32(is_puk ? MBIM_PIN_TYPE_PUK1 : MBIM_PIN_TYPE_PIN1)((__uint32_t)(is_puk ? 11 : 2)); |
2687 | |
2688 | off = offsetof(struct mbim_cid_pin, data)__builtin_offsetof(struct mbim_cid_pin, data); |
2689 | if (!umb_addstr(&cp, sizeof (cp), &off, pin, pinlen, |
2690 | &cp.pin_offs, &cp.pin_size)) |
2691 | return EINVAL22; |
2692 | |
2693 | cp.op = htole32(op)((__uint32_t)(op)); |
2694 | if (newpinlen) { |
2695 | if (!umb_addstr(&cp, sizeof (cp), &off, newpin, newpinlen, |
2696 | &cp.newpin_offs, &cp.newpin_size)) |
2697 | return EINVAL22; |
2698 | } else { |
2699 | if ((op == MBIM_PIN_OP_CHANGE3) || is_puk) |
2700 | return EINVAL22; |
2701 | if (!umb_addstr(&cp, sizeof (cp), &off, NULL((void *)0), 0, |
2702 | &cp.newpin_offs, &cp.newpin_size)) |
2703 | return EINVAL22; |
2704 | } |
2705 | umb_cmd(sc, MBIM_CID_PIN4, MBIM_CMDOP_SET1, &cp, off); |
2706 | return 0; |
2707 | } |
2708 | |
2709 | void |
2710 | umb_setdataclass(struct umb_softc *sc) |
2711 | { |
2712 | struct mbim_cid_registration_state rs; |
2713 | uint32_t classes; |
2714 | |
2715 | if (sc->sc_info.supportedclasses == MBIM_DATACLASS_NONE0x00000000) |
2716 | return; |
2717 | |
2718 | memset(&rs, 0, sizeof (rs))__builtin_memset((&rs), (0), (sizeof (rs))); |
2719 | rs.regaction = htole32(MBIM_REGACTION_AUTOMATIC)((__uint32_t)(0)); |
2720 | classes = sc->sc_info.supportedclasses; |
2721 | if (sc->sc_info.preferredclasses != MBIM_DATACLASS_NONE0x00000000) |
2722 | classes &= sc->sc_info.preferredclasses; |
2723 | rs.data_class = htole32(classes)((__uint32_t)(classes)); |
2724 | umb_cmd(sc, MBIM_CID_REGISTER_STATE9, MBIM_CMDOP_SET1, &rs, sizeof (rs)); |
2725 | } |
2726 | |
2727 | void |
2728 | umb_radio(struct umb_softc *sc, int on) |
2729 | { |
2730 | struct mbim_cid_radio_state s; |
2731 | |
2732 | DPRINTF("%s: set radio %s\n", DEVNAM(sc), on ? "on" : "off")do { } while (0); |
2733 | memset(&s, 0, sizeof (s))__builtin_memset((&s), (0), (sizeof (s))); |
2734 | s.state = htole32(on ? MBIM_RADIO_STATE_ON : MBIM_RADIO_STATE_OFF)((__uint32_t)(on ? 1 : 0)); |
2735 | umb_cmd(sc, MBIM_CID_RADIO_STATE3, MBIM_CMDOP_SET1, &s, sizeof (s)); |
2736 | } |
2737 | |
2738 | void |
2739 | umb_allocate_cid(struct umb_softc *sc) |
2740 | { |
2741 | umb_cmd1(sc, MBIM_CID_DEVICE_CAPS1, MBIM_CMDOP_SET1, |
2742 | umb_qmi_alloc_cid, sizeof (umb_qmi_alloc_cid), umb_uuid_qmi_mbim); |
2743 | } |
2744 | |
2745 | void |
2746 | umb_send_fcc_auth(struct umb_softc *sc) |
2747 | { |
2748 | uint8_t fccauth[sizeof (umb_qmi_fcc_auth)]; |
2749 | |
2750 | if (sc->sc_cid == -1) { |
2751 | DPRINTF("%s: missing CID, cannot send FCC auth\n", DEVNAM(sc))do { } while (0); |
2752 | umb_allocate_cid(sc); |
2753 | return; |
2754 | } |
2755 | memcpy(fccauth, umb_qmi_fcc_auth, sizeof (fccauth))__builtin_memcpy((fccauth), (umb_qmi_fcc_auth), (sizeof (fccauth ))); |
2756 | fccauth[UMB_QMI_CID_OFFS5] = sc->sc_cid; |
2757 | umb_cmd1(sc, MBIM_CID_DEVICE_CAPS1, MBIM_CMDOP_SET1, |
2758 | fccauth, sizeof (fccauth), umb_uuid_qmi_mbim); |
2759 | } |
2760 | |
2761 | void |
2762 | umb_packet_service(struct umb_softc *sc, int attach) |
2763 | { |
2764 | struct mbim_cid_packet_service s; |
2765 | |
2766 | DPRINTF("%s: %s packet service\n", DEVNAM(sc),do { } while (0) |
2767 | attach ? "attach" : "detach")do { } while (0); |
2768 | memset(&s, 0, sizeof (s))__builtin_memset((&s), (0), (sizeof (s))); |
2769 | s.action = htole32(attach ?((__uint32_t)(attach ? 0 : 1)) |
2770 | MBIM_PKTSERVICE_ACTION_ATTACH : MBIM_PKTSERVICE_ACTION_DETACH)((__uint32_t)(attach ? 0 : 1)); |
2771 | umb_cmd(sc, MBIM_CID_PACKET_SERVICE10, MBIM_CMDOP_SET1, &s, sizeof (s)); |
2772 | } |
2773 | |
2774 | void |
2775 | umb_connect(struct umb_softc *sc) |
2776 | { |
2777 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
2778 | |
2779 | if (sc->sc_info.regstate == MBIM_REGSTATE_ROAMING4 && !sc->sc_roamingsc_info.enable_roaming) { |
2780 | log(LOG_INFO6, "%s: connection disabled in roaming network\n", |
2781 | DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
2782 | return; |
2783 | } |
2784 | if (ifp->if_flags & IFF_DEBUG0x4) |
2785 | log(LOG_DEBUG7, "%s: connecting ...\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
2786 | umb_send_connect(sc, MBIM_CONNECT_ACTIVATE1); |
2787 | } |
2788 | |
2789 | void |
2790 | umb_disconnect(struct umb_softc *sc) |
2791 | { |
2792 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
2793 | |
2794 | if (ifp->if_flags & IFF_DEBUG0x4) |
2795 | log(LOG_DEBUG7, "%s: disconnecting ...\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
2796 | umb_send_connect(sc, MBIM_CONNECT_DEACTIVATE0); |
2797 | } |
2798 | |
2799 | void |
2800 | umb_send_connect(struct umb_softc *sc, int command) |
2801 | { |
2802 | struct mbim_cid_connect *c; |
2803 | int off; |
2804 | |
2805 | /* Too large or the stack */ |
2806 | c = malloc(sizeof (*c), M_USBDEV102, M_WAIT0x0001|M_ZERO0x0008); |
2807 | c->sessionid = htole32(umb_session_id)((__uint32_t)(umb_session_id)); |
2808 | c->command = htole32(command)((__uint32_t)(command)); |
2809 | off = offsetof(struct mbim_cid_connect, data)__builtin_offsetof(struct mbim_cid_connect, data); |
2810 | if (!umb_addstr(c, sizeof (*c), &off, sc->sc_info.apn, |
2811 | sc->sc_info.apnlen, &c->access_offs, &c->access_size)) |
2812 | goto done; |
2813 | /* XXX FIXME: support user name and passphrase */ |
2814 | c->user_offs = htole32(0)((__uint32_t)(0)); |
2815 | c->user_size = htole32(0)((__uint32_t)(0)); |
2816 | c->passwd_offs = htole32(0)((__uint32_t)(0)); |
2817 | c->passwd_size = htole32(0)((__uint32_t)(0)); |
2818 | c->authprot = htole32(MBIM_AUTHPROT_NONE)((__uint32_t)(0)); |
2819 | c->compression = htole32(MBIM_COMPRESSION_NONE)((__uint32_t)(0)); |
2820 | c->iptype = htole32(MBIM_CONTEXT_IPTYPE_IPV4)((__uint32_t)(1)); |
2821 | #ifdef INET61 |
2822 | /* XXX FIXME: support IPv6-only mode, too */ |
2823 | if ((sc->sc_flags & UMBFLG_NO_INET60x0002) == 0 && |
2824 | in6ifa_ifpforlinklocal(GET_IFP(sc)(&(sc)->sc_if), 0) != NULL((void *)0)) |
2825 | c->iptype = htole32(MBIM_CONTEXT_IPTYPE_IPV4V6)((__uint32_t)(3)); |
2826 | #endif |
2827 | memcpy(c->context, umb_uuid_context_internet, sizeof (c->context))__builtin_memcpy((c->context), (umb_uuid_context_internet) , (sizeof (c->context))); |
2828 | umb_cmd(sc, MBIM_CID_CONNECT12, MBIM_CMDOP_SET1, c, off); |
2829 | done: |
2830 | free(c, M_USBDEV102, sizeof (*c)); |
2831 | return; |
2832 | } |
2833 | |
2834 | void |
2835 | umb_qry_ipconfig(struct umb_softc *sc) |
2836 | { |
2837 | struct mbim_cid_ip_configuration_info ipc; |
2838 | |
2839 | memset(&ipc, 0, sizeof (ipc))__builtin_memset((&ipc), (0), (sizeof (ipc))); |
2840 | ipc.sessionid = htole32(umb_session_id)((__uint32_t)(umb_session_id)); |
2841 | umb_cmd(sc, MBIM_CID_IP_CONFIGURATION15, MBIM_CMDOP_QRY0, |
2842 | &ipc, sizeof (ipc)); |
2843 | } |
2844 | |
2845 | void |
2846 | umb_cmd(struct umb_softc *sc, int cid, int op, void *data, int len) |
2847 | { |
2848 | umb_cmd1(sc, cid, op, data, len, umb_uuid_basic_connect); |
2849 | } |
2850 | |
2851 | void |
2852 | umb_cmd1(struct umb_softc *sc, int cid, int op, void *data, int len, |
2853 | uint8_t *uuid) |
2854 | { |
2855 | struct mbim_h2f_cmd *cmd; |
2856 | int totlen; |
2857 | |
2858 | /* XXX FIXME support sending fragments */ |
2859 | if (sizeof (*cmd) + len > sc->sc_ctrl_len) { |
2860 | DPRINTF("%s: set %s msg too long: cannot send\n",do { } while (0) |
2861 | DEVNAM(sc), umb_cid2str(cid))do { } while (0); |
2862 | return; |
2863 | } |
2864 | cmd = sc->sc_ctrl_msg; |
2865 | memset(cmd, 0, sizeof (*cmd))__builtin_memset((cmd), (0), (sizeof (*cmd))); |
2866 | cmd->frag.nfrag = htole32(1)((__uint32_t)(1)); |
2867 | memcpy(cmd->devid, uuid, sizeof (cmd->devid))__builtin_memcpy((cmd->devid), (uuid), (sizeof (cmd->devid ))); |
2868 | cmd->cid = htole32(cid)((__uint32_t)(cid)); |
2869 | cmd->op = htole32(op)((__uint32_t)(op)); |
2870 | cmd->infolen = htole32(len)((__uint32_t)(len)); |
2871 | totlen = sizeof (*cmd); |
2872 | if (len > 0) { |
2873 | memcpy(cmd + 1, data, len)__builtin_memcpy((cmd + 1), (data), (len)); |
2874 | totlen += len; |
2875 | } |
2876 | umb_ctrl_msg(sc, MBIM_COMMAND_MSG3U, cmd, totlen); |
2877 | } |
2878 | |
2879 | void |
2880 | umb_command_done(struct umb_softc *sc, void *data, int len) |
2881 | { |
2882 | struct mbim_f2h_cmddone *cmd = data; |
2883 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
2884 | uint32_t status; |
2885 | uint32_t cid; |
2886 | uint32_t infolen; |
2887 | int qmimsg = 0; |
2888 | |
2889 | if (len < sizeof (*cmd)) { |
2890 | DPRINTF("%s: discard short %s message\n", DEVNAM(sc),do { } while (0) |
2891 | umb_request2str(letoh32(cmd->hdr.type)))do { } while (0); |
2892 | return; |
2893 | } |
2894 | cid = letoh32(cmd->cid)((__uint32_t)(cmd->cid)); |
2895 | if (memcmp(cmd->devid, umb_uuid_basic_connect, sizeof (cmd->devid))__builtin_memcmp((cmd->devid), (umb_uuid_basic_connect), ( sizeof (cmd->devid)))) { |
2896 | if (memcmp(cmd->devid, umb_uuid_qmi_mbim,__builtin_memcmp((cmd->devid), (umb_uuid_qmi_mbim), (sizeof (cmd->devid))) |
2897 | sizeof (cmd->devid))__builtin_memcmp((cmd->devid), (umb_uuid_qmi_mbim), (sizeof (cmd->devid)))) { |
2898 | DPRINTF("%s: discard %s message for other UUID '%s'\n",do { } while (0) |
2899 | DEVNAM(sc), umb_request2str(letoh32(cmd->hdr.type)),do { } while (0) |
2900 | umb_uuid2str(cmd->devid))do { } while (0); |
2901 | return; |
2902 | } else |
2903 | qmimsg = 1; |
2904 | } |
2905 | |
2906 | status = letoh32(cmd->status)((__uint32_t)(cmd->status)); |
2907 | switch (status) { |
2908 | case MBIM_STATUS_SUCCESS0: |
2909 | break; |
2910 | #ifdef INET61 |
2911 | case MBIM_STATUS_NO_DEVICE_SUPPORT9: |
2912 | if ((cid == MBIM_CID_CONNECT12) && |
2913 | (sc->sc_flags & UMBFLG_NO_INET60x0002) == 0) { |
2914 | sc->sc_flags |= UMBFLG_NO_INET60x0002; |
2915 | if (ifp->if_flags & IFF_DEBUG0x4) |
2916 | log(LOG_ERR3, |
2917 | "%s: device does not support IPv6\n", |
2918 | DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
2919 | } |
2920 | /* Re-trigger the connect, this time IPv4 only */ |
2921 | usb_add_task(sc->sc_udev, &sc->sc_umb_task); |
2922 | return; |
2923 | #endif |
2924 | case MBIM_STATUS_NOT_INITIALIZED14: |
2925 | if (ifp->if_flags & IFF_DEBUG0x4) |
2926 | log(LOG_ERR3, "%s: SIM not initialized (PIN missing)\n", |
2927 | DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname)); |
2928 | return; |
2929 | case MBIM_STATUS_PIN_REQUIRED5: |
2930 | sc->sc_info.pin_state = UMB_PIN_REQUIRED0; |
2931 | /*FALLTHROUGH*/ |
2932 | default: |
2933 | if (ifp->if_flags & IFF_DEBUG0x4) |
2934 | log(LOG_ERR3, "%s: set/qry %s failed: %s\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), |
2935 | umb_cid2str(cid)umb_val2descr(umb_cids, (cid)), umb_status2str(status)umb_val2descr(umb_status, (status))); |
2936 | return; |
2937 | } |
2938 | |
2939 | infolen = letoh32(cmd->infolen)((__uint32_t)(cmd->infolen)); |
2940 | if (len < sizeof (*cmd) + infolen) { |
2941 | DPRINTF("%s: discard truncated %s message (want %d, got %d)\n",do { } while (0) |
2942 | DEVNAM(sc), umb_cid2str(cid),do { } while (0) |
2943 | (int)sizeof (*cmd) + infolen, len)do { } while (0); |
2944 | return; |
2945 | } |
2946 | if (qmimsg) { |
2947 | if (sc->sc_flags & UMBFLG_FCC_AUTH_REQUIRED0x0001) |
2948 | umb_decode_qmi(sc, cmd->info, infolen); |
2949 | } else { |
2950 | DPRINTFN(2, "%s: set/qry %s done\n", DEVNAM(sc),do { } while (0) |
2951 | umb_cid2str(cid))do { } while (0); |
2952 | umb_decode_cid(sc, cid, cmd->info, infolen); |
2953 | } |
2954 | } |
2955 | |
2956 | void |
2957 | umb_decode_cid(struct umb_softc *sc, uint32_t cid, void *data, int len) |
2958 | { |
2959 | int ok = 1; |
2960 | |
2961 | switch (cid) { |
2962 | case MBIM_CID_DEVICE_CAPS1: |
2963 | ok = umb_decode_devices_caps(sc, data, len); |
2964 | break; |
2965 | case MBIM_CID_SUBSCRIBER_READY_STATUS2: |
2966 | ok = umb_decode_subscriber_status(sc, data, len); |
2967 | break; |
2968 | case MBIM_CID_RADIO_STATE3: |
2969 | ok = umb_decode_radio_state(sc, data, len); |
2970 | break; |
2971 | case MBIM_CID_PIN4: |
2972 | ok = umb_decode_pin(sc, data, len); |
2973 | break; |
2974 | case MBIM_CID_REGISTER_STATE9: |
2975 | ok = umb_decode_register_state(sc, data, len); |
2976 | break; |
2977 | case MBIM_CID_PACKET_SERVICE10: |
2978 | ok = umb_decode_packet_service(sc, data, len); |
2979 | break; |
2980 | case MBIM_CID_SIGNAL_STATE11: |
2981 | ok = umb_decode_signal_state(sc, data, len); |
2982 | break; |
2983 | case MBIM_CID_CONNECT12: |
2984 | ok = umb_decode_connect_info(sc, data, len); |
2985 | break; |
2986 | case MBIM_CID_IP_CONFIGURATION15: |
2987 | ok = umb_decode_ip_configuration(sc, data, len); |
2988 | break; |
2989 | default: |
2990 | /* |
2991 | * Note: the above list is incomplete and only contains |
2992 | * mandatory CIDs from the BASIC_CONNECT set. |
2993 | * So alternate values are not unusual. |
2994 | */ |
2995 | DPRINTFN(4, "%s: ignore %s\n", DEVNAM(sc), umb_cid2str(cid))do { } while (0); |
2996 | break; |
2997 | } |
2998 | if (!ok) |
2999 | DPRINTF("%s: discard %s with bad info length %d\n",do { } while (0) |
3000 | DEVNAM(sc), umb_cid2str(cid), len)do { } while (0); |
3001 | return; |
3002 | } |
3003 | |
3004 | void |
3005 | umb_decode_qmi(struct umb_softc *sc, uint8_t *data, int len) |
3006 | { |
3007 | uint8_t srv; |
3008 | uint16_t msg, tlvlen; |
3009 | uint32_t val; |
3010 | |
3011 | #define UMB_QMI_QMUXLEN6 6 |
3012 | if (len < UMB_QMI_QMUXLEN6) |
3013 | goto tooshort; |
3014 | |
3015 | srv = data[4]; |
3016 | data += UMB_QMI_QMUXLEN6; |
3017 | len -= UMB_QMI_QMUXLEN6; |
3018 | |
3019 | #define UMB_GET16(p)((uint16_t)*p | (uint16_t)*(p + 1) << 8) ((uint16_t)*p | (uint16_t)*(p + 1) << 8) |
3020 | #define UMB_GET32(p)((uint32_t)*p | (uint32_t)*(p + 1) << 8 | (uint32_t)*(p + 2) << 16 |(uint32_t)*(p + 3) << 24) ((uint32_t)*p | (uint32_t)*(p + 1) << 8 | \ |
3021 | (uint32_t)*(p + 2) << 16 |(uint32_t)*(p + 3) << 24) |
3022 | switch (srv) { |
3023 | case 0: /* ctl */ |
3024 | #define UMB_QMI_CTLLEN6 6 |
3025 | if (len < UMB_QMI_CTLLEN6) |
3026 | goto tooshort; |
3027 | msg = UMB_GET16(&data[2])((uint16_t)*&data[2] | (uint16_t)*(&data[2] + 1) << 8); |
3028 | tlvlen = UMB_GET16(&data[4])((uint16_t)*&data[4] | (uint16_t)*(&data[4] + 1) << 8); |
3029 | data += UMB_QMI_CTLLEN6; |
3030 | len -= UMB_QMI_CTLLEN6; |
3031 | break; |
3032 | case 2: /* dms */ |
3033 | #define UMB_QMI_DMSLEN7 7 |
3034 | if (len < UMB_QMI_DMSLEN7) |
3035 | goto tooshort; |
3036 | msg = UMB_GET16(&data[3])((uint16_t)*&data[3] | (uint16_t)*(&data[3] + 1) << 8); |
3037 | tlvlen = UMB_GET16(&data[5])((uint16_t)*&data[5] | (uint16_t)*(&data[5] + 1) << 8); |
3038 | data += UMB_QMI_DMSLEN7; |
3039 | len -= UMB_QMI_DMSLEN7; |
3040 | break; |
3041 | default: |
3042 | DPRINTF("%s: discard QMI message for unknown service type %d\n",do { } while (0) |
3043 | DEVNAM(sc), srv)do { } while (0); |
3044 | return; |
3045 | } |
3046 | |
3047 | if (len < tlvlen) |
3048 | goto tooshort; |
3049 | |
3050 | #define UMB_QMI_TLVLEN3 3 |
3051 | while (len > 0) { |
3052 | if (len < UMB_QMI_TLVLEN3) |
3053 | goto tooshort; |
3054 | tlvlen = UMB_GET16(&data[1])((uint16_t)*&data[1] | (uint16_t)*(&data[1] + 1) << 8); |
3055 | if (len < UMB_QMI_TLVLEN3 + tlvlen) |
3056 | goto tooshort; |
3057 | switch (data[0]) { |
3058 | case 1: /* allocation info */ |
3059 | if (msg == 0x0022) { /* Allocate CID */ |
3060 | if (tlvlen != 2 || data[3] != 2) /* dms */ |
3061 | break; |
3062 | sc->sc_cid = data[4]; |
3063 | DPRINTF("%s: QMI CID %d allocated\n",do { } while (0) |
3064 | DEVNAM(sc), sc->sc_cid)do { } while (0); |
3065 | umb_newstate(sc, UMB_S_CID, UMB_NS_DONT_DROP0x0001); |
3066 | } |
3067 | break; |
3068 | case 2: /* response */ |
3069 | if (tlvlen != sizeof (val)) |
3070 | break; |
3071 | val = UMB_GET32(&data[3])((uint32_t)*&data[3] | (uint32_t)*(&data[3] + 1) << 8 | (uint32_t)*(&data[3] + 2) << 16 |(uint32_t)*(& data[3] + 3) << 24); |
3072 | switch (msg) { |
3073 | case 0x0022: /* Allocate CID */ |
3074 | if (val != 0) { |
3075 | log(LOG_ERR3, "%s: allocation of QMI CID" |
3076 | " failed, error 0x%x\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), |
3077 | val); |
3078 | /* XXX how to proceed? */ |
3079 | return; |
3080 | } |
3081 | break; |
3082 | case 0x555f: /* Send FCC Authentication */ |
3083 | if (val == 0) |
3084 | DPRINTF("%s: send FCC "do { } while (0) |
3085 | "Authentication succeeded\n",do { } while (0) |
3086 | DEVNAM(sc))do { } while (0); |
3087 | else if (val == 0x001a0001) |
3088 | DPRINTF("%s: FCC Authentication "do { } while (0) |
3089 | "not required\n", DEVNAM(sc))do { } while (0); |
3090 | else |
3091 | log(LOG_INFO6, "%s: send FCC " |
3092 | "Authentication failed, " |
3093 | "error 0x%x\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), val); |
3094 | |
3095 | /* FCC Auth is needed only once after power-on*/ |
3096 | sc->sc_flags &= ~UMBFLG_FCC_AUTH_REQUIRED0x0001; |
3097 | |
3098 | /* Try to proceed anyway */ |
3099 | DPRINTF("%s: init: turning radio on ...\n",do { } while (0) |
3100 | DEVNAM(sc))do { } while (0); |
3101 | umb_radio(sc, 1); |
3102 | break; |
3103 | default: |
3104 | break; |
3105 | } |
3106 | break; |
3107 | default: |
3108 | break; |
3109 | } |
3110 | data += UMB_QMI_TLVLEN3 + tlvlen; |
3111 | len -= UMB_QMI_TLVLEN3 + tlvlen; |
3112 | } |
3113 | return; |
3114 | |
3115 | tooshort: |
3116 | DPRINTF("%s: discard short QMI message\n", DEVNAM(sc))do { } while (0); |
3117 | return; |
3118 | } |
3119 | |
3120 | void |
3121 | umb_intr(struct usbd_xfer *xfer, void *priv, usbd_status status) |
3122 | { |
3123 | struct umb_softc *sc = priv; |
3124 | struct ifnet *ifp = GET_IFP(sc)(&(sc)->sc_if); |
3125 | int total_len; |
3126 | |
3127 | if (status != USBD_NORMAL_COMPLETION) { |
3128 | DPRINTF("%s: notification error: %s\n", DEVNAM(sc),do { } while (0) |
3129 | usbd_errstr(status))do { } while (0); |
3130 | if (status == USBD_STALLED) |
3131 | usbd_clear_endpoint_stall_async(sc->sc_ctrl_pipe); |
3132 | return; |
3133 | } |
3134 | usbd_get_xfer_status(xfer, NULL((void *)0), NULL((void *)0), &total_len, NULL((void *)0)); |
3135 | if (total_len < UCDC_NOTIFICATION_LENGTH8) { |
3136 | DPRINTF("%s: short notification (%d<%d)\n", DEVNAM(sc),do { } while (0) |
3137 | total_len, UCDC_NOTIFICATION_LENGTH)do { } while (0); |
3138 | return; |
3139 | } |
3140 | if (sc->sc_intr_msg.bmRequestType != UCDC_NOTIFICATION0xa1) { |
3141 | DPRINTF("%s: unexpected notification (type=0x%02x)\n",do { } while (0) |
3142 | DEVNAM(sc), sc->sc_intr_msg.bmRequestType)do { } while (0); |
3143 | return; |
3144 | } |
3145 | |
3146 | switch (sc->sc_intr_msg.bNotification) { |
3147 | case UCDC_N_NETWORK_CONNECTION0x00: |
3148 | if (ifp->if_flags & IFF_DEBUG0x4) |
3149 | log(LOG_DEBUG7, "%s: network %sconnected\n", DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), |
3150 | UGETW(sc->sc_intr_msg.wValue)(*(u_int16_t *)(sc->sc_intr_msg.wValue)) ? "" : "dis"); |
3151 | break; |
3152 | case UCDC_N_RESPONSE_AVAILABLE0x01: |
3153 | DPRINTFN(2, "%s: umb_intr: response available\n", DEVNAM(sc))do { } while (0); |
3154 | ++sc->sc_nresp; |
3155 | usb_add_task(sc->sc_udev, &sc->sc_get_response_task); |
3156 | break; |
3157 | case UCDC_N_CONNECTION_SPEED_CHANGE0x2a: |
3158 | DPRINTFN(2, "%s: umb_intr: connection speed changed\n",do { } while (0) |
3159 | DEVNAM(sc))do { } while (0); |
3160 | break; |
3161 | default: |
3162 | DPRINTF("%s: unexpected notification (0x%02x)\n",do { } while (0) |
3163 | DEVNAM(sc), sc->sc_intr_msg.bNotification)do { } while (0); |
3164 | break; |
3165 | } |
3166 | } |
3167 | |
3168 | /* |
3169 | * Diagnostic routines |
3170 | */ |
3171 | #ifdef UMB_DEBUG |
3172 | char * |
3173 | umb_uuid2str(uint8_t uuid[MBIM_UUID_LEN16]) |
3174 | { |
3175 | static char uuidstr[2 * MBIM_UUID_LEN16 + 5]; |
3176 | |
3177 | #define UUID_BFMT "%02X" |
3178 | #define UUID_SEP "-" |
3179 | snprintf(uuidstr, sizeof (uuidstr), |
3180 | UUID_BFMT UUID_BFMT UUID_BFMT UUID_BFMT UUID_SEP |
3181 | UUID_BFMT UUID_BFMT UUID_SEP |
3182 | UUID_BFMT UUID_BFMT UUID_SEP |
3183 | UUID_BFMT UUID_BFMT UUID_SEP |
3184 | UUID_BFMT UUID_BFMT UUID_BFMT UUID_BFMT UUID_BFMT UUID_BFMT, |
3185 | uuid[0], uuid[1], uuid[2], uuid[3], uuid[4], uuid[5], |
3186 | uuid[6], uuid[7], uuid[8], uuid[9], uuid[10], uuid[11], |
3187 | uuid[12], uuid[13], uuid[14], uuid[15]); |
3188 | return uuidstr; |
3189 | } |
3190 | |
3191 | void |
3192 | umb_dump(void *buf, int len) |
3193 | { |
3194 | int i = 0; |
3195 | uint8_t *c = buf; |
3196 | |
3197 | if (len == 0) |
3198 | return; |
3199 | while (i < len) { |
3200 | if ((i % 16) == 0) { |
3201 | if (i > 0) |
3202 | addlog("\n"); |
3203 | log(LOG_DEBUG7, "%4d: ", i); |
3204 | } |
3205 | addlog(" %02x", *c); |
3206 | c++; |
3207 | i++; |
3208 | } |
3209 | addlog("\n"); |
3210 | } |
3211 | #endif /* UMB_DEBUG */ |
3212 | |
3213 | #if NKSTAT1 > 0 |
3214 | |
3215 | void |
3216 | umb_kstat_attach(struct umb_softc *sc) |
3217 | { |
3218 | struct kstat *ks; |
3219 | struct umb_kstat_signal *uks; |
3220 | |
3221 | rw_init(&sc->sc_kstat_lock, "umbkstat")_rw_init_flags(&sc->sc_kstat_lock, "umbkstat", 0, ((void *)0)); |
3222 | |
3223 | ks = kstat_create(DEVNAM(sc)(((struct umb_softc *)(sc))->sc_dev.dv_xname), 0, "mbim-signal", 0, KSTAT_T_KV1, 0); |
3224 | if (ks == NULL((void *)0)) |
3225 | return; |
3226 | |
3227 | uks = malloc(sizeof(*uks), M_DEVBUF2, M_WAITOK0x0001|M_ZERO0x0008); |
3228 | kstat_kv_init(&uks->rssi, "rssi", KSTAT_KV_T_NULL); |
3229 | kstat_kv_init(&uks->error_rate, "error rate", KSTAT_KV_T_NULL); |
3230 | kstat_kv_init(&uks->reports, "reports", KSTAT_KV_T_COUNTER64); |
3231 | |
3232 | kstat_set_rlock(ks, &sc->sc_kstat_lock); |
3233 | ks->ks_data = uks; |
3234 | ks->ks_datalen = sizeof(*uks); |
3235 | ks->ks_read = kstat_read_nop; |
3236 | |
3237 | ks->ks_softc = sc; |
3238 | sc->sc_kstat_signal = ks; |
3239 | kstat_install(ks); |
3240 | } |
3241 | |
3242 | void |
3243 | umb_kstat_detach(struct umb_softc *sc) |
3244 | { |
3245 | struct kstat *ks = sc->sc_kstat_signal; |
3246 | struct umb_kstat_signal *uks; |
3247 | |
3248 | if (ks == NULL((void *)0)) |
3249 | return; |
3250 | |
3251 | kstat_remove(ks); |
3252 | sc->sc_kstat_signal = NULL((void *)0); |
3253 | |
3254 | uks = ks->ks_data; |
3255 | free(uks, M_DEVBUF2, sizeof(*uks)); |
3256 | |
3257 | kstat_destroy(ks); |
3258 | } |
3259 | #endif /* NKSTAT > 0 */ |