[net-next-2.6.git] / drivers / net / usb / net1080.c

/*
 * Net1080 based USB host-to-host cables
 * Copyright (C) 2000-2005 by David Brownell
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

// #define	DEBUG			// error path messages, extra info
// #define	VERBOSE			// more; success messages

#include <linux/module.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/ethtool.h>
#include <linux/workqueue.h>
#include <linux/mii.h>
#include <linux/usb.h>
#include <linux/usb/usbnet.h>

#include <asm/unaligned.h>


/*
 * Netchip 1080 driver ... http://www.netchip.com
 * (Sept 2004:  End-of-life announcement has been sent.)
 * Used in (some) LapLink cables
 */

#define frame_errors	data[1]

/*
 * NetChip framing of ethernet packets, supporting additional error
 * checks for links that may drop bulk packets from inside messages.
 * Odd USB length == always short read for last usb packet.
 *	- nc_header
 *	- Ethernet header (14 bytes)
 *	- payload
 *	- (optional padding byte, if needed so length becomes odd)
 *	- nc_trailer
 *
 * This framing is to be avoided for non-NetChip devices.
 */

struct nc_header {		// packed:
	__le16	hdr_len;		// sizeof nc_header (LE, all)
	__le16	packet_len;		// payload size (including ethhdr)
	__le16	packet_id;		// detects dropped packets
#define MIN_HEADER	6

	// all else is optional, and must start with:
	// __le16	vendorId;	// from usb-if
	// __le16	productId;
} __attribute__((__packed__));

#define	PAD_BYTE	((unsigned char)0xAC)

struct nc_trailer {
	__le16	packet_id;
} __attribute__((__packed__));

// packets may use FLAG_FRAMING_NC and optional pad
#define FRAMED_SIZE(mtu) (sizeof (struct nc_header) \
				+ sizeof (struct ethhdr) \
				+ (mtu) \
				+ 1 \
				+ sizeof (struct nc_trailer))

#define MIN_FRAMED	FRAMED_SIZE(0)

/* packets _could_ be up to 64KB... */
#define NC_MAX_PACKET	32767


/*
 * Zero means no timeout; else, how long a 64 byte bulk packet may be queued
 * before the hardware drops it.  If that's done, the driver will need to
 * frame network packets to guard against the dropped USB packets.  The win32
 * driver sets this for both sides of the link.
 */
#define	NC_READ_TTL_MS	((u8)255)	// ms

/*
 * We ignore most registers and EEPROM contents.
 */
#define	REG_USBCTL	((u8)0x04)
#define REG_TTL		((u8)0x10)
#define REG_STATUS	((u8)0x11)

/*
 * Vendor specific requests to read/write data
 */
#define	REQUEST_REGISTER	((u8)0x10)
#define	REQUEST_EEPROM		((u8)0x11)

static int
nc_vendor_read(struct usbnet *dev, u8 req, u8 regnum, u16 *retval_ptr)
{
	int status = usb_control_msg(dev->udev,
		usb_rcvctrlpipe(dev->udev, 0),
		req,
		USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
		0, regnum,
		retval_ptr, sizeof *retval_ptr,
		USB_CTRL_GET_TIMEOUT);
	if (status > 0)
		status = 0;
	if (!status)
		le16_to_cpus(retval_ptr);
	return status;
}

static inline int
nc_register_read(struct usbnet *dev, u8 regnum, u16 *retval_ptr)
{
	return nc_vendor_read(dev, REQUEST_REGISTER, regnum, retval_ptr);
}

// no retval ... can become async, usable in_interrupt()
static void
nc_vendor_write(struct usbnet *dev, u8 req, u8 regnum, u16 value)
{
	usb_control_msg(dev->udev,
		usb_sndctrlpipe(dev->udev, 0),
		req,
		USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
		value, regnum,
		NULL, 0,			// data is in setup packet
		USB_CTRL_SET_TIMEOUT);
}

static inline void
nc_register_write(struct usbnet *dev, u8 regnum, u16 value)
{
	nc_vendor_write(dev, REQUEST_REGISTER, regnum, value);
}


#if 0
static void nc_dump_registers(struct usbnet *dev)
{
	u8	reg;
	u16	*vp = kmalloc(sizeof (u16));

	if (!vp) {
		dbg("no memory?");
		return;
	}

	dbg("%s registers:", dev->net->name);
	for (reg = 0; reg < 0x20; reg++) {
		int retval;

		// reading some registers is trouble
		if (reg >= 0x08 && reg <= 0xf)
			continue;
		if (reg >= 0x12 && reg <= 0x1e)
			continue;

		retval = nc_register_read(dev, reg, vp);
		if (retval < 0)
			dbg("%s reg [0x%x] ==> error %d",
				dev->net->name, reg, retval);
		else
			dbg("%s reg [0x%x] = 0x%x",
				dev->net->name, reg, *vp);
	}
	kfree(vp);
}
#endif


/*-------------------------------------------------------------------------*/

/*
 * Control register
 */

#define	USBCTL_WRITABLE_MASK	0x1f0f
// bits 15-13 reserved, r/o
#define	USBCTL_ENABLE_LANG	(1 << 12)
#define	USBCTL_ENABLE_MFGR	(1 << 11)
#define	USBCTL_ENABLE_PROD	(1 << 10)
#define	USBCTL_ENABLE_SERIAL	(1 << 9)
#define	USBCTL_ENABLE_DEFAULTS	(1 << 8)
// bits 7-4 reserved, r/o
#define	USBCTL_FLUSH_OTHER	(1 << 3)
#define	USBCTL_FLUSH_THIS	(1 << 2)
#define	USBCTL_DISCONN_OTHER	(1 << 1)
#define	USBCTL_DISCONN_THIS	(1 << 0)

