iPXE
axge.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2016 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17  * 02110-1301, USA.
18  *
19  * You can also choose to distribute this program under the terms of
20  * the Unmodified Binary Distribution Licence (as given in the file
21  * COPYING.UBDL), provided that you have satisfied its requirements.
22  */
23 
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25 
26 #include <stdint.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include <errno.h>
30 #include <ipxe/netdevice.h>
31 #include <ipxe/ethernet.h>
32 #include <ipxe/if_ether.h>
33 #include <ipxe/profile.h>
34 #include <ipxe/usb.h>
35 #include "axge.h"
36 
37 /** @file
38  *
39  * Asix 10/100/1000 USB Ethernet driver
40  *
41  * Large chunks of functionality are undocumented in the available
42  * datasheets. The gaps are deduced from combinations of the Linux
43  * driver, the FreeBSD driver, and experimentation with the hardware.
44  */
45 
46 /** Interrupt completion profiler */
47 static struct profiler axge_intr_profiler __profiler =
48  { .name = "axge.intr" };
49 
50 /** Bulk IN completion profiler */
51 static struct profiler axge_in_profiler __profiler =
52  { .name = "axge.in" };
53 
54 /** Bulk OUT profiler */
55 static struct profiler axge_out_profiler __profiler =
56  { .name = "axge.out" };
57 
58 /** Default bulk IN configuration
59  *
60  * The Linux and FreeBSD drivers have set of magic constants which are
61  * chosen based on both the Ethernet and USB link speeds.
62  *
63  * Experimentation shows that setting the "timer" value to zero seems
64  * to prevent the device from ever coalescing multiple packets into a
65  * single bulk IN transfer. This allows us to get away with using a
66  * 2kB receive I/O buffer and a zerocopy receive path.
67  */
69  .ctrl = 7,
70  .timer = cpu_to_le16 ( 0 ),
71  .size = 0,
72  .ifg = 0,
73 };
74 
75 /******************************************************************************
76  *
77  * Register access
78  *
79  ******************************************************************************
80  */
81 
82 /**
83  * Read register
84  *
85  * @v asix AXGE device
86  * @v offset Register offset
87  * @v data Data buffer
88  * @v len Length of data
89  * @ret rc Return status code
90  */
91 static inline int axge_read_register ( struct axge_device *axge,
92  unsigned int offset, void *data,
93  size_t len ) {
94 
95  return usb_control ( axge->usb, AXGE_READ_MAC_REGISTER,
96  offset, len, data, len );
97 }
98 
99 /**
100  * Read one-byte register
101  *
102  * @v asix AXGE device
103  * @v offset Register offset
104  * @v value Value to fill in
105  * @ret rc Return status code
106  */
107 static inline int axge_read_byte ( struct axge_device *axge,
108  unsigned int offset, uint8_t *value ) {
109 
110  return axge_read_register ( axge, offset, value, sizeof ( *value ) );
111 }
112 
113 /**
114  * Read two-byte register
115  *
116  * @v asix AXGE device
117  * @v offset Register offset
118  * @v value Value to fill in
119  * @ret rc Return status code
120  */
121 static inline int axge_read_word ( struct axge_device *axge,
122  unsigned int offset, uint16_t *value ) {
123 
124  return axge_read_register ( axge, offset, value, sizeof ( *value ) );
125 }
126 
127 /**
128  * Read four-byte register
129  *
130  * @v asix AXGE device
131  * @v offset Register offset
132  * @v value Value to fill in
133  * @ret rc Return status code
134  */
135 static inline int axge_read_dword ( struct axge_device *axge,
136  unsigned int offset, uint32_t *value ) {
137 
138  return axge_read_register ( axge, offset, value, sizeof ( *value ) );
139 }
140 
141 /**
142  * Write register
143  *
144  * @v asix AXGE device
145  * @v offset Register offset
146  * @v data Data buffer
147  * @v len Length of data
148  * @ret rc Return status code
149  */
150 static inline int axge_write_register ( struct axge_device *axge,
151  unsigned int offset, void *data,
152  size_t len ) {
153 
154  return usb_control ( axge->usb, AXGE_WRITE_MAC_REGISTER,
155  offset, len, data, len );
156 }
157 
158 /**
159  * Write one-byte register
160  *
161  * @v asix AXGE device
162  * @v offset Register offset
163  * @v value Value
164  * @ret rc Return status code
165  */
166 static inline int axge_write_byte ( struct axge_device *axge,
167  unsigned int offset, uint8_t value ) {
168 
169  return axge_write_register ( axge, offset, &value, sizeof ( value ));
170 }
171 
172 /**
173  * Write two-byte register
174  *
175  * @v asix AXGE device
176  * @v offset Register offset
177  * @v value Value
178  * @ret rc Return status code
179  */
180 static inline int axge_write_word ( struct axge_device *axge,
181  unsigned int offset, uint16_t value ) {
182 
183  return axge_write_register ( axge, offset, &value, sizeof ( value ));
184 }
185 
186 /**
187  * Write one-byte register
188  *
189  * @v asix AXGE device
190  * @v offset Register offset
191  * @v value Value
192  * @ret rc Return status code
193  */
194 static inline int axge_write_dword ( struct axge_device *axge,
195  unsigned int offset, uint32_t value ) {
196 
197  return axge_write_register ( axge, offset, &value, sizeof ( value ));
198 }
199 
200 /******************************************************************************
201  *
202  * Link status
203  *
204  ******************************************************************************
205  */
206 
207 /**
208  * Get link status
209  *
210  * @v asix AXGE device
211  * @ret rc Return status code
212  */
213 static int axge_check_link ( struct axge_device *axge ) {
214  struct net_device *netdev = axge->netdev;
215  uint8_t plsr;
216  int rc;
217 
218  /* Read physical link status register */
219  if ( ( rc = axge_read_byte ( axge, AXGE_PLSR, &plsr ) ) != 0 ) {
220  DBGC ( axge, "AXGE %p could not read PLSR: %s\n",
221  axge, strerror ( rc ) );
222  return rc;
223  }
224 
225  /* Update link status */
226  if ( plsr & AXGE_PLSR_EPHY_ANY ) {
227  DBGC ( axge, "AXGE %p link up (PLSR %02x)\n", axge, plsr );
229  } else {
230  DBGC ( axge, "AXGE %p link down (PLSR %02x)\n", axge, plsr );
232  }
233 
234  return 0;
235 }
236 
237 /******************************************************************************
238  *
239  * AXGE communications interface
240  *
241  ******************************************************************************
242  */
243 
244 /**
245  * Complete interrupt transfer
246  *
247  * @v ep USB endpoint
248  * @v iobuf I/O buffer
249  * @v rc Completion status code
250  */
251 static void axge_intr_complete ( struct usb_endpoint *ep,
252  struct io_buffer *iobuf, int rc ) {
253  struct axge_device *axge = container_of ( ep, struct axge_device,
254  usbnet.intr );
255  struct net_device *netdev = axge->netdev;
256  struct axge_interrupt *intr;
257  size_t len = iob_len ( iobuf );
258  unsigned int link_ok;
259 
260  /* Profile completions */
261  profile_start ( &axge_intr_profiler );
262 
263  /* Ignore packets cancelled when the endpoint closes */
264  if ( ! ep->open )
265  goto ignore;
266 
267  /* Drop packets with errors */
268  if ( rc != 0 ) {
269  DBGC ( axge, "AXGE %p interrupt failed: %s\n",
270  axge, strerror ( rc ) );
271  DBGC_HDA ( axge, 0, iobuf->data, iob_len ( iobuf ) );
272  goto error;
273  }
274 
275  /* Extract message header */
276  if ( len < sizeof ( *intr ) ) {
277  DBGC ( axge, "AXGE %p underlength interrupt:\n", axge );
278  DBGC_HDA ( axge, 0, iobuf->data, iob_len ( iobuf ) );
279  rc = -EINVAL;
280  goto error;
281  }
282  intr = iobuf->data;
283 
284  /* Check magic signature */
285  if ( intr->magic != cpu_to_le16 ( AXGE_INTR_MAGIC ) ) {
286  DBGC ( axge, "AXGE %p malformed interrupt:\n", axge );
287  DBGC_HDA ( axge, 0, iobuf->data, iob_len ( iobuf ) );
288  rc = -EINVAL;
289  goto error;
290  }
291 
292  /* Extract link status */
293  link_ok = ( intr->link & cpu_to_le16 ( AXGE_INTR_LINK_PPLS ) );
294  if ( link_ok && ! netdev_link_ok ( netdev ) ) {
295  DBGC ( axge, "AXGE %p link up\n", axge );
297  } else if ( netdev_link_ok ( netdev ) && ! link_ok ) {
298  DBGC ( axge, "AXGE %p link down\n", axge );
300  }
301 
302  /* Free I/O buffer */
303  free_iob ( iobuf );
304  profile_stop ( &axge_intr_profiler );
305 
306  return;
307 
308  error:
309  netdev_rx_err ( netdev, iob_disown ( iobuf ), rc );
310  ignore:
311  free_iob ( iobuf );
312  return;
313 }
314 
315 /** Interrupt endpoint operations */
318 };
319 
320 /******************************************************************************
321  *
322  * AXGE data interface
323  *
324  ******************************************************************************
325  */
326 
327 /**
328  * Complete bulk IN transfer
329  *
330  * @v ep USB endpoint
331  * @v iobuf I/O buffer
332  * @v rc Completion status code
333  */
334 static void axge_in_complete ( struct usb_endpoint *ep,
335  struct io_buffer *iobuf, int rc ) {
336  struct axge_device *axge = container_of ( ep, struct axge_device,
337  usbnet.in );
338  struct net_device *netdev = axge->netdev;
339  struct axge_rx_footer *ftr;
340  struct axge_rx_descriptor *desc;
341  struct io_buffer *pkt;
342  unsigned int count;
343  unsigned int offset;
344  size_t len;
345  size_t padded_len;
346 
347  /* Profile receive completions */
348  profile_start ( &axge_in_profiler );
349 
350  /* Ignore packets cancelled when the endpoint closes */
351  if ( ! ep->open )
352  goto ignore;
353 
354  /* Record USB errors against the network device */
355  if ( rc != 0 ) {
356  DBGC ( axge, "AXGE %p bulk IN failed: %s\n",
357  axge, strerror ( rc ) );
358  goto error;
359  }
360 
361  /* Sanity check */
362  if ( iob_len ( iobuf ) < sizeof ( *ftr ) ) {
363  DBGC ( axge, "AXGE %p underlength bulk IN:\n", axge );
364  DBGC_HDA ( axge, 0, iobuf->data, iob_len ( iobuf ) );
365  rc = -EINVAL;
366  goto error;
367  }
368 
369  /* Parse ftr, strip ftr and descriptors */
370  iob_unput ( iobuf, sizeof ( *ftr ) );
371  ftr = ( iobuf->data + iob_len ( iobuf ) );
372  count = le16_to_cpu ( ftr->count );
373  if ( count == 0 ) {
374  DBGC ( axge, "AXGE %p zero-packet bulk IN:\n", axge );
375  DBGC_HDA ( axge, 0, iobuf->data, iob_len ( iobuf ) );
376  goto ignore;
377  }
378  offset = le16_to_cpu ( ftr->offset );
379  if ( ( iob_len ( iobuf ) < offset ) ||
380  ( ( iob_len ( iobuf ) - offset ) < ( count * sizeof ( *desc ) ) )){
381  DBGC ( axge, "AXGE %p malformed bulk IN footer:\n", axge );
382  DBGC_HDA ( axge, 0, iobuf->data, iob_len ( iobuf ) );
383  rc = -EINVAL;
384  goto error;
385  }
386  desc = ( iobuf->data + offset );
387  iob_unput ( iobuf, ( iob_len ( iobuf ) - offset ) );
388 
389  /* Process packets */
390  for ( ; count-- ; desc++ ) {
391 
392  /* Parse descriptor */
393  len = ( le16_to_cpu ( desc->len_flags ) & AXGE_RX_LEN_MASK );
394  padded_len = ( ( len + AXGE_RX_LEN_PAD_ALIGN - 1 ) &
395  ~( AXGE_RX_LEN_PAD_ALIGN - 1 ) );
396  if ( iob_len ( iobuf ) < padded_len ) {
397  DBGC ( axge, "AXGE %p malformed bulk IN descriptor:\n",
398  axge );
399  DBGC_HDA ( axge, 0, iobuf->data, iob_len ( iobuf ) );
400  rc = -EINVAL;
401  goto error;
402  }
403 
404  /* Check for previous dropped packets */
405  if ( desc->len_flags & cpu_to_le16 ( AXGE_RX_CRC_ERROR ) )
406  netdev_rx_err ( netdev, NULL, -EIO );
407  if ( desc->len_flags & cpu_to_le16 ( AXGE_RX_DROP_ERROR ) )
409 
410  /* Allocate new I/O buffer, if applicable */
411  if ( count ) {
412 
413  /* More packets remain: allocate a new buffer */
414  pkt = alloc_iob ( AXGE_IN_RESERVE + len );
415  if ( ! pkt ) {
416  /* Record error and continue */
418  iob_pull ( iobuf, padded_len );
419  continue;
420  }
421  iob_reserve ( pkt, AXGE_IN_RESERVE );
422  memcpy ( iob_put ( pkt, len ), iobuf->data, len );
423  iob_pull ( iobuf, padded_len );
424 
425  } else {
426 
427  /* This is the last (or only) packet: use this buffer */
428  iob_unput ( iobuf, ( padded_len - len ) );
429  pkt = iob_disown ( iobuf );
430  }
431 
432  /* Hand off to network stack */
433  netdev_rx ( netdev, iob_disown ( pkt ) );
434  }
435 
436  assert ( iobuf == NULL );
437  profile_stop ( &axge_in_profiler );
438  return;
439 
440  error:
441  netdev_rx_err ( netdev, iob_disown ( iobuf ), rc );
442  ignore:
443  free_iob ( iobuf );
444 }
445 
446 /** Bulk IN endpoint operations */
449 };
450 
451 /**
452  * Transmit packet
453  *
454  * @v asix AXGE device
455  * @v iobuf I/O buffer
456  * @ret rc Return status code
457  */
458 static int axge_out_transmit ( struct axge_device *axge,
459  struct io_buffer *iobuf ) {
460  struct axge_tx_header *hdr;
461  size_t len = iob_len ( iobuf );
462  int rc;
463 
464  /* Profile transmissions */
465  profile_start ( &axge_out_profiler );
466 
467  /* Prepend header */
468  if ( ( rc = iob_ensure_headroom ( iobuf, sizeof ( *hdr ) ) ) != 0 )
469  return rc;
470  hdr = iob_push ( iobuf, sizeof ( *hdr ) );
471  hdr->len = cpu_to_le32 ( len );
472  hdr->wtf = 0;
473 
474  /* Enqueue I/O buffer */
475  if ( ( rc = usb_stream ( &axge->usbnet.out, iobuf, 0 ) ) != 0 )
476  return rc;
477 
478  profile_stop ( &axge_out_profiler );
479  return 0;
480 }
481 
482 /**
483  * Complete bulk OUT transfer
484  *
485  * @v ep USB endpoint
486  * @v iobuf I/O buffer
487  * @v rc Completion status code
488  */
489 static void axge_out_complete ( struct usb_endpoint *ep,
490  struct io_buffer *iobuf, int rc ) {
491  struct axge_device *axge = container_of ( ep, struct axge_device,
492  usbnet.out );
493  struct net_device *netdev = axge->netdev;
494 
495  /* Report TX completion */
496  netdev_tx_complete_err ( netdev, iobuf, rc );
497 }
498 
499 /** Bulk OUT endpoint operations */
502 };
503 
504 /******************************************************************************
505  *
506  * Network device interface
507  *
508  ******************************************************************************
509  */
510 
511 /**
512  * Open network device
513  *
514  * @v netdev Network device
515  * @ret rc Return status code
516  */
517 static int axge_open ( struct net_device *netdev ) {
518  struct axge_device *axge = netdev->priv;
519  uint16_t rcr;
520  int rc;
521 
522  /* Open USB network device */
523  if ( ( rc = usbnet_open ( &axge->usbnet ) ) != 0 ) {
524  DBGC ( axge, "AXGE %p could not open: %s\n",
525  axge, strerror ( rc ) );
526  goto err_open;
527  }
528 
529  /* Set MAC address */
530  if ( ( rc = axge_write_register ( axge, AXGE_NIDR,
531  netdev->ll_addr, ETH_ALEN ) ) !=0){
532  DBGC ( axge, "AXGE %p could not set MAC address: %s\n",
533  axge, strerror ( rc ) );
534  goto err_write_mac;
535  }
536 
537  /* Enable receiver */
540  if ( ( rc = axge_write_word ( axge, AXGE_RCR, rcr ) ) != 0 ) {
541  DBGC ( axge, "AXGE %p could not write RCR: %s\n",
542  axge, strerror ( rc ) );
543  goto err_write_rcr;
544  }
545 
546  /* Update link status */
547  axge_check_link ( axge );
548 
549  return 0;
550 
551  axge_write_word ( axge, AXGE_RCR, 0 );
552  err_write_rcr:
553  err_write_mac:
554  usbnet_close ( &axge->usbnet );
555  err_open:
556  return rc;
557 }
558 
559 /**
560  * Close network device
561  *
562  * @v netdev Network device
563  */
564 static void axge_close ( struct net_device *netdev ) {
565  struct axge_device *axge = netdev->priv;
566 
567  /* Disable receiver */
568  axge_write_word ( axge, AXGE_RCR, 0 );
569 
570  /* Close USB network device */
571  usbnet_close ( &axge->usbnet );
572 }
573 
574 /**
575  * Transmit packet
576  *
577  * @v netdev Network device
578  * @v iobuf I/O buffer
579  * @ret rc Return status code
580  */
581 static int axge_transmit ( struct net_device *netdev,
582  struct io_buffer *iobuf ) {
583  struct axge_device *axge = netdev->priv;
584  int rc;
585 
586  /* Transmit packet */
587  if ( ( rc = axge_out_transmit ( axge, iobuf ) ) != 0 )
588  return rc;
589 
590  return 0;
591 }
592 
593 /**
594  * Poll for completed and received packets
595  *
596  * @v netdev Network device
597  */
598 static void axge_poll ( struct net_device *netdev ) {
599  struct axge_device *axge = netdev->priv;
600  int rc;
601 
602  /* Poll USB bus */
603  usb_poll ( axge->bus );
604 
605  /* Refill endpoints */
606  if ( ( rc = usbnet_refill ( &axge->usbnet ) ) != 0 )
607  netdev_rx_err ( netdev, NULL, rc );
608 }
609 
610 /** AXGE network device operations */
612  .open = axge_open,
613  .close = axge_close,
614  .transmit = axge_transmit,
615  .poll = axge_poll,
616 };
617 
618 /******************************************************************************
619  *
620  * USB interface
621  *
622  ******************************************************************************
623  */
624 
625 /**
626  * Probe device
627  *
628  * @v func USB function
629  * @v config Configuration descriptor
630  * @ret rc Return status code
631  */
632 static int axge_probe ( struct usb_function *func,
633  struct usb_configuration_descriptor *config ) {
634  struct usb_device *usb = func->usb;
635  struct net_device *netdev;
636  struct axge_device *axge;
637  uint16_t epprcr;
638  uint16_t msr;
639  uint8_t csr;
640  int rc;
641 
642  /* Allocate and initialise structure */
643  netdev = alloc_etherdev ( sizeof ( *axge ) );
644  if ( ! netdev ) {
645  rc = -ENOMEM;
646  goto err_alloc;
647  }
649  netdev->dev = &func->dev;
650  axge = netdev->priv;
651  memset ( axge, 0, sizeof ( *axge ) );
652  axge->usb = usb;
653  axge->bus = usb->port->hub->bus;
654  axge->netdev = netdev;
655  usbnet_init ( &axge->usbnet, func, &axge_intr_operations,
657  usb_refill_init ( &axge->usbnet.intr, 0, 0, AXGE_INTR_MAX_FILL );
660  DBGC ( axge, "AXGE %p on %s\n", axge, func->name );
661 
662  /* Describe USB network device */
663  if ( ( rc = usbnet_describe ( &axge->usbnet, config ) ) != 0 ) {
664  DBGC ( axge, "AXGE %p could not describe: %s\n",
665  axge, strerror ( rc ) );
666  goto err_describe;
667  }
668 
669  /* Fetch MAC address */
670  if ( ( rc = axge_read_register ( axge, AXGE_NIDR, netdev->hw_addr,
671  ETH_ALEN ) ) != 0 ) {
672  DBGC ( axge, "AXGE %p could not fetch MAC address: %s\n",
673  axge, strerror ( rc ) );
674  goto err_read_mac;
675  }
676 
677  /* Power up PHY */
678  if ( ( rc = axge_write_word ( axge, AXGE_EPPRCR, 0 ) ) != 0 ) {
679  DBGC ( axge, "AXGE %p could not write EPPRCR: %s\n",
680  axge, strerror ( rc ) );
681  goto err_write_epprcr_off;
682  }
683  epprcr = cpu_to_le16 ( AXGE_EPPRCR_IPRL );
684  if ( ( rc = axge_write_word ( axge, AXGE_EPPRCR, epprcr ) ) != 0){
685  DBGC ( axge, "AXGE %p could not write EPPRCR: %s\n",
686  axge, strerror ( rc ) );
687  goto err_write_epprcr_on;
688  }
690 
691  /* Select clocks */
692  csr = ( AXGE_CSR_BCS | AXGE_CSR_ACS );
693  if ( ( rc = axge_write_byte ( axge, AXGE_CSR, csr ) ) != 0){
694  DBGC ( axge, "AXGE %p could not write CSR: %s\n",
695  axge, strerror ( rc ) );
696  goto err_write_csr;
697  }
699 
700  /* Configure bulk IN pipeline */
701  if ( ( rc = axge_write_register ( axge, AXGE_BICR, &axge_bicr,
702  sizeof ( axge_bicr ) ) ) != 0 ){
703  DBGC ( axge, "AXGE %p could not write BICR: %s\n",
704  axge, strerror ( rc ) );
705  goto err_write_bicr;
706  }
707 
708  /* Set medium status */
711  if ( ( rc = axge_write_word ( axge, AXGE_MSR, msr ) ) != 0 ) {
712  DBGC ( axge, "AXGE %p could not write MSR: %s\n",
713  axge, strerror ( rc ) );
714  goto err_write_msr;
715  }
716 
717  /* Register network device */
718  if ( ( rc = register_netdev ( netdev ) ) != 0 )
719  goto err_register;
720 
721  /* Update link status */
722  axge_check_link ( axge );
723 
724  usb_func_set_drvdata ( func, axge );
725  return 0;
726 
728  err_register:
729  err_write_msr:
730  err_write_bicr:
731  err_write_csr:
732  err_write_epprcr_on:
733  err_write_epprcr_off:
734  err_read_mac:
735  err_describe:
737  netdev_put ( netdev );
738  err_alloc:
739  return rc;
740 }
741 
742 /**
743  * Remove device
744  *
745  * @v func USB function
746  */
747 static void axge_remove ( struct usb_function *func ) {
748  struct axge_device *axge = usb_func_get_drvdata ( func );
749  struct net_device *netdev = axge->netdev;
750 
753  netdev_put ( netdev );
754 }
755 
756 /** AXGE device IDs */
757 static struct usb_device_id axge_ids[] = {
758  {
759  .name = "ax88179",
760  .vendor = 0x0b95,
761  .product = 0x1790,
762  },
763  {
764  .name = "ax88178a",
765  .vendor = 0x0b95,
766  .product = 0x178a,
767  },
768  {
769  .name = "dub1312",
770  .vendor = 0x2001,
771  .product = 0x4a00,
772  },
773  {
774  .name = "axge-sitecom",
775  .vendor = 0x0df6,
776  .product = 0x0072,
777  },
778  {
779  .name = "axge-samsung",
780  .vendor = 0x04e8,
781  .product = 0xa100,
782  },
783  {
784  .name = "onelinkdock",
785  .vendor = 0x17ef,
786  .product = 0x304b,
787  },
788 };
789 
790 /** AXGE driver */
791 struct usb_driver axge_driver __usb_driver = {
792  .ids = axge_ids,
793  .id_count = ( sizeof ( axge_ids ) / sizeof ( axge_ids[0] ) ),
795  .score = USB_SCORE_NORMAL,
796  .probe = axge_probe,
797  .remove = axge_remove,
798 };
Asix 10/100/1000 USB Ethernet driver.
#define iob_pull(iobuf, len)
Definition: iobuf.h:98
A USB driver.
Definition: usb.h:1363
#define EINVAL
Invalid argument.
Definition: errno.h:428
#define AXGE_INTR_MAGIC
Interrupt magic signature.
Definition: axge.h:132
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
unsigned short uint16_t
Definition: stdint.h:11
A USB device ID.
Definition: usb.h:1317
#define AXGE_EPPRCR_IPRL
Undocumented.
Definition: axge.h:55
#define iob_put(iobuf, len)
Definition: iobuf.h:116
void(* complete)(struct usb_endpoint *ep, struct io_buffer *iobuf, int rc)
Complete transfer.
Definition: usb.h:481
void netdev_rx_err(struct net_device *netdev, struct io_buffer *iobuf, int rc)
Discard received packet.
Definition: netdevice.c:501
static void * usb_func_get_drvdata(struct usb_function *func)
Get USB function driver private data.
Definition: usb.h:701
static int axge_read_byte(struct axge_device *axge, unsigned int offset, uint8_t *value)
Read one-byte register.
Definition: axge.c:107
#define AXGE_RX_DROP_ERROR
Receive packet dropped error.
Definition: axge.h:117
const char * name
Name.
Definition: usb.h:659
struct usb_device * usb
USB device.
Definition: axge.h:140
int(* open)(struct net_device *netdev)
Open network device.
Definition: netdevice.h:222
const char * name
Name.
Definition: usb.h:1319
static void axge_close(struct net_device *netdev)
Close network device.
Definition: axge.c:564
static void axge_poll(struct net_device *netdev)
Poll for completed and received packets.
Definition: axge.c:598
Error codes.
#define iob_push(iobuf, len)
Definition: iobuf.h:80
#define AXGE_EPPRCR_DELAY_MS
Delay after initialising EPPRCR.
Definition: axge.h:58
struct usb_bus * bus
USB bus.
Definition: axge.h:142
Interrupt data.
Definition: axge.h:120
void free_iob(struct io_buffer *iobuf)
Free I/O buffer.
Definition: iobuf.c:145
#define AXGE_RCR
RX Control Register.
Definition: axge.h:36
struct arbelprm_completion_with_error error
Definition: arbel.h:12
static int axge_open(struct net_device *netdev)
Open network device.
Definition: axge.c:517
#define DBGC(...)
Definition: compiler.h:505
#define AXGE_IN_RESERVE
Amount of space to reserve at start of bulk IN buffers.
Definition: axge.h:172
#define AXGE_INTR_MAX_FILL
Interrupt maximum fill level.
Definition: axge.h:153
int usb_stream(struct usb_endpoint *ep, struct io_buffer *iobuf, int terminate)
Enqueue USB stream transfer.
Definition: usb.c:528
void netdev_link_down(struct net_device *netdev)
Mark network device as having link down.
Definition: netdevice.c:186
#define AXGE_RX_CRC_ERROR
Receive packet CRC error.
Definition: axge.h:114
static void axge_remove(struct usb_function *func)
Remove device.
Definition: axge.c:747
#define AXGE_MSR_RFC
RX flow control enable.
Definition: axge.h:49
#define AXGE_RX_LEN_PAD_ALIGN
Receive packet length alignment.
Definition: axge.h:111
static struct profiler axge_intr_profiler __profiler
Interrupt completion profiler.
Definition: axge.c:47
A data structure for storing profiling information.
Definition: profile.h:26
#define AXGE_RCR_SO
Start operation.
Definition: axge.h:40
#define AXGE_MSR
Medium Status Register.
Definition: axge.h:46
int open
Endpoint is open.
Definition: usb.h:404
static void profile_stop(struct profiler *profiler)
Stop profiling.
Definition: profile.h:171
struct usb_endpoint intr
Interrupt endpoint.
Definition: usbnet.h:27
static void axge_intr_complete(struct usb_endpoint *ep, struct io_buffer *iobuf, int rc)
Complete interrupt transfer.
Definition: axge.c:251
struct io_buffer * alloc_iob(size_t len)
Allocate I/O buffer.
Definition: iobuf.c:128
int usb_control(struct usb_device *usb, unsigned int request, unsigned int value, unsigned int index, void *data, size_t len)
Issue USB control transaction.
Definition: usb.c:753
static struct axge_bulk_in_control axge_bicr
Default bulk IN configuration.
Definition: axge.c:68
#define AXGE_RCR_PRO
Promiscuous mode.
Definition: axge.h:37
static struct net_device_operations axge_operations
AXGE network device operations.
Definition: axge.c:611
An AXGE network device.
Definition: axge.h:138
static int axge_out_transmit(struct axge_device *axge, struct io_buffer *iobuf)
Transmit packet.
Definition: axge.c:458
struct usb_endpoint out
Bulk OUT endpoint.
Definition: usbnet.h:31
static void netdev_init(struct net_device *netdev, struct net_device_operations *op)
Initialise a network device.
Definition: netdevice.h:498
#define AXGE_PLSR
Physical Link Status Register.
Definition: axge.h:26
#define ENOMEM
Not enough space.
Definition: errno.h:534
#define iob_disown(iobuf)
Disown an I/O buffer.
Definition: iobuf.h:208
A USB endpoint.
Definition: usb.h:389
static int axge_check_link(struct axge_device *axge)
Get link status.
Definition: axge.c:213
void * memcpy(void *dest, const void *src, size_t len) __nonnull
Transmit packet header.
Definition: axge.h:84
const char * name
Name.
Definition: profile.h:28
struct usb_port * port
USB port.
Definition: usb.h:710
#define AXGE_CSR_DELAY_MS
Delay after initialising CSR.
Definition: axge.h:81
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
static void netdev_put(struct net_device *netdev)
Drop reference to network device.
Definition: netdevice.h:555
#define container_of(ptr, type, field)
Get containing structure.
Definition: stddef.h:35
Ethernet protocol.
uint8_t intr
Interrupts enabled.
Definition: ena.h:14
void * priv
Driver private data.
Definition: netdevice.h:425
static void axge_in_complete(struct usb_endpoint *ep, struct io_buffer *iobuf, int rc)
Complete bulk IN transfer.
Definition: axge.c:334
struct net_device * netdev
Network device.
Definition: axge.h:144
#define DBGC_HDA(...)
Definition: compiler.h:506
#define AXGE_READ_MAC_REGISTER
Read MAC register.
Definition: axge.h:16
static void netdev_link_up(struct net_device *netdev)
Mark network device as having link up.
Definition: netdevice.h:768
#define AXGE_CSR
Clock Select Register (undocumented)
Definition: axge.h:76
static void usb_refill_init(struct usb_endpoint *ep, size_t reserve, size_t len, unsigned int max)
Initialise USB endpoint refill.
Definition: usb.h:601
static int axge_read_dword(struct axge_device *axge, unsigned int offset, uint32_t *value)
Read four-byte register.
Definition: axge.c:135
static int netdev_link_ok(struct net_device *netdev)
Check link state of network device.
Definition: netdevice.h:630
static userptr_t size_t offset
Offset of the first segment within the content.
Definition: deflate.h:259
static struct net_device * netdev
Definition: gdbudp.c:52
static void usb_func_set_drvdata(struct usb_function *func, void *priv)
Set USB function driver private data.
Definition: usb.h:690
static void profile_start(struct profiler *profiler)
Start profiling.
Definition: profile.h:158
Profiling.
static int axge_transmit(struct net_device *netdev, struct io_buffer *iobuf)
Transmit packet.
Definition: axge.c:581
void unregister_netdev(struct net_device *netdev)
Unregister network device.
Definition: netdevice.c:844
static int axge_write_dword(struct axge_device *axge, unsigned int offset, uint32_t value)
Write one-byte register.
Definition: axge.c:194
int usbnet_refill(struct usbnet_device *usbnet)
Refill USB network device bulk IN and interrupt endpoints.
Definition: usbnet.c:151
#define cpu_to_le32(value)
Definition: byteswap.h:107
A USB device.
Definition: usb.h:706
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
#define AXGE_IN_MAX_FILL
Bulk IN maximum fill level.
Definition: axge.h:159
static void usb_poll(struct usb_bus *bus)
Poll USB bus.
Definition: usb.h:1049
#define iob_unput(iobuf, len)
Definition: iobuf.h:131
#define AXGE_INTR_LINK_PPLS
Link is up.
Definition: axge.h:135
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
Bulk IN Control (undocumented)
Definition: axge.h:64
int register_netdev(struct net_device *netdev)
Register network device.
Definition: netdevice.c:667
static size_t iob_len(struct io_buffer *iobuf)
Calculate length of data in an I/O buffer.
Definition: iobuf.h:151
#define USB_CLASS_ID(base, subclass, protocol)
Construct USB class ID.
Definition: usb.h:1345
A network device.
Definition: netdevice.h:348
#define AXGE_CSR_BCS
Undocumented.
Definition: axge.h:77
#define AXGE_BICR
Bulk IN Control Register (undocumented)
Definition: axge.h:61
struct usb_endpoint in
Bulk IN endpoint.
Definition: usbnet.h:29
static void netdev_nullify(struct net_device *netdev)
Stop using a network device.
Definition: netdevice.h:511
static int axge_probe(struct usb_function *func, struct usb_configuration_descriptor *config)
Probe device.
Definition: axge.c:632
Normal driver.
Definition: usb.h:1406
unsigned char uint8_t
Definition: stdint.h:10
#define AXGE_PLSR_EPHY_ANY
Definition: axge.h:30
#define ETH_ALEN
Definition: if_ether.h:8
uint16_t len_flags
Length and error flags.
Definition: axge.h:104
struct usb_device * usb
USB device.
Definition: usb.h:661
struct usb_driver axge_driver __usb_driver
AXGE driver.
Definition: axge.c:791
#define le16_to_cpu(value)
Definition: byteswap.h:112
unsigned int uint32_t
Definition: stdint.h:12
static struct usb_endpoint_driver_operations axge_intr_operations
Interrupt endpoint operations.
Definition: axge.c:316
Network device operations.
Definition: netdevice.h:213
void netdev_rx(struct net_device *netdev, struct io_buffer *iobuf)
Add packet to receive queue.
Definition: netdevice.c:470
struct device * dev
Underlying hardware device.
Definition: netdevice.h:360
uint32_t hdr
Message header.
Definition: intelvf.h:12
#define AXGE_WRITE_MAC_REGISTER
Write MAC register.
Definition: axge.h:21
#define AXGE_MSR_GM
Gigabit mode.
Definition: axge.h:47
Network device management.
static int axge_write_word(struct axge_device *axge, unsigned int offset, uint16_t value)
Write two-byte register.
Definition: axge.c:180
#define AXGE_NIDR
Node ID Register.
Definition: axge.h:43
void mdelay(unsigned long msecs)
Delay for a fixed number of milliseconds.
Definition: timer.c:78
#define iob_reserve(iobuf, len)
Definition: iobuf.h:63
#define AXGE_RX_LEN_MASK
Receive packet length mask.
Definition: axge.h:108
A USB configuration descriptor.
Definition: usb.h:195
void netdev_tx_complete_err(struct net_device *netdev, struct io_buffer *iobuf, int rc)
Complete network transmission.
Definition: netdevice.c:395
#define AXGE_CSR_ACS
Undocumented.
Definition: axge.h:78
uint32_t len
Length.
Definition: ena.h:14
static int axge_read_register(struct axge_device *axge, unsigned int offset, void *data, size_t len)
Read register.
Definition: axge.c:91
#define ENOBUFS
No buffer space available.
Definition: errno.h:498
#define USB_ANY_ID
Match-anything ID.
Definition: usb.h:1329
Universal Serial Bus (USB)
static void usbnet_init(struct usbnet_device *usbnet, struct usb_function *func, struct usb_endpoint_driver_operations *intr, struct usb_endpoint_driver_operations *in, struct usb_endpoint_driver_operations *out)
Initialise USB network device.
Definition: usbnet.h:44
#define AXGE_RCR_AMALL
Accept all multicasts.
Definition: axge.h:38
void * data
Start of data.
Definition: iobuf.h:44
struct usb_hub * hub
USB hub.
Definition: usb.h:798
#define EIO
Input/output error.
Definition: errno.h:433
uint16_t count
Number of entries.
Definition: ena.h:22
struct net_device * alloc_etherdev(size_t priv_size)
Allocate Ethernet device.
Definition: ethernet.c:264
static struct usb_endpoint_driver_operations axge_out_operations
Bulk OUT endpoint operations.
Definition: axge.c:500
#define cpu_to_le16(value)
Definition: byteswap.h:106
static void axge_out_complete(struct usb_endpoint *ep, struct io_buffer *iobuf, int rc)
Complete bulk OUT transfer.
Definition: axge.c:489
static struct usb_endpoint_driver_operations axge_in_operations
Bulk IN endpoint operations.
Definition: axge.c:447
static struct usb_device_id axge_ids[]
AXGE device IDs.
Definition: axge.c:757
#define AXGE_EPPRCR
Ethernet PHY Power and Reset Control Register.
Definition: axge.h:54
int usbnet_describe(struct usbnet_device *usbnet, struct usb_configuration_descriptor *config)
Describe USB network device interfaces.
Definition: usbnet.c:277
#define AXGE_MSR_TFC
TX flow control enable.
Definition: axge.h:50
uint8_t ctrl
Control.
Definition: axge.h:66
Receive packet descriptor.
Definition: axge.h:100
struct arbelprm_port_state_change_st data
Message.
Definition: arbel.h:12
uint8_t ll_addr[MAX_LL_ADDR_LEN]
Link-layer address.
Definition: netdevice.h:381
void usbnet_close(struct usbnet_device *usbnet)
Close USB network device.
Definition: usbnet.c:127
USB endpoint driver operations.
Definition: usb.h:474
struct device dev
Generic device.
Definition: usb.h:665
A USB function.
Definition: usb.h:657
static int axge_write_register(struct axge_device *axge, unsigned int offset, void *data, size_t len)
Write register.
Definition: axge.c:150
struct usb_bus * bus
USB bus.
Definition: usb.h:828
FILE_LICENCE(GPL2_OR_LATER_OR_UBDL)
int iob_ensure_headroom(struct io_buffer *iobuf, size_t len)
Ensure I/O buffer has sufficient headroom.
Definition: iobuf.c:183
static int axge_write_byte(struct axge_device *axge, unsigned int offset, uint8_t value)
Write one-byte register.
Definition: axge.c:166
struct usbnet_device usbnet
USB network device.
Definition: axge.h:146
#define AXGE_IN_MTU
Bulk IN buffer size.
Definition: axge.h:165
#define AXGE_RCR_AB
Accept broadcasts.
Definition: axge.h:39
uint8_t hw_addr[MAX_HW_ADDR_LEN]
Hardware address.
Definition: netdevice.h:375
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
String functions.
#define AXGE_MSR_FD
Full duplex.
Definition: axge.h:48
static int axge_read_word(struct axge_device *axge, unsigned int offset, uint16_t *value)
Read two-byte register.
Definition: axge.c:121
#define AXGE_MSR_RE
Receive enable.
Definition: axge.h:51
struct usb_device_id * ids
USB ID table.
Definition: usb.h:1365
void * memset(void *dest, int character, size_t len) __nonnull
A persistent I/O buffer.
Definition: iobuf.h:32
int usbnet_open(struct usbnet_device *usbnet)
Open USB network device.
Definition: usbnet.c:54