#include <sys/sysmacros.h>

#include <sys/strsubr.h>

#include <sys/strsun.h>

#include <sys/mac_provider.h>

#include <sys/mac_wifi.h>

#include <sys/net80211.h>

#define USBDRV_MAJOR_VER 2

#define USBDRV_MINOR_VER 0

#include <sys/usb/usba.h>

#include <sys/usb/usba/usba_types.h>

#include "urtw_reg.h"

#include "urtw_var.h"

static void *urtw_soft_state_p = NULL;

#define URTW_TXBUF_SIZE (IEEE80211_MAX_LEN)

#define URTW_RXBUF_SIZE (URTW_TXBUF_SIZE)

static int urtw_attach(dev_info_t *, ddi_attach_cmd_t);

static int urtw_detach(dev_info_t *, ddi_detach_cmd_t);

DDI_DEFINE_STREAM_OPS(urtw_dev_ops, nulldev, nulldev, urtw_attach,

urtw_detach, nodev, NULL, D_MP, NULL, ddi_quiesce_not_needed);

static struct modldrv urtw_modldrv = {

&mod_driverops, /* Type of module. This one is a driver */

"RTL8187L/B driver v1.2", /* short description */

&urtw_dev_ops /* driver specific ops */

};

static struct modlinkage modlinkage = {

MODREV_1,

(void *)&urtw_modldrv,

NULL

};

static int urtw_m_stat(void *, uint_t, uint64_t *);

static int urtw_m_start(void *);

static void urtw_m_stop(void *);

static int urtw_m_promisc(void *, boolean_t);

static int urtw_m_multicst(void *, boolean_t, const uint8_t *);

static int urtw_m_unicst(void *, const uint8_t *);

static mblk_t *urtw_m_tx(void *, mblk_t *);

static void urtw_m_ioctl(void *, queue_t *, mblk_t *);

static int urtw_m_setprop(void *, const char *, mac_prop_id_t,

uint_t, const void *);

static int urtw_m_getprop(void *, const char *, mac_prop_id_t,

uint_t, void *);

static void urtw_m_propinfo(void *, const char *, mac_prop_id_t,

mac_prop_info_handle_t);

static mac_callbacks_t urtw_m_callbacks = {

MC_IOCTL | MC_SETPROP | MC_GETPROP | MC_PROPINFO,

urtw_m_stat,

urtw_m_start,

urtw_m_stop,

urtw_m_promisc,

urtw_m_multicst,

urtw_m_unicst,

urtw_m_tx,

NULL,

urtw_m_ioctl,

NULL,

NULL,

NULL,

urtw_m_setprop,

urtw_m_getprop,

urtw_m_propinfo

};

static int urtw_tx_start(struct urtw_softc *, mblk_t *, int);

static int urtw_rx_start(struct urtw_softc *);

static const struct ieee80211_rateset urtw_rateset_11b =

{ 4, { 2, 4, 11, 22 } };

static const struct ieee80211_rateset urtw_rateset_11g =

{ 12, { 2, 4, 11, 22, 12, 18, 24, 36, 48, 72, 96, 108 } };

#define USB_VENDOR_DICKSMITH 0x1371 /* Dick Smith Electronics */

#define USB_VENDOR_LOGITEC 0x0789 /* Logitec */

#define USB_VENDOR_NETGEAR 0x0846 /* BayNETGEAR */

#define USB_VENDOR_REALTEK 0x0bda /* Realtek */

#define USB_VENDOR_SPHAIRON 0x114b /* Sphairon Access Systems */

#define USB_VENDOR_SURECOM 0x0769 /* Surecom Technology */

#define USB_VENDOR_BELKIN 0x050d /* Belkin Components */

#define USB_VENDOR_SITECOMEU 0x0df6 /* Sitecom Europe */

#define USB_PRODUCT_SPHAIRON_RTL8187 0x0150 /* RTL8187 */

#define USB_PRODUCT_DICKSMITH_RTL8187 0x9401 /* RTL8187 */

#define USB_PRODUCT_LOGITEC_RTL8187 0x010c /* RTL8187 */

#define USB_PRODUCT_REALTEK_RTL8187 0x8187 /* RTL8187 */

#define USB_PRODUCT_NETGEAR_WG111V2 0x6a00 /* WG111v2 */

#define USB_PRODUCT_SURECOM_EP9001G2A 0x11f2 /* EP-9001-G rev 2A */

#define USB_PRODUCT_BELKIN_F5D7050E 0x705e /* F5D705E 54g */

#define USB_PRODUCT_NETGEAR_WG111V3 0x4260 /* WG111v3 */

#define USB_PRODUCT_REALTEK_RTL8187B_0 0x8189 /* RTL8187B */

#define USB_PRODUCT_REALTEK_RTL8187B_1 0x8197 /* RTL8187B */

#define USB_PRODUCT_REALTEK_RTL8187B_2 0x8198 /* RTL8187B */

#define USB_PRODUCT_SITECOMEU_WL168 0x0028 /* WL-168 */

#define USB_PRODUCT_ANY 0xffff

struct usb_devno {

uint16_t v;

uint16_t p;

};