static inline void nc_dump_usbctl(struct usbnet *dev, u16 usbctl)
{
	netif_dbg(dev, link, dev->net,
		  "net1080 %s-%s usbctl 0x%x:%s%s%s%s%s; this%s%s; other%s%s; r/o 0x%x\n",
		  dev->udev->bus->bus_name, dev->udev->devpath,
		  usbctl,
		  (usbctl & USBCTL_ENABLE_LANG) ? " lang" : "",
		  (usbctl & USBCTL_ENABLE_MFGR) ? " mfgr" : "",
		  (usbctl & USBCTL_ENABLE_PROD) ? " prod" : "",
		  (usbctl & USBCTL_ENABLE_SERIAL) ? " serial" : "",
		  (usbctl & USBCTL_ENABLE_DEFAULTS) ? " defaults" : "",

		  (usbctl & USBCTL_FLUSH_THIS) ? " FLUSH" : "",
		  (usbctl & USBCTL_DISCONN_THIS) ? " DIS" : "",

		  (usbctl & USBCTL_FLUSH_OTHER) ? " FLUSH" : "",
		  (usbctl & USBCTL_DISCONN_OTHER) ? " DIS" : "",

		  usbctl & ~USBCTL_WRITABLE_MASK);
}

/*-------------------------------------------------------------------------*/

/*
 * Status register
 */

#define	STATUS_PORT_A		(1 << 15)

#define	STATUS_CONN_OTHER	(1 << 14)
#define	STATUS_SUSPEND_OTHER	(1 << 13)
#define	STATUS_MAILBOX_OTHER	(1 << 12)
#define	STATUS_PACKETS_OTHER(n)	(((n) >> 8) & 0x03)

#define	STATUS_CONN_THIS	(1 << 6)
#define	STATUS_SUSPEND_THIS	(1 << 5)
#define	STATUS_MAILBOX_THIS	(1 << 4)
#define	STATUS_PACKETS_THIS(n)	(((n) >> 0) & 0x03)

#define	STATUS_UNSPEC_MASK	0x0c8c
#define	STATUS_NOISE_MASK 	((u16)~(0x0303|STATUS_UNSPEC_MASK))


static inline void nc_dump_status(struct usbnet *dev, u16 status)
{
	netif_dbg(dev, link, dev->net,
		  "net1080 %s-%s status 0x%x: this (%c) PKT=%d%s%s%s; other PKT=%d%s%s%s; unspec 0x%x\n",
		  dev->udev->bus->bus_name, dev->udev->devpath,
		  status,

		  // XXX the packet counts don't seem right
		  // (1 at reset, not 0); maybe UNSPEC too

		  (status & STATUS_PORT_A) ? 'A' : 'B',
		  STATUS_PACKETS_THIS(status),
		  (status & STATUS_CONN_THIS) ? " CON" : "",
		  (status & STATUS_SUSPEND_THIS) ? " SUS" : "",
		  (status & STATUS_MAILBOX_THIS) ? " MBOX" : "",

		  STATUS_PACKETS_OTHER(status),
		  (status & STATUS_CONN_OTHER) ? " CON" : "",
		  (status & STATUS_SUSPEND_OTHER) ? " SUS" : "",
		  (status & STATUS_MAILBOX_OTHER) ? " MBOX" : "",

		  status & STATUS_UNSPEC_MASK);
}

/*-------------------------------------------------------------------------*/

/*
 * TTL register
 */

#define	TTL_THIS(ttl)	(0x00ff & ttl)
#define	TTL_OTHER(ttl)	(0x00ff & (ttl >> 8))
#define MK_TTL(this,other)	((u16)(((other)<<8)|(0x00ff&(this))))

static inline void nc_dump_ttl(struct usbnet *dev, u16 ttl)
{
	netif_dbg(dev, link, dev->net, "net1080 %s-%s ttl 0x%x this = %d, other = %d\n",
		  dev->udev->bus->bus_name, dev->udev->devpath,
		  ttl, TTL_THIS(ttl), TTL_OTHER(ttl));
}

/*-------------------------------------------------------------------------*/

static int net1080_reset(struct usbnet *dev)
{
	u16		usbctl, status, ttl;
	u16		*vp = kmalloc(sizeof (u16), GFP_KERNEL);
	int		retval;

	if (!vp)
		return -ENOMEM;

	// nc_dump_registers(dev);

	if ((retval = nc_register_read(dev, REG_STATUS, vp)) < 0) {
		dbg("can't read %s-%s status: %d",
			dev->udev->bus->bus_name, dev->udev->devpath, retval);
		goto done;
	}
	status = *vp;
	nc_dump_status(dev, status);

	if ((retval = nc_register_read(dev, REG_USBCTL, vp)) < 0) {
		dbg("can't read USBCTL, %d", retval);
		goto done;
	}
	usbctl = *vp;
	nc_dump_usbctl(dev, usbctl);

	nc_register_write(dev, REG_USBCTL,
			USBCTL_FLUSH_THIS | USBCTL_FLUSH_OTHER);

	if ((retval = nc_register_read(dev, REG_TTL, vp)) < 0) {
		dbg("can't read TTL, %d", retval);
		goto done;
	}
	ttl = *vp;
	// nc_dump_ttl(dev, ttl);

	nc_register_write(dev, REG_TTL,
			MK_TTL(NC_READ_TTL_MS, TTL_OTHER(ttl)) );
	dbg("%s: assigned TTL, %d ms", dev->net->name, NC_READ_TTL_MS);

	netif_info(dev, link, dev->net, "port %c, peer %sconnected\n",
		   (status & STATUS_PORT_A) ? 'A' : 'B',
		   (status & STATUS_CONN_OTHER) ? "" : "dis");
	retval = 0;

done:
	kfree(vp);
	return retval;
}

