1 2#include <linux/gfp.h> 3#include <linux/if_arp.h> 4#include <linux/etherdevice.h> 5 6#include "i1480u-wlp.h" 7 8 9 10static inline 11void i1480u_init(struct i1480u *i1480u) 12{ 13 /* nothing so far... doesn't it suck? */ 14 spin_lock_init(&i1480u->lock); 15 INIT_LIST_HEAD(&i1480u->tx_list); 16 spin_lock_init(&i1480u->tx_list_lock); 17 wlp_options_init(&i1480u->options); 18 edc_init(&i1480u->tx_errors); 19 edc_init(&i1480u->rx_errors); 20#ifdef i1480u_FLOW_CONTROL 21 edc_init(&i1480u->notif_edc); 22#endif 23 stats_init(&i1480u->lqe_stats); 24 stats_init(&i1480u->rssi_stats); 25 wlp_init(&i1480u->wlp); 26} 27 28/** 29 * Fill WLP device information structure 30 * 31 * The structure will contain a few character arrays, each ending with a 32 * null terminated string. Each string has to fit (excluding terminating 33 * character) into a specified range obtained from the WLP substack. 34 * 35 * It is still not clear exactly how this device information should be 36 * obtained. Until we find out we use the USB device descriptor as backup, some 37 * information elements have intuitive mappings, other not. 38 */ 39static 40void i1480u_fill_device_info(struct wlp *wlp, struct wlp_device_info *dev_info) 41{ 42 struct i1480u *i1480u = container_of(wlp, struct i1480u, wlp); 43 struct usb_device *usb_dev = i1480u->usb_dev; 44 /* Treat device name and model name the same */ 45 if (usb_dev->descriptor.iProduct) { 46 usb_string(usb_dev, usb_dev->descriptor.iProduct, 47 dev_info->name, sizeof(dev_info->name)); 48 usb_string(usb_dev, usb_dev->descriptor.iProduct, 49 dev_info->model_name, sizeof(dev_info->model_name)); 50 } 51 if (usb_dev->descriptor.iManufacturer) 52 usb_string(usb_dev, usb_dev->descriptor.iManufacturer, 53 dev_info->manufacturer, 54 sizeof(dev_info->manufacturer)); 55 scnprintf(dev_info->model_nr, sizeof(dev_info->model_nr), "%04x", 56 __le16_to_cpu(usb_dev->descriptor.bcdDevice)); 57 if (usb_dev->descriptor.iSerialNumber) 58 usb_string(usb_dev, usb_dev->descriptor.iSerialNumber, 59 dev_info->serial, sizeof(dev_info->serial)); 60 dev_info->prim_dev_type.category = cpu_to_le16(WLP_DEV_CAT_OTHER); 61} 62 63#ifdef i1480u_FLOW_CONTROL 64/** 65 * Callback for the notification endpoint 66 * 67 * This mostly controls the xon/xoff protocol. In case of hard error, 68 * we stop the queue. If not, we always retry. 69 */ 70static 71void i1480u_notif_cb(struct urb *urb, struct pt_regs *regs) 72{ 73 struct i1480u *i1480u = urb->context; 74 struct usb_interface *usb_iface = i1480u->usb_iface; 75 struct device *dev = &usb_iface->dev; 76 int result; 77 78 switch (urb->status) { 79 case 0: /* Got valid data, do xon/xoff */ 80 switch (i1480u->notif_buffer[0]) { 81 case 'N': 82 dev_err(dev, "XOFF STOPPING queue at %lu\n", jiffies); 83 netif_stop_queue(i1480u->net_dev); 84 break; 85 case 'A': 86 dev_err(dev, "XON STARTING queue at %lu\n", jiffies); 87 netif_start_queue(i1480u->net_dev); 88 break; 89 default: 90 dev_err(dev, "NEP: unknown data 0x%02hhx\n", 91 i1480u->notif_buffer[0]); 92 } 93 break; 94 case -ECONNRESET: /* Controlled situation ... */ 95 case -ENOENT: /* we killed the URB... */ 96 dev_err(dev, "NEP: URB reset/noent %d\n", urb->status); 97 goto error; 98 case -ESHUTDOWN: /* going away! */ 99 dev_err(dev, "NEP: URB down %d\n", urb->status); 100 goto error; 101 default: /* Retry unless it gets ugly */ 102 if (edc_inc(&i1480u->notif_edc, EDC_MAX_ERRORS, 103 EDC_ERROR_TIMEFRAME)) { 104 dev_err(dev, "NEP: URB max acceptable errors " 105 "exceeded; resetting device\n"); 106 goto error_reset; 107 } 108 dev_err(dev, "NEP: URB error %d\n", urb->status); 109 break; 110 } 111 result = usb_submit_urb(urb, GFP_ATOMIC); 112 if (result < 0) { 113 dev_err(dev, "NEP: Can't resubmit URB: %d; resetting device\n", 114 result); 115 goto error_reset; 116 } 117 return; 118 119error_reset: 120 wlp_reset_all(&i1480-wlp); 121error: 122 netif_stop_queue(i1480u->net_dev); 123 return; 124} 125#endif 126 127static const struct net_device_ops i1480u_netdev_ops = { 128 .ndo_open = i1480u_open, 129 .ndo_stop = i1480u_stop, 130 .ndo_start_xmit = i1480u_hard_start_xmit, 131 .ndo_tx_timeout = i1480u_tx_timeout, 132 .ndo_set_config = i1480u_set_config, 133 .ndo_change_mtu = i1480u_change_mtu, 134}; 135 136static 137int i1480u_add(struct i1480u *i1480u, struct usb_interface *iface) 138{ 139 int result = -ENODEV; 140 struct wlp *wlp = &i1480u->wlp; 141 struct usb_device *usb_dev = interface_to_usbdev(iface); 142 struct net_device *net_dev = i1480u->net_dev; 143 struct uwb_rc *rc; 144 struct uwb_dev *uwb_dev; 145#ifdef i1480u_FLOW_CONTROL 146 struct usb_endpoint_descriptor *epd; 147#endif 148 149 i1480u->usb_dev = usb_get_dev(usb_dev); 150 i1480u->usb_iface = iface; 151 rc = uwb_rc_get_by_grandpa(&i1480u->usb_dev->dev); 152 if (rc == NULL) { 153 dev_err(&iface->dev, "Cannot get associated UWB Radio " 154 "Controller\n"); 155 goto out; 156 } 157 wlp->xmit_frame = i1480u_xmit_frame; 158 wlp->fill_device_info = i1480u_fill_device_info; 159 wlp->stop_queue = i1480u_stop_queue; 160 wlp->start_queue = i1480u_start_queue; 161 result = wlp_setup(wlp, rc, net_dev); 162 if (result < 0) { 163 dev_err(&iface->dev, "Cannot setup WLP\n"); 164 goto error_wlp_setup; 165 } 166 result = 0; 167 ether_setup(net_dev); /* make it an etherdevice */ 168 uwb_dev = &rc->uwb_dev; 169 170 memcpy(net_dev->dev_addr, uwb_dev->mac_addr.data, 171 sizeof(net_dev->dev_addr)); 172 173 net_dev->hard_header_len = sizeof(struct untd_hdr_cmp) 174 + sizeof(struct wlp_tx_hdr) 175 + WLP_DATA_HLEN 176 + ETH_HLEN; 177 net_dev->mtu = 3500; 178 net_dev->tx_queue_len = 20; 179 180 net_dev->flags &= ~IFF_MULTICAST; 181 net_dev->features &= ~NETIF_F_SG; 182 net_dev->features &= ~NETIF_F_FRAGLIST; 183 /* All NETIF_F_*_CSUM disabled */ 184 net_dev->features |= NETIF_F_HIGHDMA; 185 net_dev->watchdog_timeo = 5*HZ; 186 187 net_dev->netdev_ops = &i1480u_netdev_ops; 188 189#ifdef i1480u_FLOW_CONTROL 190 /* Notification endpoint setup (submitted when we open the device) */ 191 i1480u->notif_urb = usb_alloc_urb(0, GFP_KERNEL); 192 if (i1480u->notif_urb == NULL) { 193 dev_err(&iface->dev, "Unable to allocate notification URB\n"); 194 result = -ENOMEM; 195 goto error_urb_alloc; 196 } 197 epd = &iface->cur_altsetting->endpoint[0].desc; 198 usb_fill_int_urb(i1480u->notif_urb, usb_dev, 199 usb_rcvintpipe(usb_dev, epd->bEndpointAddress), 200 i1480u->notif_buffer, sizeof(i1480u->notif_buffer), 201 i1480u_notif_cb, i1480u, epd->bInterval); 202 203#endif 204 205 i1480u->tx_inflight.max = i1480u_TX_INFLIGHT_MAX; 206 i1480u->tx_inflight.threshold = i1480u_TX_INFLIGHT_THRESHOLD; 207 i1480u->tx_inflight.restart_ts = jiffies; 208 usb_set_intfdata(iface, i1480u); 209 return result; 210 211#ifdef i1480u_FLOW_CONTROL 212error_urb_alloc: 213#endif 214 wlp_remove(wlp); 215error_wlp_setup: 216 uwb_rc_put(rc); 217out: 218 usb_put_dev(i1480u->usb_dev); 219 return result; 220} 221 222static void i1480u_rm(struct i1480u *i1480u) 223{ 224 struct uwb_rc *rc = i1480u->wlp.rc; 225 usb_set_intfdata(i1480u->usb_iface, NULL); 226#ifdef i1480u_FLOW_CONTROL 227 usb_kill_urb(i1480u->notif_urb); 228 usb_free_urb(i1480u->notif_urb); 229#endif 230 wlp_remove(&i1480u->wlp); 231 uwb_rc_put(rc); 232 usb_put_dev(i1480u->usb_dev); 233} 234 235/** Just setup @net_dev's i1480u private data */ 236static void i1480u_netdev_setup(struct net_device *net_dev) 237{ 238 struct i1480u *i1480u = netdev_priv(net_dev); 239 /* Initialize @i1480u */ 240 memset(i1480u, 0, sizeof(*i1480u)); 241 i1480u_init(i1480u); 242} 243 244/** 245 * Probe a i1480u interface and register it 246 * 247 * @iface: USB interface to link to 248 * @id: USB class/subclass/protocol id 249 * @returns: 0 if ok, < 0 errno code on error. 250 * 251 * Does basic housekeeping stuff and then allocs a netdev with space 252 * for the i1480u data. Initializes, registers in i1480u, registers in 253 * netdev, ready to go. 254 */ 255static int i1480u_probe(struct usb_interface *iface, 256 const struct usb_device_id *id) 257{ 258 int result; 259 struct net_device *net_dev; 260 struct device *dev = &iface->dev; 261 struct i1480u *i1480u; 262 263 /* Allocate instance [calls i1480u_netdev_setup() on it] */ 264 result = -ENOMEM; 265 net_dev = alloc_netdev(sizeof(*i1480u), "wlp%d", i1480u_netdev_setup); 266 if (net_dev == NULL) { 267 dev_err(dev, "no memory for network device instance\n"); 268 goto error_alloc_netdev; 269 } 270 SET_NETDEV_DEV(net_dev, dev); 271 i1480u = netdev_priv(net_dev); 272 i1480u->net_dev = net_dev; 273 result = i1480u_add(i1480u, iface); /* Now setup all the wlp stuff */ 274 if (result < 0) { 275 dev_err(dev, "cannot add i1480u device: %d\n", result); 276 goto error_i1480u_add; 277 } 278 result = register_netdev(net_dev); /* Okey dokey, bring it up */ 279 if (result < 0) { 280 dev_err(dev, "cannot register network device: %d\n", result); 281 goto error_register_netdev; 282 } 283 i1480u_sysfs_setup(i1480u); 284 if (result < 0) 285 goto error_sysfs_init; 286 return 0; 287 288error_sysfs_init: 289 unregister_netdev(net_dev); 290error_register_netdev: 291 i1480u_rm(i1480u); 292error_i1480u_add: 293 free_netdev(net_dev); 294error_alloc_netdev: 295 return result; 296} 297 298 299/** 300 * Disconect a i1480u from the system. 301 * 302 * i1480u_stop() has been called before, so al the rx and tx contexts 303 * have been taken down already. Make sure the queue is stopped, 304 * unregister netdev and i1480u, free and kill. 305 */ 306static void i1480u_disconnect(struct usb_interface *iface) 307{ 308 struct i1480u *i1480u; 309 struct net_device *net_dev; 310 311 i1480u = usb_get_intfdata(iface); 312 net_dev = i1480u->net_dev; 313 netif_stop_queue(net_dev); 314#ifdef i1480u_FLOW_CONTROL 315 usb_kill_urb(i1480u->notif_urb); 316#endif 317 i1480u_sysfs_release(i1480u); 318 unregister_netdev(net_dev); 319 i1480u_rm(i1480u); 320 free_netdev(net_dev); 321} 322 323static struct usb_device_id i1480u_id_table[] = { 324 { 325 .match_flags = USB_DEVICE_ID_MATCH_DEVICE \ 326 | USB_DEVICE_ID_MATCH_DEV_INFO \ 327 | USB_DEVICE_ID_MATCH_INT_INFO, 328 .idVendor = 0x8086, 329 .idProduct = 0x0c3b, 330 .bDeviceClass = 0xef, 331 .bDeviceSubClass = 0x02, 332 .bDeviceProtocol = 0x02, 333 .bInterfaceClass = 0xff, 334 .bInterfaceSubClass = 0xff, 335 .bInterfaceProtocol = 0xff, 336 }, 337 {}, 338}; 339MODULE_DEVICE_TABLE(usb, i1480u_id_table); 340 341static struct usb_driver i1480u_driver = { 342 .name = KBUILD_MODNAME, 343 .probe = i1480u_probe, 344 .disconnect = i1480u_disconnect, 345 .id_table = i1480u_id_table, 346}; 347 348static int __init i1480u_driver_init(void) 349{ 350 return usb_register(&i1480u_driver); 351} 352module_init(i1480u_driver_init); 353 354 355static void __exit i1480u_driver_exit(void) 356{ 357 usb_deregister(&i1480u_driver); 358} 359module_exit(i1480u_driver_exit); 360 361MODULE_AUTHOR("Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>"); 362MODULE_DESCRIPTION("i1480 Wireless UWB Link WLP networking for USB"); 363MODULE_LICENSE("GPL"); 364