static struct urtw_type {

struct usb_devno dev;

uint8_t rev;

} urtw_devs[] = {

#define URTW_DEV_RTL8187(v, p) \

{ { USB_VENDOR_##v, USB_PRODUCT_##v##_##p }, URTW_HWREV_8187 }

#define URTW_DEV_RTL8187B(v, p) \

{ { USB_VENDOR_##v, USB_PRODUCT_##v##_##p }, URTW_HWREV_8187B }

/* Realtek RTL8187 devices. */

URTW_DEV_RTL8187(DICKSMITH, RTL8187),

URTW_DEV_RTL8187(LOGITEC, RTL8187),

URTW_DEV_RTL8187(NETGEAR, WG111V2),

URTW_DEV_RTL8187(REALTEK, RTL8187),

URTW_DEV_RTL8187(SPHAIRON, RTL8187),

URTW_DEV_RTL8187(SURECOM, EP9001G2A),

/* Realtek RTL8187B devices. */

URTW_DEV_RTL8187B(BELKIN, F5D7050E),

URTW_DEV_RTL8187B(NETGEAR, WG111V3),

URTW_DEV_RTL8187B(REALTEK, RTL8187B_0),

URTW_DEV_RTL8187B(REALTEK, RTL8187B_1),

URTW_DEV_RTL8187B(REALTEK, RTL8187B_2),

URTW_DEV_RTL8187B(SITECOMEU, WL168)

#undef URTW_DEV_RTL8187

#undef URTW_DEV_RTL8187B

};

struct urtw_type *

usb_match_device(struct urtw_type *tbl, uint32_t nentries,

uint16_t vendor, uint16_t product)

{

while (nentries-- > 0) {

uint16_t tproduct = tbl[nentries].dev.p;

if (tbl[nentries].dev.v == vendor &&

(tproduct == product || tproduct == USB_PRODUCT_ANY))

return (&tbl[nentries]);

}

return (NULL);

}

#define usb_lookup(tbl, vendor, product) \

usb_match_device(tbl, sizeof (tbl) / sizeof ((tbl)[0]), \

(vendor), (product))

#define urtw_lookup(v, p) (usb_lookup(urtw_devs, v, p))

struct urtw_pair {

uint32_t reg;

uint32_t val;

};

struct urtw_pair_idx {

uint8_t reg;

uint8_t val;

uint8_t idx;

};

static struct urtw_pair_idx urtw_8187b_regtbl[] = {

{ 0xf0, 0x32, 0 }, { 0xf1, 0x32, 0 }, { 0xf2, 0x00, 0 },

{ 0xf3, 0x00, 0 }, { 0xf4, 0x32, 0 }, { 0xf5, 0x43, 0 },

{ 0xf6, 0x00, 0 }, { 0xf7, 0x00, 0 }, { 0xf8, 0x46, 0 },

{ 0xf9, 0xa4, 0 }, { 0xfa, 0x00, 0 }, { 0xfb, 0x00, 0 },

{ 0xfc, 0x96, 0 }, { 0xfd, 0xa4, 0 }, { 0xfe, 0x00, 0 },

{ 0xff, 0x00, 0 },

{ 0x58, 0x4b, 1 }, { 0x59, 0x00, 1 }, { 0x5a, 0x4b, 1 },

{ 0x5b, 0x00, 1 }, { 0x60, 0x4b, 1 }, { 0x61, 0x09, 1 },

{ 0x62, 0x4b, 1 }, { 0x63, 0x09, 1 }, { 0xce, 0x0f, 1 },

{ 0xcf, 0x00, 1 }, { 0xe0, 0xff, 1 }, { 0xe1, 0x0f, 1 },

{ 0xe2, 0x00, 1 }, { 0xf0, 0x4e, 1 }, { 0xf1, 0x01, 1 },

{ 0xf2, 0x02, 1 }, { 0xf3, 0x03, 1 }, { 0xf4, 0x04, 1 },

{ 0xf5, 0x05, 1 }, { 0xf6, 0x06, 1 }, { 0xf7, 0x07, 1 },

{ 0xf8, 0x08, 1 },

{ 0x4e, 0x00, 2 }, { 0x0c, 0x04, 2 }, { 0x21, 0x61, 2 },

{ 0x22, 0x68, 2 }, { 0x23, 0x6f, 2 }, { 0x24, 0x76, 2 },

{ 0x25, 0x7d, 2 }, { 0x26, 0x84, 2 }, { 0x27, 0x8d, 2 },

{ 0x4d, 0x08, 2 }, { 0x50, 0x05, 2 }, { 0x51, 0xf5, 2 },

{ 0x52, 0x04, 2 }, { 0x53, 0xa0, 2 }, { 0x54, 0x1f, 2 },

{ 0x55, 0x23, 2 }, { 0x56, 0x45, 2 }, { 0x57, 0x67, 2 },

{ 0x58, 0x08, 2 }, { 0x59, 0x08, 2 }, { 0x5a, 0x08, 2 },

{ 0x5b, 0x08, 2 }, { 0x60, 0x08, 2 }, { 0x61, 0x08, 2 },

{ 0x62, 0x08, 2 }, { 0x63, 0x08, 2 }, { 0x64, 0xcf, 2 },

{ 0x72, 0x56, 2 }, { 0x73, 0x9a, 2 },

{ 0x34, 0xf0, 0 }, { 0x35, 0x0f, 0 }, { 0x5b, 0x40, 0 },

{ 0x84, 0x88, 0 }, { 0x85, 0x24, 0 }, { 0x88, 0x54, 0 },

{ 0x8b, 0xb8, 0 }, { 0x8c, 0x07, 0 }, { 0x8d, 0x00, 0 },

{ 0x94, 0x1b, 0 }, { 0x95, 0x12, 0 }, { 0x96, 0x00, 0 },

{ 0x97, 0x06, 0 }, { 0x9d, 0x1a, 0 }, { 0x9f, 0x10, 0 },

{ 0xb4, 0x22, 0 }, { 0xbe, 0x80, 0 }, { 0xdb, 0x00, 0 },

{ 0xee, 0x00, 0 }, { 0x91, 0x03, 0 },

{ 0x4c, 0x00, 2 }, { 0x9f, 0x00, 3 }, { 0x8c, 0x01, 0 },

{ 0x8d, 0x10, 0 }, { 0x8e, 0x08, 0 }, { 0x8f, 0x00, 0 }

};

static uint8_t urtw_8225_agc[] = {

0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9d, 0x9c, 0x9b,

0x9a, 0x99, 0x98, 0x97, 0x96, 0x95, 0x94, 0x93, 0x92, 0x91, 0x90,

0x8f, 0x8e, 0x8d, 0x8c, 0x8b, 0x8a, 0x89, 0x88, 0x87, 0x86, 0x85,

0x84, 0x83, 0x82, 0x81, 0x80, 0x3f, 0x3e, 0x3d, 0x3c, 0x3b, 0x3a,

0x39, 0x38, 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x30, 0x2f,

0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28, 0x27, 0x26, 0x25, 0x24,

0x23, 0x22, 0x21, 0x20, 0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19,

0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0f, 0x0e,

0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03,

0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01

};

static uint8_t urtw_8225v2_agc[] = {

0x5e, 0x5e, 0x5e, 0x5e, 0x5d, 0x5b, 0x59, 0x57,

0x55, 0x53, 0x51, 0x4f, 0x4d, 0x4b, 0x49, 0x47,

0x45, 0x43, 0x41, 0x3f, 0x3d, 0x3b, 0x39, 0x37,

0x35, 0x33, 0x31, 0x2f, 0x2d, 0x2b, 0x29, 0x27,

0x25, 0x23, 0x21, 0x1f, 0x1d, 0x1b, 0x19, 0x17,

0x15, 0x13, 0x11, 0x0f, 0x0d, 0x0b, 0x09, 0x07,

0x05, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,

0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26,

0x26, 0x27, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2a,

0x2a, 0x2b, 0x2b, 0x2b, 0x2c, 0x2c, 0x2c, 0x2d,

0x2d, 0x2d, 0x2d, 0x2e, 0x2e, 0x2e, 0x2e, 0x2f,

0x2f, 0x2f, 0x30, 0x30, 0x31, 0x31, 0x31, 0x31,

0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,

0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31

};

static uint8_t urtw_8225v2_ofdm[] = {

0x10, 0x0d, 0x01, 0x00, 0x14, 0xfb, 0xfb, 0x60,

0x00, 0x60, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00,

0x40, 0x00, 0x40, 0x00, 0x00, 0x00, 0xa8, 0x26,

0x32, 0x33, 0x07, 0xa5, 0x6f, 0x55, 0xc8, 0xb3,

0x0a, 0xe1, 0x2c, 0x8a, 0x86, 0x83, 0x34, 0x0f,

0x4f, 0x24, 0x6f, 0xc2, 0x6b, 0x40, 0x80, 0x00,

0xc0, 0xc1, 0x58, 0xf1, 0x00, 0xe4, 0x90, 0x3e,

0x6d, 0x3c, 0xfb, 0x07

};

static uint32_t urtw_8225_channel[] = {

0x0000, /* dummy channel 0 */

0x085c, /* 1 */

0x08dc, /* 2 */

0x095c, /* 3 */

0x09dc, /* 4 */

0x0a5c, /* 5 */

0x0adc, /* 6 */

0x0b5c, /* 7 */

0x0bdc, /* 8 */

0x0c5c, /* 9 */

0x0cdc, /* 10 */

0x0d5c, /* 11 */

0x0ddc, /* 12 */

0x0e5c, /* 13 */

0x0f72, /* 14 */

};

static uint8_t urtw_8225_gain[] = {

0x23, 0x88, 0x7c, 0xa5, /* -82dbm */

0x23, 0x88, 0x7c, 0xb5, /* -82dbm */

0x23, 0x88, 0x7c, 0xc5, /* -82dbm */

0x33, 0x80, 0x79, 0xc5, /* -78dbm */

0x43, 0x78, 0x76, 0xc5, /* -74dbm */

0x53, 0x60, 0x73, 0xc5, /* -70dbm */

0x63, 0x58, 0x70, 0xc5, /* -66dbm */

};

static struct urtw_pair urtw_8225_rf_part1[] = {

{ 0x00, 0x0067 }, { 0x01, 0x0fe0 }, { 0x02, 0x044d }, { 0x03, 0x0441 },

{ 0x04, 0x0486 }, { 0x05, 0x0bc0 }, { 0x06, 0x0ae6 }, { 0x07, 0x082a },

{ 0x08, 0x001f }, { 0x09, 0x0334 }, { 0x0a, 0x0fd4 }, { 0x0b, 0x0391 },

{ 0x0c, 0x0050 }, { 0x0d, 0x06db }, { 0x0e, 0x0029 }, { 0x0f, 0x0914 },

};

static struct urtw_pair urtw_8225_rf_part2[] = {

{ 0x00, 0x01 }, { 0x01, 0x02 }, { 0x02, 0x42 }, { 0x03, 0x00 },

{ 0x04, 0x00 }, { 0x05, 0x00 }, { 0x06, 0x40 }, { 0x07, 0x00 },

{ 0x08, 0x40 }, { 0x09, 0xfe }, { 0x0a, 0x09 }, { 0x0b, 0x80 },

{ 0x0c, 0x01 }, { 0x0e, 0xd3 }, { 0x0f, 0x38 }, { 0x10, 0x84 },

{ 0x11, 0x06 }, { 0x12, 0x20 }, { 0x13, 0x20 }, { 0x14, 0x00 },

{ 0x15, 0x40 }, { 0x16, 0x00 }, { 0x17, 0x40 }, { 0x18, 0xef },

{ 0x19, 0x19 }, { 0x1a, 0x20 }, { 0x1b, 0x76 }, { 0x1c, 0x04 },

{ 0x1e, 0x95 }, { 0x1f, 0x75 }, { 0x20, 0x1f }, { 0x21, 0x27 },

{ 0x22, 0x16 }, { 0x24, 0x46 }, { 0x25, 0x20 }, { 0x26, 0x90 },

{ 0x27, 0x88 }

};

static struct urtw_pair urtw_8225_rf_part3[] = {

{ 0x00, 0x98 }, { 0x03, 0x20 }, { 0x04, 0x7e }, { 0x05, 0x12 },

{ 0x06, 0xfc }, { 0x07, 0x78 }, { 0x08, 0x2e }, { 0x10, 0x9b },

{ 0x11, 0x88 }, { 0x12, 0x47 }, { 0x13, 0xd0 }, { 0x19, 0x00 },

{ 0x1a, 0xa0 }, { 0x1b, 0x08 }, { 0x40, 0x86 }, { 0x41, 0x8d },

{ 0x42, 0x15 }, { 0x43, 0x18 }, { 0x44, 0x1f }, { 0x45, 0x1e },

{ 0x46, 0x1a }, { 0x47, 0x15 }, { 0x48, 0x10 }, { 0x49, 0x0a },

{ 0x4a, 0x05 }, { 0x4b, 0x02 }, { 0x4c, 0x05 }

};

static uint16_t urtw_8225_rxgain[] = {

0x0400, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0408, 0x0409,

0x040a, 0x040b, 0x0502, 0x0503, 0x0504, 0x0505, 0x0540, 0x0541,

0x0542, 0x0543, 0x0544, 0x0545, 0x0580, 0x0581, 0x0582, 0x0583,

0x0584, 0x0585, 0x0588, 0x0589, 0x058a, 0x058b, 0x0643, 0x0644,

0x0645, 0x0680, 0x0681, 0x0682, 0x0683, 0x0684, 0x0685, 0x0688,

0x0689, 0x068a, 0x068b, 0x068c, 0x0742, 0x0743, 0x0744, 0x0745,

0x0780, 0x0781, 0x0782, 0x0783, 0x0784, 0x0785, 0x0788, 0x0789,

0x078a, 0x078b, 0x078c, 0x078d, 0x0790, 0x0791, 0x0792, 0x0793,

0x0794, 0x0795, 0x0798, 0x0799, 0x079a, 0x079b, 0x079c, 0x079d,

0x07a0, 0x07a1, 0x07a2, 0x07a3, 0x07a4, 0x07a5, 0x07a8, 0x07a9,

0x07aa, 0x07ab, 0x07ac, 0x07ad, 0x07b0, 0x07b1, 0x07b2, 0x07b3,

0x07b4, 0x07b5, 0x07b8, 0x07b9, 0x07ba, 0x07bb, 0x07bb

};

static uint8_t urtw_8225_threshold[] = {

0x8d, 0x8d, 0x8d, 0x8d, 0x9d, 0xad, 0xbd,

};

static uint8_t urtw_8225_tx_gain_cck_ofdm[] = {

0x02, 0x06, 0x0e, 0x1e, 0x3e, 0x7e

};

static uint8_t urtw_8225_txpwr_cck[] = {

0x18, 0x17, 0x15, 0x11, 0x0c, 0x08, 0x04, 0x02,

0x1b, 0x1a, 0x17, 0x13, 0x0e, 0x09, 0x04, 0x02,

0x1f, 0x1e, 0x1a, 0x15, 0x10, 0x0a, 0x05, 0x02,

0x22, 0x21, 0x1d, 0x18, 0x11, 0x0b, 0x06, 0x02,

0x26, 0x25, 0x21, 0x1b, 0x14, 0x0d, 0x06, 0x03,

0x2b, 0x2a, 0x25, 0x1e, 0x16, 0x0e, 0x07, 0x03

};

static uint8_t urtw_8225_txpwr_cck_ch14[] = {

0x18, 0x17, 0x15, 0x0c, 0x00, 0x00, 0x00, 0x00,

0x1b, 0x1a, 0x17, 0x0e, 0x00, 0x00, 0x00, 0x00,

0x1f, 0x1e, 0x1a, 0x0f, 0x00, 0x00, 0x00, 0x00,

0x22, 0x21, 0x1d, 0x11, 0x00, 0x00, 0x00, 0x00,

0x26, 0x25, 0x21, 0x13, 0x00, 0x00, 0x00, 0x00,

0x2b, 0x2a, 0x25, 0x15, 0x00, 0x00, 0x00, 0x00

};

static uint8_t urtw_8225_txpwr_ofdm[] = {

0x80, 0x90, 0xa2, 0xb5, 0xcb, 0xe4

};

static uint8_t urtw_8225v2_gain_bg[] = {

0x23, 0x15, 0xa5, /* -82-1dbm */

0x23, 0x15, 0xb5, /* -82-2dbm */

0x23, 0x15, 0xc5, /* -82-3dbm */

0x33, 0x15, 0xc5, /* -78dbm */

0x43, 0x15, 0xc5, /* -74dbm */

0x53, 0x15, 0xc5, /* -70dbm */

0x63, 0x15, 0xc5, /* -66dbm */

};

static struct urtw_pair urtw_8225v2_rf_part1[] = {

{ 0x00, 0x02bf }, { 0x01, 0x0ee0 }, { 0x02, 0x044d }, { 0x03, 0x0441 },

{ 0x04, 0x08c3 }, { 0x05, 0x0c72 }, { 0x06, 0x00e6 }, { 0x07, 0x082a },

{ 0x08, 0x003f }, { 0x09, 0x0335 }, { 0x0a, 0x09d4 }, { 0x0b, 0x07bb },

{ 0x0c, 0x0850 }, { 0x0d, 0x0cdf }, { 0x0e, 0x002b }, { 0x0f, 0x0114 }

};

static struct urtw_pair urtw_8225v2_rf_part2[] = {

{ 0x00, 0x01 }, { 0x01, 0x02 }, { 0x02, 0x42 }, { 0x03, 0x00 },

{ 0x04, 0x00 }, { 0x05, 0x00 }, { 0x06, 0x40 }, { 0x07, 0x00 },

{ 0x08, 0x40 }, { 0x09, 0xfe }, { 0x0a, 0x08 }, { 0x0b, 0x80 },

{ 0x0c, 0x01 }, { 0x0d, 0x43 }, { 0x0e, 0xd3 }, { 0x0f, 0x38 },

{ 0x10, 0x84 }, { 0x11, 0x07 }, { 0x12, 0x20 }, { 0x13, 0x20 },

{ 0x14, 0x00 }, { 0x15, 0x40 }, { 0x16, 0x00 }, { 0x17, 0x40 },

{ 0x18, 0xef }, { 0x19, 0x19 }, { 0x1a, 0x20 }, { 0x1b, 0x15 },

{ 0x1c, 0x04 }, { 0x1d, 0xc5 }, { 0x1e, 0x95 }, { 0x1f, 0x75 },

{ 0x20, 0x1f }, { 0x21, 0x17 }, { 0x22, 0x16 }, { 0x23, 0x80 },

{ 0x24, 0x46 }, { 0x25, 0x00 }, { 0x26, 0x90 }, { 0x27, 0x88 }

};

static struct urtw_pair urtw_8225v2_rf_part3[] = {

{ 0x00, 0x98 }, { 0x03, 0x20 }, { 0x04, 0x7e }, { 0x05, 0x12 },

{ 0x06, 0xfc }, { 0x07, 0x78 }, { 0x08, 0x2e }, { 0x09, 0x11 },

{ 0x0a, 0x17 }, { 0x0b, 0x11 }, { 0x10, 0x9b }, { 0x11, 0x88 },

{ 0x12, 0x47 }, { 0x13, 0xd0 }, { 0x19, 0x00 }, { 0x1a, 0xa0 },

{ 0x1b, 0x08 }, { 0x1d, 0x00 }, { 0x40, 0x86 }, { 0x41, 0x9d },

{ 0x42, 0x15 }, { 0x43, 0x18 }, { 0x44, 0x36 }, { 0x45, 0x35 },

{ 0x46, 0x2e }, { 0x47, 0x25 }, { 0x48, 0x1c }, { 0x49, 0x12 },

{ 0x4a, 0x09 }, { 0x4b, 0x04 }, { 0x4c, 0x05 }

};

static uint16_t urtw_8225v2_rxgain[] = {

0x0400, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0408, 0x0409,

0x040a, 0x040b, 0x0502, 0x0503, 0x0504, 0x0505, 0x0540, 0x0541,

0x0542, 0x0543, 0x0544, 0x0545, 0x0580, 0x0581, 0x0582, 0x0583,

0x0584, 0x0585, 0x0588, 0x0589, 0x058a, 0x058b, 0x0643, 0x0644,

0x0645, 0x0680, 0x0681, 0x0682, 0x0683, 0x0684, 0x0685, 0x0688,

0x0689, 0x068a, 0x068b, 0x068c, 0x0742, 0x0743, 0x0744, 0x0745,

0x0780, 0x0781, 0x0782, 0x0783, 0x0784, 0x0785, 0x0788, 0x0789,

0x078a, 0x078b, 0x078c, 0x078d, 0x0790, 0x0791, 0x0792, 0x0793,

0x0794, 0x0795, 0x0798, 0x0799, 0x079a, 0x079b, 0x079c, 0x079d,

0x07a0, 0x07a1, 0x07a2, 0x07a3, 0x07a4, 0x07a5, 0x07a8, 0x07a9,

0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03b0, 0x03b1, 0x03b2, 0x03b3,

0x03b4, 0x03b5, 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bb

};

static uint8_t urtw_8225v2_tx_gain_cck_ofdm[] = {

0x00, 0x01, 0x02, 0x03, 0x04, 0x05,

0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,

0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11,

0x12, 0x13, 0x14, 0x15, 0x16, 0x17,

0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,

0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,

};

static uint8_t urtw_8225v2_txpwr_cck[] = {

0x36, 0x35, 0x2e, 0x25, 0x1c, 0x12, 0x09, 0x04,

0x30, 0x2f, 0x29, 0x21, 0x19, 0x10, 0x08, 0x03,

0x2b, 0x2a, 0x25, 0x1e, 0x16, 0x0e, 0x07, 0x03,

0x26, 0x25, 0x21, 0x1b, 0x14, 0x0d, 0x06, 0x03

};

static uint8_t urtw_8225v2_txpwr_cck_ch14[] = {

0x36, 0x35, 0x2e, 0x1b, 0x00, 0x00, 0x00, 0x00,

0x30, 0x2f, 0x29, 0x15, 0x00, 0x00, 0x00, 0x00,

0x30, 0x2f, 0x29, 0x15, 0x00, 0x00, 0x00, 0x00,

0x30, 0x2f, 0x29, 0x15, 0x00, 0x00, 0x00, 0x00

};

static struct urtw_pair urtw_8225v2_b_rf[] = {

{ 0x00, 0x00b7 }, { 0x01, 0x0ee0 }, { 0x02, 0x044d }, { 0x03, 0x0441 },

{ 0x04, 0x08c3 }, { 0x05, 0x0c72 }, { 0x06, 0x00e6 }, { 0x07, 0x082a },

{ 0x08, 0x003f }, { 0x09, 0x0335 }, { 0x0a, 0x09d4 }, { 0x0b, 0x07bb },

{ 0x0c, 0x0850 }, { 0x0d, 0x0cdf }, { 0x0e, 0x002b }, { 0x0f, 0x0114 },

{ 0x00, 0x01b7 }

};

static struct urtw_pair urtw_ratetable[] = {

{ 2, 0 }, { 4, 1 }, { 11, 2 }, { 12, 4 }, { 18, 5 },

{ 22, 3 }, { 24, 6 }, { 36, 7 }, { 48, 8 }, { 72, 9 },

{ 96, 10 }, { 108, 11 }

};

static int urtw_8187_init(void *);

static void urtw_stop(struct urtw_softc *);

static int urtw_set_channel(struct urtw_softc *);

static void

urtw_rxeof(usb_pipe_handle_t, usb_bulk_req_t *);

static int

urtw_newstate(struct ieee80211com *, enum ieee80211_state, int);

static usbd_status

urtw_read8_c(struct urtw_softc *, int, uint8_t *, uint8_t);

static usbd_status

urtw_read16_c(struct urtw_softc *, int, uint16_t *, uint8_t);

static usbd_status

urtw_read32_c(struct urtw_softc *, int, uint32_t *, uint8_t);

static usbd_status

urtw_write8_c(struct urtw_softc *, int, uint8_t, uint8_t);

static usbd_status

urtw_write16_c(struct urtw_softc *, int, uint16_t, uint8_t);

static usbd_status

urtw_write32_c(struct urtw_softc *, int, uint32_t, uint8_t);

static usbd_status urtw_eprom_cs(struct urtw_softc *, int);

static usbd_status urtw_eprom_ck(struct urtw_softc *);

static usbd_status urtw_eprom_sendbits(struct urtw_softc *, int16_t *,

int);

static usbd_status urtw_eprom_read32(struct urtw_softc *, uint32_t,

uint32_t *);

static usbd_status urtw_eprom_readbit(struct urtw_softc *, int16_t *);

static usbd_status urtw_eprom_writebit(struct urtw_softc *, int16_t);

static usbd_status urtw_get_macaddr(struct urtw_softc *);

static usbd_status urtw_get_txpwr(struct urtw_softc *);

static usbd_status urtw_get_rfchip(struct urtw_softc *);

static usbd_status urtw_led_init(struct urtw_softc *);

static usbd_status

urtw_8225_read(struct urtw_softc *, uint8_t, uint32_t *);

static usbd_status urtw_8225_rf_init(struct urtw_rf *);

static usbd_status urtw_8225_rf_set_chan(struct urtw_rf *, int);

static usbd_status urtw_8225_rf_set_sens(struct urtw_rf *);

static usbd_status urtw_8225v2_rf_init(struct urtw_rf *);

static usbd_status urtw_8225v2_rf_set_chan(struct urtw_rf *, int);

static usbd_status urtw_open_pipes(struct urtw_softc *);

static void urtw_close_pipes(struct urtw_softc *);

static void urtw_led_launch(void *);

static void urtw_8187b_update_wmm(struct urtw_softc *);

static usbd_status urtw_8187b_reset(struct urtw_softc *);

static int urtw_8187b_init(void *);

static void urtw_8225v2_b_config_mac(struct urtw_softc *);

static void urtw_8225v2_b_init_rfe(struct urtw_softc *);

static usbd_status urtw_8225v2_b_update_chan(struct urtw_softc *);

static usbd_status urtw_8225v2_b_rf_init(struct urtw_rf *);

static usbd_status urtw_8225v2_b_rf_set_chan(struct urtw_rf *, int);

static void urtw_8225v2_b_set_txpwrlvl(struct urtw_softc *, int);

#ifdef DEBUG

#define URTW_DEBUG_XMIT 0x00000001

#define URTW_DEBUG_RECV 0x00000002

#define URTW_DEBUG_LED 0x00000004

#define URTW_DEBUG_GLD 0x00000008

#define URTW_DEBUG_RF 0x00000010

#define URTW_DEBUG_ATTACH 0x00000020

#define URTW_DEBUG_ACTIVE 0x00000040

#define URTW_DEBUG_HWTYPE 0x00000080

#define URTW_DEBUG_DEVREQ 0x00000100

#define URTW_DEBUG_HOTPLUG 0x00000200

#define URTW_DEBUG_STATE 0x00000400

#define URTW_DEBUG_TX_PROC 0x00000800

#define URTW_DEBUG_RX_PROC 0x00001000

#define URTW_DEBUG_EEPROM 0x00002000

#define URTW_DEBUG_RESET 0x00004000

#define URTW_DEBUG_ANY 0xffffffff

uint32_t urtw8187_dbg_flags = 0;

static void

urtw8187_dbg(dev_info_t *dip, int level, const char *fmt, ...)

{

char msg_buffer[255];

va_list ap;

if (dip == NULL) {

return;

}

va_start(ap, fmt);

(void) vsprintf(msg_buffer, fmt, ap);

cmn_err(level, "%s%d: %s", ddi_get_name(dip),

ddi_get_instance(dip), msg_buffer);

va_end(ap);

}

#define URTW8187_DBG(l, x) do {\

_NOTE(CONSTANTCONDITION) \

if ((l) & urtw8187_dbg_flags) \

urtw8187_dbg x;\

_NOTE(CONSTANTCONDITION) \

} while (0)

#else

#define URTW8187_DBG(l, x)

#endif

static usbd_status

urtw_led_init(struct urtw_softc *sc)

{

uint32_t rev;

usbd_status error;

if (error = urtw_read8_c(sc, URTW_PSR, &sc->sc_psr, 0))

goto fail;

error = urtw_eprom_read32(sc, URTW_EPROM_SWREV, &rev);

if (error != 0)

goto fail;

switch (rev & URTW_EPROM_CID_MASK) {

case URTW_EPROM_CID_ALPHA0:

sc->sc_strategy = URTW_SW_LED_MODE1;

break;

case URTW_EPROM_CID_SERCOMM_PS:

sc->sc_strategy = URTW_SW_LED_MODE3;

break;

case URTW_EPROM_CID_HW_LED:

sc->sc_strategy = URTW_HW_LED;

break;

case URTW_EPROM_CID_RSVD0:

case URTW_EPROM_CID_RSVD1:

default:

sc->sc_strategy = URTW_SW_LED_MODE0;

break;

}

sc->sc_gpio_ledpin = URTW_LED_PIN_GPIO0;

fail:

return (error);

}

static usbd_status

urtw_8225_write_s16(struct urtw_softc *sc, uint8_t addr, int index,

uint16_t *data)

{

usb_ctrl_setup_t req;

usb_cr_t cr;

usb_cb_flags_t cf;

mblk_t *mp = 0;

uint16_t data16;

usbd_status error;

data16 = *data;

bzero(&req, sizeof (req));

req.bmRequestType = UT_WRITE_VENDOR_DEVICE;

req.bRequest = URTW_8187_SETREGS_REQ;

req.wValue = addr;

req.wIndex = (uint16_t)index;

req.wLength = sizeof (uint16_t);

req.attrs = USB_ATTRS_NONE;

mp = allocb(sizeof (uint16_t), BPRI_MED);

if (mp == 0) {

cmn_err(CE_WARN, "urtw_8225_write_s16: allocb failed\n");

return (-1);

}

*(mp->b_rptr) = (data16 & 0x00ff);

*(mp->b_rptr + 1) = (data16 & 0xff00) >> 8;

mp->b_wptr += sizeof (uint16_t);

error = usb_pipe_ctrl_xfer_wait(sc->sc_udev->dev_default_ph, &req, &mp,

&cr, &cf, 0);

if (error != USB_SUCCESS) {

URTW8187_DBG(URTW_DEBUG_DEVREQ, (sc->sc_dev, CE_CONT,

"urtw_8225_write_s16: could not set regs:"

"cr:%s(%d), cf:(%x)\n", usb_str_cr(cr), cr, cf));

}

if (mp)

freemsg(mp);

return (error);

}

static usbd_status

urtw_8225_read(struct urtw_softc *sc, uint8_t addr, uint32_t *data)

{

int i;

int16_t bit;

uint8_t rlen = 12, wlen = 6;

uint16_t o1, o2, o3, tmp;

uint32_t d2w = ((uint32_t)(addr & 0x1f)) << 27;

uint32_t mask = 0x80000000, value = 0;

usbd_status error;

if (error = urtw_read16_c(sc, URTW_RF_PINS_OUTPUT, &o1, 0))

goto fail;

if (error = urtw_read16_c(sc, URTW_RF_PINS_ENABLE, &o2, 0))

goto fail;

if (error = urtw_read16_c(sc, URTW_RF_PINS_SELECT, &o3, 0))

goto fail;

if (error = urtw_write16_c(sc, URTW_RF_PINS_ENABLE, o2 | 0xf, 0))

goto fail;

if (error = urtw_write16_c(sc, URTW_RF_PINS_SELECT, o3 | 0xf, 0))

goto fail;

o1 &= ~0xf;

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

o1 | URTW_BB_HOST_BANG_EN, 0))

goto fail;

DELAY(5);

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT, o1, 0))

