/*
* upf_usbgem.c : ADMtek an986/adm8511/adm8513/adm8515 USB to
* Fast Ethernet Driver for Solaris
*/
/*
* Copyright (c) 2004-2011 Masayuki Murayama. 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. Neither the name of the author nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*/
/*
* Changelog:
*/
/*
* TODO
*/
/* ======================================================= */
/*
* Solaris system header files and macros
*/
#include <sys/types.h>
#include <sys/conf.h>
#include <sys/debug.h>
#include <sys/kmem.h>
#include <sys/modctl.h>
#include <sys/errno.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/byteorder.h>
/* ethernet stuff */
#include <sys/ethernet.h>
/* interface card depend stuff */
#include <sys/stropts.h>
#include <sys/stream.h>
#include <sys/strlog.h>
#include <sys/usb/usba.h>
#include "usbgem.h"
/* hardware stuff */
#include "usbgem_mii.h"
#include "adm8511reg.h"
char ident[] = "pegasus usbnic driver v" VERSION;
/*
* Useful macros
*/
#define CHECK_AND_JUMP(val, label) \
if ((val) != USB_SUCCESS) { goto label; }
/*
* Debugging
*/
#ifdef DEBUG_LEVEL
static int upf_debug = DEBUG_LEVEL;
#define DPRINTF(n, args) if (upf_debug > (n)) cmn_err args
#else
#define DPRINTF(n, args)
#endif
/*
* Our configration for ADMtek Pegasus/PegasusII
*/
/* timeouts */
#define ONESEC (drv_usectohz(1*1000000))
/*
* Local device definitions
*/
struct upf_dev {
/*
* Misc HW information
*/
uint8_t ec[3];
uint8_t mac_addr[ETHERADDRL];
int chip_type;
#define CHIP_AN986 1 /* avoid 0 */
#define CHIP_ADM8511 2 /* including adm8515 */
#define CHIP_ADM8513 3
boolean_t phy_init_done;
uint8_t last_link_state;
uint16_t vid; /* vendor id */
uint16_t pid; /* product id */
};
/*
* private functions
*/
/* mii operations */
static uint16_t upf_mii_read(struct usbgem_dev *, uint_t, int *errp);
static void upf_mii_write(struct usbgem_dev *, uint_t, uint16_t, int *errp);
/* nic operations */
static int upf_attach_chip(struct usbgem_dev *);
static int upf_reset_chip(struct usbgem_dev *);
static int upf_init_chip(struct usbgem_dev *);
static int upf_start_chip(struct usbgem_dev *);
static int upf_stop_chip(struct usbgem_dev *);
static int upf_set_media(struct usbgem_dev *);
static int upf_set_rx_filter(struct usbgem_dev *);
static int upf_get_stats(struct usbgem_dev *);
/* packet operations */
static mblk_t *upf_tx_make_packet(struct usbgem_dev *, mblk_t *);
static mblk_t *upf_rx_make_packet(struct usbgem_dev *, mblk_t *);
/* interrupt handler */
static void upf_interrupt(struct usbgem_dev *, mblk_t *);
/* =============================================================== */
/*
* I/O functions
*/
/* =============================================================== */
#define UPF_REQ_GET_REGISTER 0xf0
#define UPF_REQ_SET_REGISTER 0xf1
#define OUTB(dp, p, v, errp, label) \
if ((*(errp) = usbgem_ctrl_out((dp), \
/* bmRequestType */ USB_DEV_REQ_HOST_TO_DEV \
| USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_RCPT_DEV, \
/* bRequest */ UPF_REQ_SET_REGISTER, \
/* wValue */ (v), \
/* wIndex */ (p), \
/* wLength */ 1, \
/* buf */ NULL, \
/* size */ 0)) != USB_SUCCESS) goto label;
#define OUTW(dp, p, v, errp, label) \
if ((*(errp) = usbgem_ctrl_out_val((dp), \
/* bmRequestType */ USB_DEV_REQ_HOST_TO_DEV \
| USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_RCPT_DEV, \
/* bRequest */ UPF_REQ_SET_REGISTER, \
/* wValue */ 0, \
/* wIndex */ (p), \
/* wLength */ 2, \
/* value */ (v))) != USB_SUCCESS) goto label
#define OUTS(dp, p, buf, len, errp, label) \
if ((*(errp) = usbgem_ctrl_out((dp), \
/* bmRequestType */ USB_DEV_REQ_HOST_TO_DEV \
| USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_RCPT_DEV, \
/* bRequest */ UPF_REQ_SET_REGISTER, \
/* wValue */ 0, \
/* wIndex */ (p), \
/* wLength */ (len), \
/* buf */ (buf), \
/* size */ (len))) != USB_SUCCESS) goto label
#define INB(dp, p, vp, errp, label) \
if ((*(errp) = usbgem_ctrl_in_val((dp), \
/* bmRequestType */ USB_DEV_REQ_DEV_TO_HOST \
| USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_RCPT_DEV, \
/* bRequest */ UPF_REQ_GET_REGISTER, \
/* wValue */ 0, \
/* wIndex */ (p), \
/* wLength */ 1, \
/* valuep */ (vp))) != USB_SUCCESS) goto label
#define INW(dp, p, vp, errp, label) \
if ((*(errp) = usbgem_ctrl_in_val((dp), \
/* bmRequestType */ USB_DEV_REQ_DEV_TO_HOST \
| USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_RCPT_DEV, \
/* bRequest */ UPF_REQ_GET_REGISTER, \
/* wValue */ 0, \
/* wIndex */ (p), \
/* wLength */ 2, \
/* valuep */ (vp))) != USB_SUCCESS) goto label
#define INS(dp, p, buf, len, errp, label) \
if ((*(errp) = usbgem_ctrl_in((dp), \
/* bmRequestType */ USB_DEV_REQ_DEV_TO_HOST \
| USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_RCPT_DEV, \
/* bRequest */ UPF_REQ_GET_REGISTER, \
/* wValue */ 0, \
/* wIndex */ (p), \
/* wLength */ (len), \
/* buf */ (buf), \
/* size */ (len))) != USB_SUCCESS) goto label
/* =============================================================== */
/*
* Hardware manupilation
*/
/* =============================================================== */
static int
upf_reset_chip(struct usbgem_dev *dp)
{
int i;
uint8_t val;
int err;
struct upf_dev *lp = dp->private;
DPRINTF(0, (CE_CONT, "!%s: %s: called", dp->name, __func__));
bzero(lp->mac_addr, sizeof (lp->mac_addr));
lp->ec[1] = 0;
OUTB(dp, EC1, EC1_RM, &err, usberr);
for (i = 0; i < 1000; i++) {
INB(dp, EC1, &val, &err, usberr);
if ((val & EC1_RM) == 0) {
lp->ec[1] = val;
return (USB_SUCCESS);
}
drv_usecwait(10);
}
/* time out */
cmn_err(CE_WARN, "!%s: failed to reset: timeout", dp->name);
return (USB_FAILURE);
usberr:
cmn_err(CE_NOTE, "!%s: %s: usberr detected", dp->name, __func__);
return (USB_FAILURE);
}
/*
* Setup an986/adm8511/adm8513/adm8515
*/
static int
upf_init_chip(struct usbgem_dev *dp)
{
uint64_t zero64 = 0;
int err = USB_SUCCESS;
struct upf_dev *lp = dp->private;
DPRINTF(0, (CE_CONT, "!%s: %s: called", dp->name, __func__));
/* ethernet control register 0 */
lp->ec[0] |= EC0_RXSA | EC0_RXCS;
OUTB(dp, EC0, lp->ec[0], &err, usberr);
/* ethernet control reg1: will be set later in set_rx_filter() */
/* ethernet control register 2: will be set later in set_rx_filter() */
INB(dp, EC2, &lp->ec[2], &err, usberr);
lp->ec[2] |= EC2_RXBP | EC2_EP3RC;
#ifdef CONFIG_VLAN
if (dp->misc_flag & USBGEM_VLAN) {
lp->ec[2] |= EC2_MEPL;
}
#endif
OUTB(dp, EC2, lp->ec[2], &err, usberr);
/* Multicast address hash: clear */
OUTS(dp, MA, &zero64, 8, &err, usberr);
/* Ethernet ID : will be set later in upf_set_rx_filter() */
/* PAUSE timer */
OUTB(dp, PAUSETIMER, 0x1f, &err, usberr);
/* receive packet number based pause control:set in upf_set_media() */
/* occupied receive FIFO based pause control:set in upf_set_media() */
/* EP1 control: default */
/* Rx FIFO control */
if (lp->chip_type != CHIP_AN986) {
/* use 24K internal sram, 16pkts in fifo */
OUTB(dp, RXFC, 0, &err, usberr);
}
/* BIST contror: do nothing */
err = upf_set_media(dp);
CHECK_AND_JUMP(err, usberr);
DPRINTF(2, (CE_CONT, "!%s: %s: end (success)", dp->name, __func__));
return (USB_SUCCESS);
usberr:
cmn_err(CE_NOTE, "!%s: %s: usberr(%d) detected",
dp->name, __func__, err);
return (err);
}
static int
upf_start_chip(struct usbgem_dev *dp)
{
int err = USB_SUCCESS;
struct upf_dev *lp = dp->private;
DPRINTF(0, (CE_CONT, "!%s: %s: called", dp->name, __func__));
/* enable RX and TX */
lp->ec[0] |= EC0_TXE | EC0_RXE;
OUTB(dp, EC0, lp->ec[0], &err, usberr);
return (USB_SUCCESS);
usberr:
cmn_err(CE_WARN, "!%s: %s: usberr(%d) detected",
dp->name, __func__, err);
return (err);
}
static int
upf_stop_chip(struct usbgem_dev *dp)
{
int err;
struct upf_dev *lp = dp->private;
DPRINTF(0, (CE_CONT, "!%s: %s: called", dp->name, __func__));
/* disable RX and TX */
lp->ec[0] &= ~(EC0_TXE | EC0_RXE);
OUTB(dp, EC0, lp->ec[0], &err, usberr);
return (USB_SUCCESS);
usberr:
cmn_err(CE_WARN, "!%s: %s: usberr(%d) detected",
dp->name, __func__, err);
return (err);
}
static int
upf_get_stats(struct usbgem_dev *dp)
{
/* do nothing */
return (USB_SUCCESS);
}
static uint_t
upf_mcast_hash(struct usbgem_dev *dp, const uint8_t *addr)
{
/* hash table is 64 = 2^6 bit width */
return (usbgem_ether_crc_le(addr) & 0x3f);
}
static int
upf_set_rx_filter(struct usbgem_dev *dp)
{
int i;
int err;
#ifdef DEBUG_LEVEL
uint8_t reg0;
uint8_t reg1;
uint8_t reg2;
#endif
struct upf_dev *lp = dp->private;
DPRINTF(0, (CE_CONT, "!%s: %s: called, rxmode:%b",
dp->name, __func__, dp->rxmode, RXMODE_BITS));
/* reset rx mode */
lp->ec[0] &= ~EC0_RXMA;
lp->ec[2] &= ~EC2_PROM;
if (dp->rxmode & RXMODE_PROMISC) {
/* promiscious mode implies all multicast and all physical */
lp->ec[0] |= EC0_RXMA;
lp->ec[2] |= EC2_PROM;
} else if ((dp->rxmode & RXMODE_ALLMULTI) || dp->mc_count > 0) {
/* XXX - multicast hash table didin't work */
/* accept all multicast packets */
lp->ec[0] |= EC0_RXMA;
}
if (bcmp(dp->cur_addr.ether_addr_octet,
lp->mac_addr, ETHERADDRL) != 0) {
/* need to update mac address */
bcopy(dp->cur_addr.ether_addr_octet,
lp->mac_addr, ETHERADDRL);
OUTS(dp, EID,
lp->mac_addr, ETHERADDRL, &err, usberr);
}
/* update rx mode */
OUTS(dp, EC0, lp->ec, 3, &err, usberr);
#if DEBUG_LEVEL > 0
INB(dp, EC0, ®0, &err, usberr);
INB(dp, EC1, ®1, &err, usberr);
INB(dp, EC2, ®2, &err, usberr);
cmn_err(CE_CONT, "!%s: %s: returned, ec:%b %b %b",
dp->name, __func__,
reg0, EC0_BITS, reg1, EC1_BITS, reg2, EC2_BITS);
#endif
return (USB_SUCCESS);
usberr:
cmn_err(CE_NOTE, "!%s: %s: usberr detected", dp->name, __func__);
return (err);
}
static int
upf_set_media(struct usbgem_dev *dp)
{
int err;
struct upf_dev *lp = dp->private;
DPRINTF(0, (CE_CONT, "!%s: %s: called", dp->name, __func__));
lp->ec[1] &= ~(EC1_FD | EC1_100M);
/* select duplex */
if (dp->full_duplex) {
lp->ec[1] |= EC1_FD;
}
/* select speed */
if (dp->speed == USBGEM_SPD_100) {
lp->ec[1] |= EC1_100M;
}
/* rx flow control */
switch (dp->flow_control) {
case FLOW_CONTROL_SYMMETRIC:
case FLOW_CONTROL_RX_PAUSE:
lp->ec[0] |= EC0_RXFCE;
break;
default:
lp->ec[0] &= ~EC0_RXFCE;
break;
}
/* tx flow control */
switch (dp->flow_control) {
case FLOW_CONTROL_SYMMETRIC:
case FLOW_CONTROL_TX_PAUSE:
if (lp->chip_type != CHIP_AN986) {
/* pegasus II has internal 24k fifo */
OUTB(dp, ORFBFC,
(12 << ORFBFC_RXS_SHIFT) | ORFBFC_FCRXS,
&err, usberr);
/* 16 packts can be stored in rx fifo */
OUTB(dp, RPNBFC_PN,
(8 << RPNBFC_PN_SHIFT) | RPNBFC_FCP,
&err, usberr);
} else {
/* an986 has external 32k fifo */
OUTB(dp, ORFBFC,
(16 << ORFBFC_RXS_SHIFT) | ORFBFC_FCRXS,
&err, usberr);
/* AN986 fails to link up when RPNBFC is enabled */
OUTB(dp, RPNBFC, 0, &err, usberr);
}
break;
default:
OUTB(dp, ORFBFC, 0, &err, usberr);
OUTB(dp, RPNBFC, 0, &err, usberr);
break;
}
/* update ether control registers */
OUTS(dp, EC0, lp->ec, 2, &err, usberr);
DPRINTF(0, (CE_CONT, "!%s: %s: returned, ec0:%b, ec1:%b",
dp->name, __func__, lp->ec[0], EC0_BITS, lp->ec[1], EC1_BITS));
return (USB_SUCCESS);
usberr:
cmn_err(CE_WARN, "%s: %s: failed to write ec1", dp->name, __func__);
return (err);
}
/*
* send/receive packet check
*/
static mblk_t *
upf_tx_make_packet(struct usbgem_dev *dp, mblk_t *mp)
{
size_t len;
mblk_t *new;
mblk_t *tp;
uint8_t *bp;
uint8_t *last_pos;
int msglen;
DPRINTF(3, (CE_CONT, "!%s: %s: called", dp->name, __func__));
len = msgdsize(mp);
if (len < ETHERMIN) {
len = ETHERMIN;
}
/* allocate msg block */
msglen = len + sizeof (uint16_t);
/* avoid usb controller bug */
if ((msglen & 0x3f) == 0) {
/* add a header for additional 0-length usb message */
msglen += sizeof (uint16_t);
}
if ((new = allocb(msglen, 0)) == NULL) {
return (NULL);
}
/* copy contents of the buffer */
new->b_wptr = new->b_rptr + msglen;
bp = new->b_rptr;
/* the nic requires a two byte header of the packet size */
bp[0] = (uint8_t)len;
bp[1] = (uint8_t)(len >> 8);
bp += sizeof (uint16_t);
/* copy the payload */
for (tp = mp; tp; tp = tp->b_cont) {
len = (uintptr_t)tp->b_wptr - (uintptr_t)tp->b_rptr;
if (len > 0) {
bcopy(tp->b_rptr, bp, len);
bp += len;
}
}
/* clear ethernet pads and additional usb header if we have */
last_pos = new->b_wptr;
while (bp < last_pos) {
*bp++ = 0;
}
return (new);
}
static void
upf_dump_packet(struct usbgem_dev *dp, uint8_t *bp, int n)
{
int i;
for (i = 0; i < n; i += 8, bp += 8) {
cmn_err(CE_CONT, "%02x %02x %02x %02x %02x %02x %02x %02x",
bp[0], bp[1], bp[2], bp[3], bp[4], bp[5], bp[6], bp[7]);
}
}
static mblk_t *
upf_rx_make_packet(struct usbgem_dev *dp, mblk_t *mp)
{
uint8_t *p;
uint16_t rxhd;
uint_t len;
uint8_t rsr;
struct upf_dev *lp = dp->private;
ASSERT(mp != NULL);
#ifdef DEBUG_LEVEL
len = msgdsize(mp);
DPRINTF(2, (CE_CONT, "!%s: time:%d %s: cont:%p",
dp->name, ddi_get_lbolt(), __func__, len, mp->b_cont));
if (upf_debug > 3) {
upf_dump_packet(dp, mp->b_rptr, max(6, len));
}
#endif
/* get the length of Rx packet */
p = mp->b_wptr - 4;
rsr = p[3];
if (lp->chip_type == CHIP_ADM8513) {
/* As Rx packets from ADM8513 have two byte header, remove it */
p = mp->b_rptr;
len = ((p[1] << 8) | p[0]) & 0x0fff;
mp->b_rptr += 2;
} else {
len = (((p[1] << 8) | p[0]) & 0x0fff) - ETHERFCSL - 4;
}
DPRINTF(2, (CE_CONT, "!%s: %s: rsr:%b len:%d",
dp->name, __func__, rsr, RSR_BITS, len));
/* check if error happen */
if (rsr & RSR_ERRORS) {
DPRINTF(0, (CE_CONT, "!%s: rsr:%b", dp->name, rsr, RSR_BITS));
if (rsr & (RSR_CRC | RSR_DRIBBLE)) {
dp->stats.frame++;
}
if (rsr & RSR_LONG) {
dp->stats.frame_too_long++;
}
if (rsr & RSR_RUNT) {
dp->stats.runt++;
}
dp->stats.errrcv++;
return (NULL);
}
#ifndef CONFIG_VLAN
/* check packet size */
if (len > ETHERMAX) {
/* too long */
dp->stats.frame_too_long++;
dp->stats.errrcv++;
return (NULL);
} else if (len < ETHERMIN) {
dp->stats.runt++;
dp->stats.errrcv++;
return (NULL);
}
#endif
/* remove tailing crc and rx status fields */
mp->b_wptr = mp->b_rptr + len;
ASSERT(mp->b_next == NULL);
return (mp);
}
/*
* Device depend interrupt handler
*/
static void
upf_interrupt(struct usbgem_dev *dp, mblk_t *mp)
{
uint8_t *bp;
struct upf_dev *lp = dp->private;
bp = mp->b_rptr;
DPRINTF(2, (CE_CONT,
"!%s: %s: size:%d, %02x %02x %02x %02x %02x %02x %02x %02x",
dp->name, __func__, mp->b_wptr - mp->b_rptr,
bp[0], bp[1], bp[2], bp[3], bp[4], bp[5], bp[6], bp[7]));
if ((lp->last_link_state ^ bp[5]) & 1) {
DPRINTF(1, (CE_CONT, "!%s:%s link status changed:",
dp->name, __func__));
usbgem_mii_update_link(dp);
}
lp->last_link_state = bp[5] & 1;
}
/*
* MII Interfaces
*/
static uint16_t
upf_mii_read(struct usbgem_dev *dp, uint_t index, int *errp)
{
uint8_t phyctrl;
uint16_t val;
int i;
DPRINTF(4, (CE_CONT, "!%s: %s: called, ix:%d",
dp->name, __func__, index));
ASSERT(index >= 0 && index < 32);
*errp = USB_SUCCESS;
/* set PHYADDR */
OUTB(dp, PHYA, dp->mii_phy_addr, errp, usberr);
/* Initiate MII read transaction */
OUTB(dp, PHYAC, index | PHYAC_RDPHY, errp, usberr);
for (i = 0; i < 100; i++) {
INB(dp, PHYAC, &phyctrl, errp, usberr);
if (phyctrl & PHYAC_DO) {
/* done */
INW(dp, PHYD, &val, errp, usberr);
DPRINTF(4, (CE_CONT, "!%s: %s: return %04x",
dp->name, __func__, val));
return (val);
}
drv_usecwait(10);
}
/* timeout */
cmn_err(CE_WARN, "!%s: %s: timeout detected", dp->name, __func__);
*errp = USB_FAILURE;
return (0);
usberr:
cmn_err(CE_CONT,
"!%s: %s: usberr(%d) detected", dp->name, __func__, *errp);
return (0);
}
static void
upf_mii_write(struct usbgem_dev *dp, uint_t index, uint16_t val, int *errp)
{
int i;
uint8_t phyctrl;
DPRINTF(4, (CE_CONT, "!%s: %s called index:%d val:0x%04x",
dp->name, __func__, index, val));
ASSERT(index >= 0 && index < 32);
*errp = USB_SUCCESS;
OUTW(dp, PHYD, val, errp, usberr);
OUTB(dp, PHYA, dp->mii_phy_addr, errp, usberr);
OUTB(dp, PHYAC, index | PHYAC_WRPHY, errp, usberr);
for (i = 0; i < 100; i++) {
INB(dp, PHYAC, &phyctrl, errp, usberr);
if (phyctrl & PHYAC_DO) {
/* done */
return;
}
drv_usecwait(10);
}
/* time out */
cmn_err(CE_WARN, "!%s: %s: timeout detected", dp->name, __func__);
*errp = USB_FAILURE;
return;
usberr:
cmn_err(CE_CONT,
"!%s: %s: usberr(%d) detected", dp->name, __func__, *errp);
}
static int
upf_enable_phy(struct usbgem_dev *dp)
{
uint8_t val;
int err;
struct upf_dev *lp = dp->private;
/*
* first, try to enable internal phy
*/
INB(dp, IPHYC, &val, &err, usberr);
val = (val | IPHYC_EPHY) & ~IPHYC_PHYR;
OUTB(dp, IPHYC, val, &err, usberr);
INB(dp, IPHYC, &val, &err, usberr);
DPRINTF(0, (CE_CONT, "!%s: %s: IPHYC: %b",
dp->name, __func__, val, IPHYC_BITS));
if (val) {
/* reset internal phy */
OUTB(dp, IPHYC, val | IPHYC_PHYR, &err, usberr);
OUTB(dp, IPHYC, val, &err, usberr);
delay(drv_usectohz(10000));
/* identify the chip generation */
OUTB(dp, 0x83, 0xa5, &err, usberr);
INB(dp, 0x83, &val, &err, usberr);
if (val == 0xa5) {
lp->chip_type = CHIP_ADM8513;
} else {
/* adm8511 or adm8515 */
lp->chip_type = CHIP_ADM8511;
}
dp->ugc.usbgc_mii_hw_link_detection = B_TRUE;
} else {
/*
* It should be AN986 which doesn't have an internal PHY.
* We need to setup gpio ports in AN986, which are
* connected to external PHY control pins.
*/
lp->chip_type = CHIP_AN986;
/* reset external phy */
/* output port#0 L, port#1 L */
OUTB(dp, GPIO10, GPIO10_0O | GPIO10_0OE, &err, usberr);
/* output port#0 H, port#1 L */
OUTB(dp, GPIO10,
GPIO10_0O | GPIO10_0OE | GPIO10_1OE, &err, usberr);
/* hw link detection doesn't work correctly */
dp->ugc.usbgc_mii_hw_link_detection = B_FALSE;
}
return (USB_SUCCESS);
usberr:
cmn_err(CE_NOTE, "!%s: %s: usberr detected", dp->name, __func__);
return (USB_FAILURE);
}
static int
upf_mii_probe(struct usbgem_dev *dp)
{
int err;
uint16_t val;
struct upf_dev *lp = dp->private;
if (!lp->phy_init_done) {
upf_enable_phy(dp);
lp->phy_init_done = B_TRUE;
}
return (usbgem_mii_probe_default(dp));
}
static int
upf_mii_init(struct usbgem_dev *dp)
{
uint16_t val;
int err = USB_SUCCESS;
struct upf_dev *lp = dp->private;
if (!lp->phy_init_done) {
upf_enable_phy(dp);
}
lp->phy_init_done = B_FALSE;
if (lp->chip_type == CHIP_AN986 &&
(lp->vid == 0x0db7 /* elecom */ ||
lp->vid == 0x066b /* linksys */ ||
lp->vid == 0x077b /* linksys */ ||
lp->vid == 0x2001 /* dlink */)) {
/* special treatment for Linksys products */
val = upf_mii_read(dp, 0x1b, &err) | 0x4;
upf_mii_write(dp, 0x1b, val, &err);
}
return (err);
}
/* ======================================================== */
/*
* OS depend (device driver DKI) routine
*/
/* ======================================================== */
static uint16_t
upf_read_eeprom(struct usbgem_dev *dp, int index, int *errp)
{
int i;
uint8_t eectrl;
uint16_t data;
*errp = USB_SUCCESS;
OUTB(dp, EECTRL, 0, errp, usberr);
OUTB(dp, EEOFFSET, index, errp, usberr);
OUTB(dp, EECTRL, EECTRL_RD, errp, usberr);
for (i = 0; i < 100; i++) {
INB(dp, EECTRL, &eectrl, errp, usberr);
if (eectrl & EECTRL_DONE) {
INW(dp, EEDATA, &data, errp, usberr);
return (data);
}
drv_usecwait(10);
}
/* time out */
*errp = USB_FAILURE;
return (0);
usberr:
cmn_err(CE_CONT,
"!%s: %s: usberr(%d) detected", dp->name, __func__, *errp);
return (0);
}
static void
upf_eeprom_dump(struct usbgem_dev *dp, int size)
{
int i;
int err;
cmn_err(CE_CONT, "!%s: %s dump:", dp->name, __func__);
for (i = 0; i < size; i += 4) {
cmn_err(CE_CONT, "!0x%02x: 0x%04x 0x%04x 0x%04x 0x%04x",
i*2,
upf_read_eeprom(dp, i + 0, &err),
upf_read_eeprom(dp, i + 1, &err),
upf_read_eeprom(dp, i + 2, &err),
upf_read_eeprom(dp, i + 3, &err));
}
}
static int
upf_attach_chip(struct usbgem_dev *dp)
{
int i;
int err;
uint16_t val;
uint8_t *mac;
struct upf_dev *lp = dp->private;
/*
* Read mac address from EEPROM
*/
mac = dp->dev_addr.ether_addr_octet;
for (i = 0; i < 3; i++) {
val = upf_read_eeprom(dp, i, &err);
if (err != USB_SUCCESS) {
goto usberr;
}
mac[i*2+0] = (uint8_t)val;
mac[i*2+1] = (uint8_t)(val >> 8);
}
DPRINTF(0, (CE_CONT,
"%s: %s: mac: %02x:%02x:%02x:%02x:%02x:%02x",
dp->name, __func__,
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]));
dp->misc_flag = 0;
#ifdef CONFIG_VLAN
dp->misc_flag |= USBGEM_VLAN;
#endif
#if DEBUG_LEVEL > 3
upf_eeprom_dump(dp, 0x80);
#endif
return (USB_SUCCESS);
usberr:
cmn_err(CE_WARN, "!%s: %s: usb error detected", dp->name, __func__);
return (USB_FAILURE);
}
static int
upfattach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
int i;
ddi_iblock_cookie_t c;
int ret;
int unit;
uint32_t tcr;
int len;
const char *drv_name;
struct usbgem_dev *dp;
void *base;
struct usbgem_conf *ugcp;
struct upf_dev *lp;
unit = ddi_get_instance(dip);
drv_name = ddi_driver_name(dip);
DPRINTF(3, (CE_CONT, "!%s%d: %s: called, cmd:%d",
drv_name, unit, __func__, cmd));
if (cmd == DDI_ATTACH) {
/*
* construct usbgem configration
*/
ugcp = kmem_zalloc(sizeof (*ugcp), KM_SLEEP);
/* name */
(void) sprintf(ugcp->usbgc_name, "%s%d", drv_name, unit);
ugcp->usbgc_ppa = unit;
ugcp->usbgc_ifnum = 0;
ugcp->usbgc_alt = 0;
ugcp->usbgc_tx_list_max = 16;
ugcp->usbgc_rx_header_len = 4;
ugcp->usbgc_rx_list_max = 64;
/* time out parameters */
ugcp->usbgc_tx_timeout = USBGEM_TX_TIMEOUT;
ugcp->usbgc_tx_timeout_interval = USBGEM_TX_TIMEOUT_INTERVAL;
/* flow control */
ugcp->usbgc_flow_control = FLOW_CONTROL_NONE;
ugcp->usbgc_flow_control = FLOW_CONTROL_RX_PAUSE;
/* MII timeout parameters */
ugcp->usbgc_mii_link_watch_interval = ONESEC;
ugcp->usbgc_mii_an_watch_interval = ONESEC/5;
ugcp->usbgc_mii_reset_timeout = MII_RESET_TIMEOUT; /* 1 sec */
ugcp->usbgc_mii_an_timeout = MII_AN_TIMEOUT; /* 5 sec */
ugcp->usbgc_mii_an_wait = MII_AN_TIMEOUT/2;
ugcp->usbgc_mii_linkdown_timeout = MII_LINKDOWN_TIMEOUT;
ugcp->usbgc_mii_an_delay = ONESEC/10;
ugcp->usbgc_mii_linkdown_action = MII_ACTION_RESET;
ugcp->usbgc_mii_linkdown_timeout_action = MII_ACTION_RESET;
ugcp->usbgc_mii_dont_reset = B_FALSE;
/* I/O methods */
/* mac operation */
ugcp->usbgc_attach_chip = &upf_attach_chip;
ugcp->usbgc_reset_chip = &upf_reset_chip;
ugcp->usbgc_init_chip = &upf_init_chip;
ugcp->usbgc_start_chip = &upf_start_chip;
ugcp->usbgc_stop_chip = &upf_stop_chip;
ugcp->usbgc_multicast_hash = &upf_mcast_hash;
ugcp->usbgc_set_rx_filter = &upf_set_rx_filter;
ugcp->usbgc_set_media = &upf_set_media;
ugcp->usbgc_get_stats = &upf_get_stats;
ugcp->usbgc_interrupt = &upf_interrupt;
/* packet operation */
ugcp->usbgc_tx_make_packet = &upf_tx_make_packet;
ugcp->usbgc_rx_make_packet = &upf_rx_make_packet;
/* mii operations */
ugcp->usbgc_mii_probe = &upf_mii_probe;
ugcp->usbgc_mii_init = &upf_mii_init;
ugcp->usbgc_mii_config = &usbgem_mii_config_default;
ugcp->usbgc_mii_read = &upf_mii_read;
ugcp->usbgc_mii_write = &upf_mii_write;
/* mtu */
ugcp->usbgc_min_mtu = ETHERMTU;
ugcp->usbgc_max_mtu = ETHERMTU;
ugcp->usbgc_default_mtu = ETHERMTU;
lp = kmem_zalloc(sizeof (struct upf_dev), KM_SLEEP);
lp->vid = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
DDI_PROP_DONTPASS, "usb-vendor-id", -1);
lp->pid = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
DDI_PROP_DONTPASS, "usb-product-id", -1);
dp = usbgem_do_attach(dip, ugcp, lp, sizeof (struct upf_dev));
kmem_free(ugcp, sizeof (*ugcp));
if (dp != NULL) {
return (DDI_SUCCESS);
}
err_free_mem:
kmem_free(lp, sizeof (struct upf_dev));
err_close_pipe:
err:
return (DDI_FAILURE);
}
if (cmd == DDI_RESUME) {
dp = USBGEM_GET_DEV(dip);
lp = dp->private;
lp->phy_init_done = B_FALSE;
return (usbgem_resume(dip));
}
return (DDI_FAILURE);
}
static int
upfdetach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
int ret;
if (cmd == DDI_DETACH) {
ret = usbgem_do_detach(dip);
if (ret != DDI_SUCCESS) {
return (DDI_FAILURE);
}
return (DDI_SUCCESS);
}
if (cmd == DDI_SUSPEND) {
return (usbgem_suspend(dip));
}
return (DDI_FAILURE);
}
/* ======================================================== */
/*
* OS depend (loadable streams driver) routine
*/
/* ======================================================== */
USBGEM_STREAM_OPS(upf_ops, upfattach, upfdetach);
static struct modldrv modldrv = {
&mod_driverops, /* Type of module. This one is a driver */
ident,
&upf_ops, /* driver ops */
};
static struct modlinkage modlinkage = {
MODREV_1, &modldrv, NULL
};
/* ======================================================== */
/*
* _init : done
*/
/* ======================================================== */
int
_init(void)
{
int status;
DPRINTF(2, (CE_CONT, "!upf: _init: called"));
status = usbgem_mod_init(&upf_ops, "upf");
if (status != DDI_SUCCESS) {
return (status);
}
status = mod_install(&modlinkage);
if (status != DDI_SUCCESS) {
usbgem_mod_fini(&upf_ops);
}
return (status);
}
/*
* _fini : done
*/
int
_fini(void)
{
int status;
DPRINTF(2, (CE_CONT, "!upf: _fini: called"));
status = mod_remove(&modlinkage);
if (status == DDI_SUCCESS) {
usbgem_mod_fini(&upf_ops);
}
return (status);
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}