static int net1080_check_connect(struct usbnet *dev)
{
	int			retval;
	u16			status;
	u16			*vp = kmalloc(sizeof (u16), GFP_KERNEL);

	if (!vp)
		return -ENOMEM;
	retval = nc_register_read(dev, REG_STATUS, vp);
	status = *vp;
	kfree(vp);
	if (retval != 0) {
		dbg("%s net1080_check_conn read - %d", dev->net->name, retval);
		return retval;
	}
	if ((status & STATUS_CONN_OTHER) != STATUS_CONN_OTHER)
		return -ENOLINK;
	return 0;
}

static void nc_flush_complete(struct urb *urb)
{
	kfree(urb->context);
	usb_free_urb(urb);
}

static void nc_ensure_sync(struct usbnet *dev)
{
	dev->frame_errors++;
	if (dev->frame_errors > 5) {
		struct urb		*urb;
		struct usb_ctrlrequest	*req;
		int			status;

		/* Send a flush */
		urb = usb_alloc_urb(0, GFP_ATOMIC);
		if (!urb)
			return;

		req = kmalloc(sizeof *req, GFP_ATOMIC);
		if (!req) {
			usb_free_urb(urb);
			return;
		}

		req->bRequestType = USB_DIR_OUT
			| USB_TYPE_VENDOR
			| USB_RECIP_DEVICE;
		req->bRequest = REQUEST_REGISTER;
		req->wValue = cpu_to_le16(USBCTL_FLUSH_THIS
				| USBCTL_FLUSH_OTHER);
		req->wIndex = cpu_to_le16(REG_USBCTL);
		req->wLength = cpu_to_le16(0);

		/* queue an async control request, we don't need
		 * to do anything when it finishes except clean up.
		 */
		usb_fill_control_urb(urb, dev->udev,
			usb_sndctrlpipe(dev->udev, 0),
			(unsigned char *) req,
			NULL, 0,
			nc_flush_complete, req);
		status = usb_submit_urb(urb, GFP_ATOMIC);
		if (status) {
			kfree(req);
			usb_free_urb(urb);
			return;
		}

		netif_dbg(dev, rx_err, dev->net,
			  "flush net1080; too many framing errors\n");
		dev->frame_errors = 0;
	}
}

static int net1080_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
{
	struct nc_header	*header;
	struct nc_trailer	*trailer;
	u16			hdr_len, packet_len;

	if (!(skb->len & 0x01)) {
#ifdef DEBUG
		struct net_device	*net = dev->net;
		dbg("rx framesize %d range %d..%d mtu %d", skb->len,
			net->hard_header_len, dev->hard_mtu, net->mtu);
#endif
		dev->net->stats.rx_frame_errors++;
		nc_ensure_sync(dev);
		return 0;
	}

	header = (struct nc_header *) skb->data;
	hdr_len = le16_to_cpup(&header->hdr_len);
	packet_len = le16_to_cpup(&header->packet_len);
	if (FRAMED_SIZE(packet_len) > NC_MAX_PACKET) {
		dev->net->stats.rx_frame_errors++;
		dbg("packet too big, %d", packet_len);
		nc_ensure_sync(dev);
		return 0;
	} else if (hdr_len < MIN_HEADER) {
		dev->net->stats.rx_frame_errors++;
		dbg("header too short, %d", hdr_len);
		nc_ensure_sync(dev);
		return 0;
	} else if (hdr_len > MIN_HEADER) {
		// out of band data for us?
		dbg("header OOB, %d bytes", hdr_len - MIN_HEADER);
		nc_ensure_sync(dev);
		// switch (vendor/product ids) { ... }
	}
	skb_pull(skb, hdr_len);

	trailer = (struct nc_trailer *)
		(skb->data + skb->len - sizeof *trailer);
	skb_trim(skb, skb->len - sizeof *trailer);

	if ((packet_len & 0x01) == 0) {
		if (skb->data [packet_len] != PAD_BYTE) {
			dev->net->stats.rx_frame_errors++;
			dbg("bad pad");
			return 0;
		}
		skb_trim(skb, skb->len - 1);
	}
	if (skb->len != packet_len) {
		dev->net->stats.rx_frame_errors++;
		dbg("bad packet len %d (expected %d)",
			skb->len, packet_len);
		nc_ensure_sync(dev);
		return 0;
	}
	if (header->packet_id != get_unaligned(&trailer->packet_id)) {
		dev->net->stats.rx_fifo_errors++;
		dbg("(2+ dropped) rx packet_id mismatch 0x%x 0x%x",
			le16_to_cpu(header->packet_id),
			le16_to_cpu(trailer->packet_id));
		return 0;
	}
#if 0
	netdev_dbg(dev->net, "frame <rx h %d p %d id %d\n", header->hdr_len,
		   header->packet_len, header->packet_id);
#endif
	dev->frame_errors = 0;
	return 1;
}

