diff -urN orig/share/man/man4/zyd.4 src/share/man/man4/zyd.4 --- orig/share/man/man4/zyd.4 1970-01-01 09:00:00.000000000 +0900 +++ src/share/man/man4/zyd.4 2007-08-05 14:33:17.000000000 +0900 @@ -0,0 +1,186 @@ +.\" $OpenBSD: zyd.4,v 1.22 2007/05/24 02:49:57 cnst Exp $ +.\" $NetBSD: zyd.4,v 1.1 2007/06/09 11:20:55 kiyohara Exp $ +.\" +.\" Copyright (c) 1997, 1998, 1999 +.\" Bill Paul . All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" 3. All advertising materials mentioning features or use of this software +.\" must display the following acknowledgement: +.\" This product includes software developed by Bill Paul. +.\" 4. Neither the name of the author nor the names of any co-contributors +.\" may be used to endorse or promote products derived from this software +.\" without specific prior written permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD +.\" BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +.\" CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +.\" SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +.\" INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +.\" CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +.\" ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF +.\" THE POSSIBILITY OF SUCH DAMAGE. +.\" +.Dd May 28, 2007 +.Dt ZYD 4 +.Os +.Sh NAME +.Nm zyd +.Nd ZyDAS ZD1211/ZD1211B USB IEEE 802.11b/g wireless network device +.Sh SYNOPSIS +.Cd "zyd* at uhub? port ?" +.Sh DESCRIPTION +The +.Nm +driver provides support for wireless network adapters based around +the ZyDAS ZD1211 and ZD1211B USB chips. +.Pp +These are the modes the +.Nm +driver can operate in: +.Bl -tag -width "IBSS-masterXX" +.It BSS mode +Also known as +.Em infrastructure +mode, this is used when associating with an access point, through +which all traffic passes. +This mode is the default. +.It monitor mode +In this mode the driver is able to receive packets without +associating with an access point. +This disables the internal receive filter and enables the card to +capture packets from networks which it wouldn't normally have access to, +or to scan for access points. +.El +.Pp +.Nm +supports software WEP. +Wired Equivalent Privacy (WEP) is the de facto encryption standard +for wireless networks. +It can be typically configured in one of three modes: +no encryption; 40-bit encryption; or 104-bit encryption. +Unfortunately, due to serious weaknesses in WEP protocol +it is strongly recommended that it not be used as the +sole mechanism to secure wireless communication. +WEP is not enabled by default. +.Sh HARDWARE +The following devices are known to be supported by the +.Nm +driver: +.Pp +.Bl -tag -width Ds -offset indent -compact +.It 3COM 3CRUSB10075 +.It Acer WLAN-G-US1 +.It Airlink+ AWLL3025 +.It Airlink 101 AWLL3026 +.It AOpen 802.11g WL54 +.It Asus A9T integrated wirless +.It Asus WL-159g +.It Belkin F5D7050 v.4000 +.It Billion BiPAC 3011G +.It Buffalo WLI-U2-KG54L +.It CC&C WL-2203B +.It DrayTek Vigor 550 +.It Edimax EW-7317UG +.It Edimax EW-7317LDG +.It Fiberline Networks WL-43OU +.It iNexQ UR055g +.It Linksys WUSBF54G +.It Longshine LCS-8131G3 +.It MSI US54SE +.It Philips SNU5600 +.It Planet WL-U356 +.It Planex GW-US54GZ +.It Planex GW-US54GZL +.It Planex GW-US54Mini +.It Safecom SWMULZ-5400 +.It Sagem XG 760A +.It Sagem XG 76NA +.It Sandberg Wireless G54 USB +.It Sitecom WL-113 +.It SMC SMCWUSB-G +.It Sweex wireless USB 54 Mbps +.It Tekram/Siemens USB adapter +.It Telegent TG54USB +.It Trendnet TEW-424UB +.It Trendnet TEW-429UB +.It TwinMOS G240 +.It Unicorn WL-54G +.It US Robotics 5423 +.It X-Micro XWL-11GUZX +.It Yakumo QuickWLAN USB +.It Zonet ZEW2501 +.It ZyXEL ZyAIR G-220 +.El +.Sh EXAMPLES +The following +examples configures zyd0 to join whatever network is available on boot, +using WEP key +.Dq 0x1deadbeef1 , +channel 11: +.Bd -literal -offset indent +inet 192.168.1.1 netmask 255.255.255.0 wepkey 0x1deadbeef1 channel 11 +.Ed +.Pp +Configure zyd0 for WEP, using hex key +.Dq 0x1deadbeef1 : +.Bd -literal -offset indent +# ifconfig zyd0 wepkey 0x1deadbeef1 +.Ed +.Pp +Join an existing BSS network, +.Dq my_net : +.Bd -literal -offset indent +# ifconfig zyd0 192.168.0.2 netmask 0xffffff00 ssid my_net +.Ed +.Sh DIAGNOSTICS +.Bl -diag +.It "zyd%d: could not load firmware (error=%d)" +An error occurred while attempting to upload the firmware to the onboard +microcontroller unit. +.It "zyd%d: could not send command (error=%s)" +An attempt to send a command to the firmware failed. +.It "zyd%d: sorry, radio %s is not supported yet" +Support for the specified radio chip is not yet implemented in the driver. +The device will not attach. +.It "zyd%d: device version mismatch: 0x%x (only >= 43.30 supported)" +Early revisions of the ZD1211 chipset are not supported by this driver. +The device will not attach. +.It "zyd%d: device timeout" +A frame dispatched to the hardware for transmission did not complete in time. +The driver will reset the hardware. +This should not happen. +.El +.Sh SEE ALSO +.Xr arp 4 , +.Xr intro 4 , +.Xr netintro 4 , +.Xr usb 4 , +.Xr wlan 4 , +.Xr wlan_amrr 4 , +.Xr ifconfig 8 +.Sh AUTHORS +.An -nosplit +The +.Nm +driver was written by +.An Florian Stoehr Aq ich@florian-stoehr.de , +.An Damien Bergamini Aq damien@openbsd.org , +and +.An Jonathan Gray Aq jsg@openbsd.org . +.Sh CAVEATS +The +.Nm +driver does not support a lot of the functionality available in the hardware. +More work is required to properly support the IBSS and power management +features. diff -urN orig/sys/conf/files src/sys/conf/files --- orig/sys/conf/files 2007-07-25 00:35:01.000000000 +0900 +++ src/sys/conf/files 2007-08-05 12:51:10.000000000 +0900 @@ -1107,6 +1107,7 @@ dev/usb/if_rue.c optional rue dev/usb/if_rum.c optional rum dev/usb/if_udav.c optional udav +dev/usb/if_zyd.c optional zyd dev/usb/ohci.c optional ohci dev/usb/ohci_pci.c optional ohci pci dev/usb/sl811hs.c optional slhci diff -urN orig/sys/dev/usb/if_zyd.c src/sys/dev/usb/if_zyd.c --- orig/sys/dev/usb/if_zyd.c 1970-01-01 09:00:00.000000000 +0900 +++ src/sys/dev/usb/if_zyd.c 2007-08-05 13:36:43.000000000 +0900 @@ -0,0 +1,2692 @@ +/* $OpenBSD: if_zyd.c,v 1.52 2007/02/11 00:08:04 jsg Exp $ */ +/* $NetBSD: if_zyd.c,v 1.7 2007/06/21 04:04:29 kiyohara Exp $ */ + +/*- + * Copyright (c) 2006 by Damien Bergamini + * Copyright (c) 2006 by Florian Stoehr + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* + * ZyDAS ZD1211/ZD1211B USB WLAN driver. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include "usbdevs.h" +#include + +#include +#include + +#include +#include + +#ifdef USB_DEBUG +#define ZYD_DEBUG +#endif + +#ifdef ZYD_DEBUG +#define DPRINTF(x) do { if (zyddebug > 0) printf x; } while (0) +#define DPRINTFN(n, x) do { if (zyddebug > (n)) printf x; } while (0) +int zyddebug = 0; +#else +#define DPRINTF(x) +#define DPRINTFN(n, x) +#endif + +static const struct zyd_phy_pair zyd_def_phy[] = ZYD_DEF_PHY; +static const struct zyd_phy_pair zyd_def_phyB[] = ZYD_DEF_PHYB; + +/* various supported device vendors/products */ +#define ZYD_ZD1211_DEV(v, p) \ + { { USB_VENDOR_##v, USB_PRODUCT_##v##_##p }, ZYD_ZD1211 } +#define ZYD_ZD1211B_DEV(v, p) \ + { { USB_VENDOR_##v, USB_PRODUCT_##v##_##p }, ZYD_ZD1211B } +static const struct zyd_type { + struct usb_devno dev; + uint8_t rev; +#define ZYD_ZD1211 0 +#define ZYD_ZD1211B 1 +} zyd_devs[] = { + ZYD_ZD1211_DEV(3COM2, 3CRUSB10075), + ZYD_ZD1211_DEV(ABOCOM, WL54), + ZYD_ZD1211_DEV(ASUS, WL159G), + ZYD_ZD1211_DEV(CYBERTAN, TG54USB), + ZYD_ZD1211_DEV(DRAYTEK, VIGOR550), + ZYD_ZD1211_DEV(PLANEX2, GWUS54GZL), + ZYD_ZD1211_DEV(PLANEX3, GWUS54GZ), + ZYD_ZD1211_DEV(PLANEX3, GWUS54MINI), + ZYD_ZD1211_DEV(SAGEM, XG760A), + ZYD_ZD1211_DEV(SENAO, NUB8301), + ZYD_ZD1211_DEV(SITECOMEU, WL113), + ZYD_ZD1211_DEV(SWEEX, ZD1211), + ZYD_ZD1211_DEV(TEKRAM, QUICKWLAN), + ZYD_ZD1211_DEV(TEKRAM, ZD1211_1), + ZYD_ZD1211_DEV(TEKRAM, ZD1211_2), + ZYD_ZD1211_DEV(TWINMOS, G240), + ZYD_ZD1211_DEV(UMEDIA, ALL0298V2), + ZYD_ZD1211_DEV(UMEDIA, TEW429UB_A), + ZYD_ZD1211_DEV(UMEDIA, TEW429UB), + ZYD_ZD1211_DEV(WISTRONNEWEB, UR055G), + ZYD_ZD1211_DEV(ZCOM, ZD1211), + ZYD_ZD1211_DEV(ZYDAS, ZD1211), + ZYD_ZD1211_DEV(ZYXEL, AG225H), + ZYD_ZD1211_DEV(ZYXEL, ZYAIRG220), + + ZYD_ZD1211B_DEV(ACCTON, SMCWUSBG), + ZYD_ZD1211B_DEV(ACCTON, ZD1211B), + ZYD_ZD1211B_DEV(ASUS, A9T_WIFI), + ZYD_ZD1211B_DEV(BELKIN, F5D7050_V4000), + ZYD_ZD1211B_DEV(BELKIN, ZD1211B), + ZYD_ZD1211B_DEV(CISCOLINKSYS, WUSBF54G), + ZYD_ZD1211B_DEV(FIBERLINE, WL430U), + ZYD_ZD1211B_DEV(MELCO, KG54L), + ZYD_ZD1211B_DEV(PHILIPS, SNU5600), + ZYD_ZD1211B_DEV(SAGEM, XG76NA), + ZYD_ZD1211B_DEV(SITECOMEU, ZD1211B), + ZYD_ZD1211B_DEV(UMEDIA, TEW429UBC1), +#if 0 /* Shall we needs? */ + ZYD_ZD1211B_DEV(UNKNOWN1, ZD1211B_1), + ZYD_ZD1211B_DEV(UNKNOWN1, ZD1211B_2), + ZYD_ZD1211B_DEV(UNKNOWN2, ZD1211B), + ZYD_ZD1211B_DEV(UNKNOWN3, ZD1211B), +#endif + ZYD_ZD1211B_DEV(USR, USR5423), + ZYD_ZD1211B_DEV(VTECH, ZD1211B), + ZYD_ZD1211B_DEV(ZCOM, ZD1211B), + ZYD_ZD1211B_DEV(ZYDAS, ZD1211B), + ZYD_ZD1211B_DEV(ZYXEL, M202), + ZYD_ZD1211B_DEV(ZYXEL, G220V2), +}; +#define zyd_lookup(v, p) \ + ((const struct zyd_type *)usb_lookup(zyd_devs, v, p)) + +static device_probe_t zyd_match; +static device_attach_t zyd_attach; +static device_detach_t zyd_detach; + +static int zyd_attachhook(struct zyd_softc *); +static int zyd_complete_attach(struct zyd_softc *); +static int zyd_open_pipes(struct zyd_softc *); +static void zyd_close_pipes(struct zyd_softc *); +static int zyd_alloc_tx_list(struct zyd_softc *); +static void zyd_free_tx_list(struct zyd_softc *); +static int zyd_alloc_rx_list(struct zyd_softc *); +static void zyd_free_rx_list(struct zyd_softc *); +static struct ieee80211_node *zyd_node_alloc(struct ieee80211_node_table *); +static int zyd_media_change(struct ifnet *); +static void zyd_task(void *); +static int zyd_newstate(struct ieee80211com *, enum ieee80211_state, int); +static int zyd_cmd(struct zyd_softc *, uint16_t, const void *, int, + void *, int, u_int); +static int zyd_read16(struct zyd_softc *, uint16_t, uint16_t *); +static int zyd_read32(struct zyd_softc *, uint16_t, uint32_t *); +static int zyd_write16(struct zyd_softc *, uint16_t, uint16_t); +static int zyd_write32(struct zyd_softc *, uint16_t, uint32_t); +static int zyd_rfwrite(struct zyd_softc *, uint32_t); +static void zyd_lock_phy(struct zyd_softc *); +static void zyd_unlock_phy(struct zyd_softc *); +static int zyd_rfmd_init(struct zyd_rf *); +static int zyd_rfmd_switch_radio(struct zyd_rf *, int); +static int zyd_rfmd_set_channel(struct zyd_rf *, uint8_t); +static int zyd_al2230_init(struct zyd_rf *); +static int zyd_al2230_switch_radio(struct zyd_rf *, int); +static int zyd_al2230_set_channel(struct zyd_rf *, uint8_t); +static int zyd_al2230_init_b(struct zyd_rf *); +static int zyd_al7230B_init(struct zyd_rf *); +static int zyd_al7230B_switch_radio(struct zyd_rf *, int); +static int zyd_al7230B_set_channel(struct zyd_rf *, uint8_t); +static int zyd_al2210_init(struct zyd_rf *); +static int zyd_al2210_switch_radio(struct zyd_rf *, int); +static int zyd_al2210_set_channel(struct zyd_rf *, uint8_t); +static int zyd_gct_init(struct zyd_rf *); +static int zyd_gct_switch_radio(struct zyd_rf *, int); +static int zyd_gct_set_channel(struct zyd_rf *, uint8_t); +static int zyd_maxim_init(struct zyd_rf *); +static int zyd_maxim_switch_radio(struct zyd_rf *, int); +static int zyd_maxim_set_channel(struct zyd_rf *, uint8_t); +static int zyd_maxim2_init(struct zyd_rf *); +static int zyd_maxim2_switch_radio(struct zyd_rf *, int); +static int zyd_maxim2_set_channel(struct zyd_rf *, uint8_t); +static int zyd_rf_attach(struct zyd_softc *, uint8_t); +static const char *zyd_rf_name(uint8_t); +static int zyd_hw_init(struct zyd_softc *); +static int zyd_read_eeprom(struct zyd_softc *); +static int zyd_set_macaddr(struct zyd_softc *, const uint8_t *); +static int zyd_set_bssid(struct zyd_softc *, const uint8_t *); +static int zyd_switch_radio(struct zyd_softc *, int); +static void zyd_set_led(struct zyd_softc *, int, int); +static int zyd_set_rxfilter(struct zyd_softc *); +static void zyd_set_chan(struct zyd_softc *, struct ieee80211_channel *); +static int zyd_set_beacon_interval(struct zyd_softc *, int); +static uint8_t zyd_plcp_signal(int); +static void zyd_intr(usbd_xfer_handle, usbd_private_handle, usbd_status); +static void zyd_rx_data(struct zyd_softc *, const uint8_t *, uint16_t); +static void zyd_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status); +static void zyd_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status); +static int zyd_tx_mgt(struct zyd_softc *, struct mbuf *, + struct ieee80211_node *); +static int zyd_tx_data(struct zyd_softc *, struct mbuf *, + struct ieee80211_node *); +static void zyd_start(struct ifnet *); +static void zyd_watchdog(void *); +static int zyd_ioctl(struct ifnet *, u_long, caddr_t); +static void zyd_init(void *); +static void zyd_stop(struct ifnet *, int); +static int zyd_loadfirmware(struct zyd_softc *, u_char *, size_t); +static void zyd_iter_func(void *, struct ieee80211_node *); +static void zyd_amrr_timeout(void *); +static void zyd_newassoc(struct ieee80211_node *, int); +static void zyd_scantask(void *); +static void zyd_scan_start(struct ieee80211com *); +static void zyd_scan_end(struct ieee80211com *); +static void zyd_set_channel(struct ieee80211com *); + +static const struct ieee80211_rateset zyd_rateset_11b = + { 4, { 2, 4, 11, 22 } }; + +static const struct ieee80211_rateset zyd_rateset_11g = + { 12, { 2, 4, 11, 22, 12, 18, 24, 36, 48, 72, 96, 108 } }; + +static int +zyd_match(device_t dev) +{ + struct usb_attach_arg *uaa = device_get_ivars(dev); + + if (!uaa->iface) + return UMATCH_NONE; + + return (zyd_lookup(uaa->vendor, uaa->product) != NULL) ? + UMATCH_VENDOR_PRODUCT : UMATCH_NONE; +} + +static int +zyd_attachhook(struct zyd_softc *sc) +{ + u_char *firmware; + int len, error; + + if (sc->mac_rev == ZYD_ZD1211) { + firmware = (u_char *)zd1211_firmware; + len = sizeof(zd1211_firmware); + } else { + firmware = (u_char *)zd1211b_firmware; + len = sizeof(zd1211b_firmware); + } + + error = zyd_loadfirmware(sc, firmware, len); + if (error != 0) { + printf("%s: could not load firmware (error=%d)\n", + device_get_nameunit(sc->sc_dev), error); + return error; + } + + sc->sc_flags |= ZD1211_FWLOADED; + + /* complete the attach process */ + if ((error = zyd_complete_attach(sc)) == 0) + sc->attached = 1; + + return error; +} + +static int +zyd_attach(device_t dev) +{ + struct zyd_softc *sc = device_get_softc(dev); + struct usb_attach_arg *uaa = device_get_ivars(dev); + usb_device_descriptor_t* ddesc; + struct ifnet *ifp; + + sc->sc_dev = dev; + + ifp = sc->sc_ifp = if_alloc(IFT_ETHER); + if (ifp == NULL) { + printf("%s: can not if_alloc()\n", + device_get_nameunit(sc->sc_dev)); + return ENXIO; + } + + sc->sc_udev = uaa->device; + sc->sc_flags = 0; + sc->mac_rev = zyd_lookup(uaa->vendor, uaa->product)->rev; + + ddesc = usbd_get_device_descriptor(sc->sc_udev); + if (UGETW(ddesc->bcdDevice) < 0x4330) { + printf("%s: device version mismatch: 0x%x " + "(only >= 43.30 supported)\n", + device_get_nameunit(sc->sc_dev), + UGETW(ddesc->bcdDevice)); + return -1; + } + + ifp->if_softc = sc; + if_initname(ifp, "zyd", device_get_unit(sc->sc_dev)); + ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; + ifp->if_init = zyd_init; + ifp->if_ioctl = zyd_ioctl; + ifp->if_start = zyd_start; + IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN); + IFQ_SET_READY(&ifp->if_snd); + + STAILQ_INIT(&sc->sc_rqh); + + zyd_attachhook(sc); + + return 0; +} + +static int +zyd_complete_attach(struct zyd_softc *sc) +{ + struct ieee80211com *ic = &sc->sc_ic; + struct ifnet *ifp = sc->sc_ifp; + usbd_status error; + int bands; + + mtx_init(&sc->sc_mtx, device_get_nameunit(sc->sc_dev), MTX_NETWORK_LOCK, + MTX_DEF | MTX_RECURSE); + + usb_init_task(&sc->sc_scantask, zyd_scantask, sc); + usb_init_task(&sc->sc_task, zyd_task, sc); + + callout_init(&sc->sc_amrr_ch, 0); + callout_init(&sc->sc_watchdog_ch, 0); + + error = usbd_set_config_no(sc->sc_udev, ZYD_CONFIG_NO, 1); + if (error != 0) { + printf("%s: setting config no failed\n", + device_get_nameunit(sc->sc_dev)); + goto fail; + } + + error = usbd_device2interface_handle(sc->sc_udev, ZYD_IFACE_INDEX, + &sc->sc_iface); + if (error != 0) { + printf("%s: getting interface handle failed\n", + device_get_nameunit(sc->sc_dev)); + goto fail; + } + + if ((error = zyd_open_pipes(sc)) != 0) { + printf("%s: could not open pipes\n", + device_get_nameunit(sc->sc_dev)); + goto fail; + } + + if ((error = zyd_read_eeprom(sc)) != 0) { + printf("%s: could not read EEPROM\n", + device_get_nameunit(sc->sc_dev)); + goto fail; + } + + if ((error = zyd_rf_attach(sc, sc->rf_rev)) != 0) { + printf("%s: could not attach RF\n", + device_get_nameunit(sc->sc_dev)); + goto fail; + } + + if ((error = zyd_hw_init(sc)) != 0) { + printf("%s: hardware initialization failed\n", + device_get_nameunit(sc->sc_dev)); + goto fail; + } + + printf("%s: HMAC ZD1211%s, FW %02x.%02x, RF %s, PA %x, address %s\n", + device_get_nameunit(sc->sc_dev), + (sc->mac_rev == ZYD_ZD1211) ? "": "B", + sc->fw_rev >> 8, sc->fw_rev & 0xff, zyd_rf_name(sc->rf_rev), + sc->pa_rev, ether_sprintf(ic->ic_myaddr)); + + ic->ic_ifp = ifp; + ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */ + ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */ + ic->ic_state = IEEE80211_S_INIT; + + /* set device capabilities */ + ic->ic_caps = + IEEE80211_C_MONITOR | /* monitor mode supported */ + IEEE80211_C_TXPMGT | /* tx power management */ + IEEE80211_C_SHPREAMBLE | /* short preamble supported */ + IEEE80211_C_WEP; /* s/w WEP */ + + bands = 0; + setbit(&bands, IEEE80211_MODE_11B); + setbit(&bands, IEEE80211_MODE_11G); + ieee80211_init_channels(ic, 0, CTRY_DEFAULT, bands, 0, 1); + + ieee80211_ifattach(ic); + ic->ic_node_alloc = zyd_node_alloc; + ic->ic_newassoc = zyd_newassoc; + + /* for bg scanning. */ + ic->ic_scan_start = zyd_scan_start; + ic->ic_scan_end = zyd_scan_end; + ic->ic_set_channel = zyd_set_channel; + + /* override state transition machine */ + sc->sc_newstate = ic->ic_newstate; + ic->ic_newstate = zyd_newstate; + ieee80211_media_init(ic, zyd_media_change, ieee80211_media_status); + ieee80211_amrr_init(&sc->amrr, ic, + IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD, + IEEE80211_AMRR_MAX_SUCCESS_THRESHOLD); + + bpfattach2(ifp, DLT_IEEE802_11_RADIO, + sizeof (struct ieee80211_frame) + IEEE80211_RADIOTAP_HDRLEN, + &sc->sc_drvbpf); + + sc->sc_rxtap_len = sizeof sc->sc_rxtapu; + sc->sc_rxtap.wr_ihdr.it_len = htole16(sc->sc_rxtap_len); + sc->sc_rxtap.wr_ihdr.it_present = htole32(ZYD_RX_RADIOTAP_PRESENT); + + sc->sc_txtap_len = sizeof sc->sc_txtapu; + sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len); + sc->sc_txtap.wt_ihdr.it_present = htole32(ZYD_TX_RADIOTAP_PRESENT); + + if (bootverbose) + ieee80211_announce(ic); + + usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev); + + return error; + +fail: + mtx_destroy(&sc->sc_mtx); + + return error; +} + +static int +zyd_detach(device_t dev) +{ + struct zyd_softc *sc = device_get_softc(dev); + struct ieee80211com *ic = &sc->sc_ic; + struct ifnet *ifp = sc->sc_ifp; + + if (!sc->attached) + return 0; + + zyd_stop(ifp, 1); + usb_rem_task(sc->sc_udev, &sc->sc_scantask); + usb_rem_task(sc->sc_udev, &sc->sc_task); + callout_stop(&sc->sc_amrr_ch); + callout_stop(&sc->sc_watchdog_ch); + + zyd_close_pipes(sc); + + zyd_free_rx_list(sc); + zyd_free_tx_list(sc); + + sc->attached = 0; + + bpfdetach(ifp); + ieee80211_ifdetach(ic); + if_free(ifp); + + mtx_destroy(&sc->sc_mtx); + + usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev); + + return 0; +} + +static int +zyd_open_pipes(struct zyd_softc *sc) +{ + usb_endpoint_descriptor_t *edesc; + int isize; + usbd_status error; + + /* interrupt in */ + edesc = usbd_get_endpoint_descriptor(sc->sc_iface, 0x83); + if (edesc == NULL) + return EINVAL; + + isize = UGETW(edesc->wMaxPacketSize); + if (isize == 0) /* should not happen */ + return EINVAL; + + sc->ibuf = malloc(isize, M_USBDEV, M_NOWAIT); + if (sc->ibuf == NULL) + return ENOMEM; + + error = usbd_open_pipe_intr(sc->sc_iface, 0x83, USBD_SHORT_XFER_OK, + &sc->zyd_ep[ZYD_ENDPT_IIN], sc, sc->ibuf, isize, zyd_intr, + USBD_DEFAULT_INTERVAL); + if (error != 0) { + printf("%s: open rx intr pipe failed: %s\n", + device_get_nameunit(sc->sc_dev), usbd_errstr(error)); + goto fail; + } + + /* interrupt out (not necessarily an interrupt pipe) */ + error = usbd_open_pipe(sc->sc_iface, 0x04, USBD_EXCLUSIVE_USE, + &sc->zyd_ep[ZYD_ENDPT_IOUT]); + if (error != 0) { + printf("%s: open tx intr pipe failed: %s\n", + device_get_nameunit(sc->sc_dev), usbd_errstr(error)); + goto fail; + } + + /* bulk in */ + error = usbd_open_pipe(sc->sc_iface, 0x82, USBD_EXCLUSIVE_USE, + &sc->zyd_ep[ZYD_ENDPT_BIN]); + if (error != 0) { + printf("%s: open rx pipe failed: %s\n", + device_get_nameunit(sc->sc_dev), usbd_errstr(error)); + goto fail; + } + + /* bulk out */ + error = usbd_open_pipe(sc->sc_iface, 0x01, USBD_EXCLUSIVE_USE, + &sc->zyd_ep[ZYD_ENDPT_BOUT]); + if (error != 0) { + printf("%s: open tx pipe failed: %s\n", + device_get_nameunit(sc->sc_dev), usbd_errstr(error)); + goto fail; + } + + return 0; + +fail: zyd_close_pipes(sc); + return error; +} + +static void +zyd_close_pipes(struct zyd_softc *sc) +{ + int i; + + for (i = 0; i < ZYD_ENDPT_CNT; i++) { + if (sc->zyd_ep[i] != NULL) { + usbd_abort_pipe(sc->zyd_ep[i]); + usbd_close_pipe(sc->zyd_ep[i]); + sc->zyd_ep[i] = NULL; + } + } + if (sc->ibuf != NULL) { + free(sc->ibuf, M_USBDEV); + sc->ibuf = NULL; + } +} + +static int +zyd_alloc_tx_list(struct zyd_softc *sc) +{ + int i, error; + + sc->tx_queued = 0; + + for (i = 0; i < ZYD_TX_LIST_CNT; i++) { + struct zyd_tx_data *data = &sc->tx_data[i]; + + data->sc = sc; /* backpointer for callbacks */ + + data->xfer = usbd_alloc_xfer(sc->sc_udev); + if (data->xfer == NULL) { + printf("%s: could not allocate tx xfer\n", + device_get_nameunit(sc->sc_dev)); + error = ENOMEM; + goto fail; + } + data->buf = usbd_alloc_buffer(data->xfer, ZYD_MAX_TXBUFSZ); + if (data->buf == NULL) { + printf("%s: could not allocate tx buffer\n", + device_get_nameunit(sc->sc_dev)); + error = ENOMEM; + goto fail; + } + + /* clear Tx descriptor */ + bzero(data->buf, sizeof (struct zyd_tx_desc)); + } + return 0; + +fail: zyd_free_tx_list(sc); + return error; +} + +static void +zyd_free_tx_list(struct zyd_softc *sc) +{ + int i; + + for (i = 0; i < ZYD_TX_LIST_CNT; i++) { + struct zyd_tx_data *data = &sc->tx_data[i]; + + if (data->xfer != NULL) { + usbd_free_xfer(data->xfer); + data->xfer = NULL; + } + if (data->ni != NULL) { + ieee80211_free_node(data->ni); + data->ni = NULL; + } + } +} + +static int +zyd_alloc_rx_list(struct zyd_softc *sc) +{ + int i, error; + + for (i = 0; i < ZYD_RX_LIST_CNT; i++) { + struct zyd_rx_data *data = &sc->rx_data[i]; + + data->sc = sc; /* backpointer for callbacks */ + + data->xfer = usbd_alloc_xfer(sc->sc_udev); + if (data->xfer == NULL) { + printf("%s: could not allocate rx xfer\n", + device_get_nameunit(sc->sc_dev)); + error = ENOMEM; + goto fail; + } + data->buf = usbd_alloc_buffer(data->xfer, ZYX_MAX_RXBUFSZ); + if (data->buf == NULL) { + printf("%s: could not allocate rx buffer\n", + device_get_nameunit(sc->sc_dev)); + error = ENOMEM; + goto fail; + } + } + return 0; + +fail: zyd_free_rx_list(sc); + return error; +} + +static void +zyd_free_rx_list(struct zyd_softc *sc) +{ + int i; + + for (i = 0; i < ZYD_RX_LIST_CNT; i++) { + struct zyd_rx_data *data = &sc->rx_data[i]; + + if (data->xfer != NULL) { + usbd_free_xfer(data->xfer); + data->xfer = NULL; + } + } +} + +/* ARGUSED */ +static struct ieee80211_node * +zyd_node_alloc(struct ieee80211_node_table *nt __unused) +{ + struct zyd_node *zn; + + zn = malloc(sizeof (struct zyd_node), M_DEVBUF, M_NOWAIT); + if (zn != NULL) + bzero(zn, sizeof (struct zyd_node)); + return (struct ieee80211_node *)zn; +} + +static int +zyd_media_change(struct ifnet *ifp) +{ + struct zyd_softc *sc = ifp->if_softc; + int error; + + error = ieee80211_media_change(ifp); + if (error != ENETRESET) + return error; + + if ((ifp->if_flags & IFF_UP) == IFF_UP && + (ifp->if_drv_flags & IFF_DRV_RUNNING) == IFF_DRV_RUNNING) + zyd_init(sc); + + return 0; +} + +static void +zyd_task(void *arg) +{ + struct zyd_softc *sc = arg; + struct ieee80211com *ic = &sc->sc_ic; + enum ieee80211_state ostate; + + ostate = ic->ic_state; + + switch (sc->sc_state) { + case IEEE80211_S_INIT: + if (ostate == IEEE80211_S_RUN) { + /* turn link LED off */ + zyd_set_led(sc, ZYD_LED1, 0); + + /* stop data LED from blinking */ + zyd_write32(sc, sc->fwbase + ZYD_FW_LINK_STATUS, 0); + } + break; + + case IEEE80211_S_RUN: + { + struct ieee80211_node *ni = ic->ic_bss; + + zyd_set_chan(sc, ic->ic_curchan); + + if (ic->ic_opmode != IEEE80211_M_MONITOR) { + /* turn link LED on */ + zyd_set_led(sc, ZYD_LED1, 1); + + /* make data LED blink upon Tx */ + zyd_write32(sc, sc->fwbase + ZYD_FW_LINK_STATUS, 1); + + zyd_set_bssid(sc, ni->ni_bssid); + } + + if (ic->ic_opmode == IEEE80211_M_STA) { + /* fake a join to init the tx rate */ + zyd_newassoc(ni, 1); + } + + /* start automatic rate control timer */ + if (ic->ic_fixed_rate == IEEE80211_FIXED_RATE_NONE) + callout_reset(&sc->sc_amrr_ch, hz, + zyd_amrr_timeout, sc); + + break; + } + default: + break; + } + + sc->sc_newstate(ic, sc->sc_state, sc->sc_arg); +} + +static int +zyd_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg) +{ + struct zyd_softc *sc = ic->ic_ifp->if_softc; + + usb_rem_task(sc->sc_udev, &sc->sc_task); + callout_stop(&sc->sc_amrr_ch); + + /* do it in a process context */ + sc->sc_state = nstate; + sc->sc_arg = arg; + + usb_add_task(sc->sc_udev, &sc->sc_task, USB_TASKQ_DRIVER); + + return 0; +} + +static int +zyd_cmd(struct zyd_softc *sc, uint16_t code, const void *idata, int ilen, + void *odata, int olen, u_int flags) +{ + usbd_xfer_handle xfer; + struct zyd_cmd cmd; + struct rq rq; + uint16_t xferflags; + usbd_status error; + + if ((xfer = usbd_alloc_xfer(sc->sc_udev)) == NULL) + return ENOMEM; + + cmd.code = htole16(code); + bcopy(idata, cmd.data, ilen); + + xferflags = USBD_FORCE_SHORT_XFER; + if (!(flags & ZYD_CMD_FLAG_READ)) + xferflags |= USBD_SYNCHRONOUS; + else { + rq.idata = idata; + rq.odata = odata; + rq.len = olen / sizeof (struct zyd_pair); + STAILQ_INSERT_TAIL(&sc->sc_rqh, &rq, rq); + } + + usbd_setup_xfer(xfer, sc->zyd_ep[ZYD_ENDPT_IOUT], 0, &cmd, + sizeof (uint16_t) + ilen, xferflags, ZYD_INTR_TIMEOUT, NULL); + error = usbd_transfer(xfer); + if (error != USBD_IN_PROGRESS && error != 0) { + printf("%s: could not send command (error=%s)\n", + device_get_nameunit(sc->sc_dev), usbd_errstr(error)); + (void)usbd_free_xfer(xfer); + return EIO; + } + if (!(flags & ZYD_CMD_FLAG_READ)) { + (void)usbd_free_xfer(xfer); + return 0; /* write: don't wait for reply */ + } + /* wait at most one second for command reply */ + error = tsleep(odata, PCATCH, "zydcmd", hz); + if (error == EWOULDBLOCK) + printf("%s: zyd_read sleep timeout\n", + device_get_nameunit(sc->sc_dev)); + STAILQ_REMOVE(&sc->sc_rqh, &rq, rq, rq); + + (void)usbd_free_xfer(xfer); + return error; +} + +static int +zyd_read16(struct zyd_softc *sc, uint16_t reg, uint16_t *val) +{ + struct zyd_pair tmp; + int error; + + reg = htole16(reg); + error = zyd_cmd(sc, ZYD_CMD_IORD, ®, sizeof reg, &tmp, sizeof tmp, + ZYD_CMD_FLAG_READ); + if (error == 0) + *val = le16toh(tmp.val); + return error; +} + +static int +zyd_read32(struct zyd_softc *sc, uint16_t reg, uint32_t *val) +{ + struct zyd_pair tmp[2]; + uint16_t regs[2]; + int error; + + regs[0] = htole16(ZYD_REG32_HI(reg)); + regs[1] = htole16(ZYD_REG32_LO(reg)); + error = zyd_cmd(sc, ZYD_CMD_IORD, regs, sizeof regs, tmp, sizeof tmp, + ZYD_CMD_FLAG_READ); + if (error == 0) + *val = le16toh(tmp[0].val) << 16 | le16toh(tmp[1].val); + return error; +} + +static int +zyd_write16(struct zyd_softc *sc, uint16_t reg, uint16_t val) +{ + struct zyd_pair pair; + + pair.reg = htole16(reg); + pair.val = htole16(val); + + return zyd_cmd(sc, ZYD_CMD_IOWR, &pair, sizeof pair, NULL, 0, 0); +} + +static int +zyd_write32(struct zyd_softc *sc, uint16_t reg, uint32_t val) +{ + struct zyd_pair pair[2]; + + pair[0].reg = htole16(ZYD_REG32_HI(reg)); + pair[0].val = htole16(val >> 16); + pair[1].reg = htole16(ZYD_REG32_LO(reg)); + pair[1].val = htole16(val & 0xffff); + + return zyd_cmd(sc, ZYD_CMD_IOWR, pair, sizeof pair, NULL, 0, 0); +} + +static int +zyd_rfwrite(struct zyd_softc *sc, uint32_t val) +{ + struct zyd_rf *rf = &sc->sc_rf; + struct zyd_rfwrite req; + uint16_t cr203; + int i; + + (void)zyd_read16(sc, ZYD_CR203, &cr203); + cr203 &= ~(ZYD_RF_IF_LE | ZYD_RF_CLK | ZYD_RF_DATA); + + req.code = htole16(2); + req.width = htole16(rf->width); + for (i = 0; i < rf->width; i++) { + req.bit[i] = htole16(cr203); + if (val & (1 << (rf->width - 1 - i))) + req.bit[i] |= htole16(ZYD_RF_DATA); + } + return zyd_cmd(sc, ZYD_CMD_RFCFG, &req, 4 + 2 * rf->width, NULL, 0, 0); +} + +static void +zyd_lock_phy(struct zyd_softc *sc) +{ + uint32_t tmp; + + (void)zyd_read32(sc, ZYD_MAC_MISC, &tmp); + tmp &= ~ZYD_UNLOCK_PHY_REGS; + (void)zyd_write32(sc, ZYD_MAC_MISC, tmp); +} + +static void +zyd_unlock_phy(struct zyd_softc *sc) +{ + uint32_t tmp; + + (void)zyd_read32(sc, ZYD_MAC_MISC, &tmp); + tmp |= ZYD_UNLOCK_PHY_REGS; + (void)zyd_write32(sc, ZYD_MAC_MISC, tmp); +} + +/* + * RFMD RF methods. + */ +static int +zyd_rfmd_init(struct zyd_rf *rf) +{ +#define N(a) (sizeof (a) / sizeof ((a)[0])) + struct zyd_softc *sc = rf->rf_sc; + static const struct zyd_phy_pair phyini[] = ZYD_RFMD_PHY; + static const uint32_t rfini[] = ZYD_RFMD_RF; + int i, error; + + /* init RF-dependent PHY registers */ + for (i = 0; i < N(phyini); i++) { + error = zyd_write16(sc, phyini[i].reg, phyini[i].val); + if (error != 0) + return error; + } + + /* init RFMD radio */ + for (i = 0; i < N(rfini); i++) { + if ((error = zyd_rfwrite(sc, rfini[i])) != 0) + return error; + } + return 0; +#undef N +} + +static int +zyd_rfmd_switch_radio(struct zyd_rf *rf, int on) +{ + struct zyd_softc *sc = rf->rf_sc; + + (void)zyd_write16(sc, ZYD_CR10, on ? 0x89 : 0x15); + (void)zyd_write16(sc, ZYD_CR11, on ? 0x00 : 0x81); + + return 0; +} + +static int +zyd_rfmd_set_channel(struct zyd_rf *rf, uint8_t chan) +{ + struct zyd_softc *sc = rf->rf_sc; + static const struct { + uint32_t r1, r2; + } rfprog[] = ZYD_RFMD_CHANTABLE; + + (void)zyd_rfwrite(sc, rfprog[chan - 1].r1); + (void)zyd_rfwrite(sc, rfprog[chan - 1].r2); + + return 0; +} + +/* + * AL2230 RF methods. + */ +static int +zyd_al2230_init(struct zyd_rf *rf) +{ +#define N(a) (sizeof (a) / sizeof ((a)[0])) + struct zyd_softc *sc = rf->rf_sc; + static const struct zyd_phy_pair phyini[] = ZYD_AL2230_PHY; + static const uint32_t rfini[] = ZYD_AL2230_RF; + int i, error; + + /* init RF-dependent PHY registers */ + for (i = 0; i < N(phyini); i++) { + error = zyd_write16(sc, phyini[i].reg, phyini[i].val); + if (error != 0) + return error; + } + + /* init AL2230 radio */ + for (i = 0; i < N(rfini); i++) { + if ((error = zyd_rfwrite(sc, rfini[i])) != 0) + return error; + } + return 0; +#undef N +} + +static int +zyd_al2230_init_b(struct zyd_rf *rf) +{ +#define N(a) (sizeof (a) / sizeof ((a)[0])) + struct zyd_softc *sc = rf->rf_sc; + static const struct zyd_phy_pair phyini[] = ZYD_AL2230_PHY_B; + static const uint32_t rfini[] = ZYD_AL2230_RF_B; + int i, error; + + /* init RF-dependent PHY registers */ + for (i = 0; i < N(phyini); i++) { + error = zyd_write16(sc, phyini[i].reg, phyini[i].val); + if (error != 0) + return error; + } + + /* init AL2230 radio */ + for (i = 0; i < N(rfini); i++) { + if ((error = zyd_rfwrite(sc, rfini[i])) != 0) + return error; + } + return 0; +#undef N +} + +static int +zyd_al2230_switch_radio(struct zyd_rf *rf, int on) +{ + struct zyd_softc *sc = rf->rf_sc; + int on251 = (sc->mac_rev == ZYD_ZD1211) ? 0x3f : 0x7f; + + (void)zyd_write16(sc, ZYD_CR11, on ? 0x00 : 0x04); + (void)zyd_write16(sc, ZYD_CR251, on ? on251 : 0x2f); + + return 0; +} + +static int +zyd_al2230_set_channel(struct zyd_rf *rf, uint8_t chan) +{ + struct zyd_softc *sc = rf->rf_sc; + static const struct { + uint32_t r1, r2, r3; + } rfprog[] = ZYD_AL2230_CHANTABLE; + + (void)zyd_rfwrite(sc, rfprog[chan - 1].r1); + (void)zyd_rfwrite(sc, rfprog[chan - 1].r2); + (void)zyd_rfwrite(sc, rfprog[chan - 1].r3); + + (void)zyd_write16(sc, ZYD_CR138, 0x28); + (void)zyd_write16(sc, ZYD_CR203, 0x06); + + return 0; +} + +/* + * AL7230B RF methods. + */ +static int +zyd_al7230B_init(struct zyd_rf *rf) +{ +#define N(a) (sizeof (a) / sizeof ((a)[0])) + struct zyd_softc *sc = rf->rf_sc; + static const struct zyd_phy_pair phyini_1[] = ZYD_AL7230B_PHY_1; + static const struct zyd_phy_pair phyini_2[] = ZYD_AL7230B_PHY_2; + static const struct zyd_phy_pair phyini_3[] = ZYD_AL7230B_PHY_3; + static const uint32_t rfini_1[] = ZYD_AL7230B_RF_1; + static const uint32_t rfini_2[] = ZYD_AL7230B_RF_2; + int i, error; + + /* for AL7230B, PHY and RF need to be initialized in "phases" */ + + /* init RF-dependent PHY registers, part one */ + for (i = 0; i < N(phyini_1); i++) { + error = zyd_write16(sc, phyini_1[i].reg, phyini_1[i].val); + if (error != 0) + return error; + } + /* init AL7230B radio, part one */ + for (i = 0; i < N(rfini_1); i++) { + if ((error = zyd_rfwrite(sc, rfini_1[i])) != 0) + return error; + } + /* init RF-dependent PHY registers, part two */ + for (i = 0; i < N(phyini_2); i++) { + error = zyd_write16(sc, phyini_2[i].reg, phyini_2[i].val); + if (error != 0) + return error; + } + /* init AL7230B radio, part two */ + for (i = 0; i < N(rfini_2); i++) { + if ((error = zyd_rfwrite(sc, rfini_2[i])) != 0) + return error; + } + /* init RF-dependent PHY registers, part three */ + for (i = 0; i < N(phyini_3); i++) { + error = zyd_write16(sc, phyini_3[i].reg, phyini_3[i].val); + if (error != 0) + return error; + } + + return 0; +#undef N +} + +static int +zyd_al7230B_switch_radio(struct zyd_rf *rf, int on) +{ + struct zyd_softc *sc = rf->rf_sc; + + (void)zyd_write16(sc, ZYD_CR11, on ? 0x00 : 0x04); + (void)zyd_write16(sc, ZYD_CR251, on ? 0x3f : 0x2f); + + return 0; +} + +static int +zyd_al7230B_set_channel(struct zyd_rf *rf, uint8_t chan) +{ +#define N(a) (sizeof (a) / sizeof ((a)[0])) + struct zyd_softc *sc = rf->rf_sc; + static const struct { + uint32_t r1, r2; + } rfprog[] = ZYD_AL7230B_CHANTABLE; + static const uint32_t rfsc[] = ZYD_AL7230B_RF_SETCHANNEL; + int i, error; + + (void)zyd_write16(sc, ZYD_CR240, 0x57); + (void)zyd_write16(sc, ZYD_CR251, 0x2f); + + for (i = 0; i < N(rfsc); i++) { + if ((error = zyd_rfwrite(sc, rfsc[i])) != 0) + return error; + } + + (void)zyd_write16(sc, ZYD_CR128, 0x14); + (void)zyd_write16(sc, ZYD_CR129, 0x12); + (void)zyd_write16(sc, ZYD_CR130, 0x10); + (void)zyd_write16(sc, ZYD_CR38, 0x38); + (void)zyd_write16(sc, ZYD_CR136, 0xdf); + + (void)zyd_rfwrite(sc, rfprog[chan - 1].r1); + (void)zyd_rfwrite(sc, rfprog[chan - 1].r2); + (void)zyd_rfwrite(sc, 0x3c9000); + + (void)zyd_write16(sc, ZYD_CR251, 0x3f); + (void)zyd_write16(sc, ZYD_CR203, 0x06); + (void)zyd_write16(sc, ZYD_CR240, 0x08); + + return 0; +#undef N +} + +/* + * AL2210 RF methods. + */ +static int +zyd_al2210_init(struct zyd_rf *rf) +{ +#define N(a) (sizeof (a) / sizeof ((a)[0])) + struct zyd_softc *sc = rf->rf_sc; + static const struct zyd_phy_pair phyini[] = ZYD_AL2210_PHY; + static const uint32_t rfini[] = ZYD_AL2210_RF; + uint32_t tmp; + int i, error; + + (void)zyd_write32(sc, ZYD_CR18, 2); + + /* init RF-dependent PHY registers */ + for (i = 0; i < N(phyini); i++) { + error = zyd_write16(sc, phyini[i].reg, phyini[i].val); + if (error != 0) + return error; + } + /* init AL2210 radio */ + for (i = 0; i < N(rfini); i++) { + if ((error = zyd_rfwrite(sc, rfini[i])) != 0) + return error; + } + (void)zyd_write16(sc, ZYD_CR47, 0x1e); + (void)zyd_read32(sc, ZYD_CR_RADIO_PD, &tmp); + (void)zyd_write32(sc, ZYD_CR_RADIO_PD, tmp & ~1); + (void)zyd_write32(sc, ZYD_CR_RADIO_PD, tmp | 1); + (void)zyd_write32(sc, ZYD_CR_RFCFG, 0x05); + (void)zyd_write32(sc, ZYD_CR_RFCFG, 0x00); + (void)zyd_write16(sc, ZYD_CR47, 0x1e); + (void)zyd_write32(sc, ZYD_CR18, 3); + + return 0; +#undef N +} + +static int +zyd_al2210_switch_radio(struct zyd_rf *rf, int on) +{ + /* vendor driver does nothing for this RF chip */ + + return 0; +} + +static int +zyd_al2210_set_channel(struct zyd_rf *rf, uint8_t chan) +{ + struct zyd_softc *sc = rf->rf_sc; + static const uint32_t rfprog[] = ZYD_AL2210_CHANTABLE; + uint32_t tmp; + + (void)zyd_write32(sc, ZYD_CR18, 2); + (void)zyd_write16(sc, ZYD_CR47, 0x1e); + (void)zyd_read32(sc, ZYD_CR_RADIO_PD, &tmp); + (void)zyd_write32(sc, ZYD_CR_RADIO_PD, tmp & ~1); + (void)zyd_write32(sc, ZYD_CR_RADIO_PD, tmp | 1); + (void)zyd_write32(sc, ZYD_CR_RFCFG, 0x05); + + (void)zyd_write32(sc, ZYD_CR_RFCFG, 0x00); + (void)zyd_write16(sc, ZYD_CR47, 0x1e); + + /* actually set the channel */ + (void)zyd_rfwrite(sc, rfprog[chan - 1]); + + (void)zyd_write32(sc, ZYD_CR18, 3); + + return 0; +} + +/* + * GCT RF methods. + */ +static int +zyd_gct_init(struct zyd_rf *rf) +{ +#define N(a) (sizeof (a) / sizeof ((a)[0])) + struct zyd_softc *sc = rf->rf_sc; + static const struct zyd_phy_pair phyini[] = ZYD_GCT_PHY; + static const uint32_t rfini[] = ZYD_GCT_RF; + int i, error; + + /* init RF-dependent PHY registers */ + for (i = 0; i < N(phyini); i++) { + error = zyd_write16(sc, phyini[i].reg, phyini[i].val); + if (error != 0) + return error; + } + /* init cgt radio */ + for (i = 0; i < N(rfini); i++) { + if ((error = zyd_rfwrite(sc, rfini[i])) != 0) + return error; + } + return 0; +#undef N +} + +static int +zyd_gct_switch_radio(struct zyd_rf *rf, int on) +{ + /* vendor driver does nothing for this RF chip */ + + return 0; +} + +static int +zyd_gct_set_channel(struct zyd_rf *rf, uint8_t chan) +{ + struct zyd_softc *sc = rf->rf_sc; + static const uint32_t rfprog[] = ZYD_GCT_CHANTABLE; + + (void)zyd_rfwrite(sc, 0x1c0000); + (void)zyd_rfwrite(sc, rfprog[chan - 1]); + (void)zyd_rfwrite(sc, 0x1c0008); + + return 0; +} + +/* + * Maxim RF methods. + */ +static int +zyd_maxim_init(struct zyd_rf *rf) +{ +#define N(a) (sizeof (a) / sizeof ((a)[0])) + struct zyd_softc *sc = rf->rf_sc; + static const struct zyd_phy_pair phyini[] = ZYD_MAXIM_PHY; + static const uint32_t rfini[] = ZYD_MAXIM_RF; + uint16_t tmp; + int i, error; + + /* init RF-dependent PHY registers */ + for (i = 0; i < N(phyini); i++) { + error = zyd_write16(sc, phyini[i].reg, phyini[i].val); + if (error != 0) + return error; + } + (void)zyd_read16(sc, ZYD_CR203, &tmp); + (void)zyd_write16(sc, ZYD_CR203, tmp & ~(1 << 4)); + + /* init maxim radio */ + for (i = 0; i < N(rfini); i++) { + if ((error = zyd_rfwrite(sc, rfini[i])) != 0) + return error; + } + (void)zyd_read16(sc, ZYD_CR203, &tmp); + (void)zyd_write16(sc, ZYD_CR203, tmp | (1 << 4)); + + return 0; +#undef N +} + +static int +zyd_maxim_switch_radio(struct zyd_rf *rf, int on) +{ + /* vendor driver does nothing for this RF chip */ + + return 0; +} + +static int +zyd_maxim_set_channel(struct zyd_rf *rf, uint8_t chan) +{ +#define N(a) (sizeof (a) / sizeof ((a)[0])) + struct zyd_softc *sc = rf->rf_sc; + static const struct zyd_phy_pair phyini[] = ZYD_MAXIM_PHY; + static const uint32_t rfini[] = ZYD_MAXIM_RF; + static const struct { + uint32_t r1, r2; + } rfprog[] = ZYD_MAXIM_CHANTABLE; + uint16_t tmp; + int i, error; + + /* + * Do the same as we do when initializing it, except for the channel + * values coming from the two channel tables. + */ + + /* init RF-dependent PHY registers */ + for (i = 0; i < N(phyini); i++) { + error = zyd_write16(sc, phyini[i].reg, phyini[i].val); + if (error != 0) + return error; + } + (void)zyd_read16(sc, ZYD_CR203, &tmp); + (void)zyd_write16(sc, ZYD_CR203, tmp & ~(1 << 4)); + + /* first two values taken from the chantables */ + (void)zyd_rfwrite(sc, rfprog[chan - 1].r1); + (void)zyd_rfwrite(sc, rfprog[chan - 1].r2); + + /* init maxim radio - skipping the two first values */ + for (i = 2; i < N(rfini); i++) { + if ((error = zyd_rfwrite(sc, rfini[i])) != 0) + return error; + } + (void)zyd_read16(sc, ZYD_CR203, &tmp); + (void)zyd_write16(sc, ZYD_CR203, tmp | (1 << 4)); + + return 0; +#undef N +} + +/* + * Maxim2 RF methods. + */ +static int +zyd_maxim2_init(struct zyd_rf *rf) +{ +#define N(a) (sizeof (a) / sizeof ((a)[0])) + struct zyd_softc *sc = rf->rf_sc; + static const struct zyd_phy_pair phyini[] = ZYD_MAXIM2_PHY; + static const uint32_t rfini[] = ZYD_MAXIM2_RF; + uint16_t tmp; + int i, error; + + /* init RF-dependent PHY registers */ + for (i = 0; i < N(phyini); i++) { + error = zyd_write16(sc, phyini[i].reg, phyini[i].val); + if (error != 0) + return error; + } + (void)zyd_read16(sc, ZYD_CR203, &tmp); + (void)zyd_write16(sc, ZYD_CR203, tmp & ~(1 << 4)); + + /* init maxim2 radio */ + for (i = 0; i < N(rfini); i++) { + if ((error = zyd_rfwrite(sc, rfini[i])) != 0) + return error; + } + (void)zyd_read16(sc, ZYD_CR203, &tmp); + (void)zyd_write16(sc, ZYD_CR203, tmp | (1 << 4)); + + return 0; +#undef N +} + +static int +zyd_maxim2_switch_radio(struct zyd_rf *rf, int on) +{ + /* vendor driver does nothing for this RF chip */ + + return 0; +} + +static int +zyd_maxim2_set_channel(struct zyd_rf *rf, uint8_t chan) +{ +#define N(a) (sizeof (a) / sizeof ((a)[0])) + struct zyd_softc *sc = rf->rf_sc; + static const struct zyd_phy_pair phyini[] = ZYD_MAXIM2_PHY; + static const uint32_t rfini[] = ZYD_MAXIM2_RF; + static const struct { + uint32_t r1, r2; + } rfprog[] = ZYD_MAXIM2_CHANTABLE; + uint16_t tmp; + int i, error; + + /* + * Do the same as we do when initializing it, except for the channel + * values coming from the two channel tables. + */ + + /* init RF-dependent PHY registers */ + for (i = 0; i < N(phyini); i++) { + error = zyd_write16(sc, phyini[i].reg, phyini[i].val); + if (error != 0) + return error; + } + (void)zyd_read16(sc, ZYD_CR203, &tmp); + (void)zyd_write16(sc, ZYD_CR203, tmp & ~(1 << 4)); + + /* first two values taken from the chantables */ + (void)zyd_rfwrite(sc, rfprog[chan - 1].r1); + (void)zyd_rfwrite(sc, rfprog[chan - 1].r2); + + /* init maxim2 radio - skipping the two first values */ + for (i = 2; i < N(rfini); i++) { + if ((error = zyd_rfwrite(sc, rfini[i])) != 0) + return error; + } + (void)zyd_read16(sc, ZYD_CR203, &tmp); + (void)zyd_write16(sc, ZYD_CR203, tmp | (1 << 4)); + + return 0; +#undef N +} + +static int +zyd_rf_attach(struct zyd_softc *sc, uint8_t type) +{ + struct zyd_rf *rf = &sc->sc_rf; + + rf->rf_sc = sc; + + switch (type) { + case ZYD_RF_RFMD: + rf->init = zyd_rfmd_init; + rf->switch_radio = zyd_rfmd_switch_radio; + rf->set_channel = zyd_rfmd_set_channel; + rf->width = 24; /* 24-bit RF values */ + break; + case ZYD_RF_AL2230: + if (sc->mac_rev == ZYD_ZD1211B) + rf->init = zyd_al2230_init_b; + else + rf->init = zyd_al2230_init; + rf->switch_radio = zyd_al2230_switch_radio; + rf->set_channel = zyd_al2230_set_channel; + rf->width = 24; /* 24-bit RF values */ + break; + case ZYD_RF_AL7230B: + rf->init = zyd_al7230B_init; + rf->switch_radio = zyd_al7230B_switch_radio; + rf->set_channel = zyd_al7230B_set_channel; + rf->width = 24; /* 24-bit RF values */ + break; + case ZYD_RF_AL2210: + rf->init = zyd_al2210_init; + rf->switch_radio = zyd_al2210_switch_radio; + rf->set_channel = zyd_al2210_set_channel; + rf->width = 24; /* 24-bit RF values */ + break; + case ZYD_RF_GCT: + rf->init = zyd_gct_init; + rf->switch_radio = zyd_gct_switch_radio; + rf->set_channel = zyd_gct_set_channel; + rf->width = 21; /* 21-bit RF values */ + break; + case ZYD_RF_MAXIM_NEW: + rf->init = zyd_maxim_init; + rf->switch_radio = zyd_maxim_switch_radio; + rf->set_channel = zyd_maxim_set_channel; + rf->width = 18; /* 18-bit RF values */ + break; + case ZYD_RF_MAXIM_NEW2: + rf->init = zyd_maxim2_init; + rf->switch_radio = zyd_maxim2_switch_radio; + rf->set_channel = zyd_maxim2_set_channel; + rf->width = 18; /* 18-bit RF values */ + break; + default: + printf("%s: sorry, radio \"%s\" is not supported yet\n", + device_get_nameunit(sc->sc_dev), zyd_rf_name(type)); + return EINVAL; + } + return 0; +} + +static const char * +zyd_rf_name(uint8_t type) +{ + static const char * const zyd_rfs[] = { + "unknown", "unknown", "UW2451", "UCHIP", "AL2230", + "AL7230B", "THETA", "AL2210", "MAXIM_NEW", "GCT", + "PV2000", "RALINK", "INTERSIL", "RFMD", "MAXIM_NEW2", + "PHILIPS" + }; + + return zyd_rfs[(type > 15) ? 0 : type]; +} + +static int +zyd_hw_init(struct zyd_softc *sc) +{ + struct zyd_rf *rf = &sc->sc_rf; + const struct zyd_phy_pair *phyp; + int error; + + /* specify that the plug and play is finished */ + (void)zyd_write32(sc, ZYD_MAC_AFTER_PNP, 1); + + (void)zyd_read16(sc, ZYD_FIRMWARE_BASE_ADDR, &sc->fwbase); + DPRINTF(("firmware base address=0x%04x\n", sc->fwbase)); + + /* retrieve firmware revision number */ + (void)zyd_read16(sc, sc->fwbase + ZYD_FW_FIRMWARE_REV, &sc->fw_rev); + + (void)zyd_write32(sc, ZYD_CR_GPI_EN, 0); + (void)zyd_write32(sc, ZYD_MAC_CONT_WIN_LIMIT, 0x7f043f); + + /* disable interrupts */ + (void)zyd_write32(sc, ZYD_CR_INTERRUPT, 0); + + /* PHY init */ + zyd_lock_phy(sc); + phyp = (sc->mac_rev == ZYD_ZD1211B) ? zyd_def_phyB : zyd_def_phy; + for (; phyp->reg != 0; phyp++) { + if ((error = zyd_write16(sc, phyp->reg, phyp->val)) != 0) + goto fail; + } + zyd_unlock_phy(sc); + + /* HMAC init */ + zyd_write32(sc, ZYD_MAC_ACK_EXT, 0x00000020); + zyd_write32(sc, ZYD_CR_ADDA_MBIAS_WT, 0x30000808); + + if (sc->mac_rev == ZYD_ZD1211) { + zyd_write32(sc, ZYD_MAC_RETRY, 0x00000002); + } else { + zyd_write32(sc, ZYD_MAC_RETRY, 0x02020202); + zyd_write32(sc, ZYD_MACB_TXPWR_CTL4, 0x007f003f); + zyd_write32(sc, ZYD_MACB_TXPWR_CTL3, 0x007f003f); + zyd_write32(sc, ZYD_MACB_TXPWR_CTL2, 0x003f001f); + zyd_write32(sc, ZYD_MACB_TXPWR_CTL1, 0x001f000f); + zyd_write32(sc, ZYD_MACB_AIFS_CTL1, 0x00280028); + zyd_write32(sc, ZYD_MACB_AIFS_CTL2, 0x008C003C); + zyd_write32(sc, ZYD_MACB_TXOP, 0x01800824); + } + + zyd_write32(sc, ZYD_MAC_SNIFFER, 0x00000000); + zyd_write32(sc, ZYD_MAC_RXFILTER, 0x00000000); + zyd_write32(sc, ZYD_MAC_GHTBL, 0x00000000); + zyd_write32(sc, ZYD_MAC_GHTBH, 0x80000000); + zyd_write32(sc, ZYD_MAC_MISC, 0x000000a4); + zyd_write32(sc, ZYD_CR_ADDA_PWR_DWN, 0x0000007f); + zyd_write32(sc, ZYD_MAC_BCNCFG, 0x00f00401); + zyd_write32(sc, ZYD_MAC_PHY_DELAY2, 0x00000000); + zyd_write32(sc, ZYD_MAC_ACK_EXT, 0x00000080); + zyd_write32(sc, ZYD_CR_ADDA_PWR_DWN, 0x00000000); + zyd_write32(sc, ZYD_MAC_SIFS_ACK_TIME, 0x00000100); + zyd_write32(sc, ZYD_MAC_DIFS_EIFS_SIFS, 0x0547c032); + zyd_write32(sc, ZYD_CR_RX_PE_DELAY, 0x00000070); + zyd_write32(sc, ZYD_CR_PS_CTRL, 0x10000000); + zyd_write32(sc, ZYD_MAC_RTSCTSRATE, 0x02030203); + zyd_write32(sc, ZYD_MAC_RX_THRESHOLD, 0x000c0640); + zyd_write32(sc, ZYD_MAC_BACKOFF_PROTECT, 0x00000114); + + /* RF chip init */ + zyd_lock_phy(sc); + error = (*rf->init)(rf); + zyd_unlock_phy(sc); + if (error != 0) { + printf("%s: radio initialization failed\n", + device_get_nameunit(sc->sc_dev)); + goto fail; + } + + /* init beacon interval to 100ms */ + if ((error = zyd_set_beacon_interval(sc, 100)) != 0) + goto fail; + +fail: return error; +} + +static int +zyd_read_eeprom(struct zyd_softc *sc) +{ + struct ieee80211com *ic = &sc->sc_ic; + uint32_t tmp; + uint16_t val; + int i; + + /* read MAC address */ + (void)zyd_read32(sc, ZYD_EEPROM_MAC_ADDR_P1, &tmp); + ic->ic_myaddr[0] = tmp & 0xff; + ic->ic_myaddr[1] = tmp >> 8; + ic->ic_myaddr[2] = tmp >> 16; + ic->ic_myaddr[3] = tmp >> 24; + (void)zyd_read32(sc, ZYD_EEPROM_MAC_ADDR_P2, &tmp); + ic->ic_myaddr[4] = tmp & 0xff; + ic->ic_myaddr[5] = tmp >> 8; + + (void)zyd_read32(sc, ZYD_EEPROM_POD, &tmp); + sc->rf_rev = tmp & 0x0f; + sc->pa_rev = (tmp >> 16) & 0x0f; + + /* read regulatory domain (currently unused) */ + (void)zyd_read32(sc, ZYD_EEPROM_SUBID, &tmp); + sc->regdomain = tmp >> 16; + DPRINTF(("regulatory domain %x\n", sc->regdomain)); + + /* read Tx power calibration tables */ + for (i = 0; i < 7; i++) { + (void)zyd_read16(sc, ZYD_EEPROM_PWR_CAL + i, &val); + sc->pwr_cal[i * 2] = val >> 8; + sc->pwr_cal[i * 2 + 1] = val & 0xff; + + (void)zyd_read16(sc, ZYD_EEPROM_PWR_INT + i, &val); + sc->pwr_int[i * 2] = val >> 8; + sc->pwr_int[i * 2 + 1] = val & 0xff; + + (void)zyd_read16(sc, ZYD_EEPROM_36M_CAL + i, &val); + sc->ofdm36_cal[i * 2] = val >> 8; + sc->ofdm36_cal[i * 2 + 1] = val & 0xff; + + (void)zyd_read16(sc, ZYD_EEPROM_48M_CAL + i, &val); + sc->ofdm48_cal[i * 2] = val >> 8; + sc->ofdm48_cal[i * 2 + 1] = val & 0xff; + + (void)zyd_read16(sc, ZYD_EEPROM_54M_CAL + i, &val); + sc->ofdm54_cal[i * 2] = val >> 8; + sc->ofdm54_cal[i * 2 + 1] = val & 0xff; + } + return 0; +} + +static int +zyd_set_macaddr(struct zyd_softc *sc, const uint8_t *addr) +{ + uint32_t tmp; + + tmp = addr[3] << 24 | addr[2] << 16 | addr[1] << 8 | addr[0]; + (void)zyd_write32(sc, ZYD_MAC_MACADRL, tmp); + + tmp = addr[5] << 8 | addr[4]; + (void)zyd_write32(sc, ZYD_MAC_MACADRH, tmp); + + return 0; +} + +static int +zyd_set_bssid(struct zyd_softc *sc, const uint8_t *addr) +{ + uint32_t tmp; + + tmp = addr[3] << 24 | addr[2] << 16 | addr[1] << 8 | addr[0]; + (void)zyd_write32(sc, ZYD_MAC_BSSADRL, tmp); + + tmp = addr[5] << 8 | addr[4]; + (void)zyd_write32(sc, ZYD_MAC_BSSADRH, tmp); + + return 0; +} + +static int +zyd_switch_radio(struct zyd_softc *sc, int on) +{ + struct zyd_rf *rf = &sc->sc_rf; + int error; + + zyd_lock_phy(sc); + error = (*rf->switch_radio)(rf, on); + zyd_unlock_phy(sc); + + return error; +} + +static void +zyd_set_led(struct zyd_softc *sc, int which, int on) +{ + uint32_t tmp; + + (void)zyd_read32(sc, ZYD_MAC_TX_PE_CONTROL, &tmp); + tmp &= ~which; + if (on) + tmp |= which; + (void)zyd_write32(sc, ZYD_MAC_TX_PE_CONTROL, tmp); +} + +static int +zyd_set_rxfilter(struct zyd_softc *sc) +{ + uint32_t rxfilter; + + switch (sc->sc_ic.ic_opmode) { + case IEEE80211_M_STA: + rxfilter = ZYD_FILTER_BSS; + break; + case IEEE80211_M_IBSS: + case IEEE80211_M_HOSTAP: + rxfilter = ZYD_FILTER_HOSTAP; + break; + case IEEE80211_M_MONITOR: + rxfilter = ZYD_FILTER_MONITOR; + break; + default: + /* should not get there */ + return EINVAL; + } + return zyd_write32(sc, ZYD_MAC_RXFILTER, rxfilter); +} + +static void +zyd_set_chan(struct zyd_softc *sc, struct ieee80211_channel *c) +{ + struct ieee80211com *ic = &sc->sc_ic; + struct zyd_rf *rf = &sc->sc_rf; + u_int chan; + + chan = ieee80211_chan2ieee(ic, c); + if (chan == 0 || chan == IEEE80211_CHAN_ANY) + return; + + zyd_lock_phy(sc); + + (*rf->set_channel)(rf, chan); + + /* update Tx power */ + (void)zyd_write32(sc, ZYD_CR31, sc->pwr_int[chan - 1]); + (void)zyd_write32(sc, ZYD_CR68, sc->pwr_cal[chan - 1]); + + if (sc->mac_rev == ZYD_ZD1211B) { + (void)zyd_write32(sc, ZYD_CR67, sc->ofdm36_cal[chan - 1]); + (void)zyd_write32(sc, ZYD_CR66, sc->ofdm48_cal[chan - 1]); + (void)zyd_write32(sc, ZYD_CR65, sc->ofdm54_cal[chan - 1]); + + (void)zyd_write32(sc, ZYD_CR69, 0x28); + (void)zyd_write32(sc, ZYD_CR69, 0x2a); + } + + zyd_unlock_phy(sc); +} + +static int +zyd_set_beacon_interval(struct zyd_softc *sc, int bintval) +{ + /* XXX this is probably broken.. */ + (void)zyd_write32(sc, ZYD_CR_ATIM_WND_PERIOD, bintval - 2); + (void)zyd_write32(sc, ZYD_CR_PRE_TBTT, bintval - 1); + (void)zyd_write32(sc, ZYD_CR_BCN_INTERVAL, bintval); + + return 0; +} + +static uint8_t +zyd_plcp_signal(int rate) +{ + switch (rate) { + /* CCK rates (returned values are device-dependent) */ + case 2: return 0x0; + case 4: return 0x1; + case 11: return 0x2; + case 22: return 0x3; + + /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */ + case 12: return 0xb; + case 18: return 0xf; + case 24: return 0xa; + case 36: return 0xe; + case 48: return 0x9; + case 72: return 0xd; + case 96: return 0x8; + case 108: return 0xc; + + /* unsupported rates (should not get there) */ + default: return 0xff; + } +} + +static void +zyd_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) +{ + struct zyd_softc *sc = (struct zyd_softc *)priv; + struct zyd_cmd *cmd; + uint32_t datalen; + + if (status != USBD_NORMAL_COMPLETION) { + if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) + return; + + if (status == USBD_STALLED) { + usbd_clear_endpoint_stall_async( + sc->zyd_ep[ZYD_ENDPT_IIN]); + } + return; + } + + cmd = (struct zyd_cmd *)sc->ibuf; + + if (le16toh(cmd->code) == ZYD_NOTIF_RETRYSTATUS) { + struct zyd_notif_retry *retry = + (struct zyd_notif_retry *)cmd->data; + struct ieee80211com *ic = &sc->sc_ic; + struct ifnet *ifp = sc->sc_ifp; + struct ieee80211_node *ni; + + DPRINTF(("retry intr: rate=0x%x addr=%s count=%d (0x%x)\n", + le16toh(retry->rate), ether_sprintf(retry->macaddr), + le16toh(retry->count) & 0xff, le16toh(retry->count))); + + /* + * Find the node to which the packet was sent and update its + * retry statistics. In BSS mode, this node is the AP we're + * associated to so no lookup is actually needed. + */ + if (ic->ic_opmode != IEEE80211_M_STA) { + ni = ieee80211_find_node(&ic->ic_sta, retry->macaddr); + if (ni == NULL) + return; /* just ignore */ + } else + ni = ic->ic_bss; + + ((struct zyd_node *)ni)->amn.amn_retrycnt++; + + if (le16toh(retry->count) & 0x100) + ifp->if_oerrors++; /* too many retries */ + } else if (le16toh(cmd->code) == ZYD_NOTIF_IORD) { + struct rq *rqp; + + if (le16toh(*(uint16_t *)cmd->data) == ZYD_CR_INTERRUPT) + return; /* HMAC interrupt */ + + usbd_get_xfer_status(xfer, NULL, NULL, &datalen, NULL); + datalen -= sizeof(cmd->code); + datalen -= 2; /* XXX: padding? */ + + STAILQ_FOREACH(rqp, &sc->sc_rqh, rq) { + int i; + + if (sizeof(struct zyd_pair) * rqp->len != datalen) + continue; + for (i = 0; i < rqp->len; i++) { + if (*(((const uint16_t *)rqp->idata) + i) != + (((struct zyd_pair *)cmd->data) + i)->reg) + break; + } + if (i != rqp->len) + continue; + + /* copy answer into caller-supplied buffer */ + bcopy(cmd->data, rqp->odata, + sizeof(struct zyd_pair) * rqp->len); + wakeup(rqp->odata); /* wakeup caller */ + + return; + } + return; /* unexpected IORD notification */ + } else { + printf("%s: unknown notification %x\n", + device_get_nameunit(sc->sc_dev), le16toh(cmd->code)); + } +} + +static void +zyd_rx_data(struct zyd_softc *sc, const uint8_t *buf, uint16_t len) +{ + struct ieee80211com *ic = &sc->sc_ic; + struct ifnet *ifp = sc->sc_ifp; + struct ieee80211_node *ni; + struct ieee80211_frame *wh; + const struct zyd_plcphdr *plcp; + const struct zyd_rx_stat *stat; + struct mbuf *m; + int rlen; + + if (len < ZYD_MIN_FRAGSZ) { + printf("%s: frame too short (length=%d)\n", + device_get_nameunit(sc->sc_dev), len); + ifp->if_ierrors++; + return; + } + + plcp = (const struct zyd_plcphdr *)buf; + stat = (const struct zyd_rx_stat *) + (buf + len - sizeof (struct zyd_rx_stat)); + + if (stat->flags & ZYD_RX_ERROR) { + DPRINTF(("%s: RX status indicated error (%x)\n", + device_get_nameunit(sc->sc_dev), stat->flags)); + ifp->if_ierrors++; + return; + } + + /* compute actual frame length */ + rlen = len - sizeof (struct zyd_plcphdr) - + sizeof (struct zyd_rx_stat) - IEEE80211_CRC_LEN; + + /* allocate a mbuf to store the frame */ + MGETHDR(m, M_DONTWAIT, MT_DATA); + if (m == NULL) { + printf("%s: could not allocate rx mbuf\n", + device_get_nameunit(sc->sc_dev)); + ifp->if_ierrors++; + return; + } + if (rlen > MHLEN) { + MCLGET(m, M_DONTWAIT); + if (!(m->m_flags & M_EXT)) { + printf("%s: could not allocate rx mbuf cluster\n", + device_get_nameunit(sc->sc_dev)); + m_freem(m); + ifp->if_ierrors++; + return; + } + } + m->m_pkthdr.rcvif = ifp; + m->m_pkthdr.len = m->m_len = rlen; + bcopy((const uint8_t *)(plcp + 1), mtod(m, uint8_t *), rlen); + + if (bpf_peers_present(sc->sc_drvbpf)) { + struct zyd_rx_radiotap_header *tap = &sc->sc_rxtap; + static const uint8_t rates[] = { + /* reverse function of zyd_plcp_signal() */ + 2, 4, 11, 22, 0, 0, 0, 0, + 96, 48, 24, 12, 108, 72, 36, 18 + }; + + tap->wr_flags = IEEE80211_RADIOTAP_F_FCS; + tap->wr_chan_freq = htole16(ic->ic_curchan->ic_freq); + tap->wr_chan_flags = htole16(ic->ic_curchan->ic_flags); + tap->wr_rssi = stat->rssi; + tap->wr_rate = rates[plcp->signal & 0xf]; + + bpf_mtap2(sc->sc_drvbpf, tap, sc->sc_rxtap_len, m); + } + + wh = mtod(m, struct ieee80211_frame *); + ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *)wh); + ieee80211_input(ic, m, ni, stat->rssi, -95/*XXX*/, 0); + + /* node is no longer needed */ + ieee80211_free_node(ni); +} + +static void +zyd_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) +{ + struct zyd_rx_data *data = priv; + struct zyd_softc *sc = data->sc; + struct ifnet *ifp = sc->sc_ifp; + const struct zyd_rx_desc *desc; + int len; + + if (status != USBD_NORMAL_COMPLETION) { + if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) + return; + + if (status == USBD_STALLED) + usbd_clear_endpoint_stall(sc->zyd_ep[ZYD_ENDPT_BIN]); + + goto skip; + } + usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL); + + if (len < ZYD_MIN_RXBUFSZ) { + printf("%s: xfer too short (length=%d)\n", + device_get_nameunit(sc->sc_dev), len); + ifp->if_ierrors++; + goto skip; + } + + desc = (const struct zyd_rx_desc *) + (data->buf + len - sizeof (struct zyd_rx_desc)); + + if (UGETW(desc->tag) == ZYD_TAG_MULTIFRAME) { + const uint8_t *p = data->buf, *end = p + len; + int i; + + DPRINTFN(3, ("received multi-frame transfer\n")); + + for (i = 0; i < ZYD_MAX_RXFRAMECNT; i++) { + const uint16_t len16 = UGETW(desc->len[i]); + + if (len16 == 0 || p + len16 > end) + break; + + zyd_rx_data(sc, p, len16); + /* next frame is aligned on a 32-bit boundary */ + p += (len16 + 3) & ~3; + } + } else { + DPRINTFN(3, ("received single-frame transfer\n")); + + zyd_rx_data(sc, data->buf, len); + } + +skip: /* setup a new transfer */ + usbd_setup_xfer(xfer, sc->zyd_ep[ZYD_ENDPT_BIN], data, NULL, + ZYX_MAX_RXBUFSZ, USBD_NO_COPY | USBD_SHORT_XFER_OK, + USBD_NO_TIMEOUT, zyd_rxeof); + (void)usbd_transfer(xfer); +} + +static int +zyd_tx_mgt(struct zyd_softc *sc, struct mbuf *m0, struct ieee80211_node *ni) +{ + struct ieee80211com *ic = &sc->sc_ic; + struct ifnet *ifp = sc->sc_ifp; + struct zyd_tx_desc *desc; + struct zyd_tx_data *data; + struct ieee80211_frame *wh; + int xferlen, totlen, rate; + uint16_t pktlen; + usbd_status error; + + data = &sc->tx_data[0]; + desc = (struct zyd_tx_desc *)data->buf; + + rate = IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan) ? 12 : 2; + + data->ni = ni; + + wh = mtod(m0, struct ieee80211_frame *); + + xferlen = sizeof (struct zyd_tx_desc) + m0->m_pkthdr.len; + totlen = m0->m_pkthdr.len + IEEE80211_CRC_LEN; + + /* fill Tx descriptor */ + desc->len = htole16(totlen); + + desc->flags = ZYD_TX_FLAG_BACKOFF; + if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) { + /* multicast frames are not sent at OFDM rates in 802.11b/g */ + if (totlen > ic->ic_rtsthreshold) { + desc->flags |= ZYD_TX_FLAG_RTS; + } else if (ZYD_RATE_IS_OFDM(rate) && + (ic->ic_flags & IEEE80211_F_USEPROT)) { + if (ic->ic_protmode == IEEE80211_PROT_CTSONLY) + desc->flags |= ZYD_TX_FLAG_CTS_TO_SELF; + else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS) + desc->flags |= ZYD_TX_FLAG_RTS; + } + } else + desc->flags |= ZYD_TX_FLAG_MULTICAST; + + if ((wh->i_fc[0] & + (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) == + (IEEE80211_FC0_TYPE_CTL | IEEE80211_FC0_SUBTYPE_PS_POLL)) + desc->flags |= ZYD_TX_FLAG_TYPE(ZYD_TX_TYPE_PS_POLL); + + desc->phy = zyd_plcp_signal(rate); + if (ZYD_RATE_IS_OFDM(rate)) { + desc->phy |= ZYD_TX_PHY_OFDM; + if (ic->ic_curmode == IEEE80211_MODE_11A) + desc->phy |= ZYD_TX_PHY_5GHZ; + } else if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE)) + desc->phy |= ZYD_TX_PHY_SHPREAMBLE; + + /* actual transmit length (XXX why +10?) */ + pktlen = sizeof (struct zyd_tx_desc) + 10; + if (sc->mac_rev == ZYD_ZD1211) + pktlen += totlen; + desc->pktlen = htole16(pktlen); + + desc->plcp_length = (16 * totlen + rate - 1) / rate; + desc->plcp_service = 0; + if (rate == 22) { + const int remainder = (16 * totlen) % 22; + if (remainder != 0 && remainder < 7) + desc->plcp_service |= ZYD_PLCP_LENGEXT; + } + + if (bpf_peers_present(sc->sc_drvbpf)) { + struct zyd_tx_radiotap_header *tap = &sc->sc_txtap; + + tap->wt_flags = 0; + tap->wt_rate = rate; + tap->wt_chan_freq = htole16(ic->ic_curchan->ic_freq); + tap->wt_chan_flags = htole16(ic->ic_curchan->ic_flags); + + bpf_mtap2(sc->sc_drvbpf, tap, sc->sc_txtap_len, m0); + } + + m_copydata(m0, 0, m0->m_pkthdr.len, + data->buf + sizeof (struct zyd_tx_desc)); + + DPRINTFN(10, ("%s: sending mgt frame len=%zu rate=%u xferlen=%u\n", + device_get_nameunit(sc->sc_dev), (size_t)m0->m_pkthdr.len, + rate, xferlen)); + + m_freem(m0); /* mbuf no longer needed */ + + usbd_setup_xfer(data->xfer, sc->zyd_ep[ZYD_ENDPT_BOUT], data, + data->buf, xferlen, USBD_FORCE_SHORT_XFER | USBD_NO_COPY, + ZYD_TX_TIMEOUT, zyd_txeof); + error = usbd_transfer(data->xfer); + if (error != USBD_IN_PROGRESS && error != 0) { + ifp->if_oerrors++; + return EIO; + } + sc->tx_queued++; + + return 0; +} + +static void +zyd_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) +{ + struct zyd_tx_data *data = priv; + struct zyd_softc *sc = data->sc; + struct ifnet *ifp = sc->sc_ifp; + + if (status != USBD_NORMAL_COMPLETION) { + if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) + return; + + printf("%s: could not transmit buffer: %s\n", + device_get_nameunit(sc->sc_dev), usbd_errstr(status)); + + if (status == USBD_STALLED) { + usbd_clear_endpoint_stall_async( + sc->zyd_ep[ZYD_ENDPT_BOUT]); + } + ifp->if_oerrors++; + return; + } + + /* update rate control statistics */ + ((struct zyd_node *)data->ni)->amn.amn_txcnt++; + + ieee80211_free_node(data->ni); + data->ni = NULL; + + sc->tx_queued--; + ifp->if_opackets++; + + sc->tx_timer = 0; + ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; + zyd_start(ifp); +} + +static int +zyd_tx_data(struct zyd_softc *sc, struct mbuf *m0, struct ieee80211_node *ni) +{ + struct ieee80211com *ic = &sc->sc_ic; + struct ifnet *ifp = sc->sc_ifp; + struct zyd_tx_desc *desc; + struct zyd_tx_data *data; + struct ieee80211_frame *wh; + struct ieee80211_key *k; + int xferlen, totlen, rate; + uint16_t pktlen; + usbd_status error; + + wh = mtod(m0, struct ieee80211_frame *); + + if (ic->ic_fixed_rate != IEEE80211_FIXED_RATE_NONE) + rate = ic->ic_bss->ni_rates.rs_rates[ic->ic_fixed_rate]; + else + rate = ni->ni_rates.rs_rates[ni->ni_txrate]; + rate &= IEEE80211_RATE_VAL; + + if (wh->i_fc[1] & IEEE80211_FC1_WEP) { + k = ieee80211_crypto_encap(ic, ni, m0); + if (k == NULL) { + m_freem(m0); + return ENOBUFS; + } + + /* packet header may have moved, reset our local pointer */ + wh = mtod(m0, struct ieee80211_frame *); + } + + data = &sc->tx_data[0]; + desc = (struct zyd_tx_desc *)data->buf; + + data->ni = ni; + + xferlen = sizeof (struct zyd_tx_desc) + m0->m_pkthdr.len; + totlen = m0->m_pkthdr.len + IEEE80211_CRC_LEN; + + /* fill Tx descriptor */ + desc->len = htole16(totlen); + + desc->flags = ZYD_TX_FLAG_BACKOFF; + if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) { + /* multicast frames are not sent at OFDM rates in 802.11b/g */ + if (totlen > ic->ic_rtsthreshold) { + desc->flags |= ZYD_TX_FLAG_RTS; + } else if (ZYD_RATE_IS_OFDM(rate) && + (ic->ic_flags & IEEE80211_F_USEPROT)) { + if (ic->ic_protmode == IEEE80211_PROT_CTSONLY) + desc->flags |= ZYD_TX_FLAG_CTS_TO_SELF; + else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS) + desc->flags |= ZYD_TX_FLAG_RTS; + } + } else + desc->flags |= ZYD_TX_FLAG_MULTICAST; + + if ((wh->i_fc[0] & + (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) == + (IEEE80211_FC0_TYPE_CTL | IEEE80211_FC0_SUBTYPE_PS_POLL)) + desc->flags |= ZYD_TX_FLAG_TYPE(ZYD_TX_TYPE_PS_POLL); + + desc->phy = zyd_plcp_signal(rate); + if (ZYD_RATE_IS_OFDM(rate)) { + desc->phy |= ZYD_TX_PHY_OFDM; + if (ic->ic_curmode == IEEE80211_MODE_11A) + desc->phy |= ZYD_TX_PHY_5GHZ; + } else if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE)) + desc->phy |= ZYD_TX_PHY_SHPREAMBLE; + + /* actual transmit length (XXX why +10?) */ + pktlen = sizeof (struct zyd_tx_desc) + 10; + if (sc->mac_rev == ZYD_ZD1211) + pktlen += totlen; + desc->pktlen = htole16(pktlen); + + desc->plcp_length = (16 * totlen + rate - 1) / rate; + desc->plcp_service = 0; + if (rate == 22) { + const int remainder = (16 * totlen) % 22; + if (remainder != 0 && remainder < 7) + desc->plcp_service |= ZYD_PLCP_LENGEXT; + } + + if (bpf_peers_present(sc->sc_drvbpf)) { + struct zyd_tx_radiotap_header *tap = &sc->sc_txtap; + + tap->wt_flags = 0; + tap->wt_rate = rate; + tap->wt_chan_freq = htole16(ic->ic_curchan->ic_freq); + tap->wt_chan_flags = htole16(ic->ic_curchan->ic_flags); + + bpf_mtap2(sc->sc_drvbpf, tap, sc->sc_txtap_len, m0); + } + + m_copydata(m0, 0, m0->m_pkthdr.len, + data->buf + sizeof (struct zyd_tx_desc)); + + DPRINTFN(10, ("%s: sending data frame len=%zu rate=%u xferlen=%u\n", + device_get_nameunit(sc->sc_dev), (size_t)m0->m_pkthdr.len, + rate, xferlen)); + + m_freem(m0); /* mbuf no longer needed */ + + usbd_setup_xfer(data->xfer, sc->zyd_ep[ZYD_ENDPT_BOUT], data, + data->buf, xferlen, USBD_FORCE_SHORT_XFER | USBD_NO_COPY, + ZYD_TX_TIMEOUT, zyd_txeof); + error = usbd_transfer(data->xfer); + if (error != USBD_IN_PROGRESS && error != 0) { + ifp->if_oerrors++; + return EIO; + } + sc->tx_queued++; + + return 0; +} + +static void +zyd_start(struct ifnet *ifp) +{ + struct zyd_softc *sc = ifp->if_softc; + struct ieee80211com *ic = &sc->sc_ic; + struct ether_header *eh; + struct ieee80211_node *ni; + struct mbuf *m0; + + for (;;) { + IF_POLL(&ic->ic_mgtq, m0); + if (m0 != NULL) { + if (sc->tx_queued >= ZYD_TX_LIST_CNT) { + ifp->if_drv_flags |= IFF_DRV_OACTIVE; + break; + } + IF_DEQUEUE(&ic->ic_mgtq, m0); + + ni = (struct ieee80211_node *)m0->m_pkthdr.rcvif; + m0->m_pkthdr.rcvif = NULL; + if (bpf_peers_present(ic->ic_rawbpf)) + bpf_mtap(ic->ic_rawbpf, m0); + if (zyd_tx_mgt(sc, m0, ni) != 0) + break; + } else { + if (ic->ic_state != IEEE80211_S_RUN) + break; + IFQ_POLL(&ifp->if_snd, m0); + if (m0 == NULL) + break; + if (sc->tx_queued >= ZYD_TX_LIST_CNT) { + ifp->if_drv_flags |= IFF_DRV_OACTIVE; + break; + } + IFQ_DEQUEUE(&ifp->if_snd, m0); + + if (m0->m_len < sizeof(struct ether_header) && + !(m0 = m_pullup(m0, sizeof(struct ether_header)))) + continue; + + eh = mtod(m0, struct ether_header *); + ni = ieee80211_find_txnode(ic, eh->ether_dhost); + if (ni == NULL) { + m_freem(m0); + continue; + } + if (bpf_peers_present(ifp->if_bpf)) + bpf_mtap(ifp->if_bpf, m0); + if ((m0 = ieee80211_encap(ic, m0, ni)) == NULL) { + ieee80211_free_node(ni); + ifp->if_oerrors++; + continue; + } + if (bpf_peers_present(ic->ic_rawbpf)) + bpf_mtap(ic->ic_rawbpf, m0); + if (zyd_tx_data(sc, m0, ni) != 0) { + ieee80211_free_node(ni); + ifp->if_oerrors++; + break; + } + } + + sc->tx_timer = 5; + callout_reset(&sc->sc_watchdog_ch, hz, zyd_watchdog, sc); + } +} + +static void +zyd_watchdog(void *arg) +{ + struct zyd_softc *sc = arg; + struct ieee80211com *ic = &sc->sc_ic; + struct ifnet *ifp = ic->ic_ifp; + + if (sc->tx_timer > 0) { + if (--sc->tx_timer == 0) { + printf("%s: device timeout\n", + device_get_nameunit(sc->sc_dev)); + /* zyd_init(ifp); XXX needs a process context ? */ + ifp->if_oerrors++; + return; + } + callout_reset(&sc->sc_watchdog_ch, hz, zyd_watchdog, sc); + } +} + +static int +zyd_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) +{ + struct zyd_softc *sc = ifp->if_softc; + struct ieee80211com *ic = &sc->sc_ic; + int error = 0; + + ZYD_LOCK(sc); + + switch (cmd) { + case SIOCSIFFLAGS: + if (ifp->if_flags & IFF_UP) { + if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) + zyd_init(sc); + } else { + if (ifp->if_drv_flags & IFF_DRV_RUNNING) + zyd_stop(ifp, 1); + } + break; + + default: + if (!sc->attached) + error = ENOTTY; + else + error = ieee80211_ioctl(ic, cmd, data); + } + + if (error == ENETRESET) { + if ((ifp->if_flags & IFF_UP) == IFF_UP && + (ifp->if_drv_flags & IFF_DRV_RUNNING) == IFF_DRV_RUNNING) + zyd_init(sc); + error = 0; + } + + ZYD_UNLOCK(sc); + + return error; +} + +static void +zyd_init(void *priv) +{ + struct zyd_softc *sc = priv; + struct ieee80211com *ic = &sc->sc_ic; + struct ifnet *ifp = ic->ic_ifp; + int i, error; + + zyd_stop(ifp, 0); + + IEEE80211_ADDR_COPY(ic->ic_myaddr, IF_LLADDR(ifp)); + DPRINTF(("setting MAC address to %s\n", ether_sprintf(ic->ic_myaddr))); + error = zyd_set_macaddr(sc, ic->ic_myaddr); + if (error != 0) + return; + + /* we'll do software WEP decryption for now */ + DPRINTF(("setting encryption type\n")); + error = zyd_write32(sc, ZYD_MAC_ENCRYPTION_TYPE, ZYD_ENC_SNIFFER); + if (error != 0) + return; + + /* promiscuous mode */ + (void)zyd_write32(sc, ZYD_MAC_SNIFFER, + (ic->ic_opmode == IEEE80211_M_MONITOR) ? 1 : 0); + + (void)zyd_set_rxfilter(sc); + + /* switch radio transmitter ON */ + (void)zyd_switch_radio(sc, 1); + + /* set basic rates */ + if (ic->ic_curmode == IEEE80211_MODE_11B) + (void)zyd_write32(sc, ZYD_MAC_BAS_RATE, 0x0003); + else if (ic->ic_curmode == IEEE80211_MODE_11A) + (void)zyd_write32(sc, ZYD_MAC_BAS_RATE, 0x1500); + else /* assumes 802.11b/g */ + (void)zyd_write32(sc, ZYD_MAC_BAS_RATE, 0x000f); + + /* set mandatory rates */ + if (ic->ic_curmode == IEEE80211_MODE_11B) + (void)zyd_write32(sc, ZYD_MAC_MAN_RATE, 0x000f); + else if (ic->ic_curmode == IEEE80211_MODE_11A) + (void)zyd_write32(sc, ZYD_MAC_MAN_RATE, 0x1500); + else /* assumes 802.11b/g */ + (void)zyd_write32(sc, ZYD_MAC_MAN_RATE, 0x150f); + + /* set default BSS channel */ + zyd_set_chan(sc, ic->ic_curchan); + + /* enable interrupts */ + (void)zyd_write32(sc, ZYD_CR_INTERRUPT, ZYD_HWINT_MASK); + + /* + * Allocate Tx and Rx xfer queues. + */ + if ((error = zyd_alloc_tx_list(sc)) != 0) { + printf("%s: could not allocate Tx list\n", + device_get_nameunit(sc->sc_dev)); + goto fail; + } + if ((error = zyd_alloc_rx_list(sc)) != 0) { + printf("%s: could not allocate Rx list\n", + device_get_nameunit(sc->sc_dev)); + goto fail; + } + + /* + * Start up the receive pipe. + */ + for (i = 0; i < ZYD_RX_LIST_CNT; i++) { + struct zyd_rx_data *data = &sc->rx_data[i]; + + usbd_setup_xfer(data->xfer, sc->zyd_ep[ZYD_ENDPT_BIN], data, + NULL, ZYX_MAX_RXBUFSZ, USBD_NO_COPY | USBD_SHORT_XFER_OK, + USBD_NO_TIMEOUT, zyd_rxeof); + error = usbd_transfer(data->xfer); + if (error != USBD_IN_PROGRESS && error != 0) { + printf("%s: could not queue Rx transfer\n", + device_get_nameunit(sc->sc_dev)); + goto fail; + } + } + + ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; + ifp->if_drv_flags |= IFF_DRV_RUNNING; + + if (ic->ic_opmode == IEEE80211_M_MONITOR) + ieee80211_new_state(ic, IEEE80211_S_RUN, -1); + else + ieee80211_new_state(ic, IEEE80211_S_SCAN, -1); + + return; + +fail: zyd_stop(ifp, 1); + return; +} + +static void +zyd_stop(struct ifnet *ifp, int disable) +{ + struct zyd_softc *sc = ifp->if_softc; + struct ieee80211com *ic = &sc->sc_ic; + + ieee80211_new_state(ic, IEEE80211_S_INIT, -1); /* free all nodes */ + + sc->tx_timer = 0; + ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); + + /* switch radio transmitter OFF */ + (void)zyd_switch_radio(sc, 0); + + /* disable Rx */ + (void)zyd_write32(sc, ZYD_MAC_RXFILTER, 0); + + /* disable interrupts */ + (void)zyd_write32(sc, ZYD_CR_INTERRUPT, 0); + + usbd_abort_pipe(sc->zyd_ep[ZYD_ENDPT_BIN]); + usbd_abort_pipe(sc->zyd_ep[ZYD_ENDPT_BOUT]); + + zyd_free_rx_list(sc); + zyd_free_tx_list(sc); +} + +static int +zyd_loadfirmware(struct zyd_softc *sc, u_char *fw, size_t size) +{ + usb_device_request_t req; + uint16_t addr; + uint8_t stat; + + DPRINTF(("firmware size=%zu\n", size)); + + req.bmRequestType = UT_WRITE_VENDOR_DEVICE; + req.bRequest = ZYD_DOWNLOADREQ; + USETW(req.wIndex, 0); + + addr = ZYD_FIRMWARE_START_ADDR; + while (size > 0) { +#if 0 + const int mlen = min(size, 4096); +#else + /* + * XXXX: When the transfer size is 4096 bytes, it is not + * likely to be able to transfer it. + * The cause is port or machine or chip? + */ + const int mlen = min(size, 64); +#endif + + DPRINTF(("loading firmware block: len=%d, addr=0x%x\n", mlen, + addr)); + + USETW(req.wValue, addr); + USETW(req.wLength, mlen); + if (usbd_do_request(sc->sc_udev, &req, fw) != 0) + return EIO; + + addr += mlen / 2; + fw += mlen; + size -= mlen; + } + + /* check whether the upload succeeded */ + req.bmRequestType = UT_READ_VENDOR_DEVICE; + req.bRequest = ZYD_DOWNLOADSTS; + USETW(req.wValue, 0); + USETW(req.wIndex, 0); + USETW(req.wLength, sizeof stat); + if (usbd_do_request(sc->sc_udev, &req, &stat) != 0) + return EIO; + + return (stat & 0x80) ? EIO : 0; +} + +static void +zyd_iter_func(void *arg, struct ieee80211_node *ni) +{ + struct zyd_softc *sc = arg; + struct zyd_node *zn = (struct zyd_node *)ni; + + ieee80211_amrr_choose(&sc->amrr, ni, &zn->amn); +} + +static void +zyd_amrr_timeout(void *arg) +{ + struct zyd_softc *sc = arg; + struct ieee80211com *ic = &sc->sc_ic; + + ZYD_LOCK(sc); + if (ic->ic_opmode == IEEE80211_M_STA) + zyd_iter_func(sc, ic->ic_bss); + else + ieee80211_iterate_nodes(&ic->ic_sta, zyd_iter_func, sc); + ZYD_UNLOCK(sc); + + callout_reset(&sc->sc_amrr_ch, hz, zyd_amrr_timeout, sc); +} + +static void +zyd_newassoc(struct ieee80211_node *ni, int isnew) +{ + struct zyd_softc *sc = ni->ni_ic->ic_ifp->if_softc; + int i; + + ieee80211_amrr_node_init(&sc->amrr, &((struct zyd_node *)ni)->amn); + + /* set rate to some reasonable initial value */ + for (i = ni->ni_rates.rs_nrates - 1; + i > 0 && (ni->ni_rates.rs_rates[i] & IEEE80211_RATE_VAL) > 72; + i--); + ni->ni_txrate = i; +} + +static void +zyd_scan_start(struct ieee80211com *ic) +{ + struct zyd_softc *sc = ic->ic_ifp->if_softc; + + usb_rem_task(sc->sc_udev, &sc->sc_scantask); + + /* do it in a process context */ + sc->sc_scan_action = ZYD_SCAN_START; + usb_add_task(sc->sc_udev, &sc->sc_scantask, USB_TASKQ_DRIVER); +} + +static void +zyd_scan_end(struct ieee80211com *ic) +{ + struct zyd_softc *sc = ic->ic_ifp->if_softc; + + usb_rem_task(sc->sc_udev, &sc->sc_scantask); + + /* do it in a process context */ + sc->sc_scan_action = ZYD_SCAN_END; + usb_add_task(sc->sc_udev, &sc->sc_scantask, USB_TASKQ_DRIVER); +} + +static void +zyd_set_channel(struct ieee80211com *ic) +{ + struct zyd_softc *sc = ic->ic_ifp->if_softc; + + usb_rem_task(sc->sc_udev, &sc->sc_scantask); + + /* do it in a process context */ + sc->sc_scan_action = ZYD_SET_CHANNEL; + usb_add_task(sc->sc_udev, &sc->sc_scantask, USB_TASKQ_DRIVER); +} + +static void +zyd_scantask(void *arg) +{ + struct zyd_softc *sc = arg; + struct ieee80211com *ic = &sc->sc_ic; + struct ifnet *ifp = ic->ic_ifp; + + ZYD_LOCK(sc); + + switch (sc->sc_scan_action) { + case ZYD_SCAN_START: + zyd_set_bssid(sc, ifp->if_broadcastaddr); + break; + + case ZYD_SCAN_END: + zyd_set_bssid(sc, ic->ic_bss->ni_bssid); + break; + + case ZYD_SET_CHANNEL: + mtx_lock(&Giant); + zyd_set_chan(sc, ic->ic_curchan); + mtx_unlock(&Giant); + break; + + default: + panic("unknown scan action %d\n", sc->sc_scan_action); + /* NEVER REACHED */ + break; + } + + ZYD_UNLOCK(sc); +} + +static device_method_t zyd_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, zyd_match), + DEVMETHOD(device_attach, zyd_attach), + DEVMETHOD(device_detach, zyd_detach), + + { 0, 0 } +}; + +static driver_t zyd_driver = { + "zyd", + zyd_methods, + sizeof(struct zyd_softc) +}; + +static devclass_t zyd_devclass; + +DRIVER_MODULE(zyd, uhub, zyd_driver, zyd_devclass, usbd_driver_load, 0); +MODULE_DEPEND(rum, wlan, 1, 1, 1); +MODULE_DEPEND(rum, wlan_amrr, 1, 1, 1); +MODULE_DEPEND(rum, usb, 1, 1, 1); diff -urN orig/sys/dev/usb/if_zydfw.h src/sys/dev/usb/if_zydfw.h --- orig/sys/dev/usb/if_zydfw.h 1970-01-01 09:00:00.000000000 +0900 +++ src/sys/dev/usb/if_zydfw.h 2007-08-05 12:53:38.000000000 +0900 @@ -0,0 +1,1183 @@ +/* + * Copyright (C) 2001, 2002, 2003,2004 ZyDAS Technology Corporation. + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted provided + * that the following conditions are met: + * 1. Redistribution of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistribution in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +uint8_t zd1211_firmware[] = { + 0x08, 0x91, 0xFF, 0xED, 0x09, 0x93, 0x1E, 0xEE, + 0xD1, 0x94, 0x11, 0xEE, 0x88, 0xD4, 0xD1, 0x96, + 0xD1, 0x98, 0x5C, 0x99, 0x5C, 0x99, 0x4C, 0x99, + 0x04, 0x9D, 0xD1, 0x98, 0xD1, 0x9A, 0x03, 0xEE, + 0xF4, 0x94, 0xD3, 0xD4, 0x41, 0x2A, 0x40, 0x4A, + 0x45, 0xBE, 0x88, 0x92, 0x41, 0x24, 0x40, 0x44, + 0x53, 0xBE, 0x40, 0xF0, 0x93, 0xEE, 0x41, 0xEE, + 0x98, 0x9A, 0xD4, 0xF7, 0x02, 0x00, 0x1F, 0xEC, + 0x00, 0x00, 0xB2, 0xF8, 0x4D, 0x00, 0xA1, 0xEC, + 0x00, 0x00, 0xA6, 0xF7, 0x21, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xD8, + 0xA0, 0x90, 0x98, 0x9A, 0x98, 0x9A, 0xA0, 0xD8, + 0x40, 0xF0, 0xB4, 0xF0, 0xA0, 0x90, 0x98, 0x9A, + 0xA0, 0xD8, 0x40, 0xF0, 0x64, 0xEF, 0xA0, 0x90, + 0x98, 0x9A, 0xA0, 0xD8, 0x40, 0xF0, 0xF6, 0xF0, + 0xA0, 0x90, 0x98, 0x9A, 0xA0, 0xD8, 0x40, 0xF0, + 0xF7, 0xF6, 0xA0, 0x90, 0x98, 0x9A, 0xA0, 0xD8, + 0x40, 0xF0, 0xF8, 0xF5, 0xA0, 0x90, 0x98, 0x9A, + 0xA0, 0xD8, 0x40, 0xF0, 0xF1, 0xF0, 0xA0, 0x90, + 0x98, 0x9A, 0x98, 0x9A, 0xA0, 0xD8, 0x40, 0xF0, + 0x97, 0xF7, 0xA0, 0x90, 0x98, 0x9A, 0x88, 0xDA, + 0x08, 0x0B, 0x01, 0x00, 0x0D, 0x03, 0x03, 0x00, + 0x09, 0x05, 0x01, 0x00, 0xC2, 0x94, 0x42, 0x02, + 0xC1, 0x92, 0x03, 0x96, 0x1B, 0xD7, 0x2A, 0x86, + 0x1A, 0xD5, 0x2B, 0x86, 0x09, 0xA3, 0x00, 0x80, + 0x19, 0xD3, 0x2C, 0x86, 0x00, 0xEE, 0x0A, 0x65, + 0xC0, 0x7A, 0x02, 0x97, 0xC3, 0x92, 0x09, 0xB3, + 0xFE, 0xFF, 0xC2, 0xD2, 0x88, 0x98, 0x90, 0x9A, + 0x88, 0xDA, 0x42, 0x20, 0x08, 0x0B, 0x01, 0x00, + 0x0D, 0x03, 0x05, 0x00, 0x05, 0x94, 0xC5, 0xD4, + 0x09, 0x05, 0x01, 0x00, 0xC2, 0x94, 0x01, 0xD4, + 0x42, 0x02, 0xC1, 0x96, 0x0A, 0x65, 0xC0, 0x7A, + 0x02, 0x99, 0xC4, 0x92, 0x41, 0xA2, 0xC4, 0xD2, + 0xC5, 0x98, 0x1C, 0xD9, 0x2A, 0x86, 0x01, 0x98, + 0x1C, 0xD9, 0x2B, 0x86, 0x1B, 0xD7, 0x2C, 0x86, + 0x00, 0xEE, 0x09, 0xB3, 0xFE, 0xFF, 0xC2, 0xD2, + 0x42, 0x00, 0x88, 0x98, 0x90, 0x9A, 0x88, 0xDA, + 0x41, 0x20, 0x08, 0x0B, 0x01, 0x00, 0x40, 0xF0, + 0xE5, 0xEE, 0x11, 0x93, 0xD8, 0xF7, 0x41, 0x42, + 0x02, 0x5E, 0x0F, 0x9F, 0xAE, 0xEE, 0x40, 0xF1, + 0x40, 0x92, 0x19, 0xD3, 0xD8, 0xF7, 0xC5, 0x92, + 0x41, 0x92, 0x19, 0xD3, 0x00, 0x83, 0x40, 0x92, + 0x19, 0xD3, 0x00, 0x83, 0x0F, 0x9F, 0x95, 0xF8, + 0x0F, 0x9F, 0x99, 0xEE, 0x42, 0x42, 0x02, 0x5E, + 0x0F, 0x9F, 0x99, 0xEE, 0x40, 0x92, 0x19, 0xD3, + 0xD8, 0xF7, 0x09, 0x93, 0xC7, 0xF7, 0x19, 0xD3, + 0x91, 0xEC, 0x40, 0xF0, 0x5F, 0xF2, 0x09, 0x63, + 0x00, 0x80, 0x19, 0xD3, 0xF2, 0xBD, 0x0F, 0x9F, + 0x99, 0xEE, 0x41, 0x00, 0x88, 0x98, 0x90, 0x9A, + 0x88, 0xDA, 0x08, 0x0B, 0x01, 0x00, 0x40, 0x92, + 0x19, 0xD3, 0x12, 0x95, 0x19, 0xD3, 0x10, 0x95, + 0x19, 0xD3, 0x02, 0x80, 0x19, 0xD3, 0x03, 0x82, + 0x09, 0x93, 0xC7, 0xF7, 0x19, 0xD3, 0x91, 0xEC, + 0x40, 0xF0, 0x5F, 0xF2, 0x40, 0xF0, 0xDE, 0xF3, + 0x11, 0x93, 0x04, 0xEC, 0x42, 0x42, 0x02, 0x5E, + 0x0F, 0x9F, 0xE3, 0xEE, 0x40, 0x92, 0x19, 0xD3, + 0x04, 0xEC, 0x40, 0xF0, 0x38, 0xF2, 0x88, 0x98, + 0x90, 0x9A, 0x88, 0xDA, 0x08, 0x0B, 0x01, 0x00, + 0x11, 0x93, 0x44, 0x96, 0x09, 0xB3, 0xFF, 0xFD, + 0x19, 0xD3, 0x44, 0x96, 0x40, 0xF0, 0x90, 0xF7, + 0x6E, 0x92, 0x19, 0xD3, 0x05, 0x84, 0x40, 0xF0, + 0xC4, 0xEE, 0x4B, 0x62, 0x0A, 0x95, 0x2E, 0xEE, + 0xD1, 0xD4, 0x0B, 0x97, 0x2B, 0xEE, 0xD1, 0xD6, + 0x0A, 0x95, 0x00, 0xEE, 0xD1, 0xD4, 0x0B, 0x97, + 0x2F, 0xEE, 0xD1, 0xD6, 0x0A, 0x95, 0x34, 0xEE, + 0xD1, 0xD4, 0x0B, 0x97, 0x39, 0xEE, 0xD1, 0xD6, + 0x0A, 0x95, 0x3E, 0xEE, 0xD1, 0xD4, 0x0B, 0x97, + 0x43, 0xEE, 0xD1, 0xD6, 0x0A, 0x95, 0x48, 0xEE, + 0xD1, 0xD4, 0x0B, 0x97, 0x4D, 0xEE, 0xD1, 0xD6, + 0x0A, 0x95, 0x4E, 0xEE, 0xC1, 0xD4, 0x0A, 0x65, + 0x00, 0x44, 0x02, 0x97, 0xC3, 0x92, 0x44, 0xA2, + 0xC2, 0xD2, 0x43, 0xF1, 0x09, 0x93, 0x01, 0x3F, + 0x19, 0xD3, 0xC0, 0x85, 0x11, 0x93, 0x44, 0x96, + 0x09, 0xB3, 0xFF, 0xFC, 0x19, 0xD3, 0x44, 0x96, + 0x88, 0x98, 0x90, 0x9A, 0x88, 0xDA, 0x08, 0x0B, + 0x01, 0x00, 0x0D, 0x03, 0x03, 0x00, 0x03, 0x96, + 0x41, 0x02, 0x03, 0x99, 0xC4, 0x94, 0x42, 0x04, + 0xC1, 0x04, 0xC2, 0x94, 0xC3, 0xD4, 0x88, 0x98, + 0x90, 0x9A, 0x88, 0xDA, 0x08, 0x0B, 0x01, 0x00, + 0x40, 0x92, 0x19, 0xD3, 0x94, 0xEC, 0x13, 0x97, + 0x95, 0xEC, 0x1B, 0xD7, 0x02, 0x80, 0x11, 0x93, + 0x99, 0xEC, 0x19, 0xD3, 0x7C, 0x96, 0x0B, 0x97, + 0xA0, 0x00, 0x1B, 0xD7, 0x6E, 0xEC, 0x0A, 0x65, + 0x0E, 0x42, 0x02, 0x97, 0xC3, 0x92, 0x09, 0xB3, + 0xFF, 0xBF, 0x11, 0xA3, 0x9A, 0xEC, 0xC2, 0xD2, + 0x0A, 0x65, 0xEB, 0x43, 0x02, 0x97, 0xC3, 0x92, + 0x09, 0xA3, 0xC0, 0x00, 0xC2, 0xD2, 0x0A, 0x65, + 0xE9, 0x43, 0x02, 0x97, 0xC3, 0x92, 0x09, 0xB3, + 0xBF, 0xFF, 0xC2, 0xD2, 0x88, 0x98, 0x90, 0x9A, + 0x88, 0xDA, 0x47, 0x20, 0x08, 0x0B, 0x01, 0x00, + 0x14, 0x99, 0x03, 0x80, 0x0C, 0xB3, 0x00, 0x10, + 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, 0x97, 0xF0, + 0x11, 0x93, 0x9F, 0xEC, 0x41, 0x02, 0x19, 0xD3, + 0x9F, 0xEC, 0x11, 0x93, 0xD6, 0xF7, 0x40, 0x42, + 0x02, 0x4E, 0x0F, 0x9F, 0x84, 0xEF, 0x0A, 0x65, + 0xFE, 0x7F, 0x02, 0x97, 0xC3, 0x92, 0x09, 0xA3, + 0x00, 0x04, 0xC2, 0xD2, 0x0F, 0x9F, 0xB1, 0xF0, + 0x11, 0x93, 0x94, 0xEC, 0x02, 0xD2, 0x40, 0x42, + 0x02, 0x5E, 0x0F, 0x9F, 0xD0, 0xEF, 0x41, 0x92, + 0x19, 0xD3, 0x94, 0xEC, 0x19, 0xD3, 0x9F, 0xEC, + 0x12, 0x95, 0x02, 0x80, 0x1A, 0xD5, 0x95, 0xEC, + 0x13, 0x97, 0x7C, 0x96, 0x1B, 0xD7, 0x99, 0xEC, + 0x0A, 0x65, 0x0E, 0x42, 0x02, 0x97, 0xC3, 0x92, + 0x09, 0xB3, 0x00, 0x40, 0x19, 0xD3, 0x9A, 0xEC, + 0x09, 0x63, 0x00, 0x40, 0xC2, 0xD2, 0x02, 0x94, + 0x1A, 0xD5, 0x7C, 0x96, 0x0C, 0xB3, 0x00, 0x08, + 0x40, 0x42, 0x02, 0x5E, 0x0F, 0x9F, 0xB0, 0xEF, + 0x0C, 0xB3, 0xFF, 0x07, 0x0F, 0x9F, 0xB4, 0xEF, + 0x11, 0x93, 0x06, 0x80, 0x09, 0xB3, 0xFF, 0x07, + 0x09, 0x03, 0x00, 0xA0, 0x19, 0xD3, 0x97, 0xEC, + 0x40, 0x98, 0x0B, 0x97, 0x9C, 0xEC, 0x04, 0x95, + 0x03, 0x05, 0x14, 0x03, 0x97, 0xEC, 0x46, 0x02, + 0xC1, 0x92, 0xC2, 0xD2, 0x41, 0x08, 0x42, 0x48, + 0x02, 0x9E, 0x0F, 0x9F, 0xBB, 0xEF, 0x11, 0x93, + 0x97, 0xEC, 0xC1, 0x92, 0xC5, 0xD2, 0x5F, 0xB2, + 0x19, 0xD3, 0x9B, 0xEC, 0x0F, 0x9F, 0xD3, 0xEF, + 0x13, 0x97, 0x98, 0xEC, 0xC5, 0xD6, 0x11, 0x93, + 0x03, 0x80, 0x09, 0xB3, 0x00, 0x08, 0x40, 0x42, + 0x02, 0x4E, 0x0F, 0x9F, 0xE9, 0xEF, 0x11, 0x93, + 0xDC, 0xF7, 0x41, 0x02, 0x19, 0xD3, 0xDC, 0xF7, + 0x11, 0x93, 0xDB, 0xF7, 0x09, 0xA3, 0x00, 0x10, + 0x19, 0xD3, 0xDB, 0xF7, 0x40, 0x98, 0x1C, 0xD9, + 0x9B, 0xEC, 0x12, 0x95, 0x9B, 0xEC, 0x40, 0x44, + 0x02, 0x4E, 0x0F, 0x9F, 0x86, 0xF0, 0x0A, 0xB3, + 0x08, 0x00, 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, + 0x07, 0xF0, 0x0A, 0xB3, 0x07, 0x00, 0x09, 0x05, + 0xA9, 0xEC, 0xC2, 0x94, 0x01, 0xD4, 0x09, 0x03, + 0xA1, 0xEC, 0xC1, 0x92, 0x19, 0xD3, 0x9B, 0xEC, + 0xC5, 0x94, 0x0A, 0xB5, 0x00, 0xFF, 0x01, 0xA5, + 0xC5, 0xD4, 0x0F, 0x9F, 0x13, 0xF0, 0x0A, 0x05, + 0xFF, 0xFF, 0x0A, 0x03, 0xB1, 0xEC, 0xC1, 0x92, + 0x01, 0xD2, 0x1A, 0xD5, 0x9B, 0xEC, 0xC5, 0x96, + 0x0B, 0x07, 0xFF, 0xFF, 0xC5, 0xD6, 0x11, 0x93, + 0x97, 0xEC, 0xC5, 0x98, 0xC1, 0xD8, 0x11, 0x93, + 0x97, 0xEC, 0x09, 0x05, 0x0B, 0x00, 0x03, 0xD4, + 0xC2, 0x96, 0x06, 0xD6, 0x7B, 0x95, 0x7A, 0x95, + 0x4C, 0x02, 0xC1, 0x92, 0x59, 0x93, 0x59, 0x93, + 0x01, 0xA5, 0x01, 0x98, 0x0C, 0xF5, 0x7B, 0x93, + 0x09, 0x09, 0x01, 0x00, 0x06, 0x92, 0x09, 0xB3, + 0xFF, 0x00, 0x04, 0xD2, 0x5C, 0x93, 0x59, 0x93, + 0x04, 0x94, 0x01, 0xA5, 0x03, 0x96, 0xC3, 0xD4, + 0x11, 0x93, 0x97, 0xEC, 0x4C, 0x02, 0x05, 0xD2, + 0xC1, 0x92, 0x09, 0xB3, 0x00, 0xFF, 0x7C, 0x95, + 0x7A, 0x95, 0x02, 0xA3, 0x05, 0x98, 0xC4, 0xD2, + 0x12, 0x95, 0x97, 0xEC, 0x45, 0x04, 0x02, 0x97, + 0xC3, 0x92, 0x09, 0xA3, 0x00, 0x01, 0xC2, 0xD2, + 0x12, 0x95, 0x9B, 0xEC, 0x0A, 0xB3, 0x08, 0x00, + 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, 0x5B, 0xF0, + 0x12, 0x95, 0x97, 0xEC, 0x4A, 0x04, 0x02, 0x99, + 0xC4, 0x92, 0x01, 0x98, 0x0C, 0xF3, 0x7B, 0x93, + 0x41, 0x02, 0x0F, 0x9F, 0x7C, 0xF0, 0x43, 0x44, + 0x02, 0x8E, 0x0F, 0x9F, 0x7D, 0xF0, 0x11, 0x93, + 0x97, 0xEC, 0x42, 0x02, 0x0A, 0x05, 0xFF, 0xFF, + 0xC1, 0xD4, 0x11, 0x93, 0x97, 0xEC, 0x4A, 0x02, + 0x12, 0x95, 0x60, 0x96, 0xC1, 0xD4, 0x12, 0x95, + 0x97, 0xEC, 0x4B, 0x04, 0x02, 0x97, 0xC3, 0x92, + 0x09, 0xB3, 0x1F, 0xFF, 0xC2, 0xD2, 0x12, 0x95, + 0x97, 0xEC, 0x4B, 0x04, 0x11, 0x93, 0x62, 0x96, + 0x41, 0x93, 0x59, 0x93, 0x02, 0x99, 0xC4, 0xA2, + 0xC2, 0xD2, 0xC5, 0x92, 0x19, 0xD3, 0x98, 0xEC, + 0x0A, 0x95, 0x0C, 0x02, 0x1A, 0xD5, 0x02, 0x80, + 0x0F, 0x9F, 0xB1, 0xF0, 0x09, 0x63, 0xFE, 0x7F, + 0x01, 0x97, 0xC3, 0x94, 0x0A, 0xA5, 0x00, 0x04, + 0xC1, 0xD4, 0x11, 0x93, 0x9F, 0xEC, 0x09, 0xA3, + 0x00, 0x01, 0x19, 0xD3, 0x9F, 0xEC, 0x40, 0xF0, + 0x39, 0xEF, 0x0F, 0x9F, 0xB1, 0xF0, 0x11, 0x93, + 0x94, 0xEC, 0x41, 0x42, 0x02, 0x5E, 0x0F, 0x9F, + 0xA6, 0xF0, 0x40, 0xF0, 0x39, 0xEF, 0x11, 0x93, + 0x95, 0xEC, 0x44, 0xB2, 0x40, 0x42, 0x02, 0x4E, + 0x0F, 0x9F, 0xB1, 0xF0, 0x48, 0x98, 0x1C, 0xD9, + 0x02, 0x80, 0x11, 0x93, 0x91, 0xEC, 0x41, 0x22, + 0x0A, 0x95, 0xB1, 0xF0, 0x88, 0xD4, 0x88, 0xDC, + 0x91, 0x9A, 0x47, 0x00, 0x88, 0x98, 0x90, 0x9A, + 0x88, 0xDA, 0x08, 0x0B, 0x01, 0x00, 0x11, 0x93, + 0x04, 0x82, 0x48, 0xB2, 0x40, 0x42, 0x02, 0x4E, + 0x0F, 0x9F, 0xC8, 0xF0, 0x0A, 0x65, 0xFD, 0x7D, + 0x02, 0x97, 0xC3, 0x92, 0x09, 0xB3, 0xFF, 0xFE, + 0xC2, 0xD2, 0x41, 0x92, 0x19, 0xD3, 0xBF, 0xEC, + 0x11, 0x93, 0x04, 0x82, 0x43, 0xB2, 0x12, 0x95, + 0x03, 0x82, 0x02, 0xB3, 0x40, 0x42, 0x02, 0x4E, + 0x0F, 0x9F, 0xEF, 0xF0, 0x0A, 0xB3, 0x00, 0xFF, + 0x48, 0xA2, 0x19, 0xD3, 0x03, 0x82, 0x40, 0xF0, + 0xEB, 0xF3, 0x11, 0x93, 0xBF, 0xEC, 0x41, 0x42, + 0x02, 0x5E, 0x0F, 0x9F, 0xEF, 0xF0, 0x11, 0x93, + 0x07, 0x82, 0x11, 0x43, 0x03, 0xEC, 0x02, 0x0E, + 0x0F, 0x9F, 0xEF, 0xF0, 0x11, 0x93, 0x03, 0x82, + 0x09, 0xA3, 0x00, 0x01, 0x19, 0xD3, 0x03, 0x82, + 0x40, 0x96, 0x1B, 0xD7, 0xBF, 0xEC, 0x88, 0x98, + 0x90, 0x9A, 0x88, 0xDA, 0x08, 0x0B, 0x01, 0x00, + 0x88, 0x98, 0x90, 0x9A, 0x88, 0xDA, 0x08, 0x0B, + 0x01, 0x00, 0x11, 0x93, 0x20, 0xBC, 0xC8, 0xD2, + 0x40, 0xF0, 0x48, 0xF1, 0x41, 0x00, 0x88, 0x98, + 0x90, 0x9A, 0x88, 0xDA, 0x42, 0x20, 0x08, 0x0B, + 0x01, 0x00, 0x0D, 0x03, 0x05, 0x00, 0x05, 0x94, + 0x41, 0x02, 0xC1, 0x92, 0x01, 0x97, 0xC3, 0x96, + 0xC2, 0xD6, 0x0A, 0x45, 0x00, 0x95, 0x02, 0x5E, + 0x0F, 0x9F, 0x45, 0xF1, 0xC1, 0x92, 0x41, 0xB2, + 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, 0x45, 0xF1, + 0x11, 0x93, 0xC0, 0xEC, 0x40, 0x42, 0x02, 0x5E, + 0x0F, 0x9F, 0x45, 0xF1, 0x41, 0x98, 0x1C, 0xD9, + 0xC0, 0xEC, 0x12, 0x95, 0x02, 0x80, 0x01, 0xD4, + 0x40, 0xF0, 0x56, 0xF2, 0x0B, 0x67, 0xFD, 0x7D, + 0x03, 0x99, 0xC4, 0x92, 0x0C, 0x99, 0x96, 0x03, + 0x1C, 0xD9, 0x06, 0x82, 0x41, 0x98, 0x1C, 0xD9, + 0x02, 0x82, 0x42, 0x98, 0x1C, 0xD9, 0x05, 0x82, + 0x0C, 0x69, 0x80, 0x7F, 0x1C, 0xD9, 0x00, 0xB0, + 0x09, 0xA3, 0x00, 0x01, 0xC3, 0xD2, 0x01, 0x94, + 0x0A, 0xB3, 0x04, 0x00, 0x40, 0x42, 0x02, 0x4E, + 0x0F, 0x9F, 0x43, 0xF1, 0x42, 0xA4, 0x1A, 0xD5, + 0x02, 0x80, 0x42, 0x00, 0x88, 0x98, 0x90, 0x9A, + 0x88, 0xDA, 0x42, 0x20, 0x08, 0x0B, 0x01, 0x00, + 0x05, 0x92, 0xC5, 0xD2, 0x60, 0xB2, 0x40, 0x42, + 0x02, 0x4E, 0x0F, 0x9F, 0x55, 0xF1, 0x40, 0xF0, + 0x35, 0xF7, 0xC5, 0x94, 0x0A, 0xB3, 0x10, 0x00, + 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, 0x5E, 0xF1, + 0x40, 0xF0, 0x23, 0xF6, 0xC5, 0x96, 0x0B, 0xB3, + 0x40, 0x00, 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, + 0x67, 0xF1, 0x40, 0xF0, 0x5D, 0xF5, 0xC5, 0x94, + 0x0A, 0xB3, 0x01, 0x00, 0x40, 0x42, 0x02, 0x4E, + 0x0F, 0x9F, 0xC8, 0xF1, 0x13, 0x97, 0x21, 0xBC, + 0x01, 0xD6, 0x0B, 0xB3, 0x02, 0x00, 0x40, 0x42, + 0x02, 0x4E, 0x0F, 0x9F, 0x79, 0xF1, 0x40, 0xF0, + 0x62, 0xFB, 0x01, 0x94, 0x0A, 0xB3, 0x04, 0x00, + 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, 0x82, 0xF1, + 0x40, 0xF0, 0x6C, 0xFB, 0x01, 0x96, 0x0B, 0xB3, + 0x01, 0x00, 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, + 0xA2, 0xF1, 0x40, 0xF0, 0xB0, 0xFA, 0x41, 0x92, + 0x19, 0xD3, 0xD5, 0xF7, 0x11, 0x93, 0x03, 0xEC, + 0x09, 0x43, 0x40, 0x00, 0x02, 0x5E, 0x0F, 0x9F, + 0x98, 0xF1, 0x40, 0x94, 0x1A, 0xD5, 0xD5, 0xF7, + 0x11, 0x93, 0x00, 0xEC, 0x40, 0x42, 0x02, 0x4E, + 0x0F, 0x9F, 0xAB, 0xF1, 0x40, 0xF0, 0x38, 0xF2, + 0x0F, 0x9F, 0xAB, 0xF1, 0x01, 0x96, 0x0B, 0xB3, + 0x08, 0x00, 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, + 0xAB, 0xF1, 0x40, 0xF0, 0x7C, 0xFB, 0x01, 0x94, + 0x0A, 0xB3, 0x10, 0x00, 0x40, 0x42, 0x02, 0x4E, + 0x0F, 0x9F, 0xB4, 0xF1, 0x40, 0xF0, 0x87, 0xFB, + 0x11, 0x93, 0x10, 0xEC, 0x42, 0x42, 0x02, 0x5E, + 0x0F, 0x9F, 0xBF, 0xF1, 0x44, 0x96, 0x1B, 0xD7, + 0x0B, 0xBC, 0x0F, 0x9F, 0xC5, 0xF1, 0x41, 0x42, + 0x02, 0x5E, 0x0F, 0x9F, 0xC5, 0xF1, 0x19, 0xD3, + 0x0B, 0xBC, 0x40, 0x92, 0x19, 0xD3, 0x10, 0xEC, + 0xC5, 0x94, 0x0A, 0xB3, 0x80, 0x00, 0x40, 0x42, + 0x02, 0x4E, 0x0F, 0x9F, 0x12, 0xF2, 0x13, 0x97, + 0x28, 0xBC, 0x01, 0xD6, 0x0B, 0xB3, 0x40, 0x00, + 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, 0xDA, 0xF1, + 0x40, 0xF0, 0x18, 0xF7, 0x01, 0x94, 0x0A, 0xB3, + 0x02, 0x00, 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, + 0xED, 0xF1, 0x40, 0xF0, 0xC4, 0xEE, 0x40, 0xF0, + 0x8F, 0xFB, 0x40, 0xF0, 0x1B, 0xF2, 0x40, 0x96, + 0x1B, 0xD7, 0x00, 0xEC, 0x41, 0x92, 0x19, 0xD3, + 0xD8, 0xF7, 0x01, 0x94, 0x0A, 0xB3, 0x04, 0x00, + 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, 0x09, 0xF2, + 0x40, 0xF0, 0x9E, 0xFB, 0x09, 0x63, 0x00, 0x44, + 0x01, 0x97, 0xC3, 0x94, 0x48, 0xA4, 0xC1, 0xD4, + 0x00, 0xEE, 0x40, 0x92, 0x19, 0xD3, 0x12, 0x95, + 0x19, 0xD3, 0x10, 0x95, 0x19, 0xD3, 0x02, 0x80, + 0x19, 0xD3, 0x03, 0x82, 0x41, 0x92, 0x19, 0xD3, + 0xD8, 0xF7, 0x01, 0x94, 0x0A, 0xB3, 0x08, 0x00, + 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, 0x12, 0xF2, + 0x40, 0xF0, 0xAE, 0xFB, 0x0A, 0x65, 0x00, 0x44, + 0x02, 0x97, 0xC3, 0x92, 0x44, 0xA2, 0xC2, 0xD2, + 0x42, 0x00, 0x88, 0x98, 0x90, 0x9A, 0x88, 0xDA, + 0x08, 0x0B, 0x01, 0x00, 0x09, 0x63, 0x00, 0x40, + 0x19, 0xD3, 0xF2, 0xBD, 0x0A, 0x65, 0xEA, 0x43, + 0x02, 0x97, 0xC3, 0x92, 0x44, 0xA2, 0xC2, 0xD2, + 0x0A, 0x65, 0xE9, 0x43, 0x02, 0x97, 0xC3, 0x92, + 0x09, 0xA3, 0x40, 0x00, 0xC2, 0xD2, 0x0A, 0x65, + 0xEB, 0x43, 0x02, 0x97, 0xC3, 0x92, 0x09, 0xA3, + 0xC0, 0x00, 0xC2, 0xD2, 0x88, 0x98, 0x90, 0x9A, + 0x88, 0xDA, 0x08, 0x0B, 0x01, 0x00, 0x09, 0x63, + 0x00, 0x80, 0x19, 0xD3, 0xF2, 0xBD, 0x0A, 0x65, + 0xE8, 0x43, 0x02, 0x97, 0xC3, 0x92, 0x09, 0xA3, + 0xC0, 0x00, 0xC2, 0xD2, 0x0A, 0x65, 0xEB, 0x43, + 0x02, 0x97, 0xC3, 0x92, 0x09, 0xB3, 0xBF, 0xFF, + 0xC2, 0xD2, 0x0A, 0x65, 0xEA, 0x43, 0x02, 0x97, + 0xC3, 0x92, 0x09, 0xB3, 0xFB, 0xFF, 0xC2, 0xD2, + 0x88, 0x98, 0x90, 0x9A, 0x88, 0xDA, 0x08, 0x0B, + 0x01, 0x00, 0x09, 0x93, 0x00, 0x01, 0x19, 0xD3, + 0x02, 0x80, 0x88, 0x98, 0x90, 0x9A, 0x88, 0xDA, + 0x08, 0x0B, 0x01, 0x00, 0x09, 0x93, 0x00, 0x09, + 0x19, 0xD3, 0x02, 0x80, 0x40, 0xF0, 0x56, 0xF2, + 0x40, 0x92, 0x19, 0xD3, 0x94, 0xEC, 0xC8, 0xD2, + 0x09, 0x93, 0x91, 0xEC, 0xC8, 0xD2, 0x40, 0xF0, + 0x2A, 0xEF, 0x42, 0x00, 0x88, 0x98, 0x90, 0x9A, + 0x88, 0xDA, 0x08, 0x0B, 0x01, 0x00, 0x40, 0xF0, + 0x3B, 0xF5, 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, + 0x85, 0xF2, 0x0A, 0x65, 0xFE, 0x7F, 0x02, 0x97, + 0xC3, 0x92, 0x44, 0xA2, 0xC2, 0xD2, 0x0F, 0x9F, + 0x92, 0xF2, 0x40, 0xF0, 0x94, 0xF2, 0x40, 0x42, + 0x02, 0x5E, 0x0F, 0x9F, 0x92, 0xF2, 0xC8, 0xD2, + 0x09, 0x93, 0x91, 0xEC, 0xC8, 0xD2, 0x40, 0xF0, + 0x2A, 0xEF, 0x42, 0x00, 0x88, 0x98, 0x90, 0x9A, + 0x88, 0xDA, 0x08, 0x0B, 0x01, 0x00, 0x11, 0x93, + 0xF1, 0xBD, 0x19, 0xD3, 0xB6, 0xEC, 0x11, 0x93, + 0xB4, 0xEC, 0x40, 0x42, 0x02, 0x5E, 0x0F, 0x9F, + 0xAC, 0xF2, 0x09, 0x63, 0x00, 0x80, 0x01, 0x97, + 0xC3, 0x94, 0x0A, 0x07, 0x07, 0x00, 0xC1, 0xD6, + 0x0A, 0x05, 0x00, 0xA0, 0x1A, 0xD5, 0x96, 0xEC, + 0x11, 0x93, 0xB6, 0xEC, 0x19, 0xD3, 0x01, 0x80, + 0x0A, 0x65, 0xFE, 0x7F, 0x02, 0x97, 0xC3, 0x92, + 0x41, 0xA2, 0xC2, 0xD2, 0x40, 0x92, 0x88, 0x98, + 0x90, 0x9A, 0x88, 0xDA, 0x41, 0x20, 0x08, 0x0B, + 0x01, 0x00, 0x13, 0x97, 0xB4, 0xEC, 0x40, 0x46, + 0x02, 0x5E, 0x0F, 0x9F, 0x2C, 0xF3, 0x12, 0x95, + 0x96, 0xEC, 0x0A, 0x03, 0x07, 0x00, 0xC1, 0x92, + 0xC2, 0xD2, 0x11, 0x93, 0x96, 0xEC, 0x09, 0x05, + 0x01, 0x00, 0x48, 0x02, 0xC1, 0x92, 0xC2, 0xD2, + 0x11, 0x93, 0x96, 0xEC, 0x4E, 0x02, 0xC1, 0x94, + 0xC5, 0xD6, 0xC5, 0x92, 0x11, 0x07, 0x96, 0xEC, + 0x0B, 0x03, 0x0F, 0x00, 0xC1, 0x98, 0x46, 0x06, + 0x7A, 0x93, 0x79, 0x93, 0x5C, 0x95, 0x5A, 0x95, + 0x02, 0xA3, 0xC3, 0xD2, 0x04, 0x95, 0xC5, 0x96, + 0x41, 0x06, 0xC5, 0xD6, 0x42, 0x46, 0x02, 0x9E, + 0x0F, 0x9F, 0xD5, 0xF2, 0x11, 0x93, 0x96, 0xEC, + 0x09, 0x05, 0x05, 0x00, 0x41, 0x02, 0xC1, 0x92, + 0xC2, 0xD2, 0x11, 0x93, 0x96, 0xEC, 0xC1, 0x92, + 0x09, 0xB5, 0x1F, 0x00, 0x43, 0x44, 0x02, 0x8E, + 0x0F, 0x9F, 0x02, 0xF3, 0x40, 0x44, 0x02, 0x4E, + 0x0F, 0x9F, 0x03, 0xF3, 0x0A, 0x05, 0xFF, 0xFF, + 0x0F, 0x9F, 0x03, 0xF3, 0x43, 0x94, 0x11, 0x93, + 0x96, 0xEC, 0x42, 0x02, 0xC1, 0xD4, 0x11, 0x93, + 0x96, 0xEC, 0x49, 0x02, 0xC1, 0x92, 0x19, 0xD3, + 0xB4, 0xEC, 0x09, 0x05, 0xF2, 0xFF, 0x1A, 0xD5, + 0x92, 0xEC, 0x09, 0x43, 0xD0, 0x07, 0x02, 0x9E, + 0x0F, 0x9F, 0x2C, 0xF3, 0x11, 0x93, 0xDC, 0xF7, + 0x41, 0x02, 0x19, 0xD3, 0xDC, 0xF7, 0x11, 0x93, + 0xDB, 0xF7, 0x09, 0xA3, 0x40, 0x00, 0x19, 0xD3, + 0xDB, 0xF7, 0x09, 0x63, 0x00, 0x80, 0x01, 0x95, + 0xC2, 0x94, 0x1A, 0xD5, 0xB5, 0xEC, 0x40, 0x96, + 0x1B, 0xD7, 0xB4, 0xEC, 0x0F, 0x9F, 0x92, 0xF3, + 0x11, 0x93, 0x92, 0xEC, 0x12, 0x95, 0xB6, 0xEC, + 0x02, 0x43, 0x02, 0x8E, 0x0F, 0x9F, 0x7A, 0xF3, + 0x02, 0x0E, 0x0F, 0x9F, 0x4D, 0xF3, 0x11, 0x93, + 0xDC, 0xF7, 0x41, 0x02, 0x19, 0xD3, 0xDC, 0xF7, + 0x11, 0x93, 0xDB, 0xF7, 0x09, 0xA3, 0x80, 0x00, + 0x19, 0xD3, 0xDB, 0xF7, 0x09, 0x63, 0x00, 0x80, + 0x01, 0x95, 0xC2, 0x94, 0x1A, 0xD5, 0xB5, 0xEC, + 0x40, 0x96, 0x1B, 0xD7, 0xB4, 0xEC, 0x0F, 0x9F, + 0x92, 0xF3, 0x11, 0x93, 0x03, 0x80, 0x09, 0xB3, + 0x00, 0x40, 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, + 0x5F, 0xF3, 0x11, 0x93, 0xC0, 0xEC, 0x40, 0x42, + 0x02, 0x5E, 0x0F, 0x9F, 0x5F, 0xF3, 0x40, 0xF0, + 0xA6, 0xF3, 0x0F, 0x9F, 0x94, 0xF3, 0x41, 0x92, + 0xC8, 0xD2, 0x0A, 0x95, 0x91, 0xEC, 0xC8, 0xD4, + 0x40, 0xF0, 0x2A, 0xEF, 0x42, 0x00, 0x11, 0x93, + 0xC0, 0xEC, 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, + 0x72, 0xF3, 0x42, 0x96, 0x1B, 0xD7, 0xC0, 0xEC, + 0x0F, 0x9F, 0x94, 0xF3, 0x0A, 0x65, 0xFE, 0x7F, + 0x02, 0x97, 0xC3, 0x92, 0x42, 0xA2, 0xC2, 0xD2, + 0x0F, 0x9F, 0x94, 0xF3, 0x12, 0x45, 0x03, 0xEC, + 0x02, 0x4E, 0x0F, 0x9F, 0x8C, 0xF3, 0x11, 0x93, + 0xDC, 0xF7, 0x41, 0x02, 0x19, 0xD3, 0xDC, 0xF7, + 0x11, 0x93, 0xDB, 0xF7, 0x09, 0xA3, 0x00, 0x08, + 0x19, 0xD3, 0xDB, 0xF7, 0x1A, 0xD5, 0x92, 0xEC, + 0x11, 0x93, 0x92, 0xEC, 0x19, 0x25, 0x92, 0xEC, + 0x09, 0x63, 0x00, 0x80, 0x19, 0xD3, 0xF2, 0xBD, + 0x41, 0x00, 0x88, 0x98, 0x90, 0x9A, 0x88, 0xDA, + 0x08, 0x0B, 0x01, 0x00, 0x40, 0xF0, 0xA6, 0xF3, + 0x40, 0x92, 0xC8, 0xD2, 0x09, 0x93, 0x91, 0xEC, + 0xC8, 0xD2, 0x40, 0xF0, 0x2A, 0xEF, 0x42, 0x00, + 0x88, 0x98, 0x90, 0x9A, 0x88, 0xDA, 0x08, 0x0B, + 0x01, 0x00, 0x11, 0x93, 0xD7, 0xF7, 0x40, 0x42, + 0x02, 0x4E, 0x0F, 0x9F, 0xB6, 0xF3, 0x0A, 0x65, + 0xBC, 0x69, 0x02, 0x97, 0xC3, 0x92, 0x09, 0x83, + 0x00, 0x02, 0xC2, 0xD2, 0x11, 0x93, 0x03, 0x80, + 0x09, 0xB3, 0x00, 0x40, 0x40, 0x42, 0x02, 0x5E, + 0x0F, 0x9F, 0xC9, 0xF3, 0x11, 0x93, 0xDC, 0xF7, + 0x41, 0x02, 0x19, 0xD3, 0xDC, 0xF7, 0x11, 0x93, + 0xDB, 0xF7, 0x09, 0xA3, 0x00, 0x20, 0x19, 0xD3, + 0xDB, 0xF7, 0x11, 0x93, 0xB5, 0xEC, 0x19, 0xD3, + 0x04, 0x80, 0x12, 0x95, 0xB4, 0xEC, 0x1A, 0xD5, + 0x05, 0x80, 0x09, 0x63, 0x00, 0x80, 0x01, 0x97, + 0xC3, 0x96, 0x1B, 0xD7, 0xB5, 0xEC, 0x40, 0x94, + 0x1A, 0xD5, 0xB4, 0xEC, 0x19, 0xD3, 0xF2, 0xBD, + 0x88, 0x98, 0x90, 0x9A, 0x88, 0xDA, 0x08, 0x0B, + 0x01, 0x00, 0x09, 0x93, 0x96, 0x03, 0x19, 0xD3, + 0x06, 0x82, 0x09, 0x93, 0x00, 0x01, 0x19, 0xD3, + 0x03, 0x82, 0x88, 0x98, 0x90, 0x9A, 0x88, 0xDA, + 0x47, 0x20, 0x08, 0x0B, 0x01, 0x00, 0x11, 0x93, + 0x01, 0x82, 0xC5, 0xD2, 0x40, 0x94, 0x01, 0xD4, + 0x13, 0x97, 0xB8, 0xEC, 0x02, 0xD6, 0x03, 0x95, + 0x0C, 0x99, 0xBB, 0xEC, 0x04, 0x05, 0x13, 0x97, + 0x03, 0xEC, 0x01, 0x27, 0x02, 0x99, 0xC4, 0x92, + 0x03, 0x03, 0xC2, 0xD2, 0x14, 0x99, 0xBA, 0xEC, + 0x03, 0x09, 0x1C, 0xD9, 0xBA, 0xEC, 0x12, 0x95, + 0x04, 0x82, 0x0A, 0xB3, 0x02, 0x00, 0x40, 0x42, + 0x02, 0x4E, 0x0F, 0x9F, 0x29, 0xF5, 0x01, 0x92, + 0x03, 0xD2, 0x0A, 0xA3, 0x02, 0x00, 0x19, 0xD3, + 0x04, 0x82, 0x02, 0x96, 0x0B, 0x05, 0x01, 0x00, + 0x1A, 0xD5, 0xB8, 0xEC, 0xC5, 0x92, 0x43, 0x42, + 0x02, 0x9E, 0x0F, 0x9F, 0x37, 0xF4, 0x42, 0x44, + 0x02, 0x8E, 0x0F, 0x9F, 0x37, 0xF4, 0x11, 0x93, + 0xBF, 0xEC, 0x40, 0x42, 0x02, 0x5E, 0x0F, 0x9F, + 0x37, 0xF4, 0x0C, 0x49, 0xD3, 0x08, 0x02, 0x8E, + 0x0F, 0x9F, 0x37, 0xF4, 0x11, 0x63, 0x07, 0x82, + 0x11, 0xA3, 0x07, 0x82, 0x71, 0x93, 0x79, 0x93, + 0x79, 0x93, 0x79, 0x93, 0x03, 0xD2, 0xC5, 0x94, + 0x0A, 0xB5, 0xFC, 0xFF, 0x04, 0xD4, 0x03, 0x96, + 0x40, 0x46, 0x02, 0x5E, 0x0F, 0x9F, 0x46, 0xF4, + 0x11, 0x93, 0xB8, 0xEC, 0x41, 0x42, 0x02, 0x8E, + 0x0F, 0x9F, 0x4D, 0xF4, 0xC5, 0x98, 0x0C, 0x03, + 0xFF, 0xFF, 0x42, 0x42, 0x02, 0x8E, 0x0F, 0x9F, + 0x74, 0xF4, 0x0A, 0x95, 0xBB, 0xEC, 0x42, 0x92, + 0x19, 0xD3, 0xB9, 0xEC, 0xC5, 0x96, 0x43, 0x46, + 0x02, 0x9E, 0x0F, 0x9F, 0x66, 0xF4, 0x0B, 0x07, + 0xFC, 0xFF, 0xC5, 0xD6, 0xD2, 0x98, 0x1C, 0xD9, + 0xC8, 0xBC, 0xD2, 0x96, 0x1B, 0xD7, 0xCA, 0xBC, + 0x09, 0x03, 0xFF, 0xFF, 0x40, 0x42, 0x02, 0x5E, + 0x0F, 0x9F, 0x52, 0xF4, 0x19, 0xD3, 0xB9, 0xEC, + 0x40, 0x42, 0x02, 0x5E, 0x0F, 0x9F, 0x72, 0xF4, + 0x0A, 0x05, 0xFE, 0xFF, 0xCA, 0xD2, 0xC2, 0xD2, + 0x0F, 0x9F, 0x74, 0xF4, 0x1A, 0xD5, 0x93, 0xEC, + 0x03, 0x98, 0x40, 0x48, 0x02, 0x5E, 0x0F, 0x9F, + 0xA1, 0xF4, 0x11, 0x93, 0xB8, 0xEC, 0x41, 0x42, + 0x02, 0x9E, 0x0F, 0x9F, 0x84, 0xF4, 0x04, 0x94, + 0x48, 0x44, 0x02, 0x4E, 0x0F, 0x9F, 0x8F, 0xF4, + 0x41, 0x42, 0x02, 0x5E, 0x0F, 0x9F, 0xA1, 0xF4, + 0x11, 0x93, 0x04, 0x82, 0x41, 0xB2, 0x40, 0x42, + 0x02, 0x4E, 0x0F, 0x9F, 0xA1, 0xF4, 0x41, 0x96, + 0x01, 0xD6, 0x0A, 0x65, 0xBD, 0x43, 0x02, 0x99, + 0xC4, 0x92, 0x09, 0xA3, 0x80, 0x00, 0xC2, 0xD2, + 0x0A, 0x65, 0xE8, 0x43, 0x02, 0x97, 0xC3, 0x92, + 0x09, 0xB3, 0xBF, 0xFF, 0xC2, 0xD2, 0x0F, 0x9F, + 0xFA, 0xF4, 0xC5, 0x98, 0x43, 0x48, 0x02, 0x9E, + 0x0F, 0x9F, 0xFA, 0xF4, 0x4F, 0x96, 0x0C, 0xB3, + 0x01, 0x00, 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, + 0xAE, 0xF4, 0x47, 0x96, 0x11, 0x93, 0xB7, 0xEC, + 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, 0xD6, 0xF4, + 0x11, 0x93, 0xB8, 0xEC, 0x41, 0x42, 0x02, 0x5E, + 0x0F, 0x9F, 0xD6, 0xF4, 0x12, 0x95, 0x00, 0x82, + 0x0A, 0x05, 0xFF, 0xAF, 0x05, 0xD4, 0xC8, 0xD6, + 0xC8, 0xD2, 0x40, 0xF0, 0x7B, 0xF7, 0x42, 0x00, + 0x05, 0x96, 0xC3, 0x94, 0x01, 0xB5, 0x40, 0x44, + 0x02, 0x4E, 0x0F, 0x9F, 0xD6, 0xF4, 0x06, 0x98, + 0x50, 0x98, 0x1C, 0xD9, 0xA2, 0xBC, 0x40, 0x98, + 0x1C, 0xD9, 0xA2, 0xBC, 0x40, 0x92, 0x03, 0xD2, + 0x0F, 0x9F, 0xFF, 0xF4, 0x03, 0x94, 0x40, 0x44, + 0x02, 0x5E, 0x0F, 0x9F, 0xE3, 0xF4, 0x0A, 0x65, + 0x5E, 0x43, 0x02, 0x97, 0xC3, 0x92, 0x48, 0xA2, + 0xC2, 0xD2, 0x0F, 0x9F, 0xFF, 0xF4, 0x11, 0x93, + 0xB8, 0xEC, 0x0C, 0x99, 0xBB, 0xEC, 0x04, 0x03, + 0x04, 0x96, 0x13, 0x25, 0x03, 0xEC, 0xC1, 0xD4, + 0x11, 0x93, 0xBA, 0xEC, 0x19, 0x05, 0xBA, 0xEC, + 0x1B, 0xD7, 0x01, 0x82, 0x0A, 0x65, 0xFD, 0x7D, + 0x02, 0x99, 0xC4, 0x92, 0x43, 0xA2, 0xC2, 0xD2, + 0x41, 0x92, 0x01, 0xD2, 0x03, 0x94, 0x40, 0x44, + 0x02, 0x5E, 0x0F, 0x9F, 0x13, 0xF5, 0x11, 0x93, + 0xB9, 0xEC, 0x40, 0x42, 0x02, 0x5E, 0x0F, 0x9F, + 0x0B, 0xF5, 0x19, 0xD3, 0xB8, 0xEC, 0x19, 0xD3, + 0xBA, 0xEC, 0x19, 0xD3, 0xBB, 0xEC, 0x03, 0x96, + 0x40, 0x46, 0x02, 0x5E, 0x0F, 0x9F, 0x13, 0xF5, + 0x41, 0x98, 0x1C, 0xD9, 0xB7, 0xEC, 0x11, 0x93, + 0xBF, 0xEC, 0x41, 0x42, 0x02, 0x5E, 0x0F, 0x9F, + 0x24, 0xF5, 0x11, 0x93, 0x00, 0x82, 0x19, 0xD3, + 0x02, 0x82, 0x0A, 0x65, 0xFD, 0x7D, 0x02, 0x97, + 0xC3, 0x92, 0x09, 0xA3, 0x00, 0x01, 0xC2, 0xD2, + 0x40, 0x98, 0x1C, 0xD9, 0xBF, 0xEC, 0x0F, 0x9F, + 0x2C, 0xF5, 0x01, 0x92, 0x19, 0xD3, 0xB7, 0xEC, + 0x01, 0x94, 0x40, 0x44, 0x02, 0x5E, 0x0F, 0x9F, + 0x38, 0xF5, 0x0A, 0x65, 0xEA, 0x43, 0x02, 0x97, + 0xC3, 0x92, 0x09, 0xB3, 0xFB, 0xFF, 0xC2, 0xD2, + 0x47, 0x00, 0x88, 0x98, 0x90, 0x9A, 0x88, 0xDA, + 0x08, 0x0B, 0x01, 0x00, 0x12, 0x95, 0x03, 0x80, + 0x0A, 0xB3, 0x00, 0x40, 0x40, 0x42, 0x02, 0x4E, + 0x0F, 0x9F, 0x57, 0xF5, 0x0A, 0xB7, 0x00, 0x08, + 0x40, 0x46, 0x02, 0x5E, 0x0F, 0x9F, 0x5A, 0xF5, + 0x11, 0x93, 0x03, 0xEC, 0x41, 0x02, 0x09, 0xB3, + 0xFE, 0xFF, 0x12, 0x95, 0x07, 0x80, 0x01, 0x45, + 0x02, 0x8E, 0x0F, 0x9F, 0x5A, 0xF5, 0x41, 0x92, + 0x0F, 0x9F, 0x5B, 0xF5, 0x40, 0x92, 0x88, 0x98, + 0x90, 0x9A, 0x88, 0xDA, 0x41, 0x20, 0x08, 0x0B, + 0x01, 0x00, 0x0A, 0x65, 0xE9, 0x43, 0x02, 0x97, + 0xC3, 0x92, 0x09, 0xA3, 0x40, 0x00, 0xC2, 0xD2, + 0x13, 0x97, 0x6E, 0xEC, 0x0B, 0x47, 0xA0, 0x00, + 0x02, 0x5E, 0x0F, 0x9F, 0x86, 0xF5, 0x09, 0x63, + 0x08, 0x43, 0x0A, 0x65, 0xFF, 0x5F, 0x01, 0x99, + 0xC4, 0xD4, 0x0A, 0x95, 0x9B, 0xEC, 0xD2, 0x96, + 0x1B, 0xD7, 0xFA, 0xBC, 0xD2, 0x96, 0xC4, 0xD6, + 0xD2, 0x98, 0x1C, 0xD9, 0xFA, 0xBC, 0xD2, 0x96, + 0xC1, 0xD6, 0xC2, 0x94, 0x1A, 0xD5, 0xFA, 0xBC, + 0x0F, 0x9F, 0xC4, 0xF5, 0x0C, 0x69, 0xFF, 0x6F, + 0x1C, 0xD9, 0xF8, 0xBC, 0x0B, 0x47, 0x10, 0x95, + 0x02, 0x5E, 0x0F, 0x9F, 0x9E, 0xF5, 0x0A, 0x95, + 0x6F, 0xEC, 0x09, 0x63, 0x06, 0x43, 0x01, 0x99, + 0xC4, 0xD6, 0xD2, 0x96, 0x1B, 0xD7, 0xF8, 0xBC, + 0x0C, 0x69, 0xEE, 0x6A, 0xC1, 0xD8, 0xC2, 0x94, + 0x1A, 0xD5, 0xF8, 0xBC, 0x40, 0x92, 0xC5, 0xD2, + 0x11, 0x43, 0xC1, 0xEC, 0x02, 0x0E, 0x0F, 0x9F, + 0xC1, 0xF5, 0xC5, 0x94, 0x0A, 0x03, 0x71, 0xEC, + 0xC1, 0x94, 0x1A, 0xD5, 0xFA, 0xBC, 0x11, 0x93, + 0xC0, 0xEC, 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, + 0xB3, 0xF5, 0x0A, 0x95, 0x6F, 0xEC, 0xC8, 0xD4, + 0x40, 0xF0, 0x9C, 0xF7, 0x19, 0xD3, 0xF8, 0xBC, + 0x41, 0x00, 0xC5, 0x96, 0x41, 0x06, 0xC5, 0xD6, + 0x13, 0x47, 0xC1, 0xEC, 0x02, 0x1E, 0x0F, 0x9F, + 0xA5, 0xF5, 0x40, 0x98, 0x1C, 0xD9, 0xFA, 0xBC, + 0x40, 0x92, 0x19, 0xD3, 0x6E, 0xEC, 0x19, 0xD3, + 0xC1, 0xEC, 0x0A, 0x65, 0x52, 0x43, 0x02, 0x97, + 0xC3, 0x92, 0x48, 0xA2, 0xC2, 0xD2, 0x0A, 0x65, + 0xEB, 0x43, 0x02, 0x99, 0xC4, 0x92, 0x09, 0xB3, + 0xBF, 0xFF, 0xC2, 0xD2, 0x41, 0x00, 0x88, 0x98, + 0x90, 0x9A, 0x88, 0xDA, 0x43, 0x20, 0x08, 0x0B, + 0x01, 0x00, 0x06, 0x92, 0x01, 0xD2, 0x0A, 0x65, + 0xF0, 0x6A, 0x0B, 0x97, 0x6F, 0xEC, 0x02, 0x99, + 0xC4, 0x98, 0xD3, 0xD8, 0x02, 0xD6, 0x0A, 0x03, + 0x02, 0x00, 0x01, 0x97, 0xC3, 0x98, 0x02, 0x96, + 0xC3, 0xD8, 0x01, 0x96, 0xC1, 0xD6, 0x1A, 0xD5, + 0x6E, 0xEC, 0xC5, 0x98, 0x14, 0x99, 0x6F, 0xEC, + 0xC2, 0xD8, 0x43, 0x00, 0x88, 0x98, 0x90, 0x9A, + 0x88, 0xDA, 0x08, 0x0B, 0x01, 0x00, 0x40, 0x92, + 0xC8, 0xD2, 0x40, 0xF0, 0xD9, 0xF5, 0x41, 0x00, + 0x11, 0x93, 0xC0, 0xEC, 0x40, 0x42, 0x02, 0x4E, + 0x0F, 0x9F, 0x13, 0xF6, 0x42, 0x42, 0x02, 0x5E, + 0x0F, 0x9F, 0x10, 0xF6, 0x0A, 0x65, 0xFE, 0x7F, + 0x02, 0x97, 0xC3, 0x92, 0x42, 0xA2, 0xC2, 0xD2, + 0x40, 0x92, 0x19, 0xD3, 0xC0, 0xEC, 0x0A, 0x65, + 0xEB, 0x43, 0x02, 0x97, 0xC3, 0x92, 0x09, 0xA3, + 0xC0, 0x00, 0xC2, 0xD2, 0x0A, 0x65, 0xE9, 0x43, + 0x02, 0x97, 0xC3, 0x92, 0x09, 0xB3, 0xBF, 0xFF, + 0xC2, 0xD2, 0x88, 0x98, 0x90, 0x9A, 0x88, 0xDA, + 0x63, 0x20, 0x08, 0x0B, 0x01, 0x00, 0x11, 0x93, + 0xAF, 0xBC, 0x47, 0xB2, 0x59, 0x95, 0x5A, 0x95, + 0x12, 0xA5, 0xBF, 0xBC, 0x0A, 0xB3, 0x01, 0x00, + 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, 0x35, 0xF6, + 0x41, 0x04, 0x05, 0x93, 0x40, 0x96, 0x20, 0xD6, + 0x62, 0x97, 0x0F, 0x9F, 0x44, 0xF6, 0x14, 0x99, + 0xFC, 0xBC, 0xD1, 0xD8, 0x14, 0x99, 0xFE, 0xBC, + 0xD1, 0xD8, 0x20, 0x98, 0x42, 0x08, 0x20, 0xD8, + 0x20, 0x98, 0x03, 0x49, 0x02, 0x1E, 0x0F, 0x9F, + 0x3B, 0xF6, 0xC5, 0x92, 0x62, 0x42, 0x02, 0x4E, + 0x0F, 0x9F, 0x5D, 0xF6, 0x02, 0x8E, 0x0F, 0x9F, + 0x57, 0xF6, 0x61, 0x42, 0x02, 0x4E, 0x0F, 0x9F, + 0x81, 0xF6, 0x0F, 0x9F, 0xAE, 0xF6, 0x63, 0x42, + 0x02, 0x4E, 0x0F, 0x9F, 0xA4, 0xF6, 0x0F, 0x9F, + 0xAE, 0xF6, 0x0D, 0x03, 0x01, 0x00, 0x0C, 0x99, + 0x71, 0xEC, 0x0B, 0x05, 0xFF, 0xFF, 0x40, 0x96, + 0x0F, 0x9F, 0x6A, 0xF6, 0xD1, 0x96, 0xD4, 0xD6, + 0x20, 0x96, 0x41, 0x06, 0x20, 0xD6, 0x02, 0x47, + 0x02, 0x1E, 0x0F, 0x9F, 0x66, 0xF6, 0x1A, 0xD5, + 0xC1, 0xEC, 0x0A, 0x65, 0xEB, 0x43, 0x02, 0x99, + 0xC4, 0x92, 0x09, 0xA3, 0xC0, 0x00, 0xC2, 0xD2, + 0x0A, 0x65, 0xE9, 0x43, 0x02, 0x97, 0xC3, 0x92, + 0x09, 0xB3, 0xBF, 0xFF, 0xC2, 0xD2, 0x0F, 0x9F, + 0xAE, 0xF6, 0x0A, 0x03, 0xFE, 0xFF, 0x61, 0x95, + 0x40, 0x98, 0x20, 0xD8, 0x02, 0x49, 0x02, 0x0E, + 0x0F, 0x9F, 0xAE, 0xF6, 0x0D, 0x03, 0x01, 0x00, + 0x21, 0xD2, 0x20, 0x92, 0x05, 0x03, 0x42, 0x02, + 0xC8, 0xD2, 0x21, 0x96, 0xC3, 0x92, 0x42, 0x06, + 0x21, 0xD6, 0xC8, 0xD2, 0x22, 0xD4, 0x40, 0xF0, + 0x01, 0xF1, 0x42, 0x00, 0x20, 0x98, 0x42, 0x08, + 0x20, 0xD8, 0x22, 0x94, 0x02, 0x49, 0x02, 0x1E, + 0x0F, 0x9F, 0x8D, 0xF6, 0x0F, 0x9F, 0xAE, 0xF6, + 0x0D, 0x03, 0x03, 0x00, 0xC8, 0xD2, 0x02, 0x92, + 0xC8, 0xD2, 0x01, 0x96, 0xC8, 0xD6, 0x40, 0xF0, + 0xB1, 0xF6, 0x43, 0x00, 0x63, 0x00, 0x88, 0x98, + 0x90, 0x9A, 0x88, 0xDA, 0x45, 0x20, 0x08, 0x0B, + 0x01, 0x00, 0x0D, 0x03, 0x08, 0x00, 0x08, 0x94, + 0xC5, 0xD4, 0x09, 0x05, 0x01, 0x00, 0xC2, 0x94, + 0x03, 0xD4, 0x42, 0x02, 0xC1, 0x92, 0x01, 0xD2, + 0x02, 0x97, 0xC5, 0x94, 0x0A, 0x83, 0xFF, 0xFF, + 0x11, 0xB3, 0x2C, 0x93, 0x09, 0xB3, 0xFB, 0xFF, + 0x19, 0xD3, 0x2C, 0x93, 0x03, 0x92, 0x40, 0x42, + 0x02, 0x4E, 0x0F, 0x9F, 0xE4, 0xF6, 0x01, 0x94, + 0xD2, 0x92, 0x19, 0xD3, 0x2C, 0x93, 0x01, 0xD4, + 0x02, 0x94, 0x12, 0x95, 0x2C, 0x93, 0x44, 0xA4, + 0x1A, 0xD5, 0x2C, 0x93, 0x0A, 0xB5, 0xFB, 0xFF, + 0x1A, 0xD5, 0x2C, 0x93, 0x0B, 0x07, 0xFF, 0xFF, + 0x40, 0x46, 0x02, 0x5E, 0x0F, 0x9F, 0xCF, 0xF6, + 0x09, 0x63, 0xD4, 0x6C, 0x01, 0x95, 0xC2, 0x96, + 0xC5, 0x94, 0x02, 0xA7, 0xC1, 0xD6, 0x03, 0x92, + 0x54, 0x42, 0x02, 0x5E, 0x0F, 0x9F, 0xF4, 0xF6, + 0x0A, 0x83, 0xFF, 0xFF, 0x1B, 0xB3, 0x2C, 0x93, + 0x45, 0x00, 0x88, 0x98, 0x90, 0x9A, 0x88, 0xDA, + 0x08, 0x0B, 0x01, 0x00, 0x09, 0x63, 0x00, 0x40, + 0x19, 0xD3, 0xF2, 0xBD, 0x40, 0xF0, 0x3B, 0xF5, + 0x40, 0x42, 0x02, 0x5E, 0x0F, 0x9F, 0x08, 0xF7, + 0x40, 0xF0, 0x94, 0xF2, 0x0F, 0x9F, 0x16, 0xF7, + 0x40, 0x96, 0xC8, 0xD6, 0x09, 0x93, 0x91, 0xEC, + 0xC8, 0xD2, 0x40, 0xF0, 0x2A, 0xEF, 0x0A, 0x65, + 0xFE, 0x7F, 0x02, 0x97, 0xC3, 0x92, 0x44, 0xA2, + 0xC2, 0xD2, 0x42, 0x00, 0x88, 0x98, 0x90, 0x9A, + 0x88, 0xDA, 0x08, 0x0B, 0x01, 0x00, 0x0A, 0x65, + 0xE8, 0x43, 0x02, 0x97, 0xC3, 0x92, 0x09, 0xA3, + 0x40, 0x00, 0xC2, 0xD2, 0x0A, 0x65, 0xEA, 0x43, + 0x02, 0x97, 0xC3, 0x92, 0x09, 0xB3, 0xFB, 0xFF, + 0xC2, 0xD2, 0x40, 0x92, 0x19, 0xD3, 0x2D, 0xBC, + 0x0A, 0x65, 0xD8, 0x43, 0x02, 0x97, 0xC3, 0x92, + 0x09, 0xB3, 0xBF, 0xFF, 0xC2, 0xD2, 0x88, 0x98, + 0x90, 0x9A, 0x88, 0xDA, 0x08, 0x0B, 0x01, 0x00, + 0x09, 0x63, 0xEA, 0x43, 0x01, 0x97, 0xC3, 0x94, + 0x44, 0xA4, 0xC1, 0xD4, 0x11, 0x93, 0xB9, 0xEC, + 0x40, 0x42, 0x02, 0x4E, 0x0F, 0x9F, 0x6F, 0xF7, + 0x12, 0x95, 0x93, 0xEC, 0x0B, 0x67, 0x36, 0x43, + 0xD2, 0x98, 0x1C, 0xD9, 0xC8, 0xBC, 0xD2, 0x98, + 0x03, 0x93, 0xC1, 0xD8, 0x11, 0x93, 0xB9, 0xEC, + 0x09, 0x03, 0xFF, 0xFF, 0x19, 0xD3, 0xB9, 0xEC, + 0x40, 0x42, 0x02, 0x5E, 0x0F, 0x9F, 0x48, 0xF7, + 0x19, 0xD3, 0xB8, 0xEC, 0x19, 0xD3, 0xBA, 0xEC, + 0x0A, 0x05, 0xFE, 0xFF, 0xCA, 0xD2, 0xCA, 0xD2, + 0xC2, 0xD2, 0x0A, 0x65, 0x5E, 0x43, 0x02, 0x97, + 0xC3, 0x92, 0x48, 0xA2, 0xC2, 0xD2, 0x0A, 0x65, + 0xEA, 0x43, 0x02, 0x99, 0xC4, 0x92, 0x09, 0xB3, + 0xFB, 0xFF, 0x0F, 0x9F, 0x78, 0xF7, 0x11, 0x93, + 0x03, 0xEC, 0x19, 0xD3, 0x01, 0x82, 0x0A, 0x65, + 0xFD, 0x7D, 0x02, 0x97, 0xC3, 0x92, 0x43, 0xA2, + 0xC2, 0xD2, 0x88, 0x98, 0x90, 0x9A, 0x88, 0xDA, + 0x08, 0x0B, 0x01, 0x00, 0x03, 0x92, 0x04, 0x96, + 0x0D, 0x5E, 0x50, 0x46, 0x02, 0x0E, 0x40, 0x92, + 0x09, 0xEE, 0x44, 0x46, 0x04, 0x0E, 0x59, 0x93, + 0x44, 0x26, 0x04, 0x5E, 0x46, 0xEE, 0x41, 0x93, + 0x41, 0x26, 0x43, 0x4E, 0x88, 0x98, 0x90, 0x9A, + 0x88, 0xDA, 0x08, 0x0B, 0x01, 0x00, 0x40, 0xF0, + 0xB1, 0xFE, 0x88, 0x98, 0x90, 0x9A, 0x88, 0xDA, + 0x08, 0x0B, 0x01, 0x00, 0x88, 0x98, 0x90, 0x9A, + 0x88, 0xDA, 0x08, 0x0B, 0x01, 0x00, 0x03, 0x94, + 0x1A, 0xD5, 0xA3, 0xF7, 0x11, 0x93, 0x00, 0x90, + 0x88, 0x98, 0x90, 0x9A, 0x1D, 0x00, 0x1A, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x18, 0x00, 0x19, 0x00, + 0x1A, 0x00, 0x1B, 0x00, 0x16, 0x00, 0x21, 0x00, + 0x12, 0x00, 0x09, 0x00, 0x13, 0x00, 0x19, 0x00, + 0x19, 0x00, 0x19, 0x00, 0x21, 0x00, 0x2D, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x69, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x5F, 0xF2, 0xCD, 0xF7, 0x00, 0x00, 0x74, 0xF2, + 0xCD, 0xF7, 0x00, 0x00, 0xB9, 0xF2, 0xCA, 0xF7, + 0xD1, 0xF7, 0x00, 0x00, 0x97, 0xF3, 0xCD, 0xF7, + 0x05, 0x46, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +uint8_t zd1211b_firmware[] = { + 0x08, 0x91, 0xff, 0xed, 0x09, 0x93, 0x1e, 0xee, 0xd1, 0x94, + 0x11, 0xee, 0x88, 0xd4, 0xd1, 0x96, 0xd1, 0x98, 0x5c, 0x99, + 0x5c, 0x99, 0x4c, 0x99, 0x04, 0x9d, 0xd1, 0x98, 0xd1, 0x9a, + 0x03, 0xee, 0xf4, 0x94, 0xd3, 0xd4, 0x41, 0x2a, 0x40, 0x4a, + 0x45, 0xbe, 0x88, 0x92, 0x41, 0x24, 0x40, 0x44, 0x53, 0xbe, + 0x40, 0xf0, 0x8e, 0xee, 0x41, 0xee, 0x98, 0x9a, 0xc9, 0xf7, + 0x02, 0x00, 0x1f, 0xec, 0x00, 0x00, 0xb2, 0xf8, 0x4d, 0x00, + 0xa1, 0xec, 0x00, 0x00, 0x9b, 0xf7, 0x21, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0xd8, 0xa0, 0x90, + 0x98, 0x9a, 0x98, 0x9a, 0xa0, 0xd8, 0x40, 0xf0, 0xbc, 0xf0, + 0xa0, 0x90, 0x98, 0x9a, 0xa0, 0xd8, 0x40, 0xf0, 0x6c, 0xef, + 0xa0, 0x90, 0x98, 0x9a, 0xa0, 0xd8, 0x40, 0xf0, 0xf9, 0xf0, + 0xa0, 0x90, 0x98, 0x9a, 0xa0, 0xd8, 0x40, 0xf0, 0xec, 0xf6, + 0xa0, 0x90, 0x98, 0x9a, 0xa0, 0xd8, 0x40, 0xf0, 0xed, 0xf5, + 0xa0, 0x90, 0x98, 0x9a, 0x98, 0x9a, 0xa0, 0xd8, 0x40, 0xf0, + 0x8c, 0xf7, 0xa0, 0x90, 0x98, 0x9a, 0x88, 0xda, 0x08, 0x0b, + 0x01, 0x00, 0x0d, 0x03, 0x03, 0x00, 0x09, 0x05, 0x01, 0x00, + 0xc2, 0x94, 0x42, 0x02, 0xc1, 0x92, 0x03, 0x96, 0x1b, 0xd7, + 0x2a, 0x86, 0x1a, 0xd5, 0x2b, 0x86, 0x09, 0xa3, 0x00, 0x80, + 0x19, 0xd3, 0x2c, 0x86, 0x00, 0xee, 0x0a, 0x65, 0xc0, 0x7a, + 0x02, 0x97, 0xc3, 0x92, 0x09, 0xb3, 0xfe, 0xff, 0xc2, 0xd2, + 0x88, 0x98, 0x90, 0x9a, 0x88, 0xda, 0x42, 0x20, 0x08, 0x0b, + 0x01, 0x00, 0x0d, 0x03, 0x05, 0x00, 0x05, 0x94, 0xc5, 0xd4, + 0x09, 0x05, 0x01, 0x00, 0xc2, 0x94, 0x01, 0xd4, 0x42, 0x02, + 0xc1, 0x96, 0x0a, 0x65, 0xc0, 0x7a, 0x02, 0x99, 0xc4, 0x92, + 0x41, 0xa2, 0xc4, 0xd2, 0xc5, 0x98, 0x1c, 0xd9, 0x2a, 0x86, + 0x01, 0x98, 0x1c, 0xd9, 0x2b, 0x86, 0x1b, 0xd7, 0x2c, 0x86, + 0x00, 0xee, 0x09, 0xb3, 0xfe, 0xff, 0xc2, 0xd2, 0x42, 0x00, + 0x88, 0x98, 0x90, 0x9a, 0x88, 0xda, 0x41, 0x20, 0x08, 0x0b, + 0x01, 0x00, 0x40, 0xf0, 0xed, 0xee, 0x11, 0x93, 0xcd, 0xf7, + 0x41, 0x42, 0x02, 0x5e, 0x0f, 0x9f, 0xa9, 0xee, 0x40, 0xf1, + 0x40, 0x92, 0x19, 0xd3, 0xcd, 0xf7, 0xc5, 0x92, 0x41, 0x92, + 0x19, 0xd3, 0x00, 0x83, 0x40, 0x92, 0x19, 0xd3, 0x00, 0x83, + 0x0f, 0x9f, 0x95, 0xf8, 0x0f, 0x9f, 0x94, 0xee, 0x42, 0x42, + 0x02, 0x5e, 0x0f, 0x9f, 0xbc, 0xee, 0x40, 0x92, 0x19, 0xd3, + 0xcd, 0xf7, 0x09, 0x93, 0xbc, 0xf7, 0x19, 0xd3, 0x91, 0xec, + 0x40, 0xf0, 0x5f, 0xf2, 0x09, 0x63, 0x00, 0x80, 0x19, 0xd3, + 0xf2, 0xbd, 0x0f, 0x9f, 0x94, 0xee, 0x43, 0x42, 0x02, 0x5e, + 0x0f, 0x9f, 0x94, 0xee, 0x09, 0x93, 0x0b, 0x01, 0x19, 0xd3, + 0x03, 0x82, 0x40, 0x92, 0x19, 0xd3, 0xcd, 0xf7, 0x0f, 0x9f, + 0x94, 0xee, 0x41, 0x00, 0x88, 0x98, 0x90, 0x9a, 0x88, 0xda, + 0x08, 0x0b, 0x01, 0x00, 0x40, 0x92, 0x19, 0xd3, 0x12, 0x95, + 0x19, 0xd3, 0x10, 0x95, 0x19, 0xd3, 0x02, 0x80, 0x19, 0xd3, + 0x03, 0x82, 0x09, 0x93, 0xbc, 0xf7, 0x19, 0xd3, 0x91, 0xec, + 0x40, 0xf0, 0x5f, 0xf2, 0x40, 0xf0, 0xcd, 0xf3, 0x11, 0x93, + 0x04, 0xec, 0x42, 0x42, 0x02, 0x5e, 0x0f, 0x9f, 0xeb, 0xee, + 0x40, 0x92, 0x19, 0xd3, 0x04, 0xec, 0x40, 0xf0, 0x38, 0xf2, + 0x88, 0x98, 0x90, 0x9a, 0x88, 0xda, 0x08, 0x0b, 0x01, 0x00, + 0x11, 0x93, 0x44, 0x96, 0x09, 0xb3, 0xff, 0xfd, 0x19, 0xd3, + 0x44, 0x96, 0x40, 0xf0, 0x85, 0xf7, 0x6e, 0x92, 0x19, 0xd3, + 0x05, 0x84, 0x40, 0xf0, 0xcc, 0xee, 0x4b, 0x62, 0x0a, 0x95, + 0x2e, 0xee, 0xd1, 0xd4, 0x0b, 0x97, 0x2b, 0xee, 0xd1, 0xd6, + 0x0a, 0x95, 0x00, 0xee, 0xd1, 0xd4, 0x0b, 0x97, 0x2f, 0xee, + 0xd1, 0xd6, 0x0a, 0x95, 0x34, 0xee, 0xd1, 0xd4, 0x0b, 0x97, + 0x39, 0xee, 0xd1, 0xd6, 0x0a, 0x95, 0x3e, 0xee, 0xd1, 0xd4, + 0x0b, 0x97, 0x43, 0xee, 0xd1, 0xd6, 0x0a, 0x95, 0x2e, 0xee, + 0xd1, 0xd4, 0x0b, 0x97, 0x48, 0xee, 0xd1, 0xd6, 0x0a, 0x95, + 0x49, 0xee, 0xc1, 0xd4, 0x0a, 0x65, 0x00, 0x44, 0x02, 0x97, + 0xc3, 0x92, 0x44, 0xa2, 0xc2, 0xd2, 0x43, 0xf1, 0x09, 0x93, + 0x01, 0x3f, 0x19, 0xd3, 0xc0, 0x85, 0x11, 0x93, 0x44, 0x96, + 0x09, 0xb3, 0xff, 0xfc, 0x19, 0xd3, 0x44, 0x96, 0x88, 0x98, + 0x90, 0x9a, 0x88, 0xda, 0x08, 0x0b, 0x01, 0x00, 0x0d, 0x03, + 0x03, 0x00, 0x03, 0x96, 0x41, 0x02, 0x03, 0x99, 0xc4, 0x94, + 0x42, 0x04, 0xc1, 0x04, 0xc2, 0x94, 0xc3, 0xd4, 0x88, 0x98, + 0x90, 0x9a, 0x88, 0xda, 0x08, 0x0b, 0x01, 0x00, 0x40, 0x92, + 0x19, 0xd3, 0x94, 0xec, 0x13, 0x97, 0x95, 0xec, 0x1b, 0xd7, + 0x02, 0x80, 0x11, 0x93, 0x99, 0xec, 0x19, 0xd3, 0x7c, 0x96, + 0x0b, 0x97, 0xa0, 0x00, 0x1b, 0xd7, 0x6e, 0xec, 0x0a, 0x65, + 0x0e, 0x42, 0x02, 0x97, 0xc3, 0x92, 0x09, 0xb3, 0xff, 0xbf, + 0x11, 0xa3, 0x9a, 0xec, 0xc2, 0xd2, 0x0a, 0x65, 0xeb, 0x43, + 0x02, 0x97, 0xc3, 0x92, 0x09, 0xa3, 0xc0, 0x00, 0xc2, 0xd2, + 0x0a, 0x65, 0xe9, 0x43, 0x02, 0x97, 0xc3, 0x92, 0x09, 0xb3, + 0xbf, 0xff, 0xc2, 0xd2, 0x88, 0x98, 0x90, 0x9a, 0x88, 0xda, + 0x47, 0x20, 0x08, 0x0b, 0x01, 0x00, 0x14, 0x99, 0x03, 0x80, + 0x0c, 0xb3, 0x00, 0x10, 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, + 0x9f, 0xf0, 0x11, 0x93, 0x9f, 0xec, 0x41, 0x02, 0x19, 0xd3, + 0x9f, 0xec, 0x11, 0x93, 0xcb, 0xf7, 0x40, 0x42, 0x02, 0x4e, + 0x0f, 0x9f, 0x8c, 0xef, 0x0a, 0x65, 0xfe, 0x7f, 0x02, 0x97, + 0xc3, 0x92, 0x09, 0xa3, 0x00, 0x04, 0xc2, 0xd2, 0x0f, 0x9f, + 0xb9, 0xf0, 0x11, 0x93, 0x94, 0xec, 0x02, 0xd2, 0x40, 0x42, + 0x02, 0x5e, 0x0f, 0x9f, 0xd8, 0xef, 0x41, 0x92, 0x19, 0xd3, + 0x94, 0xec, 0x19, 0xd3, 0x9f, 0xec, 0x12, 0x95, 0x02, 0x80, + 0x1a, 0xd5, 0x95, 0xec, 0x13, 0x97, 0x7c, 0x96, 0x1b, 0xd7, + 0x99, 0xec, 0x0a, 0x65, 0x0e, 0x42, 0x02, 0x97, 0xc3, 0x92, + 0x09, 0xb3, 0x00, 0x40, 0x19, 0xd3, 0x9a, 0xec, 0x09, 0x63, + 0x00, 0x40, 0xc2, 0xd2, 0x02, 0x94, 0x1a, 0xd5, 0x7c, 0x96, + 0x0c, 0xb3, 0x00, 0x08, 0x40, 0x42, 0x02, 0x5e, 0x0f, 0x9f, + 0xb8, 0xef, 0x0c, 0xb3, 0xff, 0x07, 0x0f, 0x9f, 0xbc, 0xef, + 0x11, 0x93, 0x06, 0x80, 0x09, 0xb3, 0xff, 0x07, 0x09, 0x03, + 0x00, 0xa0, 0x19, 0xd3, 0x97, 0xec, 0x40, 0x98, 0x0b, 0x97, + 0x9c, 0xec, 0x04, 0x95, 0x03, 0x05, 0x14, 0x03, 0x97, 0xec, + 0x46, 0x02, 0xc1, 0x92, 0xc2, 0xd2, 0x41, 0x08, 0x42, 0x48, + 0x02, 0x9e, 0x0f, 0x9f, 0xc3, 0xef, 0x11, 0x93, 0x97, 0xec, + 0xc1, 0x92, 0xc5, 0xd2, 0x5f, 0xb2, 0x19, 0xd3, 0x9b, 0xec, + 0x0f, 0x9f, 0xdb, 0xef, 0x13, 0x97, 0x98, 0xec, 0xc5, 0xd6, + 0x11, 0x93, 0x03, 0x80, 0x09, 0xb3, 0x00, 0x08, 0x40, 0x42, + 0x02, 0x4e, 0x0f, 0x9f, 0xf1, 0xef, 0x11, 0x93, 0xd1, 0xf7, + 0x41, 0x02, 0x19, 0xd3, 0xd1, 0xf7, 0x11, 0x93, 0xd0, 0xf7, + 0x09, 0xa3, 0x00, 0x10, 0x19, 0xd3, 0xd0, 0xf7, 0x40, 0x98, + 0x1c, 0xd9, 0x9b, 0xec, 0x12, 0x95, 0x9b, 0xec, 0x40, 0x44, + 0x02, 0x4e, 0x0f, 0x9f, 0x8e, 0xf0, 0x0a, 0xb3, 0x08, 0x00, + 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, 0x0f, 0xf0, 0x0a, 0xb3, + 0x07, 0x00, 0x09, 0x05, 0xa9, 0xec, 0xc2, 0x94, 0x01, 0xd4, + 0x09, 0x03, 0xa1, 0xec, 0xc1, 0x92, 0x19, 0xd3, 0x9b, 0xec, + 0xc5, 0x94, 0x0a, 0xb5, 0x00, 0xff, 0x01, 0xa5, 0xc5, 0xd4, + 0x0f, 0x9f, 0x1b, 0xf0, 0x0a, 0x05, 0xff, 0xff, 0x0a, 0x03, + 0xb1, 0xec, 0xc1, 0x92, 0x01, 0xd2, 0x1a, 0xd5, 0x9b, 0xec, + 0xc5, 0x96, 0x0b, 0x07, 0xff, 0xff, 0xc5, 0xd6, 0x11, 0x93, + 0x97, 0xec, 0xc5, 0x98, 0xc1, 0xd8, 0x11, 0x93, 0x97, 0xec, + 0x09, 0x05, 0x0b, 0x00, 0x03, 0xd4, 0xc2, 0x96, 0x06, 0xd6, + 0x7b, 0x95, 0x7a, 0x95, 0x4c, 0x02, 0xc1, 0x92, 0x59, 0x93, + 0x59, 0x93, 0x01, 0xa5, 0x01, 0x98, 0x0c, 0xf5, 0x7b, 0x93, + 0x09, 0x09, 0x01, 0x00, 0x06, 0x92, 0x09, 0xb3, 0xff, 0x00, + 0x04, 0xd2, 0x5c, 0x93, 0x59, 0x93, 0x04, 0x94, 0x01, 0xa5, + 0x03, 0x96, 0xc3, 0xd4, 0x11, 0x93, 0x97, 0xec, 0x4c, 0x02, + 0x05, 0xd2, 0xc1, 0x92, 0x09, 0xb3, 0x00, 0xff, 0x7c, 0x95, + 0x7a, 0x95, 0x02, 0xa3, 0x05, 0x98, 0xc4, 0xd2, 0x12, 0x95, + 0x97, 0xec, 0x45, 0x04, 0x02, 0x97, 0xc3, 0x92, 0x09, 0xa3, + 0x00, 0x01, 0xc2, 0xd2, 0x12, 0x95, 0x9b, 0xec, 0x0a, 0xb3, + 0x08, 0x00, 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, 0x63, 0xf0, + 0x12, 0x95, 0x97, 0xec, 0x4a, 0x04, 0x02, 0x99, 0xc4, 0x92, + 0x01, 0x98, 0x0c, 0xf3, 0x7b, 0x93, 0x41, 0x02, 0x0f, 0x9f, + 0x84, 0xf0, 0x43, 0x44, 0x02, 0x8e, 0x0f, 0x9f, 0x85, 0xf0, + 0x11, 0x93, 0x97, 0xec, 0x42, 0x02, 0x0a, 0x05, 0xff, 0xff, + 0xc1, 0xd4, 0x11, 0x93, 0x97, 0xec, 0x4a, 0x02, 0x12, 0x95, + 0x60, 0x96, 0xc1, 0xd4, 0x12, 0x95, 0x97, 0xec, 0x4b, 0x04, + 0x02, 0x97, 0xc3, 0x92, 0x09, 0xb3, 0x1f, 0xff, 0xc2, 0xd2, + 0x12, 0x95, 0x97, 0xec, 0x4b, 0x04, 0x11, 0x93, 0x62, 0x96, + 0x41, 0x93, 0x59, 0x93, 0x02, 0x99, 0xc4, 0xa2, 0xc2, 0xd2, + 0xc5, 0x92, 0x19, 0xd3, 0x98, 0xec, 0x0a, 0x95, 0x0c, 0x02, + 0x1a, 0xd5, 0x02, 0x80, 0x0f, 0x9f, 0xb9, 0xf0, 0x09, 0x63, + 0xfe, 0x7f, 0x01, 0x97, 0xc3, 0x94, 0x0a, 0xa5, 0x00, 0x04, + 0xc1, 0xd4, 0x11, 0x93, 0x9f, 0xec, 0x09, 0xa3, 0x00, 0x01, + 0x19, 0xd3, 0x9f, 0xec, 0x40, 0xf0, 0x41, 0xef, 0x0f, 0x9f, + 0xb9, 0xf0, 0x11, 0x93, 0x94, 0xec, 0x41, 0x42, 0x02, 0x5e, + 0x0f, 0x9f, 0xae, 0xf0, 0x40, 0xf0, 0x41, 0xef, 0x11, 0x93, + 0x95, 0xec, 0x44, 0xb2, 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, + 0xb9, 0xf0, 0x48, 0x98, 0x1c, 0xd9, 0x02, 0x80, 0x11, 0x93, + 0x91, 0xec, 0x41, 0x22, 0x0a, 0x95, 0xb9, 0xf0, 0x88, 0xd4, + 0x88, 0xdc, 0x91, 0x9a, 0x47, 0x00, 0x88, 0x98, 0x90, 0x9a, + 0x88, 0xda, 0x08, 0x0b, 0x01, 0x00, 0x11, 0x93, 0x04, 0x82, + 0x48, 0xb2, 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, 0xd0, 0xf0, + 0x0a, 0x65, 0xfd, 0x7d, 0x02, 0x97, 0xc3, 0x92, 0x09, 0xb3, + 0xff, 0xfe, 0xc2, 0xd2, 0x41, 0x92, 0x19, 0xd3, 0xbf, 0xec, + 0x11, 0x93, 0x04, 0x82, 0x43, 0xb2, 0x12, 0x95, 0x03, 0x82, + 0x02, 0xb3, 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, 0xf7, 0xf0, + 0x0a, 0xb3, 0x00, 0xff, 0x48, 0xa2, 0x19, 0xd3, 0x03, 0x82, + 0x40, 0xf0, 0xda, 0xf3, 0x11, 0x93, 0xbf, 0xec, 0x41, 0x42, + 0x02, 0x5e, 0x0f, 0x9f, 0xf7, 0xf0, 0x11, 0x93, 0x07, 0x82, + 0x11, 0x43, 0x03, 0xec, 0x02, 0x0e, 0x0f, 0x9f, 0xf7, 0xf0, + 0x11, 0x93, 0x03, 0x82, 0x09, 0xa3, 0x00, 0x01, 0x19, 0xd3, + 0x03, 0x82, 0x40, 0x96, 0x1b, 0xd7, 0xbf, 0xec, 0x88, 0x98, + 0x90, 0x9a, 0x88, 0xda, 0x08, 0x0b, 0x01, 0x00, 0x11, 0x93, + 0x20, 0xbc, 0xc8, 0xd2, 0x40, 0xf0, 0x4b, 0xf1, 0x41, 0x00, + 0x88, 0x98, 0x90, 0x9a, 0x88, 0xda, 0x42, 0x20, 0x08, 0x0b, + 0x01, 0x00, 0x0d, 0x03, 0x05, 0x00, 0x05, 0x94, 0x41, 0x02, + 0xc1, 0x92, 0x01, 0x97, 0xc3, 0x96, 0xc2, 0xd6, 0x0a, 0x45, + 0x00, 0x95, 0x02, 0x5e, 0x0f, 0x9f, 0x48, 0xf1, 0xc1, 0x92, + 0x41, 0xb2, 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, 0x48, 0xf1, + 0x11, 0x93, 0xc0, 0xec, 0x40, 0x42, 0x02, 0x5e, 0x0f, 0x9f, + 0x48, 0xf1, 0x41, 0x98, 0x1c, 0xd9, 0xc0, 0xec, 0x12, 0x95, + 0x02, 0x80, 0x01, 0xd4, 0x40, 0xf0, 0x56, 0xf2, 0x0b, 0x67, + 0xfd, 0x7d, 0x03, 0x99, 0xc4, 0x92, 0x0c, 0x99, 0x96, 0x03, + 0x1c, 0xd9, 0x06, 0x82, 0x41, 0x98, 0x1c, 0xd9, 0x02, 0x82, + 0x42, 0x98, 0x1c, 0xd9, 0x05, 0x82, 0x0c, 0x69, 0x80, 0x7f, + 0x1c, 0xd9, 0x00, 0xb0, 0x09, 0xa3, 0x00, 0x01, 0xc3, 0xd2, + 0x01, 0x94, 0x0a, 0xb3, 0x04, 0x00, 0x40, 0x42, 0x02, 0x4e, + 0x0f, 0x9f, 0x46, 0xf1, 0x42, 0xa4, 0x1a, 0xd5, 0x02, 0x80, + 0x42, 0x00, 0x88, 0x98, 0x90, 0x9a, 0x88, 0xda, 0x42, 0x20, + 0x08, 0x0b, 0x01, 0x00, 0x05, 0x92, 0xc5, 0xd2, 0x60, 0xb2, + 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, 0x58, 0xf1, 0x40, 0xf0, + 0x2a, 0xf7, 0xc5, 0x94, 0x0a, 0xb3, 0x10, 0x00, 0x40, 0x42, + 0x02, 0x4e, 0x0f, 0x9f, 0x61, 0xf1, 0x40, 0xf0, 0x18, 0xf6, + 0xc5, 0x96, 0x0b, 0xb3, 0x40, 0x00, 0x40, 0x42, 0x02, 0x4e, + 0x0f, 0x9f, 0x6a, 0xf1, 0x40, 0xf0, 0x52, 0xf5, 0xc5, 0x94, + 0x0a, 0xb3, 0x01, 0x00, 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, + 0xcb, 0xf1, 0x13, 0x97, 0x21, 0xbc, 0x01, 0xd6, 0x0b, 0xb3, + 0x02, 0x00, 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, 0x7c, 0xf1, + 0x40, 0xf0, 0x62, 0xfb, 0x01, 0x94, 0x0a, 0xb3, 0x04, 0x00, + 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, 0x85, 0xf1, 0x40, 0xf0, + 0x6c, 0xfb, 0x01, 0x96, 0x0b, 0xb3, 0x01, 0x00, 0x40, 0x42, + 0x02, 0x4e, 0x0f, 0x9f, 0xa5, 0xf1, 0x40, 0xf0, 0xb0, 0xfa, + 0x41, 0x92, 0x19, 0xd3, 0xca, 0xf7, 0x11, 0x93, 0x03, 0xec, + 0x09, 0x43, 0x40, 0x00, 0x02, 0x5e, 0x0f, 0x9f, 0x9b, 0xf1, + 0x40, 0x94, 0x1a, 0xd5, 0xca, 0xf7, 0x11, 0x93, 0x00, 0xec, + 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, 0xae, 0xf1, 0x40, 0xf0, + 0x38, 0xf2, 0x0f, 0x9f, 0xae, 0xf1, 0x01, 0x96, 0x0b, 0xb3, + 0x08, 0x00, 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, 0xae, 0xf1, + 0x40, 0xf0, 0x7c, 0xfb, 0x01, 0x94, 0x0a, 0xb3, 0x10, 0x00, + 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, 0xb7, 0xf1, 0x40, 0xf0, + 0x87, 0xfb, 0x11, 0x93, 0x10, 0xec, 0x42, 0x42, 0x02, 0x5e, + 0x0f, 0x9f, 0xc2, 0xf1, 0x44, 0x96, 0x1b, 0xd7, 0x0b, 0xbc, + 0x0f, 0x9f, 0xc8, 0xf1, 0x41, 0x42, 0x02, 0x5e, 0x0f, 0x9f, + 0xc8, 0xf1, 0x19, 0xd3, 0x0b, 0xbc, 0x40, 0x92, 0x19, 0xd3, + 0x10, 0xec, 0xc5, 0x94, 0x0a, 0xb3, 0x80, 0x00, 0x40, 0x42, + 0x02, 0x4e, 0x0f, 0x9f, 0x12, 0xf2, 0x13, 0x97, 0x28, 0xbc, + 0x01, 0xd6, 0x0b, 0xb3, 0x40, 0x00, 0x40, 0x42, 0x02, 0x4e, + 0x0f, 0x9f, 0xdd, 0xf1, 0x40, 0xf0, 0x0d, 0xf7, 0x01, 0x94, + 0x0a, 0xb3, 0x02, 0x00, 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, + 0xed, 0xf1, 0x40, 0xf0, 0xcc, 0xee, 0x40, 0xf0, 0x8f, 0xfb, + 0x40, 0xf0, 0x1b, 0xf2, 0x40, 0x96, 0x1b, 0xd7, 0x00, 0xec, + 0x01, 0x94, 0x0a, 0xb3, 0x04, 0x00, 0x40, 0x42, 0x02, 0x4e, + 0x0f, 0x9f, 0x09, 0xf2, 0x40, 0xf0, 0x9e, 0xfb, 0x09, 0x63, + 0x00, 0x44, 0x01, 0x97, 0xc3, 0x94, 0x48, 0xa4, 0xc1, 0xd4, + 0x00, 0xee, 0x40, 0x92, 0x19, 0xd3, 0x12, 0x95, 0x19, 0xd3, + 0x10, 0x95, 0x19, 0xd3, 0x02, 0x80, 0x19, 0xd3, 0x03, 0x82, + 0x43, 0x92, 0x19, 0xd3, 0xcd, 0xf7, 0x01, 0x94, 0x0a, 0xb3, + 0x08, 0x00, 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, 0x12, 0xf2, + 0x40, 0xf0, 0xae, 0xfb, 0x0a, 0x65, 0x00, 0x44, 0x02, 0x97, + 0xc3, 0x92, 0x44, 0xa2, 0xc2, 0xd2, 0x42, 0x00, 0x88, 0x98, + 0x90, 0x9a, 0x88, 0xda, 0x08, 0x0b, 0x01, 0x00, 0x09, 0x63, + 0x00, 0x40, 0x19, 0xd3, 0xf2, 0xbd, 0x0a, 0x65, 0xea, 0x43, + 0x02, 0x97, 0xc3, 0x92, 0x44, 0xa2, 0xc2, 0xd2, 0x0a, 0x65, + 0xe9, 0x43, 0x02, 0x97, 0xc3, 0x92, 0x09, 0xa3, 0x40, 0x00, + 0xc2, 0xd2, 0x0a, 0x65, 0xeb, 0x43, 0x02, 0x97, 0xc3, 0x92, + 0x09, 0xa3, 0xc0, 0x00, 0xc2, 0xd2, 0x88, 0x98, 0x90, 0x9a, + 0x88, 0xda, 0x08, 0x0b, 0x01, 0x00, 0x09, 0x63, 0x00, 0x80, + 0x19, 0xd3, 0xf2, 0xbd, 0x0a, 0x65, 0xe8, 0x43, 0x02, 0x97, + 0xc3, 0x92, 0x09, 0xa3, 0xc0, 0x00, 0xc2, 0xd2, 0x0a, 0x65, + 0xeb, 0x43, 0x02, 0x97, 0xc3, 0x92, 0x09, 0xb3, 0xbf, 0xff, + 0xc2, 0xd2, 0x0a, 0x65, 0xea, 0x43, 0x02, 0x97, 0xc3, 0x92, + 0x09, 0xb3, 0xfb, 0xff, 0xc2, 0xd2, 0x88, 0x98, 0x90, 0x9a, + 0x88, 0xda, 0x08, 0x0b, 0x01, 0x00, 0x09, 0x93, 0x00, 0x01, + 0x19, 0xd3, 0x02, 0x80, 0x88, 0x98, 0x90, 0x9a, 0x88, 0xda, + 0x08, 0x0b, 0x01, 0x00, 0x09, 0x93, 0x00, 0x09, 0x19, 0xd3, + 0x02, 0x80, 0x40, 0xf0, 0x56, 0xf2, 0x40, 0x92, 0x19, 0xd3, + 0x94, 0xec, 0xc8, 0xd2, 0x09, 0x93, 0x91, 0xec, 0xc8, 0xd2, + 0x40, 0xf0, 0x32, 0xef, 0x42, 0x00, 0x88, 0x98, 0x90, 0x9a, + 0x88, 0xda, 0x08, 0x0b, 0x01, 0x00, 0x40, 0xf0, 0x30, 0xf5, + 0x40, 0x42, 0x02, 0x4e, 0x0f, 0x9f, 0x85, 0xf2, 0x0a, 0x65, + 0xfe, 0x7f, 0x02, 0x97, 0xc3, 0x92, 0x44, 0xa2, 0xc2, 0xd2, + 0x0f, 0x9f, 0x92, 0xf2, 0x40, 0xf0, 0x94, 0xf2, 0x40, 0x42, + 0x02, 0x5e, 0x0f, 0x9f, 0x92, 0xf2, 0xc8, 0xd2, 0x09, 0x93, + 0x91, 0xec, 0xc8, 0xd2, 0x40, 0xf0, 0x32, 0xef, 0x42, 0x00, + 0x88, 0x98, 0x90, 0x9a, 0x88, 0xda, 0x08, 0x0b, 0x01, 0x00, + 0x11, 0x93, 0xf1, 0xbd, 0x19, 0xd3, 0xb6, 0xec, 0x11, 0x93, + 0xb4, 0xec, 0x40, 0x42, 0x02, 0x5e, 0x0f, 0x9f, 0xac, 0xf2, + 0x09, 0x63, 0x00, 0x80, 0x01, 0x97, 0xc3, 0x94, 0x0a, 0x07, + 0x07, 0x00, 0xc1, 0xd6, 0x0a, 0x05, 0x00, 0xa0, 0x1a, 0xd5, + 0x96, 0xec, 0x11, 0x93, 0xb6, 0xec, 0x19, 0xd3, 0x01, 0x80, + 0x0a, 0x65, 0xfe, 0x7f, 0x02, 0x97, 0xc3, 0x92, 0x41, 0xa2, + 0xc2, 0xd2, 0x40, 0x92, 0x88, 0x98, 0x90, 0x9a, 0x88, 0xda, + 0x41, 0x20, 0x08, 0x0b, 0x01, 0x00, 0x13, 0x97, 0xb4, 0xec, + 0x40, 0x46, 0x02, 0x5e, 0x0f, 0x9f, 0x1b, 0xf3, 0x12, 0x95, + 0x96, 0xec, 0x0a, 0x03, 0x07, 0x00, 0xc1, 0x92, 0xc2, 0xd2, + 0x11, 0x93, 0x96, 0xec, 0x09, 0x05, 0x01, 0x00, 0x48, 0x02, + 0xc1, 0x92, 0xc2, 0xd2, 0x11, 0x93, 0x96, 0xec, 0x4e, 0x02, + 0xc1, 0x94, 0xc5, 0xd6, 0xc5, 0x92, 0x11, 0x07, 0x96, 0xec, + 0x0b, 0x03, 0x0f, 0x00, 0xc1, 0x98, 0x46, 0x06, 0x7a, 0x93, + 0x79, 0x93, 0x5c, 0x95, 0x5a, 0x95, 0x02, 0xa3, 0xc3, 0xd2, + 0x04, 0x95, 0xc5, 0x96, 0x41, 0x06, 0xc5, 0xd6, 0x42, 0x46, + 0x02, 0x9e, 0x0f, 0x9f, 0xd5, 0xf2, 0x11, 0x93, 0x96, 0xec, + 0x09, 0x05, 0x05, 0x00, 0x41, 0x02, 0xc1, 0x92, 0xc2, 0xd2, + 0x11, 0x93, 0x96, 0xec, 0xc1, 0x92, 0x09, 0xb5, 0x1f, 0x00, + 0x43, 0x44, 0x02, 0x8e, 0x0f, 0x9f, 0x02, 0xf3, 0x40, 0x44, + 0x02, 0x4e, 0x0f, 0x9f, 0x03, 0xf3, 0x0a, 0x05, 0xff, 0xff, + 0x0f, 0x9f, 0x03, 0xf3, 0x43, 0x94, 0x11, 0x93, 0x96, 0xec, + 0x42, 0x02, 0xc1, 0xd4, 0x13, 0x97, 0x96, 0xec, 0x03, 0x93, + 0xd1, 0x94, 0x7a, 0x95, 0x7a, 0x95, 0xc1, 0x92, 0x59, 0x93, + 0x59, 0x93, 0x01, 0x05, 0x49, 0x06, 0xc3, 0x92, 0x7f, 0xb2, + 0x01, 0x05, 0x1a, 0xd5, 0xb4, 0xec, 0x0a, 0x05, 0xf2, 0xff, + 0x1a, 0xd5, 0x92, 0xec, 0x11, 0x93, 0x92, 0xec, 0x12, 0x95, + 0xb6, 0xec, 0x02, 0x43, 0x02, 0x8e, 0x0f, 0x9f, 0x69, 0xf3, + 0x02, 0x0e, 0x0f, 0x9f, 0x3c, 0xf3, 0x11, 0x93, 0xd1, 0xf7, + 0x41, 0x02, 0x19, 0xd3, 0xd1, 0xf7, 0x11, 0x93, 0xd0, 0xf7, + 0x09, 0xa3, 0x80, 0x00, 0x19, 0xd3, 0xd0, 0xf7, 0x09, 0x63, + 0x00, 0x80, 0x01, 0x95, 0xc2, 0x94, 0x1a, 0xd5, 0xb5, 0xec, + 0x40, 0x96, 0x1b, 0xd7, 0xb4, 0xec, 0x0f, 0x9f, 0x81, 0xf3, + 0x11, 0x93, 0x03, 0x80, 0x09, 0xb3, 0x00, 0x40, 0x40, 0x42, + 0x02, 0x4e, 0x0f, 0x9f, 0x4e, 0xf3, 0x11, 0x93, 0xc0, 0xec, + 0x40, 0x42, 0x02, 0x5e, 0x0f, 0x9f, 0x4e, 0xf3, 0x40, 0xf0, + 0x95, 0xf3, 0x0f, 0x9f, 0x83, 0xf3, 0x41, 0x92, 0xc8, 0xd2, + 0x0a, 0x95, 0x91, 0xec, 0xc8, 0xd4, 0x40, 0xf0, 0x32, 0xef, + 0x42, 0x00, 0x11, 0x93, 0xc0, 0xec, 0x40, 0x42, 0x02, 0x4e, + 0x0f, 0x9f, 0x61, 0xf3, 0x42, 0x96, 0x1b, 0xd7, 0xc0, 0xec, + 0x0f, 0x9f, 0x83, 0xf3, 0x0a, 0x65, 0xfe, 0x7f, 0x02, 0x97, + 0xc3, 0x92, 0x42, 0xa2, 0xc2, 0xd2, 0x0f, 0x9f, 0x83, 0xf3, + 0x12, 0x45, 0x03, 0xec, 0x02, 0x4e, 0x0f, 0x9f, 0x7b, 0xf3, + 0x11, 0x93, 0xd1, 0xf7, 0x41, 0x02, 0x19, 0xd3, 0xd1, 0xf7, + 0x11, 0x93, 0xd0, 0xf7, 0x09, 0xa3, 0x00, 0x08, 0x19, 0xd3, + 0xd0, 0xf7, 0x1a, 0xd5, 0x92, 0xec, 0x11, 0x93, 0x92, 0xec, + 0x19, 0x25, 0x92, 0xec, 0x09, 0x63, 0x00, 0x80, 0x19, 0xd3, + 0xf2, 0xbd, 0x41, 0x00, 0x88, 0x98, 0x90, 0x9a, 0x88, 0xda, + 0x08, 0x0b, 0x01, 0x00, 0x40, 0xf0,