goto fail;

DELAY(5);

for (i = 0; i < (wlen / 2); i++, mask = mask >> 1) {

bit = ((d2w & mask) != 0) ? 1 : 0;

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

bit | o1, 0))

goto fail;

DELAY(2);

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

bit | o1 | URTW_BB_HOST_BANG_CLK, 0))

goto fail;

DELAY(2);

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

bit | o1 | URTW_BB_HOST_BANG_CLK, 0))

goto fail;

DELAY(2);

mask = mask >> 1;

if (i == 2)

break;

bit = ((d2w & mask) != 0) ? 1 : 0;

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

bit | o1 | URTW_BB_HOST_BANG_CLK, 0))

goto fail;

DELAY(2);

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

bit | o1 | URTW_BB_HOST_BANG_CLK, 0))

goto fail;

DELAY(2);

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

bit | o1, 0))

goto fail;

DELAY(1);

}

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

bit | o1 | URTW_BB_HOST_BANG_RW | URTW_BB_HOST_BANG_CLK, 0))

goto fail;

DELAY(2);

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

bit | o1 | URTW_BB_HOST_BANG_RW, 0))

goto fail;

DELAY(2);

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

o1 | URTW_BB_HOST_BANG_RW, 0))

goto fail;

DELAY(2);

mask = 0x800;