static struct sk_buff *
net1080_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
{
	struct sk_buff		*skb2;
	struct nc_header	*header = NULL;
	struct nc_trailer	*trailer = NULL;
	int			padlen = sizeof (struct nc_trailer);
	int			len = skb->len;

	if (!((len + padlen + sizeof (struct nc_header)) & 0x01))
		padlen++;
	if (!skb_cloned(skb)) {
		int	headroom = skb_headroom(skb);
		int	tailroom = skb_tailroom(skb);

		if (padlen <= tailroom &&
		    sizeof(struct nc_header) <= headroom)
			/* There's enough head and tail room */
			goto encapsulate;

		if ((sizeof (struct nc_header) + padlen) <
				(headroom + tailroom)) {
			/* There's enough total room, so just readjust */
			skb->data = memmove(skb->head
						+ sizeof (struct nc_header),
					    skb->data, skb->len);
			skb_set_tail_pointer(skb, len);
			goto encapsulate;
		}
	}

	/* Create a new skb to use with the correct size */
	skb2 = skb_copy_expand(skb,
				sizeof (struct nc_header),
				padlen,
				flags);
	dev_kfree_skb_any(skb);
	if (!skb2)
		return skb2;
	skb = skb2;

encapsulate:
	/* header first */
	header = (struct nc_header *) skb_push(skb, sizeof *header);
	header->hdr_len = cpu_to_le16(sizeof (*header));
	header->packet_len = cpu_to_le16(len);
	header->packet_id = cpu_to_le16((u16)dev->xid++);

	/* maybe pad; then trailer */
	if (!((skb->len + sizeof *trailer) & 0x01))
		*skb_put(skb, 1) = PAD_BYTE;
	trailer = (struct nc_trailer *) skb_put(skb, sizeof *trailer);
	put_unaligned(header->packet_id, &trailer->packet_id);
#if 0
	netdev_dbg(dev->net, "frame >tx h %d p %d id %d\n",
		   header->hdr_len, header->packet_len,
		   header->packet_id);
#endif
	return skb;
}

static int net1080_bind(struct usbnet *dev, struct usb_interface *intf)
{
	unsigned	extra = sizeof (struct nc_header)
				+ 1
				+ sizeof (struct nc_trailer);

	dev->net->hard_header_len += extra;
	dev->rx_urb_size = dev->net->hard_header_len + dev->net->mtu;
	dev->hard_mtu = NC_MAX_PACKET;
	return usbnet_get_endpoints (dev, intf);
}

static const struct driver_info	net1080_info = {
	.description =	"NetChip TurboCONNECT",
	.flags =	FLAG_FRAMING_NC,
	.bind =		net1080_bind,
	.reset =	net1080_reset,
	.check_connect = net1080_check_connect,
	.rx_fixup =	net1080_rx_fixup,
	.tx_fixup =	net1080_tx_fixup,
};

static const struct usb_device_id	products [] = {
{
	USB_DEVICE(0x0525, 0x1080),	// NetChip ref design
	.driver_info =	(unsigned long) &net1080_info,
}, {
	USB_DEVICE(0x06D0, 0x0622),	// Laplink Gold
	.driver_info =	(unsigned long) &net1080_info,
},
	{ },		// END
};
MODULE_DEVICE_TABLE(usb, products);

static struct usb_driver net1080_driver = {
	.name =		"net1080",
	.id_table =	products,
	.probe =	usbnet_probe,
	.disconnect =	usbnet_disconnect,
	.suspend =	usbnet_suspend,
	.resume =	usbnet_resume,
};

static int __init net1080_init(void)
{
 	return usb_register(&net1080_driver);
}
module_init(net1080_init);

static void __exit net1080_exit(void)
{
 	usb_deregister(&net1080_driver);
}
module_exit(net1080_exit);

MODULE_AUTHOR("David Brownell");
MODULE_DESCRIPTION("NetChip 1080 based USB Host-to-Host Links");
MODULE_LICENSE("GPL");
Commit	Line	Data
904813cd DB	1	/*
	2	* Net1080 based USB host-to-host cables
	3	* Copyright (C) 2000-2005 by David Brownell
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*/
	19
	20	// #define DEBUG // error path messages, extra info
	21	// #define VERBOSE // more; success messages
	22
904813cd	23	#include <linux/module.h>
904813cd DB	24	#include <linux/init.h>
	25	#include <linux/netdevice.h>
	26	#include <linux/etherdevice.h>
	27	#include <linux/ethtool.h>
	28	#include <linux/workqueue.h>
	29	#include <linux/mii.h>
	30	#include <linux/usb.h>
3692e94f	31	#include <linux/usb/usbnet.h>
904813cd DB	32
	33	#include <asm/unaligned.h>
	34
904813cd DB	35
	36	/*
	37	* Netchip 1080 driver ... http://www.netchip.com
	38	* (Sept 2004: End-of-life announcement has been sent.)
	39	* Used in (some) LapLink cables
	40	*/
	41
	42	#define frame_errors data[1]
	43
	44	/*
	45	* NetChip framing of ethernet packets, supporting additional error
	46	* checks for links that may drop bulk packets from inside messages.
	47	* Odd USB length == always short read for last usb packet.
	48	* - nc_header
	49	* - Ethernet header (14 bytes)
	50	* - payload
	51	* - (optional padding byte, if needed so length becomes odd)
	52	* - nc_trailer
	53	*
	54	* This framing is to be avoided for non-NetChip devices.
	55	*/
	56
	57	struct nc_header { // packed:
	58	__le16 hdr_len; // sizeof nc_header (LE, all)
	59	__le16 packet_len; // payload size (including ethhdr)
	60	__le16 packet_id; // detects dropped packets
	61	#define MIN_HEADER 6
	62
	63	// all else is optional, and must start with:
	64	// __le16 vendorId; // from usb-if
	65	// __le16 productId;
	66	} __attribute__((__packed__));
	67
	68	#define PAD_BYTE ((unsigned char)0xAC)
	69
	70	struct nc_trailer {
	71	__le16 packet_id;
	72	} __attribute__((__packed__));
	73
	74	// packets may use FLAG_FRAMING_NC and optional pad
	75	#define FRAMED_SIZE(mtu) (sizeof (struct nc_header) \
	76	+ sizeof (struct ethhdr) \
	77	+ (mtu) \
	78	+ 1 \
	79	+ sizeof (struct nc_trailer))
	80
	81	#define MIN_FRAMED FRAMED_SIZE(0)
	82
	83	/* packets _could_ be up to 64KB... */
	84	#define NC_MAX_PACKET 32767
	85
	86
	87	/*
	88	* Zero means no timeout; else, how long a 64 byte bulk packet may be queued
	89	* before the hardware drops it. If that's done, the driver will need to
	90	* frame network packets to guard against the dropped USB packets. The win32
	91	* driver sets this for both sides of the link.
	92	*/
	93	#define NC_READ_TTL_MS ((u8)255) // ms
	94
	95	/*
	96	* We ignore most registers and EEPROM contents.
	97	*/
	98	#define REG_USBCTL ((u8)0x04)
