[usb] Select preferred USB device configuration based on driver score
[ipxe.git] / src / drivers / net / ncm.c
1 /*
2 * Copyright (C) 2014 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 <string.h>
27 #include <errno.h>
28 #include <ipxe/netdevice.h>
29 #include <ipxe/ethernet.h>
30 #include <ipxe/if_ether.h>
31 #include <ipxe/profile.h>
32 #include <ipxe/usb.h>
33 #include <ipxe/usbnet.h>
34 #include "ecm.h"
35 #include "ncm.h"
36
37 /** @file
38 *
39 * CDC-NCM USB Ethernet driver
40 *
41 */
42
43 /** Interrupt completion profiler */
44 static struct profiler ncm_intr_profiler __profiler =
45 { .name = "ncm.intr" };
46
47 /** Bulk IN completion profiler */
48 static struct profiler ncm_in_profiler __profiler =
49 { .name = "ncm.in" };
50
51 /** Bulk IN per-datagram profiler */
52 static struct profiler ncm_in_datagram_profiler __profiler =
53 { .name = "ncm.in_dgram" };
54
55 /** Bulk OUT profiler */
56 static struct profiler ncm_out_profiler __profiler =
57 { .name = "ncm.out" };
58
59 /******************************************************************************
60 *
61 * CDC-NCM communications interface
62 *
63 ******************************************************************************
64 */
65
66 /**
67 * Complete interrupt transfer
68 *
69 * @v ep USB endpoint
70 * @v iobuf I/O buffer
71 * @v rc Completion status code
72 */
73 static void ncm_intr_complete ( struct usb_endpoint *ep,
74 struct io_buffer *iobuf, int rc ) {
75 struct ncm_device *ncm = container_of ( ep, struct ncm_device,
76 usbnet.intr );
77 struct net_device *netdev = ncm->netdev;
78 struct usb_setup_packet *message;
79 size_t len = iob_len ( iobuf );
80
81 /* Profile completions */
82 profile_start ( &ncm_intr_profiler );
83
84 /* Ignore packets cancelled when the endpoint closes */
85 if ( ! ep->open )
86 goto ignore;
87
88 /* Ignore packets with errors */
89 if ( rc != 0 ) {
90 DBGC ( ncm, "NCM %p interrupt failed: %s\n",
91 ncm, strerror ( rc ) );
92 DBGC_HDA ( ncm, 0, iobuf->data, iob_len ( iobuf ) );
93 goto error;
94 }
95
96 /* Extract message header */
97 if ( len < sizeof ( *message ) ) {
98 DBGC ( ncm, "NCM %p underlength interrupt:\n", ncm );
99 DBGC_HDA ( ncm, 0, iobuf->data, iob_len ( iobuf ) );
100 rc = -EINVAL;
101 goto error;
102 }
103 message = iobuf->data;
104
105 /* Parse message header */
106 switch ( message->request ) {
107
108 case cpu_to_le16 ( CDC_NETWORK_CONNECTION ) :
109 if ( message->value ) {
110 DBGC ( ncm, "NCM %p link up\n", ncm );
111 netdev_link_up ( netdev );
112 } else {
113 DBGC ( ncm, "NCM %p link down\n", ncm );
114 netdev_link_down ( netdev );
115 }
116 break;
117
118 case cpu_to_le16 ( CDC_CONNECTION_SPEED_CHANGE ) :
119 /* Ignore */
120 break;
121
122 default:
123 DBGC ( ncm, "NCM %p unrecognised interrupt:\n", ncm );
124 DBGC_HDA ( ncm, 0, iobuf->data, iob_len ( iobuf ) );
125 goto error;
126 }
127
128 /* Free I/O buffer */
129 free_iob ( iobuf );
130 profile_stop ( &ncm_intr_profiler );
131
132 return;
133
134 error:
135 netdev_rx_err ( netdev, iob_disown ( iobuf ), rc );
136 ignore:
137 free_iob ( iobuf );
138 return;
139 }
140
141 /** Interrupt endpoint operations */
142 static struct usb_endpoint_driver_operations ncm_intr_operations = {
143 .complete = ncm_intr_complete,
144 };
145
146 /******************************************************************************
147 *
148 * CDC-NCM data interface
149 *
150 ******************************************************************************
151 */
152
153 /**
154 * Prefill bulk IN endpoint
155 *
156 * @v ncm CDC-NCM device
157 * @ret rc Return status code
158 */
159 static int ncm_in_prefill ( struct ncm_device *ncm ) {
160 struct usb_bus *bus = ncm->bus;
161 size_t mtu;
162 unsigned int count;
163 int rc;
164
165 /* Some devices have a very small number of internal buffers,
166 * and rely on being able to pack multiple packets into each
167 * buffer. We therefore want to use large buffers if
168 * possible. However, large allocations have a reasonable
169 * chance of failure, especially if this is not the first or
170 * only device to be opened.
171 *
172 * We therefore attempt to find a usable buffer size, starting
173 * large and working downwards until allocation succeeds.
174 * Smaller buffers will still work, albeit with a higher
175 * chance of packet loss and so lower overall throughput.
176 */
177 for ( mtu = ncm->mtu ; mtu >= NCM_MIN_NTB_INPUT_SIZE ; mtu >>= 1 ) {
178
179 /* Attempt allocation at this MTU */
180 if ( mtu > NCM_MAX_NTB_INPUT_SIZE )
181 continue;
182 if ( mtu > bus->mtu )
183 continue;
184 count = ( NCM_IN_MIN_SIZE / mtu );
185 if ( count < NCM_IN_MIN_COUNT )
186 count = NCM_IN_MIN_COUNT;
187 if ( ( count * mtu ) > NCM_IN_MAX_SIZE )
188 continue;
189 usb_refill_init ( &ncm->usbnet.in, mtu, count );
190 if ( ( rc = usb_prefill ( &ncm->usbnet.in ) ) != 0 ) {
191 DBGC ( ncm, "NCM %p could not prefill %dx %zd-byte "
192 "buffers for bulk IN\n", ncm, count, mtu );
193 continue;
194 }
195
196 DBGC ( ncm, "NCM %p using %dx %zd-byte buffers for bulk IN\n",
197 ncm, count, mtu );
198 return 0;
199 }
200
201 DBGC ( ncm, "NCM %p could not prefill bulk IN endpoint\n", ncm );
202 return -ENOMEM;
203 }
204
205 /**
206 * Complete bulk IN transfer
207 *
208 * @v ep USB endpoint
209 * @v iobuf I/O buffer
210 * @v rc Completion status code
211 */
212 static void ncm_in_complete ( struct usb_endpoint *ep, struct io_buffer *iobuf,
213 int rc ) {
214 struct ncm_device *ncm = container_of ( ep, struct ncm_device,
215 usbnet.in );
216 struct net_device *netdev = ncm->netdev;
217 struct ncm_transfer_header *nth;
218 struct ncm_datagram_pointer *ndp;
219 struct ncm_datagram_descriptor *desc;
220 struct io_buffer *pkt;
221 unsigned int remaining;
222 size_t ndp_offset;
223 size_t ndp_len;
224 size_t pkt_offset;
225 size_t pkt_len;
226 size_t headroom;
227 size_t len;
228
229 /* Profile overall bulk IN completion */
230 profile_start ( &ncm_in_profiler );
231
232 /* Ignore packets cancelled when the endpoint closes */
233 if ( ! ep->open )
234 goto ignore;
235
236 /* Record USB errors against the network device */
237 if ( rc != 0 ) {
238 DBGC ( ncm, "NCM %p bulk IN failed: %s\n",
239 ncm, strerror ( rc ) );
240 goto error;
241 }
242
243 /* Locate transfer header */
244 len = iob_len ( iobuf );
245 if ( sizeof ( *nth ) > len ) {
246 DBGC ( ncm, "NCM %p packet too short for NTH:\n", ncm );
247 rc = -EINVAL;
248 goto error;
249 }
250 nth = iobuf->data;
251
252 /* Locate datagram pointer */
253 ndp_offset = le16_to_cpu ( nth->offset );
254 if ( ( ndp_offset + sizeof ( *ndp ) ) > len ) {
255 DBGC ( ncm, "NCM %p packet too short for NDP:\n", ncm );
256 rc = -EINVAL;
257 goto error;
258 }
259 ndp = ( iobuf->data + ndp_offset );
260 ndp_len = le16_to_cpu ( ndp->header_len );
261 if ( ndp_len < offsetof ( typeof ( *ndp ), desc ) ) {
262 DBGC ( ncm, "NCM %p NDP header length too short:\n", ncm );
263 rc = -EINVAL;
264 goto error;
265 }
266 if ( ( ndp_offset + ndp_len ) > len ) {
267 DBGC ( ncm, "NCM %p packet too short for NDP:\n", ncm );
268 rc = -EINVAL;
269 goto error;
270 }
271
272 /* Process datagrams */
273 remaining = ( ( ndp_len - offsetof ( typeof ( *ndp ), desc ) ) /
274 sizeof ( ndp->desc[0] ) );
275 for ( desc = ndp->desc ; remaining && desc->offset ; remaining-- ) {
276
277 /* Profile individual datagrams */
278 profile_start ( &ncm_in_datagram_profiler );
279
280 /* Locate datagram */
281 pkt_offset = le16_to_cpu ( desc->offset );
282 pkt_len = le16_to_cpu ( desc->len );
283 if ( pkt_len < ETH_HLEN ) {
284 DBGC ( ncm, "NCM %p underlength datagram:\n", ncm );
285 rc = -EINVAL;
286 goto error;
287 }
288 if ( ( pkt_offset + pkt_len ) > len ) {
289 DBGC ( ncm, "NCM %p datagram exceeds packet:\n", ncm );
290 rc = -EINVAL;
291 goto error;
292 }
293
294 /* Move to next descriptor */
295 desc++;
296
297 /* Copy data to a new I/O buffer. Our USB buffers may
298 * be very large and so we choose to recycle the
299 * buffers directly rather than attempt reallocation
300 * while the device is running. We therefore copy the
301 * data to a new I/O buffer even if this is the only
302 * (or last) packet within the buffer.
303 *
304 * We reserve enough space at the start of each buffer
305 * to allow for our own transmission header, to
306 * support protocols such as ARP which may modify the
307 * received packet and reuse the same I/O buffer for
308 * transmission.
309 */
310 headroom = ( sizeof ( struct ncm_ntb_header ) + ncm->padding );
311 pkt = alloc_iob ( headroom + pkt_len );
312 if ( ! pkt ) {
313 /* Record error and continue */
314 netdev_rx_err ( netdev, NULL, -ENOMEM );
315 continue;
316 }
317 iob_reserve ( pkt, headroom );
318 memcpy ( iob_put ( pkt, pkt_len ),
319 ( iobuf->data + pkt_offset ), pkt_len );
320
321 /* Strip CRC, if present */
322 if ( ndp->magic & cpu_to_le32 ( NCM_DATAGRAM_POINTER_MAGIC_CRC))
323 iob_unput ( pkt, 4 /* CRC32 */ );
324
325 /* Hand off to network stack */
326 netdev_rx ( netdev, pkt );
327 profile_stop ( &ncm_in_datagram_profiler );
328 }
329
330 /* Recycle I/O buffer */
331 usb_recycle ( &ncm->usbnet.in, iobuf );
332 profile_stop ( &ncm_in_profiler );
333
334 return;
335
336 error:
337 /* Record error against network device */
338 DBGC_HDA ( ncm, 0, iobuf->data, iob_len ( iobuf ) );
339 netdev_rx_err ( netdev, NULL, rc );
340 ignore:
341 usb_recycle ( &ncm->usbnet.in, iobuf );
342 }
343
344 /** Bulk IN endpoint operations */
345 static struct usb_endpoint_driver_operations ncm_in_operations = {
346 .complete = ncm_in_complete,
347 };
348
349 /**
350 * Transmit packet
351 *
352 * @v ncm CDC-NCM device
353 * @v iobuf I/O buffer
354 * @ret rc Return status code
355 */
356 static int ncm_out_transmit ( struct ncm_device *ncm,
357 struct io_buffer *iobuf ) {
358 struct ncm_ntb_header *header;
359 size_t len = iob_len ( iobuf );
360 size_t header_len = ( sizeof ( *header ) + ncm->padding );
361 int rc;
362
363 /* Profile transmissions */
364 profile_start ( &ncm_out_profiler );
365
366 /* Prepend header */
367 if ( ( rc = iob_ensure_headroom ( iobuf, header_len ) ) != 0 )
368 return rc;
369 header = iob_push ( iobuf, header_len );
370
371 /* Populate header */
372 header->nth.magic = cpu_to_le32 ( NCM_TRANSFER_HEADER_MAGIC );
373 header->nth.header_len = cpu_to_le16 ( sizeof ( header->nth ) );
374 header->nth.sequence = cpu_to_le16 ( ncm->sequence );
375 header->nth.len = cpu_to_le16 ( iob_len ( iobuf ) );
376 header->nth.offset =
377 cpu_to_le16 ( offsetof ( typeof ( *header ), ndp ) );
378 header->ndp.magic = cpu_to_le32 ( NCM_DATAGRAM_POINTER_MAGIC );
379 header->ndp.header_len = cpu_to_le16 ( sizeof ( header->ndp ) +
380 sizeof ( header->desc ) );
381 header->ndp.offset = cpu_to_le16 ( 0 );
382 header->desc[0].offset = cpu_to_le16 ( header_len );
383 header->desc[0].len = cpu_to_le16 ( len );
384 memset ( &header->desc[1], 0, sizeof ( header->desc[1] ) );
385
386 /* Enqueue I/O buffer */
387 if ( ( rc = usb_stream ( &ncm->usbnet.out, iobuf, 0 ) ) != 0 )
388 return rc;
389
390 /* Increment sequence number */
391 ncm->sequence++;
392
393 profile_stop ( &ncm_out_profiler );
394 return 0;
395 }
396
397 /**
398 * Complete bulk OUT transfer
399 *
400 * @v ep USB endpoint
401 * @v iobuf I/O buffer
402 * @v rc Completion status code
403 */
404 static void ncm_out_complete ( struct usb_endpoint *ep, struct io_buffer *iobuf,
405 int rc ) {
406 struct ncm_device *ncm = container_of ( ep, struct ncm_device,
407 usbnet.out );
408 struct net_device *netdev = ncm->netdev;
409
410 /* Report TX completion */
411 netdev_tx_complete_err ( netdev, iobuf, rc );
412 }
413
414 /** Bulk OUT endpoint operations */
415 static struct usb_endpoint_driver_operations ncm_out_operations = {
416 .complete = ncm_out_complete,
417 };
418
419 /******************************************************************************
420 *
421 * Network device interface
422 *
423 ******************************************************************************
424 */
425
426 /**
427 * Open network device
428 *
429 * @v netdev Network device
430 * @ret rc Return status code
431 */
432 static int ncm_open ( struct net_device *netdev ) {
433 struct ncm_device *ncm = netdev->priv;
434 struct usb_device *usb = ncm->usb;
435 struct ncm_set_ntb_input_size size;
436 int rc;
437
438 /* Reset sequence number */
439 ncm->sequence = 0;
440
441 /* Prefill I/O buffers */
442 if ( ( rc = ncm_in_prefill ( ncm ) ) != 0 )
443 goto err_prefill;
444
445 /* Set maximum input size */
446 memset ( &size, 0, sizeof ( size ) );
447 size.mtu = cpu_to_le32 ( ncm->usbnet.in.len );
448 if ( ( rc = usb_control ( usb, NCM_SET_NTB_INPUT_SIZE, 0,
449 ncm->usbnet.comms, &size,
450 sizeof ( size ) ) ) != 0 ) {
451 DBGC ( ncm, "NCM %p could not set input size to %zd: %s\n",
452 ncm, ncm->usbnet.in.len, strerror ( rc ) );
453 goto err_set_ntb_input_size;
454 }
455
456 /* Open USB network device */
457 if ( ( rc = usbnet_open ( &ncm->usbnet ) ) != 0 ) {
458 DBGC ( ncm, "NCM %p could not open: %s\n",
459 ncm, strerror ( rc ) );
460 goto err_open;
461 }
462
463 return 0;
464
465 usbnet_close ( &ncm->usbnet );
466 err_open:
467 err_set_ntb_input_size:
468 usb_flush ( &ncm->usbnet.in );
469 err_prefill:
470 return rc;
471 }
472
473 /**
474 * Close network device
475 *
476 * @v netdev Network device
477 */
478 static void ncm_close ( struct net_device *netdev ) {
479 struct ncm_device *ncm = netdev->priv;
480
481 /* Close USB network device */
482 usbnet_close ( &ncm->usbnet );
483 }
484
485 /**
486 * Transmit packet
487 *
488 * @v netdev Network device
489 * @v iobuf I/O buffer
490 * @ret rc Return status code
491 */
492 static int ncm_transmit ( struct net_device *netdev,
493 struct io_buffer *iobuf ) {
494 struct ncm_device *ncm = netdev->priv;
495 int rc;
496
497 /* Transmit packet */
498 if ( ( rc = ncm_out_transmit ( ncm, iobuf ) ) != 0 )
499 return rc;
500
501 return 0;
502 }
503
504 /**
505 * Poll for completed and received packets
506 *
507 * @v netdev Network device
508 */
509 static void ncm_poll ( struct net_device *netdev ) {
510 struct ncm_device *ncm = netdev->priv;
511 int rc;
512
513 /* Poll USB bus */
514 usb_poll ( ncm->bus );
515
516 /* Refill endpoints */
517 if ( ( rc = usbnet_refill ( &ncm->usbnet ) ) != 0 )
518 netdev_rx_err ( netdev, NULL, rc );
519
520 }
521
522 /** CDC-NCM network device operations */
523 static struct net_device_operations ncm_operations = {
524 .open = ncm_open,
525 .close = ncm_close,
526 .transmit = ncm_transmit,
527 .poll = ncm_poll,
528 };
529
530 /******************************************************************************
531 *
532 * USB interface
533 *
534 ******************************************************************************
535 */
536
537 /**
538 * Probe device
539 *
540 * @v func USB function
541 * @v config Configuration descriptor
542 * @ret rc Return status code
543 */
544 static int ncm_probe ( struct usb_function *func,
545 struct usb_configuration_descriptor *config ) {
546 struct usb_device *usb = func->usb;
547 struct net_device *netdev;
548 struct ncm_device *ncm;
549 struct usb_interface_descriptor *comms;
550 struct ecm_ethernet_descriptor *ethernet;
551 struct ncm_ntb_parameters params;
552 int rc;
553
554 /* Allocate and initialise structure */
555 netdev = alloc_etherdev ( sizeof ( *ncm ) );
556 if ( ! netdev ) {
557 rc = -ENOMEM;
558 goto err_alloc;
559 }
560 netdev_init ( netdev, &ncm_operations );
561 netdev->dev = &func->dev;
562 ncm = netdev->priv;
563 memset ( ncm, 0, sizeof ( *ncm ) );
564 ncm->usb = usb;
565 ncm->bus = usb->port->hub->bus;
566 ncm->netdev = netdev;
567 usbnet_init ( &ncm->usbnet, func, &ncm_intr_operations,
568 &ncm_in_operations, &ncm_out_operations );
569 usb_refill_init ( &ncm->usbnet.intr, 0, NCM_INTR_COUNT );
570 DBGC ( ncm, "NCM %p on %s\n", ncm, func->name );
571
572 /* Describe USB network device */
573 if ( ( rc = usbnet_describe ( &ncm->usbnet, config ) ) != 0 ) {
574 DBGC ( ncm, "NCM %p could not describe: %s\n",
575 ncm, strerror ( rc ) );
576 goto err_describe;
577 }
578
579 /* Locate Ethernet descriptor */
580 comms = usb_interface_descriptor ( config, ncm->usbnet.comms, 0 );
581 assert ( comms != NULL );
582 ethernet = ecm_ethernet_descriptor ( config, comms );
583 if ( ! ethernet ) {
584 DBGC ( ncm, "NCM %p has no Ethernet descriptor\n", ncm );
585 rc = -EINVAL;
586 goto err_ethernet;
587 }
588
589 /* Fetch MAC address */
590 if ( ( rc = ecm_fetch_mac ( usb, ethernet, netdev->hw_addr ) ) != 0 ) {
591 DBGC ( ncm, "NCM %p could not fetch MAC address: %s\n",
592 ncm, strerror ( rc ) );
593 goto err_fetch_mac;
594 }
595
596 /* Get NTB parameters */
597 if ( ( rc = usb_control ( usb, NCM_GET_NTB_PARAMETERS, 0,
598 ncm->usbnet.comms, &params,
599 sizeof ( params ) ) ) != 0 ) {
600 DBGC ( ncm, "NCM %p could not get NTB parameters: %s\n",
601 ncm, strerror ( rc ) );
602 goto err_ntb_parameters;
603 }
604
605 /* Get maximum supported input size */
606 ncm->mtu = le32_to_cpu ( params.in.mtu );
607 DBGC2 ( ncm, "NCM %p maximum IN size is %zd bytes\n", ncm, ncm->mtu );
608
609 /* Calculate transmit padding */
610 ncm->padding = ( ( le16_to_cpu ( params.out.remainder ) -
611 sizeof ( struct ncm_ntb_header ) - ETH_HLEN ) &
612 ( le16_to_cpu ( params.out.divisor ) - 1 ) );
613 DBGC2 ( ncm, "NCM %p using %zd-byte transmit padding\n",
614 ncm, ncm->padding );
615 assert ( ( ( sizeof ( struct ncm_ntb_header ) + ncm->padding +
616 ETH_HLEN ) % le16_to_cpu ( params.out.divisor ) ) ==
617 le16_to_cpu ( params.out.remainder ) );
618
619 /* Register network device */
620 if ( ( rc = register_netdev ( netdev ) ) != 0 )
621 goto err_register;
622
623 usb_func_set_drvdata ( func, ncm );
624 return 0;
625
626 unregister_netdev ( netdev );
627 err_register:
628 err_ntb_parameters:
629 err_fetch_mac:
630 err_ethernet:
631 err_describe:
632 netdev_nullify ( netdev );
633 netdev_put ( netdev );
634 err_alloc:
635 return rc;
636 }
637
638 /**
639 * Remove device
640 *
641 * @v func USB function
642 */
643 static void ncm_remove ( struct usb_function *func ) {
644 struct ncm_device *ncm = usb_func_get_drvdata ( func );
645 struct net_device *netdev = ncm->netdev;
646
647 unregister_netdev ( netdev );
648 netdev_nullify ( netdev );
649 netdev_put ( netdev );
650 }
651
652 /** CDC-NCM device IDs */
653 static struct usb_device_id ncm_ids[] = {
654 {
655 .name = "cdc-ncm",
656 .vendor = USB_ANY_ID,
657 .product = USB_ANY_ID,
658 .class = {
659 .class = USB_CLASS_CDC,
660 .subclass = USB_SUBCLASS_CDC_NCM,
661 .protocol = 0,
662 },
663 },
664 };
665
666 /** CDC-NCM driver */
667 struct usb_driver ncm_driver __usb_driver = {
668 .ids = ncm_ids,
669 .id_count = ( sizeof ( ncm_ids ) / sizeof ( ncm_ids[0] ) ),
670 .score = USB_SCORE_NORMAL,
671 .probe = ncm_probe,
672 .remove = ncm_remove,
673 };