for (i = 0; i < rlen; i++, mask = mask >> 1) {

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

o1 | URTW_BB_HOST_BANG_RW, 0))

goto fail;

DELAY(2);

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

o1 | URTW_BB_HOST_BANG_RW | URTW_BB_HOST_BANG_CLK, 0))

goto fail;

DELAY(2);

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

o1 | URTW_BB_HOST_BANG_RW | URTW_BB_HOST_BANG_CLK, 0))

goto fail;

DELAY(2);

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

o1 | URTW_BB_HOST_BANG_RW | URTW_BB_HOST_BANG_CLK, 0))

goto fail;

DELAY(2);

if (error = urtw_read16_c(sc, URTW_RF_PINS_INPUT, &tmp, 0))

goto fail;

value |= ((tmp & URTW_BB_HOST_BANG_CLK) ? mask : 0);

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

o1 | URTW_BB_HOST_BANG_RW, 0))

goto fail;

DELAY(2);

}

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

o1 | URTW_BB_HOST_BANG_EN |

URTW_BB_HOST_BANG_RW, 0))

goto fail;

DELAY(2);

if (error = urtw_write16_c(sc, URTW_RF_PINS_ENABLE, o2, 0))

goto fail;

if (error = urtw_write16_c(sc, URTW_RF_PINS_SELECT, o3, 0))

goto fail;

error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT, 0x3a0, 0);

if (data != NULL)

*data = value;

fail:

return (error);

}

static void

urtw_delay_ms(int t)

{

DELAY(t * 1000);

}

static usbd_status

urtw_8225_write_c(struct urtw_softc *sc, uint8_t addr, uint16_t data)

{

uint16_t d80, d82, d84;

usbd_status error;

if (error = urtw_read16_c(sc, URTW_RF_PINS_OUTPUT, &d80, 0))

goto fail;

d80 &= 0xfff3;

if (error = urtw_read16_c(sc, URTW_RF_PINS_ENABLE, &d82, 0))

goto fail;

if (error = urtw_read16_c(sc, URTW_RF_PINS_SELECT, &d84, 0))

goto fail;

d84 &= 0xfff0;

if (error = urtw_write16_c(sc, URTW_RF_PINS_ENABLE,

d82 | 0x0007, 0))

goto fail;

if (error = urtw_write16_c(sc, URTW_RF_PINS_SELECT,

d84 | 0x0007, 0))

goto fail;

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

d80 | URTW_BB_HOST_BANG_EN, 0))

goto fail;

urtw_delay_ms(2);

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT, d80, 0))

goto fail;

error = urtw_8225_write_s16(sc, addr, 0x8225, &data);

if (error != 0)

goto fail;

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

d80 | URTW_BB_HOST_BANG_EN, 0))

goto fail;

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT,

d80 | URTW_BB_HOST_BANG_EN, 0))

goto fail;

error = urtw_write16_c(sc, URTW_RF_PINS_SELECT, d84, 0);

urtw_delay_ms(2);

fail:

return (error);

}

static usbd_status

urtw_8225_isv2(struct urtw_softc *sc, int *ret)

{

uint32_t data;

usbd_status error;

*ret = 1;

if (error = urtw_write16_c(sc, URTW_RF_PINS_OUTPUT, 0x0080, 0))

goto fail;

if (error = urtw_write16_c(sc, URTW_RF_PINS_SELECT, 0x0080, 0))

goto fail;

if (error = urtw_write16_c(sc, URTW_RF_PINS_ENABLE, 0x0080, 0))

goto fail;

urtw_delay_ms(300);

if (error = urtw_8225_write_c(sc, 0x0, 0x1b7))

goto fail;

error = urtw_8225_read(sc, 0x8, &data);

if (error != 0)

goto fail;

if (data != 0x588)

*ret = 0;

else {

error = urtw_8225_read(sc, 0x9, &data);

if (error != 0)

goto fail;

if (data != 0x700)

*ret = 0;

}

error = urtw_8225_write_c(sc, 0x0, 0xb7);

fail:

return (error);

}

static usbd_status

urtw_get_rfchip(struct urtw_softc *sc)