99	#define REG_TTL ((u8)0x10)
100	#define REG_STATUS ((u8)0x11)
101
102	/*
103	* Vendor specific requests to read/write data
104	*/
105	#define REQUEST_REGISTER ((u8)0x10)
106	#define REQUEST_EEPROM ((u8)0x11)
107
108	static int
109	nc_vendor_read(struct usbnet dev, u8 req, u8 regnum, u16 retval_ptr)
110	{
111	int status = usb_control_msg(dev->udev,
112	usb_rcvctrlpipe(dev->udev, 0),
113	req,
114	USB_DIR_IN \| USB_TYPE_VENDOR \| USB_RECIP_DEVICE,
115	0, regnum,
116	retval_ptr, sizeof *retval_ptr,
117	USB_CTRL_GET_TIMEOUT);
118	if (status > 0)
119	status = 0;
120	if (!status)
121	le16_to_cpus(retval_ptr);
122	return status;
123	}
124
125	static inline int
126	nc_register_read(struct usbnet dev, u8 regnum, u16 retval_ptr)
127	{
128	return nc_vendor_read(dev, REQUEST_REGISTER, regnum, retval_ptr);
129	}
130
131	// no retval ... can become async, usable in_interrupt()
132	static void
133	nc_vendor_write(struct usbnet *dev, u8 req, u8 regnum, u16 value)
134	{
135	usb_control_msg(dev->udev,
136	usb_sndctrlpipe(dev->udev, 0),
137	req,
138	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_DEVICE,
139	value, regnum,
140	NULL, 0, // data is in setup packet
141	USB_CTRL_SET_TIMEOUT);
142	}
143
144	static inline void
145	nc_register_write(struct usbnet *dev, u8 regnum, u16 value)
146	{
147	nc_vendor_write(dev, REQUEST_REGISTER, regnum, value);
148	}
149
150
151	#if 0
152	static void nc_dump_registers(struct usbnet *dev)
153	{
154	u8 reg;
155	u16 *vp = kmalloc(sizeof (u16));
156
157	if (!vp) {
158	dbg("no memory?");
159	return;
160	}
161
162	dbg("%s registers:", dev->net->name);
163	for (reg = 0; reg < 0x20; reg++) {
164	int retval;
165
166	// reading some registers is trouble
167	if (reg >= 0x08 && reg <= 0xf)
168	continue;
169	if (reg >= 0x12 && reg <= 0x1e)
170	continue;
171
172	retval = nc_register_read(dev, reg, vp);
173	if (retval < 0)
174	dbg("%s reg [0x%x] ==> error %d",
175	dev->net->name, reg, retval);
176	else
177	dbg("%s reg [0x%x] = 0x%x",
178	dev->net->name, reg, *vp);
179	}
180	kfree(vp);
181	}
182	#endif
183
184
185	/-------------------------------------------------------------------------/
186
187	/*
188	* Control register
189	*/
190
191	#define USBCTL_WRITABLE_MASK 0x1f0f
192	// bits 15-13 reserved, r/o
193	#define USBCTL_ENABLE_LANG (1 << 12)
194	#define USBCTL_ENABLE_MFGR (1 << 11)
195	#define USBCTL_ENABLE_PROD (1 << 10)
196	#define USBCTL_ENABLE_SERIAL (1 << 9)
197	#define USBCTL_ENABLE_DEFAULTS (1 << 8)
198	// bits 7-4 reserved, r/o
199	#define USBCTL_FLUSH_OTHER (1 << 3)
200	#define USBCTL_FLUSH_THIS (1 << 2)
201	#define USBCTL_DISCONN_OTHER (1 << 1)
202	#define USBCTL_DISCONN_THIS (1 << 0)
203
204	static inline void nc_dump_usbctl(struct usbnet *dev, u16 usbctl)
205	{
a475f603 JP	206	netif_dbg(dev, link, dev->net,
	207	"net1080 %s-%s usbctl 0x%x:%s%s%s%s%s; this%s%s; other%s%s; r/o 0x%x\n",
	208	dev->udev->bus->bus_name, dev->udev->devpath,
	209	usbctl,
	210	(usbctl & USBCTL_ENABLE_LANG) ? " lang" : "",
	211	(usbctl & USBCTL_ENABLE_MFGR) ? " mfgr" : "",
	212	(usbctl & USBCTL_ENABLE_PROD) ? " prod" : "",
	213	(usbctl & USBCTL_ENABLE_SERIAL) ? " serial" : "",
	214	(usbctl & USBCTL_ENABLE_DEFAULTS) ? " defaults" : "",
	215
	216	(usbctl & USBCTL_FLUSH_THIS) ? " FLUSH" : "",
	217	(usbctl & USBCTL_DISCONN_THIS) ? " DIS" : "",
	218
	219	(usbctl & USBCTL_FLUSH_OTHER) ? " FLUSH" : "",
	220	(usbctl & USBCTL_DISCONN_OTHER) ? " DIS" : "",
	221
	222	usbctl & ~USBCTL_WRITABLE_MASK);
904813cd DB	223	}
	224
	225	/-------------------------------------------------------------------------/
	226
	227	/*
	228	* Status register
	229	*/
	230
	231	#define STATUS_PORT_A (1 << 15)
	232
	233	#define STATUS_CONN_OTHER (1 << 14)
	234	#define STATUS_SUSPEND_OTHER (1 << 13)
	235	#define STATUS_MAILBOX_OTHER (1 << 12)
