1/* 2 * USB 10M/100M ethernet adapter 3 * 4 * This file is licensed under the terms of the GNU General Public License 5 * version 2. This program is licensed "as is" without any warranty of any 6 * kind, whether express or implied 7 * 8 */ 9 10#include <linux/kernel.h> 11#include <linux/module.h> 12#include <linux/sched.h> 13#include <linux/stddef.h> 14#include <linux/init.h> 15#include <linux/netdevice.h> 16#include <linux/etherdevice.h> 17#include <linux/ethtool.h> 18#include <linux/mii.h> 19#include <linux/usb.h> 20#include <linux/crc32.h> 21#include <linux/usb/usbnet.h> 22#include <linux/slab.h> 23 24#define CH9200_VID 0x1A86 25#define CH9200_PID_E092 0xE092 26 27#define CTRL_TIMEOUT_MS 1000 28 29#define CONTROL_TIMEOUT_MS 1000 30 31#define REQUEST_READ 0x0E 32#define REQUEST_WRITE 0x0F 33 34/* Address space: 35 * 00-63 : MII 36 * 64-128: MAC 37 * 38 * Note: all accesses must be 16-bit 39 */ 40 41#define MAC_REG_CTRL 64 42#define MAC_REG_STATUS 66 43#define MAC_REG_INTERRUPT_MASK 68 44#define MAC_REG_PHY_COMMAND 70 45#define MAC_REG_PHY_DATA 72 46#define MAC_REG_STATION_L 74 47#define MAC_REG_STATION_M 76 48#define MAC_REG_STATION_H 78 49#define MAC_REG_HASH_L 80 50#define MAC_REG_HASH_M1 82 51#define MAC_REG_HASH_M2 84 52#define MAC_REG_HASH_H 86 53#define MAC_REG_THRESHOLD 88 54#define MAC_REG_FIFO_DEPTH 90 55#define MAC_REG_PAUSE 92 56#define MAC_REG_FLOW_CONTROL 94 57 58/* Control register bits 59 * 60 * Note: bits 13 and 15 are reserved 61 */ 62#define LOOPBACK (0x01 << 14) 63#define BASE100X (0x01 << 12) 64#define MBPS_10 (0x01 << 11) 65#define DUPLEX_MODE (0x01 << 10) 66#define PAUSE_FRAME (0x01 << 9) 67#define PROMISCUOUS (0x01 << 8) 68#define MULTICAST (0x01 << 7) 69#define BROADCAST (0x01 << 6) 70#define HASH (0x01 << 5) 71#define APPEND_PAD (0x01 << 4) 72#define APPEND_CRC (0x01 << 3) 73#define TRANSMITTER_ACTION (0x01 << 2) 74#define RECEIVER_ACTION (0x01 << 1) 75#define DMA_ACTION (0x01 << 0) 76 77/* Status register bits 78 * 79 * Note: bits 7-15 are reserved 80 */ 81#define ALIGNMENT (0x01 << 6) 82#define FIFO_OVER_RUN (0x01 << 5) 83#define FIFO_UNDER_RUN (0x01 << 4) 84#define RX_ERROR (0x01 << 3) 85#define RX_COMPLETE (0x01 << 2) 86#define TX_ERROR (0x01 << 1) 87#define TX_COMPLETE (0x01 << 0) 88 89/* FIFO depth register bits 90 * 91 * Note: bits 6 and 14 are reserved 92 */ 93 94#define ETH_TXBD (0x01 << 15) 95#define ETN_TX_FIFO_DEPTH (0x01 << 8) 96#define ETH_RXBD (0x01 << 7) 97#define ETH_RX_FIFO_DEPTH (0x01 << 0) 98 99static int control_read(struct usbnet *dev, 100 unsigned char request, unsigned short value, 101 unsigned short index, void *data, unsigned short size, 102 int timeout) 103{ 104 unsigned char *buf = NULL; 105 unsigned char request_type; 106 int err = 0; 107 108 if (request == REQUEST_READ) 109 request_type = (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER); 110 else 111 request_type = (USB_DIR_IN | USB_TYPE_VENDOR | 112 USB_RECIP_DEVICE); 113 114 netdev_dbg(dev->net, "Control_read() index=0x%02x size=%d\n", 115 index, size); 116 117 buf = kmalloc(size, GFP_KERNEL); 118 if (!buf) { 119 err = -ENOMEM; 120 goto err_out; 121 } 122 123 err = usb_control_msg(dev->udev, 124 usb_rcvctrlpipe(dev->udev, 0), 125 request, request_type, value, index, buf, size, 126 timeout); 127 if (err == size) 128 memcpy(data, buf, size); 129 else if (err >= 0) 130 err = -EINVAL; 131 kfree(buf); 132 133 return err; 134 135err_out: 136 return err; 137} 138 139static int control_write(struct usbnet *dev, unsigned char request, 140 unsigned short value, unsigned short index, 141 void *data, unsigned short size, int timeout) 142{ 143 unsigned char *buf = NULL; 144 unsigned char request_type; 145 int err = 0; 146 147 if (request == REQUEST_WRITE) 148 request_type = (USB_DIR_OUT | USB_TYPE_VENDOR | 149 USB_RECIP_OTHER); 150 else 151 request_type = (USB_DIR_OUT | USB_TYPE_VENDOR | 152 USB_RECIP_DEVICE); 153 154 netdev_dbg(dev->net, "Control_write() index=0x%02x size=%d\n", 155 index, size); 156 157 if (data) { 158 buf = kmalloc(size, GFP_KERNEL); 159 if (!buf) { 160 err = -ENOMEM; 161 goto err_out; 162 } 163 memcpy(buf, data, size); 164 } 165 166 err = usb_control_msg(dev->udev, 167 usb_sndctrlpipe(dev->udev, 0), 168 request, request_type, value, index, buf, size, 169 timeout); 170 if (err >= 0 && err < size) 171 err = -EINVAL; 172 kfree(buf); 173 174 return 0; 175 176err_out: 177 return err; 178} 179 180static int ch9200_mdio_read(struct net_device *netdev, int phy_id, int loc) 181{ 182 struct usbnet *dev = netdev_priv(netdev); 183 unsigned char buff[2]; 184 185 netdev_dbg(netdev, "ch9200_mdio_read phy_id:%02x loc:%02x\n", 186 phy_id, loc); 187 188 if (phy_id != 0) 189 return -ENODEV; 190 191 control_read(dev, REQUEST_READ, 0, loc * 2, buff, 0x02, 192 CONTROL_TIMEOUT_MS); 193 194 return (buff[0] | buff[1] << 8); 195} 196 197static void ch9200_mdio_write(struct net_device *netdev, 198 int phy_id, int loc, int val) 199{ 200 struct usbnet *dev = netdev_priv(netdev); 201 unsigned char buff[2]; 202 203 netdev_dbg(netdev, "ch9200_mdio_write() phy_id=%02x loc:%02x\n", 204 phy_id, loc); 205 206 if (phy_id != 0) 207 return; 208 209 buff[0] = (unsigned char)val; 210 buff[1] = (unsigned char)(val >> 8); 211 212 control_write(dev, REQUEST_WRITE, 0, loc * 2, buff, 0x02, 213 CONTROL_TIMEOUT_MS); 214} 215 216static int ch9200_link_reset(struct usbnet *dev) 217{ 218 struct ethtool_cmd ecmd; 219 220 mii_check_media(&dev->mii, 1, 1); 221 mii_ethtool_gset(&dev->mii, &ecmd); 222 223 netdev_dbg(dev->net, "link_reset() speed:%d duplex:%d\n", 224 ecmd.speed, ecmd.duplex); 225 226 return 0; 227} 228 229static void ch9200_status(struct usbnet *dev, struct urb *urb) 230{ 231 int link; 232 unsigned char *buf; 233 234 if (urb->actual_length < 16) 235 return; 236 237 buf = urb->transfer_buffer; 238 link = !!(buf[0] & 0x01); 239 240 if (link) { 241 netif_carrier_on(dev->net); 242 usbnet_defer_kevent(dev, EVENT_LINK_RESET); 243 } else { 244 netif_carrier_off(dev->net); 245 } 246} 247 248static struct sk_buff *ch9200_tx_fixup(struct usbnet *dev, struct sk_buff *skb, 249 gfp_t flags) 250{ 251 int i = 0; 252 int len = 0; 253 int tx_overhead = 0; 254 255 tx_overhead = 0x40; 256 257 len = skb->len; 258 if (skb_headroom(skb) < tx_overhead) { 259 struct sk_buff *skb2; 260 261 skb2 = skb_copy_expand(skb, tx_overhead, 0, flags); 262 dev_kfree_skb_any(skb); 263 skb = skb2; 264 if (!skb) 265 return NULL; 266 } 267 268 __skb_push(skb, tx_overhead); 269 /* usbnet adds padding if length is a multiple of packet size 270 * if so, adjust length value in header 271 */ 272 if ((skb->len % dev->maxpacket) == 0) 273 len++; 274 275 skb->data[0] = len; 276 skb->data[1] = len >> 8; 277 skb->data[2] = 0x00; 278 skb->data[3] = 0x80; 279 280 for (i = 4; i < 48; i++) 281 skb->data[i] = 0x00; 282 283 skb->data[48] = len; 284 skb->data[49] = len >> 8; 285 skb->data[50] = 0x00; 286 skb->data[51] = 0x80; 287 288 for (i = 52; i < 64; i++) 289 skb->data[i] = 0x00; 290 291 return skb; 292} 293 294static int ch9200_rx_fixup(struct usbnet *dev, struct sk_buff *skb) 295{ 296 int len = 0; 297 int rx_overhead = 0; 298 299 rx_overhead = 64; 300 301 if (unlikely(skb->len < rx_overhead)) { 302 dev_err(&dev->udev->dev, "unexpected tiny rx frame\n"); 303 return 0; 304 } 305 306 len = (skb->data[skb->len - 16] | skb->data[skb->len - 15] << 8); 307 skb_trim(skb, len); 308 309 return 1; 310} 311 312static int get_mac_address(struct usbnet *dev, unsigned char *data) 313{ 314 int err = 0; 315 unsigned char mac_addr[0x06]; 316 int rd_mac_len = 0; 317 318 netdev_dbg(dev->net, "get_mac_address:\n\tusbnet VID:%0x PID:%0x\n", 319 dev->udev->descriptor.idVendor, 320 dev->udev->descriptor.idProduct); 321 322 memset(mac_addr, 0, sizeof(mac_addr)); 323 rd_mac_len = control_read(dev, REQUEST_READ, 0, 324 MAC_REG_STATION_L, mac_addr, 0x02, 325 CONTROL_TIMEOUT_MS); 326 rd_mac_len += control_read(dev, REQUEST_READ, 0, MAC_REG_STATION_M, 327 mac_addr + 2, 0x02, CONTROL_TIMEOUT_MS); 328 rd_mac_len += control_read(dev, REQUEST_READ, 0, MAC_REG_STATION_H, 329 mac_addr + 4, 0x02, CONTROL_TIMEOUT_MS); 330 if (rd_mac_len != ETH_ALEN) 331 err = -EINVAL; 332 333 data[0] = mac_addr[5]; 334 data[1] = mac_addr[4]; 335 data[2] = mac_addr[3]; 336 data[3] = mac_addr[2]; 337 data[4] = mac_addr[1]; 338 data[5] = mac_addr[0]; 339 340 return err; 341} 342 343static int ch9200_bind(struct usbnet *dev, struct usb_interface *intf) 344{ 345 int retval = 0; 346 unsigned char data[2]; 347 348 retval = usbnet_get_endpoints(dev, intf); 349 if (retval) 350 return retval; 351 352 dev->mii.dev = dev->net; 353 dev->mii.mdio_read = ch9200_mdio_read; 354 dev->mii.mdio_write = ch9200_mdio_write; 355 dev->mii.reg_num_mask = 0x1f; 356 357 dev->mii.phy_id_mask = 0x1f; 358 359 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len; 360 dev->rx_urb_size = 24 * 64 + 16; 361 mii_nway_restart(&dev->mii); 362 363 data[0] = 0x01; 364 data[1] = 0x0F; 365 retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_THRESHOLD, data, 366 0x02, CONTROL_TIMEOUT_MS); 367 368 data[0] = 0xA0; 369 data[1] = 0x90; 370 retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_FIFO_DEPTH, data, 371 0x02, CONTROL_TIMEOUT_MS); 372 373 data[0] = 0x30; 374 data[1] = 0x00; 375 retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_PAUSE, data, 376 0x02, CONTROL_TIMEOUT_MS); 377 378 data[0] = 0x17; 379 data[1] = 0xD8; 380 retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_FLOW_CONTROL, 381 data, 0x02, CONTROL_TIMEOUT_MS); 382 383 /* Undocumented register */ 384 data[0] = 0x01; 385 data[1] = 0x00; 386 retval = control_write(dev, REQUEST_WRITE, 0, 254, data, 0x02, 387 CONTROL_TIMEOUT_MS); 388 389 data[0] = 0x5F; 390 data[1] = 0x0D; 391 retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_CTRL, data, 0x02, 392 CONTROL_TIMEOUT_MS); 393 394 retval = get_mac_address(dev, dev->net->dev_addr); 395 396 return retval; 397} 398 399static const struct driver_info ch9200_info = { 400 .description = "CH9200 USB to Network Adaptor", 401 .flags = FLAG_ETHER, 402 .bind = ch9200_bind, 403 .rx_fixup = ch9200_rx_fixup, 404 .tx_fixup = ch9200_tx_fixup, 405 .status = ch9200_status, 406 .link_reset = ch9200_link_reset, 407 .reset = ch9200_link_reset, 408}; 409 410static const struct usb_device_id ch9200_products[] = { 411 { 412 USB_DEVICE(0x1A86, 0xE092), 413 .driver_info = (unsigned long)&ch9200_info, 414 }, 415 {}, 416}; 417 418MODULE_DEVICE_TABLE(usb, ch9200_products); 419 420static struct usb_driver ch9200_driver = { 421 .name = "ch9200", 422 .id_table = ch9200_products, 423 .probe = usbnet_probe, 424 .disconnect = usbnet_disconnect, 425 .suspend = usbnet_suspend, 426 .resume = usbnet_resume, 427}; 428 429module_usb_driver(ch9200_driver); 430 431MODULE_DESCRIPTION("QinHeng CH9200 USB Network device"); 432MODULE_LICENSE("GPL"); 433