{

struct urtw_rf *rf = &sc->sc_rf;

int ret;

uint32_t data;

usbd_status error;

rf->rf_sc = sc;

if (sc->sc_hwrev & URTW_HWREV_8187) {

error = urtw_eprom_read32(sc, URTW_EPROM_RFCHIPID, &data);

if (error != 0) {

cmn_err(CE_WARN, "RF ID read failed\n");

return (-1);

}

switch (data & 0xff) {

case URTW_EPROM_RFCHIPID_RTL8225U:

error = urtw_8225_isv2(sc, &ret);

if (error != 0) {

URTW8187_DBG(URTW_DEBUG_HWTYPE,

(sc->sc_dev, CE_CONT,

"8225 version check failed\n"));

goto fail;

}

if (ret == 0) {

URTW8187_DBG(URTW_DEBUG_HWTYPE,

(sc->sc_dev, CE_CONT,

"8225 detected\n"));

rf->init = urtw_8225_rf_init;

rf->set_chan = urtw_8225_rf_set_chan;

rf->set_sens = urtw_8225_rf_set_sens;

} else {

URTW8187_DBG(URTW_DEBUG_HWTYPE,

(sc->sc_dev, CE_CONT,

"8225 v2 detected\n"));

rf->init = urtw_8225v2_rf_init;

rf->set_chan = urtw_8225v2_rf_set_chan;

rf->set_sens = NULL;

}

break;

default:

goto fail;

}

} else {

URTW8187_DBG(URTW_DEBUG_HWTYPE,

(sc->sc_dev, CE_CONT,

"8225 v2 [b] detected\n"));

rf->init = urtw_8225v2_b_rf_init;

rf->set_chan = urtw_8225v2_b_rf_set_chan;

rf->set_sens = NULL;

}

rf->max_sens = URTW_8225_RF_MAX_SENS;

rf->sens = URTW_8225_RF_DEF_SENS;

return (0);

fail:

cmn_err(CE_WARN, "unsupported RF chip %d\n", data & 0xff);

return (-1);

}

static usbd_status

urtw_get_txpwr(struct urtw_softc *sc)

{

int i, j;

uint32_t data;

usbd_status error;

error = urtw_eprom_read32(sc, URTW_EPROM_TXPW_BASE, &data);

if (error != 0)

goto fail;

sc->sc_txpwr_cck_base = data & 0xf;

sc->sc_txpwr_ofdm_base = (data >> 4) & 0xf;

for (i = 1, j = 0; i < 6; i += 2, j++) {

error = urtw_eprom_read32(sc, URTW_EPROM_TXPW0 + j, &data);

if (error != 0)

goto fail;

sc->sc_txpwr_cck[i] = data & 0xf;

sc->sc_txpwr_cck[i + 1] = (data & 0xf00) >> 8;

sc->sc_txpwr_ofdm[i] = (data & 0xf0) >> 4;

sc->sc_txpwr_ofdm[i + 1] = (data & 0xf000) >> 12;

}

for (i = 1, j = 0; i < 4; i += 2, j++) {

error = urtw_eprom_read32(sc, URTW_EPROM_TXPW1 + j, &data);

if (error != 0)

goto fail;

sc->sc_txpwr_cck[i + 6] = data & 0xf;

sc->sc_txpwr_cck[i + 6 + 1] = (data & 0xf00) >> 8;

sc->sc_txpwr_ofdm[i + 6] = (data & 0xf0) >> 4;

sc->sc_txpwr_ofdm[i + 6 + 1] = (data & 0xf000) >> 12;

}

if (sc->sc_hwrev & URTW_HWREV_8187) {

for (i = 1, j = 0; i < 4; i += 2, j++) {

error = urtw_eprom_read32(sc, URTW_EPROM_TXPW2 + j,

&data);

if (error != 0)

goto fail;

sc->sc_txpwr_cck[i + 6 + 4] = data & 0xf;

sc->sc_txpwr_cck[i + 6 + 4 + 1] = (data & 0xf00) >> 8;

sc->sc_txpwr_ofdm[i + 6 + 4] = (data & 0xf0) >> 4;

sc->sc_txpwr_ofdm[i + 6 + 4 + 1] =

(data & 0xf000) >> 12;

}

} else {

/* Channel 11. */

error = urtw_eprom_read32(sc, 0x1b, &data);

if (error != 0)

goto fail;

sc->sc_txpwr_cck[11] = data & 0xf;

sc->sc_txpwr_ofdm[11] = (data & 0xf0) >> 4;

/* Channel 12. */

error = urtw_eprom_read32(sc, 0xa, &data);

if (error != 0)

goto fail;

sc->sc_txpwr_cck[12] = data & 0xf;

sc->sc_txpwr_ofdm[12] = (data & 0xf0) >> 4;

/* Channel 13, 14. */

error = urtw_eprom_read32(sc, 0x1c, &data);

if (error != 0)

goto fail;

sc->sc_txpwr_cck[13] = data & 0xf;

sc->sc_txpwr_ofdm[13] = (data & 0xf0) >> 4;

sc->sc_txpwr_cck[14] = (data & 0xf00) >> 8;

sc->sc_txpwr_ofdm[14] = (data & 0xf000) >> 12;

}

fail:

return (error);

}

static usbd_status

urtw_get_macaddr(struct urtw_softc *sc)

{

uint32_t data;

usbd_status error;

uint8_t *m = 0;

error = urtw_eprom_read32(sc, URTW_EPROM_MACADDR, &data);

if (error != 0)

goto fail;

sc->sc_bssid[0] = data & 0xff;

sc->sc_bssid[1] = (data & 0xff00) >> 8;

error = urtw_eprom_read32(sc, URTW_EPROM_MACADDR + 1, &data);

if (error != 0)

goto fail;

sc->sc_bssid[2] = data & 0xff;

sc->sc_bssid[3] = (data & 0xff00) >> 8;

error = urtw_eprom_read32(sc, URTW_EPROM_MACADDR + 2, &data);

if (error != 0)

goto fail;

sc->sc_bssid[4] = data & 0xff;

sc->sc_bssid[5] = (data & 0xff00) >> 8;

bcopy(sc->sc_bssid, sc->sc_ic.ic_macaddr, IEEE80211_ADDR_LEN);

m = sc->sc_bssid;

URTW8187_DBG(URTW_DEBUG_HWTYPE, (sc->sc_dev, CE_CONT,

"MAC: %x:%x:%x:%x:%x:%x\n",

m[0], m[1], m[2], m[3], m[4], m[5]));

fail:

return (error);

}

static usbd_status

urtw_eprom_read32(struct urtw_softc *sc, uint32_t addr, uint32_t *data)

{

#define URTW_READCMD_LEN 3

int addrlen, i;

int16_t addrstr[8], data16, readcmd[] = { 1, 1, 0 };

usbd_status error;

/* NB: make sure the buffer is initialized */

*data = 0;

/* enable EPROM programming */

if (error = urtw_write8_c(sc, URTW_EPROM_CMD,

URTW_EPROM_CMD_PROGRAM_MODE, 0))

goto fail;

DELAY(URTW_EPROM_DELAY);

error = urtw_eprom_cs(sc, URTW_EPROM_ENABLE);

if (error != 0)

goto fail;

error = urtw_eprom_ck(sc);

if (error != 0)

goto fail;

error = urtw_eprom_sendbits(sc, readcmd, URTW_READCMD_LEN);

if (error != 0)

goto fail;

if (sc->sc_epromtype == URTW_EEPROM_93C56) {

addrlen = 8;

addrstr[0] = addr & (1 << 7);

addrstr[1] = addr & (1 << 6);

addrstr[2] = addr & (1 << 5);

addrstr[3] = addr & (1 << 4);

addrstr[4] = addr & (1 << 3);

addrstr[5] = addr & (1 << 2);

addrstr[6] = addr & (1 << 1);

addrstr[7] = addr & (1 << 0);

} else {

addrlen = 6;

addrstr[0] = addr & (1 << 5);

addrstr[1] = addr & (1 << 4);

addrstr[2] = addr & (1 << 3);

addrstr[3] = addr & (1 << 2);

addrstr[4] = addr & (1 << 1);

addrstr[5] = addr & (1 << 0);

}

error = urtw_eprom_sendbits(sc, addrstr, addrlen);

if (error != 0)

goto fail;

error = urtw_eprom_writebit(sc, 0);

if (error != 0)

goto fail;

for (i = 0; i < 16; i++) {

error = urtw_eprom_ck(sc);

if (error != 0)

goto fail;

error = urtw_eprom_readbit(sc, &data16);

if (error != 0)

goto fail;

(*data) |= (data16 << (15 - i));

}

error = urtw_eprom_cs(sc, URTW_EPROM_DISABLE);

if (error != 0)

goto fail;

error = urtw_eprom_ck(sc);

if (error != 0)

goto fail;

/* now disable EPROM programming */

error = urtw_write8_c(sc, URTW_EPROM_CMD,

URTW_EPROM_CMD_NORMAL_MODE, 0);

fail:

return (error);

#undef URTW_READCMD_LEN

}

static usbd_status

urtw_eprom_readbit(struct urtw_softc *sc, int16_t *data)

{

uint8_t data8;

usbd_status error;

error = urtw_read8_c(sc, URTW_EPROM_CMD, &data8, 0);

*data = (data8 & URTW_EPROM_READBIT) ? 1 : 0;

DELAY(URTW_EPROM_DELAY);

return (error);

}

static usbd_status

urtw_eprom_sendbits(struct urtw_softc *sc, int16_t *buf, int buflen)

{

int i = 0;

usbd_status error;

for (i = 0; i < buflen; i++) {

error = urtw_eprom_writebit(sc, buf[i]);

if (error != 0)

goto fail;

error = urtw_eprom_ck(sc);

if (error != 0)

goto fail;

}

fail:

return (error);

}

static usbd_status

urtw_eprom_writebit(struct urtw_softc *sc, int16_t bit)

{

uint8_t data;

usbd_status error;

if (error = urtw_read8_c(sc, URTW_EPROM_CMD, &data, 0))

goto fail;

if (bit != 0)

error = urtw_write8_c(sc, URTW_EPROM_CMD,

data | URTW_EPROM_WRITEBIT, 0);

else

error = urtw_write8_c(sc, URTW_EPROM_CMD,

data & ~URTW_EPROM_WRITEBIT, 0);

DELAY(URTW_EPROM_DELAY);

fail:

return (error);

}

static usbd_status

urtw_eprom_ck(struct urtw_softc *sc)