b4ee4a23	236	#define STATUS_PACKETS_OTHER(n) (((n) >> 8) & 0x03)
904813cd DB	237
	238	#define STATUS_CONN_THIS (1 << 6)
	239	#define STATUS_SUSPEND_THIS (1 << 5)
	240	#define STATUS_MAILBOX_THIS (1 << 4)
b4ee4a23	241	#define STATUS_PACKETS_THIS(n) (((n) >> 0) & 0x03)
904813cd DB	242
	243	#define STATUS_UNSPEC_MASK 0x0c8c
	244	#define STATUS_NOISE_MASK ((u16)~(0x0303\|STATUS_UNSPEC_MASK))
	245
	246
	247	static inline void nc_dump_status(struct usbnet *dev, u16 status)
	248	{
a475f603 JP	249	netif_dbg(dev, link, dev->net,
	250	"net1080 %s-%s status 0x%x: this (%c) PKT=%d%s%s%s; other PKT=%d%s%s%s; unspec 0x%x\n",
	251	dev->udev->bus->bus_name, dev->udev->devpath,
	252	status,
	253
	254	// XXX the packet counts don't seem right
	255	// (1 at reset, not 0); maybe UNSPEC too
	256
	257	(status & STATUS_PORT_A) ? 'A' : 'B',
	258	STATUS_PACKETS_THIS(status),
	259	(status & STATUS_CONN_THIS) ? " CON" : "",
	260	(status & STATUS_SUSPEND_THIS) ? " SUS" : "",
	261	(status & STATUS_MAILBOX_THIS) ? " MBOX" : "",
	262
	263	STATUS_PACKETS_OTHER(status),
	264	(status & STATUS_CONN_OTHER) ? " CON" : "",
	265	(status & STATUS_SUSPEND_OTHER) ? " SUS" : "",
	266	(status & STATUS_MAILBOX_OTHER) ? " MBOX" : "",
	267
	268	status & STATUS_UNSPEC_MASK);
904813cd DB	269	}
	270
	271	/-------------------------------------------------------------------------/
	272
	273	/*
	274	* TTL register
	275	*/
	276
	277	#define TTL_THIS(ttl) (0x00ff & ttl)
	278	#define TTL_OTHER(ttl) (0x00ff & (ttl >> 8))
	279	#define MK_TTL(this,other) ((u16)(((other)<<8)\|(0x00ff&(this))))
	280
	281	static inline void nc_dump_ttl(struct usbnet *dev, u16 ttl)
	282	{
a475f603 JP	283	netif_dbg(dev, link, dev->net, "net1080 %s-%s ttl 0x%x this = %d, other = %d\n",
	284	dev->udev->bus->bus_name, dev->udev->devpath,
	285	ttl, TTL_THIS(ttl), TTL_OTHER(ttl));
904813cd DB	286	}
	287
	288	/-------------------------------------------------------------------------/
	289
	290	static int net1080_reset(struct usbnet *dev)
	291	{
	292	u16 usbctl, status, ttl;
	293	u16 *vp = kmalloc(sizeof (u16), GFP_KERNEL);
	294	int retval;
	295
	296	if (!vp)
	297	return -ENOMEM;
	298
	299	// nc_dump_registers(dev);
	300
	301	if ((retval = nc_register_read(dev, REG_STATUS, vp)) < 0) {
	302	dbg("can't read %s-%s status: %d",
	303	dev->udev->bus->bus_name, dev->udev->devpath, retval);
	304	goto done;
	305	}
	306	status = *vp;
	307	nc_dump_status(dev, status);
	308
	309	if ((retval = nc_register_read(dev, REG_USBCTL, vp)) < 0) {
	310	dbg("can't read USBCTL, %d", retval);
	311	goto done;
	312	}
	313	usbctl = *vp;
	314	nc_dump_usbctl(dev, usbctl);
	315
	316	nc_register_write(dev, REG_USBCTL,
	317	USBCTL_FLUSH_THIS \| USBCTL_FLUSH_OTHER);
	318
	319	if ((retval = nc_register_read(dev, REG_TTL, vp)) < 0) {
	320	dbg("can't read TTL, %d", retval);
	321	goto done;
	322	}
	323	ttl = *vp;
	324	// nc_dump_ttl(dev, ttl);
	325
	326	nc_register_write(dev, REG_TTL,
	327	MK_TTL(NC_READ_TTL_MS, TTL_OTHER(ttl)) );
	328	dbg("%s: assigned TTL, %d ms", dev->net->name, NC_READ_TTL_MS);
	329
a475f603 JP	330	netif_info(dev, link, dev->net, "port %c, peer %sconnected\n",
	331	(status & STATUS_PORT_A) ? 'A' : 'B',
	332	(status & STATUS_CONN_OTHER) ? "" : "dis");
904813cd DB	333	retval = 0;
	334
	335	done:
	336	kfree(vp);
	337	return retval;
	338	}
	339
	340	static int net1080_check_connect(struct usbnet *dev)
	341	{
	342	int retval;
	343	u16 status;
	344	u16 *vp = kmalloc(sizeof (u16), GFP_KERNEL);
	345
	346	if (!vp)
	347	return -ENOMEM;
	348	retval = nc_register_read(dev, REG_STATUS, vp);
	349	status = *vp;
	350	kfree(vp);
	351	if (retval != 0) {
	352	dbg("%s net1080_check_conn read - %d", dev->net->name, retval);
	353	return retval;
	354	}
	355	if ((status & STATUS_CONN_OTHER) != STATUS_CONN_OTHER)
	356	return -ENOLINK;
	357	return 0;
	358	}
	359
7d12e780	360	static void nc_flush_complete(struct urb *urb)
904813cd DB	361	{
	362	kfree(urb->context);
	363	usb_free_urb(urb);
	364	}
	365
	366	static void nc_ensure_sync(struct usbnet *dev)
	367	{
	368	dev->frame_errors++;
	369	if (dev->frame_errors > 5) {
	370	struct urb *urb;
	371	struct usb_ctrlrequest *req;
	372	int status;
	373
	374	/* Send a flush */
54e6ecb2	375	urb = usb_alloc_urb(0, GFP_ATOMIC);
904813cd DB	376	if (!urb)
	377	return;
	378
	379	req = kmalloc(sizeof *req, GFP_ATOMIC);
	380	if (!req) {
	381	usb_free_urb(urb);
	382	return;
	383	}
	384
	385	req->bRequestType = USB_DIR_OUT
	386	\| USB_TYPE_VENDOR
	387	\| USB_RECIP_DEVICE;
	388	req->bRequest = REQUEST_REGISTER;
	389	req->wValue = cpu_to_le16(USBCTL_FLUSH_THIS
	390	\| USBCTL_FLUSH_OTHER);
	391	req->wIndex = cpu_to_le16(REG_USBCTL);
	392	req->wLength = cpu_to_le16(0);
	393
	394	/* queue an async control request, we don't need
	395	* to do anything when it finishes except clean up.
	396	*/
	397	usb_fill_control_urb(urb, dev->udev,
	398	usb_sndctrlpipe(dev->udev, 0),
	399	(unsigned char *) req,
	400	NULL, 0,
	401	nc_flush_complete, req);
	402	status = usb_submit_urb(urb, GFP_ATOMIC);
	403	if (status) {
	404	kfree(req);
	405	usb_free_urb(urb);
	406	return;
	407	}
	408
a475f603 JP	409	netif_dbg(dev, rx_err, dev->net,
a475f603 JP	410	"flush net1080; too many framing errors\n");
904813cd DB	411	dev->frame_errors = 0;
	412	}
	413	}
	414
	415	static int net1080_rx_fixup(struct usbnet dev, struct sk_buff skb)
	416	{
	417	struct nc_header *header;
	418	struct nc_trailer *trailer;
	419	u16 hdr_len, packet_len;
	420
	421	if (!(skb->len & 0x01)) {
	422	#ifdef DEBUG
	423	struct net_device *net = dev->net;
	424	dbg("rx framesize %d range %d..%d mtu %d", skb->len,
	425	net->hard_header_len, dev->hard_mtu, net->mtu);
	426	#endif
a22d2b36	427	dev->net->stats.rx_frame_errors++;
904813cd DB	428	nc_ensure_sync(dev);
	429	return 0;
	430	}
	431
	432	header = (struct nc_header *) skb->data;
	433	hdr_len = le16_to_cpup(&header->hdr_len);
	434	packet_len = le16_to_cpup(&header->packet_len);
	435	if (FRAMED_SIZE(packet_len) > NC_MAX_PACKET) {
a22d2b36	436	dev->net->stats.rx_frame_errors++;
904813cd DB	437	dbg("packet too big, %d", packet_len);
	438	nc_ensure_sync(dev);
	439	return 0;
	440	} else if (hdr_len < MIN_HEADER) {
a22d2b36	441	dev->net->stats.rx_frame_errors++;
904813cd DB	442	dbg("header too short, %d", hdr_len);
	443	nc_ensure_sync(dev);
	444	return 0;
	445	} else if (hdr_len > MIN_HEADER) {
	446	// out of band data for us?
	447	dbg("header OOB, %d bytes", hdr_len - MIN_HEADER);
	448	nc_ensure_sync(dev);
	449	// switch (vendor/product ids) { ... }
	450	}
	451	skb_pull(skb, hdr_len);
	452
	453	trailer = (struct nc_trailer *)
	454	(skb->data + skb->len - sizeof *trailer);
	455	skb_trim(skb, skb->len - sizeof *trailer);
	456
	457	if ((packet_len & 0x01) == 0) {
	458	if (skb->data [packet_len] != PAD_BYTE) {
a22d2b36	459	dev->net->stats.rx_frame_errors++;
904813cd DB	460	dbg("bad pad");
	461	return 0;
	462	}
	463	skb_trim(skb, skb->len - 1);
	464	}
	465	if (skb->len != packet_len) {
a22d2b36	466	dev->net->stats.rx_frame_errors++;
904813cd DB	467	dbg("bad packet len %d (expected %d)",
	468	skb->len, packet_len);
	469	nc_ensure_sync(dev);
	470	return 0;
	471	}
	472	if (header->packet_id != get_unaligned(&trailer->packet_id)) {
a22d2b36	473	dev->net->stats.rx_fifo_errors++;
904813cd DB	474	dbg("(2+ dropped) rx packet_id mismatch 0x%x 0x%x",
	475	le16_to_cpu(header->packet_id),
	476	le16_to_cpu(trailer->packet_id));
	477	return 0;
	478	}
	479	#if 0
60b86755 JP	480	netdev_dbg(dev->net, "frame <rx h %d p %d id %d\n", header->hdr_len,
60b86755 JP	481	header->packet_len, header->packet_id);
904813cd DB	482	#endif
	483	dev->frame_errors = 0;
	484	return 1;
	485	}
	486
	487	static struct sk_buff *