{

uint8_t data;

usbd_status error;

/* masking */

if (error = urtw_read8_c(sc, URTW_EPROM_CMD, &data, 0))

goto fail;

if (error = urtw_write8_c(sc, URTW_EPROM_CMD, data | URTW_EPROM_CK, 0))

goto fail;

DELAY(URTW_EPROM_DELAY);

/* unmasking */

if (error = urtw_read8_c(sc, URTW_EPROM_CMD, &data, 0))

goto fail;

error = urtw_write8_c(sc, URTW_EPROM_CMD, data & ~URTW_EPROM_CK, 0);

DELAY(URTW_EPROM_DELAY);

fail:

return (error);

}

static usbd_status

urtw_eprom_cs(struct urtw_softc *sc, int able)

{

uint8_t data;

usbd_status error;

if (error = urtw_read8_c(sc, URTW_EPROM_CMD, &data, 0))

goto fail;

if (able == URTW_EPROM_ENABLE)

error = urtw_write8_c(sc, URTW_EPROM_CMD,

data | URTW_EPROM_CS, 0);

else

error = urtw_write8_c(sc, URTW_EPROM_CMD,

data & ~URTW_EPROM_CS, 0);

DELAY(URTW_EPROM_DELAY);

fail:

return (error);

}

static usbd_status

urtw_read8_c(struct urtw_softc *sc, int val, uint8_t *data, uint8_t idx)

{

usb_ctrl_setup_t req;

usb_cr_t cr;

usb_cb_flags_t cf;

mblk_t *mp = NULL;

usbd_status error;

bzero(&req, sizeof (req));

req.bmRequestType = UT_READ_VENDOR_DEVICE;

req.bRequest = URTW_8187_GETREGS_REQ;

req.wValue = val | 0xff00;

req.wIndex = idx & 0x03;

req.wLength = sizeof (uint8_t);

error = usb_pipe_ctrl_xfer_wait(sc->sc_udev->dev_default_ph, &req, &mp,

&cr, &cf, 0);

if (error != USB_SUCCESS) {

URTW8187_DBG(URTW_DEBUG_DEVREQ, (sc->sc_dev, CE_CONT,

"urtw_read8_c: get regs req failed :"

" cr:%s(%d), cf:(%x)\n", usb_str_cr(cr), cr, cf));

return (error);

}

bcopy(mp->b_rptr, data, sizeof (uint8_t));

if (mp)

freemsg(mp);

return (error);

}

static usbd_status

urtw_read8e(struct urtw_softc *sc, int val, uint8_t *data)

{

usb_ctrl_setup_t req;

usb_cr_t cr;

usb_cb_flags_t cf;

mblk_t *mp = NULL;

usbd_status error;

bzero(&req, sizeof (req));

req.bmRequestType = UT_READ_VENDOR_DEVICE;

req.bRequest = URTW_8187_GETREGS_REQ;

req.wValue = val | 0xfe00;

req.wIndex = 0;

req.wLength = sizeof (uint8_t);

req.attrs = USB_ATTRS_AUTOCLEARING;

error = usb_pipe_ctrl_xfer_wait(sc->sc_udev->dev_default_ph, &req, &mp,

&cr, &cf, 0);

if (error != USB_SUCCESS) {

URTW8187_DBG(URTW_DEBUG_DEVREQ, (sc->sc_dev, CE_CONT,

"urtw_read8e: get regs req failed :"

" cr:%s(%d), cf:(%x)\n", usb_str_cr(cr), cr, cf));

return (error);

}

if (mp) {

bcopy(mp->b_rptr, data, sizeof (uint8_t));

freemsg(mp);

}

return (error);

}

static usbd_status

urtw_read16_c(struct urtw_softc *sc, int val, uint16_t *data, uint8_t idx)

{

usb_ctrl_setup_t req;

usb_cr_t cr;

usb_cb_flags_t cf;

mblk_t *mp = NULL;

usbd_status error;

bzero(&req, sizeof (req));

req.bmRequestType = UT_READ_VENDOR_DEVICE;

req.bRequest = URTW_8187_GETREGS_REQ;

req.wValue = val | 0xff00;

req.wIndex = idx & 0x03;

req.wLength = sizeof (uint16_t);

req.attrs = USB_ATTRS_AUTOCLEARING;

error = usb_pipe_ctrl_xfer_wait(sc->sc_udev->dev_default_ph, &req, &mp,

&cr, &cf, 0);

if (error != USB_SUCCESS) {

URTW8187_DBG(URTW_DEBUG_DEVREQ, (sc->sc_dev, CE_CONT,

"urtw_read16_c: get regs req failed :"

" cr:%s(%d), cf:(%x)\n",

usb_str_cr(cr), cr, cf));

return (error);

}

if (mp) {

bcopy(mp->b_rptr, data, sizeof (uint16_t));

freemsg(mp);

}

return (error);

}

static usbd_status

urtw_read32_c(struct urtw_softc *sc, int val, uint32_t *data, uint8_t idx)

{

usb_ctrl_setup_t req;

usb_cr_t cr;

usb_cb_flags_t cf;

mblk_t *mp = NULL;

usbd_status error;

bzero(&req, sizeof (req));

req.bmRequestType = UT_READ_VENDOR_DEVICE;

req.bRequest = URTW_8187_GETREGS_REQ;

req.wValue = val | 0xff00;

req.wIndex = idx & 0x03;

req.wLength = sizeof (uint32_t);

req.attrs = USB_ATTRS_AUTOCLEARING;

error = usb_pipe_ctrl_xfer_wait(sc->sc_udev->dev_default_ph, &req, &mp,

&cr, &cf, 0);

if (error != USB_SUCCESS) {

URTW8187_DBG(URTW_DEBUG_DEVREQ, (sc->sc_dev, CE_CONT,

"urtw_read32_c: get regs req failed :"

" cr:%s(%d), cf:(%x)\n", usb_str_cr(cr), cr, cf));

return (error);

}

if (mp) {

bcopy(mp->b_rptr, data, sizeof (uint32_t));

freemsg(mp);

}

return (error);

}

static usbd_status

urtw_write8_c(struct urtw_softc *sc, int val, uint8_t data, uint8_t idx)

{

usb_ctrl_setup_t req;

usb_cr_t cr;

usb_cb_flags_t cf;

mblk_t *mp = 0;

int error;

bzero(&req, sizeof (req));

req.bmRequestType = UT_WRITE_VENDOR_DEVICE;

req.bRequest = URTW_8187_SETREGS_REQ;

req.wValue = val | 0xff00;

req.wIndex = idx & 0x03;

req.wLength = sizeof (uint8_t);

req.attrs = USB_ATTRS_NONE;

mp = allocb(sizeof (uint32_t), BPRI_MED);

if (mp == NULL) {

cmn_err(CE_CONT, "urtw_write8_c: failed alloc mblk.");

return (-1);

}

*(uint8_t *)(mp->b_rptr) = data;

mp->b_wptr += sizeof (uint8_t);

error = usb_pipe_ctrl_xfer_wait(sc->sc_udev->dev_default_ph, &req, &mp,

&cr, &cf, 0);

if (error != USB_SUCCESS) {

URTW8187_DBG(URTW_DEBUG_DEVREQ, (sc->sc_dev, CE_CONT,

"urtw_write8_c: could not set regs:"

"cr:%s(%d), cf:(%x)\n", usb_str_cr(cr), cr, cf));

}

if (mp)

freemsg(mp);

return (error);

}

static usbd_status

urtw_write8e(struct urtw_softc *sc, int val, uint8_t data)

{

usb_ctrl_setup_t req;

usb_cr_t cr;

usb_cb_flags_t cf;

mblk_t *mp = 0;

int error;

bzero(&req, sizeof (req));

req.bmRequestType = UT_WRITE_VENDOR_DEVICE;

req.bRequest = URTW_8187_SETREGS_REQ;

req.wValue = val | 0xfe00;

req.wIndex = 0;

req.wLength = sizeof (uint8_t);

req.attrs = USB_ATTRS_NONE;

mp = allocb(sizeof (uint8_t), BPRI_MED);

if (mp == NULL) {

cmn_err(CE_CONT, "urtw_write8e: failed alloc mblk.");

return (-1);

}

*(mp->b_rptr) = data;

mp->b_wptr += sizeof (uint8_t);

error = usb_pipe_ctrl_xfer_wait(sc->sc_udev->dev_default_ph, &req, &mp,

&cr, &cf, 0);

if (error != USB_SUCCESS) {

URTW8187_DBG(URTW_DEBUG_DEVREQ, (sc->sc_dev, CE_CONT,

"urtw_write8e: could not set regs:"

"cr:%s(%d), cf:(%x)\n",

usb_str_cr(cr), cr, cf));

}

if (mp)

freemsg(mp);

return (error);

}

static usbd_status

urtw_write16_c(struct urtw_softc *sc, int val, uint16_t data, uint8_t idx)

{

usb_ctrl_setup_t req;

usb_cr_t cr;

usb_cb_flags_t cf;

mblk_t *mp = 0;

int error;

bzero(&req, sizeof (req));

req.bmRequestType = UT_WRITE_VENDOR_DEVICE;

req.bRequest = URTW_8187_SETREGS_REQ;

req.wValue = val | 0xff00;

req.wIndex = idx & 0x03;

req.wLength = sizeof (uint16_t);

req.attrs = USB_ATTRS_NONE;

mp = allocb(sizeof (uint16_t), BPRI_MED);

if (mp == NULL) {

cmn_err(CE_CONT, "urtw_write16_c: failed alloc mblk.");

return (-1);

}

*(uint16_t *)(uintptr_t)(mp->b_rptr) = data;

mp->b_wptr += sizeof (uint16_t);

error = usb_pipe_ctrl_xfer_wait(sc->sc_udev->dev_default_ph, &req, &mp,

&cr, &cf, 0);

if (error != USB_SUCCESS) {

URTW8187_DBG(URTW_DEBUG_DEVREQ, (sc->sc_dev, CE_CONT,

"urtw_write16_c: could not set regs:"

"cr:%s(%d), cf:(%x)\n",

usb_str_cr(cr), cr, cf));

}

if (mp)

freemsg(mp);

return (error);

}

static usbd_status

urtw_write32_c(struct urtw_softc *sc, int val, uint32_t data, uint8_t idx)

{

usb_ctrl_setup_t req;

usb_cr_t cr;

usb_cb_flags_t cf;

mblk_t *mp = 0;

int error;

bzero(&req, sizeof (req));

req.bmRequestType = UT_WRITE_VENDOR_DEVICE;

req.bRequest = URTW_8187_SETREGS_REQ;

req.wValue = val | 0xff00;

req.wIndex = idx & 0x03;

req.wLength = sizeof (uint32_t);

req.attrs = USB_ATTRS_NONE;

mp = allocb(sizeof (uint32_t), BPRI_MED);

if (mp == NULL) {

cmn_err(CE_CONT, "urtw_write32_c: failed alloc mblk.");

return (-1);

}

*(uint32_t *)(uintptr_t)(mp->b_rptr) = data;

mp->b_wptr += sizeof (uint32_t);

error = usb_pipe_ctrl_xfer_wait(sc->sc_udev->dev_default_ph, &req, &mp,

&cr, &cf, 0);

if (error != USB_SUCCESS) {

URTW8187_DBG(URTW_DEBUG_DEVREQ, (sc->sc_dev, CE_CONT,

"urtw_write32_c: could not set regs:"

"cr:%s(%d), cf:(%x)\n",

usb_str_cr(cr), cr, cf));

}

if (mp)

freemsg(mp);

return (error);

}

static usbd_status

urtw_set_mode(struct urtw_softc *sc, uint32_t mode)

{

uint8_t data;

usbd_status error;

if (error = urtw_read8_c(sc, URTW_EPROM_CMD, &data, 0))

goto fail;

data = (data & ~URTW_EPROM_CMD_MASK) | (mode << URTW_EPROM_CMD_SHIFT);

data = data & ~(URTW_EPROM_CS | URTW_EPROM_CK);

error = urtw_write8_c(sc, URTW_EPROM_CMD, data, 0);

fail:

return (error);

}

static usbd_status

urtw_8180_set_anaparam(struct urtw_softc *sc, uint32_t val)

{

uint8_t data;

usbd_status error;

error = urtw_set_mode(sc, URTW_EPROM_CMD_CONFIG);

if (error)

goto fail;

if (error = urtw_read8_c(sc, URTW_CONFIG3, &data, 0))

goto fail;

if (error = urtw_write8_c(sc, URTW_CONFIG3,

data | URTW_CONFIG3_ANAPARAM_WRITE, 0))

goto fail;

if (error = urtw_write32_c(sc, URTW_ANAPARAM, val, 0))

goto fail;

if (error = urtw_read8_c(sc, URTW_CONFIG3, &data, 0))

goto fail;

if (error = urtw_write8_c(sc, URTW_CONFIG3,

data & ~URTW_CONFIG3_ANAPARAM_WRITE, 0))

goto fail;

error = urtw_set_mode(sc, URTW_EPROM_CMD_NORMAL);

if (error)

goto fail;

fail:

return (error);

}

static usbd_status

urtw_8185_set_anaparam2(struct urtw_softc *sc, uint32_t val)

{

uint8_t data;

usbd_status error;

error = urtw_set_mode(sc, URTW_EPROM_CMD_CONFIG);

if (error)

goto fail;

if (error = urtw_read8_c(sc, URTW_CONFIG3, &data, 0))

goto fail;

if (error = urtw_write8_c(sc, URTW_CONFIG3,

data | URTW_CONFIG3_ANAPARAM_WRITE, 0))

goto fail;

if (error = urtw_write32_c(sc, URTW_ANAPARAM2, val, 0))

goto fail;

if (error = urtw_read8_c(sc, URTW_CONFIG3, &data, 0))

goto fail;

if (error = urtw_write8_c(sc, URTW_CONFIG3,

data & ~URTW_CONFIG3_ANAPARAM_WRITE, 0))

goto fail;

error = urtw_set_mode(sc, URTW_EPROM_CMD_NORMAL);

if (error)

goto fail;

fail:

return (error);

}

static usbd_status

urtw_intr_disable(struct urtw_softc *sc)

{

usbd_status error;

error = urtw_write16_c(sc, URTW_INTR_MASK, 0, 0);

return (error);

}

static usbd_status

urtw_8187_reset(struct urtw_softc *sc)

{

uint8_t data;

usbd_status error;

error = urtw_8180_set_anaparam(sc, URTW_8187_8225_ANAPARAM_ON);

if (error)

goto fail;

error = urtw_8185_set_anaparam2(sc, URTW_8187_8225_ANAPARAM2_ON);

if (error)

goto fail;

error = urtw_intr_disable(sc);

if (error)

goto fail;

urtw_delay_ms(50);

error = urtw_write8e(sc, 0x18, 0x10);

if (error != 0)

goto fail;

error = urtw_write8e(sc, 0x18, 0x11);

if (error != 0)

goto fail;

error = urtw_write8e(sc, 0x18, 0x00);

if (error != 0)

goto fail;

urtw_delay_ms(50);

if (error = urtw_read8_c(sc, URTW_CMD, &data, 0))

goto fail;

data = (data & 2) | URTW_CMD_RST;

if (error = urtw_write8_c(sc, URTW_CMD, data, 0))

goto fail;

urtw_delay_ms(50);

if (error = urtw_read8_c(sc, URTW_CMD, &data, 0))

goto fail;

if (data & URTW_CMD_RST) {

cmn_err(CE_CONT, "urtw reset timeout\n");

goto fail;

}

error = urtw_set_mode(sc, URTW_EPROM_CMD_LOAD);

if (error)

goto fail;

urtw_delay_ms(50);

error = urtw_8180_set_anaparam(sc, URTW_8187_8225_ANAPARAM_ON);

if (error)

goto fail;

error = urtw_8185_set_anaparam2(sc, URTW_8187_8225_ANAPARAM2_ON);

if (error)

goto fail;

fail:

return (error);

}

static usbd_status

urtw_led_on(struct urtw_softc *sc, int type)

{

if (type == URTW_LED_GPIO) {

switch (sc->sc_gpio_ledpin) {

case URTW_LED_PIN_GPIO0:

(void) urtw_write8_c(sc, URTW_GPIO, 0x01, 0);

(void) urtw_write8_c(sc, URTW_GP_ENABLE, 0x00, 0);

break;

default:

cmn_err(CE_WARN, "unsupported LED PIN type 0x%x",

sc->sc_gpio_ledpin);

/* never reach */

}

} else {

cmn_err(CE_WARN, "unsupported LED type 0x%x", type);

/* never reach */

}

sc->sc_gpio_ledon = 1;

return (0);

}

static usbd_status

urtw_led_off(struct urtw_softc *sc, int type)

{

if (type == URTW_LED_GPIO) {

switch (sc->sc_gpio_ledpin) {

case URTW_LED_PIN_GPIO0:

(void) urtw_write8_c(sc, URTW_GPIO, 0x01, 0);

(void) urtw_write8_c(sc, URTW_GP_ENABLE, 0x01, 0);

break;

default:

cmn_err(CE_WARN, "unsupported LED PIN type 0x%x",

sc->sc_gpio_ledpin);

/* never reach */

}

} else {

cmn_err(CE_WARN, "unsupported LED type 0x%x", type);

/* never reach */

}

sc->sc_gpio_ledon = 0;

return (0);

}

static usbd_status

urtw_led_mode0(struct urtw_softc *sc, int mode)

{

URTW8187_DBG(URTW_DEBUG_LED, (sc->sc_dev, CE_CONT,

"urtw_led_mode0: mode = %d\n", mode));

switch (mode) {

case URTW_LED_CTL_POWER_ON:

sc->sc_gpio_ledstate = URTW_LED_POWER_ON_BLINK;

break;

case URTW_LED_CTL_TX:

if (sc->sc_gpio_ledinprogress == 1)

return (0);

sc->sc_gpio_ledstate = URTW_LED_BLINK_NORMAL;

sc->sc_gpio_blinktime =

(sc->sc_ic.ic_state == IEEE80211_S_RUN ? 4:2);

break;

case URTW_LED_CTL_LINK:

sc->sc_gpio_ledstate = URTW_LED_ON;

break;

default:

cmn_err(CE_CONT, "unsupported LED mode 0x%x", mode);

/* never reach */

}

switch (sc->sc_gpio_ledstate) {

case URTW_LED_ON:

if (sc->sc_gpio_ledinprogress != 0)

break;

(void) urtw_led_on(sc, URTW_LED_GPIO);

break;

case URTW_LED_BLINK_NORMAL:

if (sc->sc_gpio_ledinprogress != 0)

break;

sc->sc_gpio_ledinprogress = 1;

sc->sc_gpio_blinkstate = (sc->sc_gpio_ledon != 0) ?

URTW_LED_OFF : URTW_LED_ON;

URTW_LEDLOCK(sc);

if (sc->sc_led_ch == 0) {

URTW8187_DBG(URTW_DEBUG_LED, (sc->sc_dev, CE_CONT,

"urtw_led_mode0: restart led timer\n"));

sc->sc_led_ch = timeout(urtw_led_launch,

(void *)sc,

drv_usectohz((sc->sc_ic.ic_state ==

IEEE80211_S_RUN) ?

URTW_LED_LINKON_BLINK :

URTW_LED_LINKOFF_BLINK));

sc->sc_gpio_ledinprogress = 0;

}

URTW_LEDUNLOCK(sc);

break;

case URTW_LED_POWER_ON_BLINK:

(void) urtw_led_on(sc, URTW_LED_GPIO);

urtw_delay_ms(100);

(void) urtw_led_off(sc, URTW_LED_GPIO);

break;

default:

URTW8187_DBG(URTW_DEBUG_LED, (sc->sc_dev, CE_CONT,

"urtw_led_mode0: unknown LED status 0x%x",

sc->sc_gpio_ledstate));

}

return (0);

}

static usbd_status

urtw_led_mode1(struct urtw_softc *sc, int mode)

{

cmn_err(CE_WARN, "urtw sc %p, mode %d not supported", (void *)sc, mode);

return (USBD_INVAL);

}

static usbd_status

urtw_led_mode2(struct urtw_softc *sc, int mode)

{

cmn_err(CE_WARN, "urtw sc %p, mode %d not supported", (void *)sc, mode);

return (USBD_INVAL);

}

static usbd_status

urtw_led_mode3(struct urtw_softc *sc, int mode)

{

cmn_err(CE_WARN, "urtw sc %p, mode %d not supported", (void *)sc, mode);

return (USBD_INVAL);

}

static usbd_status

urtw_led_blink(struct urtw_softc *sc)