55016f10	488	net1080_tx_fixup(struct usbnet dev, struct sk_buff skb, gfp_t flags)
904813cd	489	{
904813cd DB	490	struct sk_buff *skb2;
	491	struct nc_header *header = NULL;
	492	struct nc_trailer *trailer = NULL;
9bcbcf4d	493	int padlen = sizeof (struct nc_trailer);
904813cd DB	494	int len = skb->len;
904813cd DB	495
9bcbcf4d	496	if (!((len + padlen + sizeof (struct nc_header)) & 0x01))
9bcbcf4d	497	padlen++;
904813cd DB	498	if (!skb_cloned(skb)) {
	499	int headroom = skb_headroom(skb);
	500	int tailroom = skb_tailroom(skb);
	501
9bcbcf4d	502	if (padlen <= tailroom &&
9bcbcf4d	503	sizeof(struct nc_header) <= headroom)
904813cd DB	504	/* There's enough head and tail room */
	505	goto encapsulate;
	506
9bcbcf4d	507	if ((sizeof (struct nc_header) + padlen) <
904813cd DB	508	(headroom + tailroom)) {
	509	/* There's enough total room, so just readjust */
	510	skb->data = memmove(skb->head
	511	+ sizeof (struct nc_header),
	512	skb->data, skb->len);
27a884dc	513	skb_set_tail_pointer(skb, len);
904813cd DB	514	goto encapsulate;
	515	}
	516	}
	517
	518	/* Create a new skb to use with the correct size */
	519	skb2 = skb_copy_expand(skb,
	520	sizeof (struct nc_header),
9bcbcf4d	521	padlen,
904813cd DB	522	flags);
	523	dev_kfree_skb_any(skb);
	524	if (!skb2)
	525	return skb2;
	526	skb = skb2;
	527
	528	encapsulate:
	529	/* header first */
	530	header = (struct nc_header ) skb_push(skb, sizeof header);
	531	header->hdr_len = cpu_to_le16(sizeof (*header));
	532	header->packet_len = cpu_to_le16(len);
	533	header->packet_id = cpu_to_le16((u16)dev->xid++);
	534
	535	/* maybe pad; then trailer */
	536	if (!((skb->len + sizeof *trailer) & 0x01))
	537	*skb_put(skb, 1) = PAD_BYTE;
	538	trailer = (struct nc_trailer ) skb_put(skb, sizeof trailer);
	539	put_unaligned(header->packet_id, &trailer->packet_id);
	540	#if 0
60b86755 JP	541	netdev_dbg(dev->net, "frame >tx h %d p %d id %d\n",
	542	header->hdr_len, header->packet_len,
	543	header->packet_id);
904813cd DB	544	#endif
	545	return skb;
	546	}
	547
	548	static int net1080_bind(struct usbnet dev, struct usb_interface intf)
	549	{
	550	unsigned extra = sizeof (struct nc_header)
	551	+ 1
	552	+ sizeof (struct nc_trailer);
	553
	554	dev->net->hard_header_len += extra;
	555	dev->rx_urb_size = dev->net->hard_header_len + dev->net->mtu;
	556	dev->hard_mtu = NC_MAX_PACKET;
	557	return usbnet_get_endpoints (dev, intf);
	558	}
	559
	560	static const struct driver_info net1080_info = {
	561	.description = "NetChip TurboCONNECT",
	562	.flags = FLAG_FRAMING_NC,
	563	.bind = net1080_bind,
	564	.reset = net1080_reset,
	565	.check_connect = net1080_check_connect,
	566	.rx_fixup = net1080_rx_fixup,
	567	.tx_fixup = net1080_tx_fixup,
	568	};
	569
	570	static const struct usb_device_id products [] = {
	571	{
	572	USB_DEVICE(0x0525, 0x1080), // NetChip ref design
	573	.driver_info = (unsigned long) &net1080_info,
	574	}, {
	575	USB_DEVICE(0x06D0, 0x0622), // Laplink Gold
	576	.driver_info = (unsigned long) &net1080_info,
	577	},
	578	{ }, // END
	579	};
	580	MODULE_DEVICE_TABLE(usb, products);
	581
	582	static struct usb_driver net1080_driver = {
904813cd DB	583	.name = "net1080",
	584	.id_table = products,
	585	.probe = usbnet_probe,
	586	.disconnect = usbnet_disconnect,
	587	.suspend = usbnet_suspend,
	588	.resume = usbnet_resume,
	589	};
	590
	591	static int __init net1080_init(void)
	592	{
	593	return usb_register(&net1080_driver);
	594	}
	595	module_init(net1080_init);
	596
	597	static void __exit net1080_exit(void)
	598	{
	599	usb_deregister(&net1080_driver);
	600	}
	601	module_exit(net1080_exit);
	602
	603	MODULE_AUTHOR("David Brownell");
	604	MODULE_DESCRIPTION("NetChip 1080 based USB Host-to-Host Links");
	605	MODULE_LICENSE("GPL");