{

uint8_t ing = 0;

URTW8187_DBG(URTW_DEBUG_LED, (sc->sc_dev, CE_CONT,

"urtw_led_blink: gpio_blinkstate %d\n",

sc->sc_gpio_blinkstate));

if (sc->sc_gpio_blinkstate == URTW_LED_ON)

(void) urtw_led_on(sc, URTW_LED_GPIO);

else

(void) urtw_led_off(sc, URTW_LED_GPIO);

sc->sc_gpio_blinktime--;

if (sc->sc_gpio_blinktime == 0)

ing = 1;

else {

if (sc->sc_gpio_ledstate != URTW_LED_BLINK_NORMAL &&

sc->sc_gpio_ledstate != URTW_LED_BLINK_SLOWLY &&

sc->sc_gpio_ledstate != URTW_LED_BLINK_CM3)

ing = 1;

}

if (ing == 1) {

if (sc->sc_gpio_ledstate == URTW_LED_ON &&

sc->sc_gpio_ledon == 0)

(void) urtw_led_on(sc, URTW_LED_GPIO);

else if (sc->sc_gpio_ledstate == URTW_LED_OFF &&

sc->sc_gpio_ledon == 1)

(void) urtw_led_off(sc, URTW_LED_GPIO);

sc->sc_gpio_blinktime = 0;

sc->sc_gpio_ledinprogress = 0;

return (0);

}

sc->sc_gpio_blinkstate = (sc->sc_gpio_blinkstate != URTW_LED_ON) ?

URTW_LED_ON : URTW_LED_OFF;

switch (sc->sc_gpio_ledstate) {

case URTW_LED_BLINK_NORMAL:

URTW8187_DBG(URTW_DEBUG_LED, (sc->sc_dev, CE_CONT,

"URTW_LED_BLINK_NORMAL\n"));

return (1);

default:

URTW8187_DBG(URTW_DEBUG_LED, (sc->sc_dev, CE_CONT,

"unknown LED status 0x%x", sc->sc_gpio_ledstate));

}

return (0);

}

static usbd_status

urtw_led_ctl(struct urtw_softc *sc, int mode)

{

usbd_status error = 0;

switch (sc->sc_strategy) {

case URTW_SW_LED_MODE0:

error = urtw_led_mode0(sc, mode);

break;

case URTW_SW_LED_MODE1:

error = urtw_led_mode1(sc, mode);

break;

case URTW_SW_LED_MODE2:

error = urtw_led_mode2(sc, mode);

break;

case URTW_SW_LED_MODE3:

error = urtw_led_mode3(sc, mode);

break;

default:

cmn_err(CE_CONT, "unsupported LED mode %d\n", sc->sc_strategy);

/* never reach */

return (-1);

}

return (error);

}

static usbd_status

urtw_update_msr(struct urtw_softc *sc, int nstate)

{

struct ieee80211com *ic = &sc->sc_ic;

uint8_t data;

usbd_status error;

if (error = urtw_read8_c(sc, URTW_MSR, &data, 0))

goto fail;

data &= ~URTW_MSR_LINK_MASK;

/* Should always be set. */

if (sc->sc_hwrev & URTW_HWREV_8187B)

data |= URTW_MSR_LINK_ENEDCA;

if (nstate == IEEE80211_S_RUN) {

switch (ic->ic_opmode) {

case IEEE80211_M_STA:

case IEEE80211_M_MONITOR:

data |= URTW_MSR_LINK_STA;

break;

case IEEE80211_M_IBSS:

data |= URTW_MSR_LINK_ADHOC;

break;

case IEEE80211_M_HOSTAP:

data |= URTW_MSR_LINK_HOSTAP;

break;

default:

cmn_err(CE_CONT, "unsupported operation mode 0x%x\n",

ic->ic_opmode);

return (-1);

}

} else

data |= URTW_MSR_LINK_NONE;

error = urtw_write8_c(sc, URTW_MSR, data, 0);

fail:

return (error);

}

static uint16_t

urtw_rate2rtl(int rate)

{

#define N(a) (sizeof (a) / sizeof ((a)[0]))

int i;

for (i = 0; i < N(urtw_ratetable); i++) {

if (rate == urtw_ratetable[i].reg)

return (urtw_ratetable[i].val);

}

return (3);

#undef N

}

static uint16_t

urtw_rtl2rate(int rate)

{

#define N(a) (sizeof (a) / sizeof ((a)[0]))

int i;

for (i = 0; i < N(urtw_ratetable); i++) {

if (rate == urtw_ratetable[i].val)

return (urtw_ratetable[i].reg);

}

return (0);

#undef N

}

static usbd_status

urtw_set_rate(struct urtw_softc *sc)

{

int i, basic_rate, min_rr_rate, max_rr_rate;

uint16_t data;

usbd_status error;

basic_rate = urtw_rate2rtl(48);

min_rr_rate = urtw_rate2rtl(12);

max_rr_rate = urtw_rate2rtl(48);

if (error = urtw_write8_c(sc, URTW_RESP_RATE,

max_rr_rate << URTW_RESP_MAX_RATE_SHIFT |

min_rr_rate << URTW_RESP_MIN_RATE_SHIFT, 0))

goto fail;

if (error = urtw_read16_c(sc, URTW_BRSR, &data, 0))

goto fail;

data &= ~URTW_BRSR_MBR_8185;

for (i = 0; i <= basic_rate; i++)

data |= (1 << i);

error = urtw_write16_c(sc, URTW_BRSR, data, 0);

fail:

return (error);

}

static usbd_status

urtw_intr_enable(struct urtw_softc *sc)

{

usbd_status error;

error = urtw_write16_c(sc, URTW_INTR_MASK, 0xffff, 0);

return (error);

}

static usbd_status

urtw_rx_setconf(struct urtw_softc *sc)

{

struct ieee80211com *ic = &sc->sc_ic;

uint32_t data, a, b;

usbd_status error;

if (urtw_read32_c(sc, URTW_RX, &data, 0))

goto fail;

data = data &~ URTW_RX_FILTER_MASK;

data = data | URTW_RX_FILTER_MNG | URTW_RX_FILTER_DATA;

data = data | URTW_RX_FILTER_BCAST | URTW_RX_FILTER_MCAST;

if (ic->ic_opmode == IEEE80211_M_MONITOR) {

data = data | URTW_RX_FILTER_ICVERR;

data = data | URTW_RX_FILTER_PWR;

}

if (sc->sc_crcmon == 1 && ic->ic_opmode == IEEE80211_M_MONITOR)

data = data | URTW_RX_FILTER_CRCERR;

data = data | URTW_RX_FILTER_NICMAC;

data = data | URTW_RX_CHECK_BSSID;

data = data &~ URTW_RX_FIFO_THRESHOLD_MASK;

data = data | URTW_RX_FIFO_THRESHOLD_NONE | URTW_RX_AUTORESETPHY;

data = data &~ URTW_MAX_RX_DMA_MASK;

a = URTW_MAX_RX_DMA_2048;

b = 0x80000000;

data = data | a | b;

error = urtw_write32_c(sc, URTW_RX, data, 0);

fail:

return (error);

}

static usbd_status

urtw_rx_enable(struct urtw_softc *sc)

{

int i;

usbd_status error;

uint8_t data;

sc->rx_queued = 0;

for (i = 0; i < URTW_RX_DATA_LIST_COUNT; i++) {

if (urtw_rx_start(sc) != 0) {

return (USB_FAILURE);

}

}

error = urtw_rx_setconf(sc);

if (error != 0)

goto fail;

if (error = urtw_read8_c(sc, URTW_CMD, &data, 0))

goto fail;

error = urtw_write8_c(sc, URTW_CMD, data | URTW_CMD_RX_ENABLE, 0);

fail:

return (error);

}

urtw_tx_enable(struct urtw_softc *sc)

{

uint8_t data8;

uint32_t data;

if (sc->sc_hwrev & URTW_HWREV_8187) {

(void) urtw_read8_c(sc, URTW_CW_CONF, &data8, 0);

data8 &= ~(URTW_CW_CONF_PERPACKET_CW |

URTW_CW_CONF_PERPACKET_RETRY);

(void) urtw_write8_c(sc, URTW_CW_CONF, data8, 0);

(void) urtw_read8_c(sc, URTW_TX_AGC_CTL, &data8, 0);

data8 &= ~URTW_TX_AGC_CTL_PERPACKET_GAIN;

data8 &= ~URTW_TX_AGC_CTL_PERPACKET_ANTSEL;

data8 &= ~URTW_TX_AGC_CTL_FEEDBACK_ANT;

(void) urtw_write8_c(sc, URTW_TX_AGC_CTL, data8, 0);

(void) urtw_read32_c(sc, URTW_TX_CONF, &data, 0);

data &= ~URTW_TX_LOOPBACK_MASK;

data |= URTW_TX_LOOPBACK_NONE;

data &= ~(URTW_TX_DPRETRY_MASK | URTW_TX_RTSRETRY_MASK);

data |= sc->sc_tx_retry << URTW_TX_DPRETRY_SHIFT;

data |= sc->sc_rts_retry << URTW_TX_RTSRETRY_SHIFT;

data &= ~(URTW_TX_NOCRC | URTW_TX_MXDMA_MASK);

data |= URTW_TX_MXDMA_2048 | URTW_TX_CWMIN | URTW_TX_DISCW;

data &= ~URTW_TX_SWPLCPLEN;

data |= URTW_TX_NOICV;

(void) urtw_write32_c(sc, URTW_TX_CONF, data, 0);

} else {

data = URTW_TX_DURPROCMODE | URTW_TX_DISREQQSIZE |

URTW_TX_MXDMA_2048 | URTW_TX_SHORTRETRY |

URTW_TX_LONGRETRY;

(void) urtw_write32_c(sc, URTW_TX_CONF, data, 0);

}

(void) urtw_read8_c(sc, URTW_CMD, &data8, 0);

(void) urtw_write8_c(sc, URTW_CMD, data8 | URTW_CMD_TX_ENABLE, 0);

}

static int

urtw_8187_init(void *arg)

{

struct urtw_softc *sc = arg;

usbd_status error;

struct urtw_rf *rf = &sc->sc_rf;

int i;

urtw_stop(sc);

URTW_LOCK(sc);

error = urtw_8187_reset(sc);

if (error)

goto fail;

(void) urtw_write8_c(sc, 0x85, 0, 0);

(void) urtw_write8_c(sc, URTW_GPIO, 0, 0);

/* for led */

(void) urtw_write8_c(sc, 0x85, 4, 0);

error = urtw_led_ctl(sc, URTW_LED_CTL_POWER_ON);

if (error != 0)

goto fail;

error = urtw_set_mode(sc, URTW_EPROM_CMD_CONFIG);

if (error)

goto fail;

/* applying MAC address again. */

for (i = 0; i < IEEE80211_ADDR_LEN; i++)

(void) urtw_write8_c(sc, URTW_MAC0 + i,

sc->sc_ic.ic_macaddr[i], 0);

error = urtw_set_mode(sc, URTW_EPROM_CMD_NORMAL);

if (error)

goto fail;

error = urtw_update_msr(sc, IEEE80211_S_INIT);

if (error)

goto fail;