[usb] Select preferred USB device configuration based on driver score
[ipxe.git] / src / drivers / net / dm96xx.c
1 /*
2 * Copyright (C) 2015 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 <unistd.h>
28 #include <errno.h>
29 #include <ipxe/ethernet.h>
30 #include <ipxe/usb.h>
31 #include <ipxe/usbnet.h>
32 #include "dm96xx.h"
33
34 /** @file
35 *
36 * Davicom DM96xx USB Ethernet driver
37 *
38 */
39
40 /******************************************************************************
41 *
42 * Register operations
43 *
44 ******************************************************************************
45 */
46
47 /**
48 * Reset device
49 *
50 * @v dm96xx DM96xx device
51 * @ret rc Return status code
52 */
53 static int dm96xx_reset ( struct dm96xx_device *dm96xx ) {
54 int ncr;
55 int rc;
56
57 /* Reset device */
58 if ( ( rc = dm96xx_write_register ( dm96xx, DM96XX_NCR,
59 DM96XX_NCR_RST ) ) != 0 ) {
60 DBGC ( dm96xx, "DM96XX %p could not reset: %s\n",
61 dm96xx, strerror ( rc ) );
62 return rc;
63 }
64
65 /* Wait for reset to complete */
66 udelay ( DM96XX_RESET_DELAY_US );
67
68 /* Check that reset has completed */
69 ncr = dm96xx_read_register ( dm96xx, DM96XX_NCR );
70 if ( ncr < 0 ) {
71 rc = ncr;
72 DBGC ( dm96xx, "DM96XX %p failed to reset: %s\n",
73 dm96xx, strerror ( rc ) );
74 return rc;
75 }
76 if ( ncr & DM96XX_NCR_RST ) {
77 DBGC ( dm96xx, "DM96XX %p failed to reset (NCR=%#02x)\n",
78 dm96xx, ncr );
79 return -EIO;
80 }
81
82 return 0;
83 }
84
85 /**
86 * Read MAC address
87 *
88 * @v dm96xx DM96xx device
89 * @v mac MAC address to fill in
90 * @ret rc Return status code
91 */
92 static int dm96xx_read_mac ( struct dm96xx_device *dm96xx, uint8_t *mac ) {
93 int rc;
94
95 /* Read MAC address */
96 if ( ( rc = dm96xx_read_registers ( dm96xx, DM96XX_PAR, mac,
97 ETH_ALEN ) ) != 0 ) {
98 DBGC ( dm96xx, "DM96XX %p could not read MAC address: %s\n",
99 dm96xx, strerror ( rc ) );
100 return rc;
101 }
102
103 return 0;
104 }
105
106 /**
107 * Write MAC address
108 *
109 * @v dm96xx DM96xx device
110 * @v mac MAC address
111 * @ret rc Return status code
112 */
113 static int dm96xx_write_mac ( struct dm96xx_device *dm96xx, uint8_t *mac ) {
114 int rc;
115
116 /* Write MAC address */
117 if ( ( rc = dm96xx_write_registers ( dm96xx, DM96XX_PAR, mac,
118 ETH_ALEN ) ) != 0 ) {
119 DBGC ( dm96xx, "DM96XX %p could not write MAC address: %s\n",
120 dm96xx, strerror ( rc ) );
121 return rc;
122 }
123
124 return 0;
125 }
126
127 /**
128 * Update link status based on network status register
129 *
130 * @v dm96xx DM96xx device
131 * @v nsr Network status register
132 */
133 static void dm96xx_link_nsr ( struct dm96xx_device *dm96xx, unsigned int nsr ) {
134 struct net_device *netdev = dm96xx->netdev;
135
136 if ( nsr & DM96XX_NSR_LINKST ) {
137 if ( ! netdev_link_ok ( netdev ) )
138 netdev_link_up ( netdev );
139 } else {
140 if ( netdev_link_ok ( netdev ) )
141 netdev_link_down ( netdev );
142 }
143 }
144
145 /**
146 * Get link status
147 *
148 * @v dm96xx DM96xx device
149 * @ret rc Return status code
150 */
151 static int dm96xx_check_link ( struct dm96xx_device *dm96xx ) {
152 int nsr;
153 int rc;
154
155 /* Read network status register */
156 nsr = dm96xx_read_register ( dm96xx, DM96XX_NSR );
157 if ( nsr < 0 ) {
158 rc = nsr;
159 DBGC ( dm96xx, "DM96XX %p could not read network status: %s\n",
160 dm96xx, strerror ( rc ) );
161 return rc;
162 }
163
164 /* Update link status */
165 dm96xx_link_nsr ( dm96xx, nsr );
166
167 return 0;
168 }
169
170 /**
171 * Set DM9601-compatible RX header mode
172 *
173 * @v dm96xx DM96xx device
174 * @ret rc Return status code
175 */
176 static int dm96xx_rx_mode ( struct dm96xx_device *dm96xx ) {
177 int chipr;
178 int mode_ctl;
179 int rc;
180
181 /* Get chip revision */
182 chipr = dm96xx_read_register ( dm96xx, DM96XX_CHIPR );
183 if ( chipr < 0 ) {
184 rc = chipr;
185 DBGC ( dm96xx, "DM96XX %p could not read chip revision: %s\n",
186 dm96xx, strerror ( rc ) );
187 return rc;
188 }
189
190 /* Do nothing if device is a DM9601 anyway */
191 if ( chipr == DM96XX_CHIPR_9601 )
192 return 0;
193
194 /* Read current mode control */
195 mode_ctl = dm96xx_read_register ( dm96xx, DM96XX_MODE_CTL );
196 if ( mode_ctl < 0 ) {
197 rc = mode_ctl;
198 DBGC ( dm96xx, "DM96XX %p could not read mode control: %s\n",
199 dm96xx, strerror ( rc ) );
200 return rc;
201 }
202
203 /* Write mode control */
204 mode_ctl &= ~DM96XX_MODE_CTL_MODE;
205 if ( ( rc = dm96xx_write_register ( dm96xx, DM96XX_MODE_CTL,
206 mode_ctl ) ) != 0 ) {
207 DBGC ( dm96xx, "DM96XX %p could not write mode control: %s\n",
208 dm96xx, strerror ( rc ) );
209 return rc;
210 }
211
212 return 0;
213 }
214
215 /******************************************************************************
216 *
217 * Endpoint operations
218 *
219 ******************************************************************************
220 */
221
222 /**
223 * Complete interrupt transfer
224 *
225 * @v ep USB endpoint
226 * @v iobuf I/O buffer
227 * @v rc Completion status code
228 */
229 static void dm96xx_intr_complete ( struct usb_endpoint *ep,
230 struct io_buffer *iobuf, int rc ) {
231 struct dm96xx_device *dm96xx = container_of ( ep, struct dm96xx_device,
232 usbnet.intr );
233 struct net_device *netdev = dm96xx->netdev;
234 struct dm96xx_interrupt *intr;
235 size_t len = iob_len ( iobuf );
236
237 /* Ignore packets cancelled when the endpoint closes */
238 if ( ! ep->open )
239 goto done;
240
241 /* Record USB errors against the network device */
242 if ( rc != 0 ) {
243 DBGC ( dm96xx, "DM96XX %p interrupt failed: %s\n",
244 dm96xx, strerror ( rc ) );
245 DBGC_HDA ( dm96xx, 0, iobuf->data, iob_len ( iobuf ) );
246 netdev_rx_err ( netdev, NULL, rc );
247 goto done;
248 }
249
250 /* Extract message header */
251 if ( len < sizeof ( *intr ) ) {
252 DBGC ( dm96xx, "DM96XX %p underlength interrupt:\n", dm96xx );
253 DBGC_HDA ( dm96xx, 0, iobuf->data, iob_len ( iobuf ) );
254 netdev_rx_err ( netdev, NULL, -EINVAL );
255 goto done;
256 }
257 intr = iobuf->data;
258
259 /* Update link status */
260 dm96xx_link_nsr ( dm96xx, intr->nsr );
261
262 done:
263 /* Free I/O buffer */
264 free_iob ( iobuf );
265 }
266
267 /** Interrupt endpoint operations */
268 static struct usb_endpoint_driver_operations dm96xx_intr_operations = {
269 .complete = dm96xx_intr_complete,
270 };
271
272 /**
273 * Complete bulk IN transfer
274 *
275 * @v ep USB endpoint
276 * @v iobuf I/O buffer
277 * @v rc Completion status code
278 */
279 static void dm96xx_in_complete ( struct usb_endpoint *ep,
280 struct io_buffer *iobuf, int rc ) {
281 struct dm96xx_device *dm96xx = container_of ( ep, struct dm96xx_device,
282 usbnet.in );
283 struct net_device *netdev = dm96xx->netdev;
284 struct dm96xx_rx_header *header;
285
286 /* Ignore packets cancelled when the endpoint closes */
287 if ( ! ep->open ) {
288 free_iob ( iobuf );
289 return;
290 }
291
292 /* Record USB errors against the network device */
293 if ( rc != 0 ) {
294 DBGC ( dm96xx, "DM96XX %p bulk IN failed: %s\n",
295 dm96xx, strerror ( rc ) );
296 goto err;
297 }
298
299 /* Sanity check */
300 if ( iob_len ( iobuf ) < ( sizeof ( *header ) + 4 /* CRC */ ) ) {
301 DBGC ( dm96xx, "DM96XX %p underlength bulk IN\n", dm96xx );
302 DBGC_HDA ( dm96xx, 0, iobuf->data, iob_len ( iobuf ) );
303 rc = -EINVAL;
304 goto err;
305 }
306
307 /* Strip header and CRC */
308 header = iobuf->data;
309 iob_pull ( iobuf, sizeof ( *header ) );
310 iob_unput ( iobuf, 4 /* CRC */ );
311
312 /* Check status */
313 if ( header->rsr & ~DM96XX_RSR_MF ) {
314 DBGC ( dm96xx, "DM96XX %p receive error %02x:\n",
315 dm96xx, header->rsr );
316 DBGC_HDA ( dm96xx, 0, iobuf->data, iob_len ( iobuf ) );
317 rc = -EIO;
318 goto err;
319 }
320
321 /* Hand off to network stack */
322 netdev_rx ( netdev, iob_disown ( iobuf ) );
323 return;
324
325 err:
326 /* Hand off to network stack */
327 netdev_rx_err ( netdev, iob_disown ( iobuf ), rc );
328 }
329
330 /** Bulk IN endpoint operations */
331 static struct usb_endpoint_driver_operations dm96xx_in_operations = {
332 .complete = dm96xx_in_complete,
333 };
334
335 /**
336 * Transmit packet
337 *
338 * @v dm96xx DM96xx device
339 * @v iobuf I/O buffer
340 * @ret rc Return status code
341 */
342 static int dm96xx_out_transmit ( struct dm96xx_device *dm96xx,
343 struct io_buffer *iobuf ) {
344 struct dm96xx_tx_header *header;
345 size_t len = iob_len ( iobuf );
346 int rc;
347
348 /* Prepend header */
349 if ( ( rc = iob_ensure_headroom ( iobuf, sizeof ( *header ) ) ) != 0 )
350 return rc;
351 header = iob_push ( iobuf, sizeof ( *header ) );
352 header->len = cpu_to_le16 ( len );
353
354 /* Enqueue I/O buffer */
355 if ( ( rc = usb_stream ( &dm96xx->usbnet.out, iobuf, 0 ) ) != 0 )
356 return rc;
357
358 return 0;
359 }
360
361 /**
362 * Complete bulk OUT transfer
363 *
364 * @v ep USB endpoint
365 * @v iobuf I/O buffer
366 * @v rc Completion status code
367 */
368 static void dm96xx_out_complete ( struct usb_endpoint *ep,
369 struct io_buffer *iobuf, int rc ) {
370 struct dm96xx_device *dm96xx = container_of ( ep, struct dm96xx_device,
371 usbnet.out );
372 struct net_device *netdev = dm96xx->netdev;
373
374 /* Report TX completion */
375 netdev_tx_complete_err ( netdev, iobuf, rc );
376 }
377
378 /** Bulk OUT endpoint operations */
379 static struct usb_endpoint_driver_operations dm96xx_out_operations = {
380 .complete = dm96xx_out_complete,
381 };
382
383 /******************************************************************************
384 *
385 * Network device interface
386 *
387 ******************************************************************************
388 */
389
390 /**
391 * Open network device
392 *
393 * @v netdev Network device
394 * @ret rc Return status code
395 */
396 static int dm96xx_open ( struct net_device *netdev ) {
397 struct dm96xx_device *dm96xx = netdev->priv;
398 unsigned int rcr;
399 int rc;
400
401 /* Set DM9601-compatible RX header mode */
402 if ( ( rc = dm96xx_rx_mode ( dm96xx ) ) != 0 )
403 goto err_rx_mode;
404
405 /* Write MAC address */
406 if ( ( rc = dm96xx_write_mac ( dm96xx, netdev->ll_addr ) ) != 0 )
407 goto err_write_mac;
408
409 /* Open USB network device */
410 if ( ( rc = usbnet_open ( &dm96xx->usbnet ) ) != 0 ) {
411 DBGC ( dm96xx, "DM96XX %p could not open: %s\n",
412 dm96xx, strerror ( rc ) );
413 goto err_open;
414 }
415
416 /* Set receive filters */
417 rcr = ( DM96XX_RCR_ALL | DM96XX_RCR_RUNT | DM96XX_RCR_PRMSC |
418 DM96XX_RCR_RXEN );
419 if ( ( rc = dm96xx_write_register ( dm96xx, DM96XX_RCR, rcr ) ) != 0 ) {
420 DBGC ( dm96xx, "DM96XX %p could not write receive filters: "
421 "%s\n", dm96xx, strerror ( rc ) );
422 goto err_write_rcr;
423 }
424
425 /* Update link status */
426 if ( ( rc = dm96xx_check_link ( dm96xx ) ) != 0 )
427 goto err_check_link;
428
429 return 0;
430
431 err_check_link:
432 err_write_rcr:
433 usbnet_close ( &dm96xx->usbnet );
434 err_open:
435 err_write_mac:
436 err_rx_mode:
437 return rc;
438 }
439
440 /**
441 * Close network device
442 *
443 * @v netdev Network device
444 */
445 static void dm96xx_close ( struct net_device *netdev ) {
446 struct dm96xx_device *dm96xx = netdev->priv;
447
448 /* Close USB network device */
449 usbnet_close ( &dm96xx->usbnet );
450
451 /* Reset device */
452 dm96xx_reset ( dm96xx );
453 }
454
455 /**
456 * Transmit packet
457 *
458 * @v netdev Network device
459 * @v iobuf I/O buffer
460 * @ret rc Return status code
461 */
462 static int dm96xx_transmit ( struct net_device *netdev,
463 struct io_buffer *iobuf ) {
464 struct dm96xx_device *dm96xx = netdev->priv;
465 int rc;
466
467 /* Transmit packet */
468 if ( ( rc = dm96xx_out_transmit ( dm96xx, iobuf ) ) != 0 )
469 return rc;
470
471 return 0;
472 }
473
474 /**
475 * Poll for completed and received packets
476 *
477 * @v netdev Network device
478 */
479 static void dm96xx_poll ( struct net_device *netdev ) {
480 struct dm96xx_device *dm96xx = netdev->priv;
481 int rc;
482
483 /* Poll USB bus */
484 usb_poll ( dm96xx->bus );
485
486 /* Refill endpoints */
487 if ( ( rc = usbnet_refill ( &dm96xx->usbnet ) ) != 0 )
488 netdev_rx_err ( netdev, NULL, rc );
489 }
490
491 /** DM96xx network device operations */
492 static struct net_device_operations dm96xx_operations = {
493 .open = dm96xx_open,
494 .close = dm96xx_close,
495 .transmit = dm96xx_transmit,
496 .poll = dm96xx_poll,
497 };
498
499 /******************************************************************************
500 *
501 * USB interface
502 *
503 ******************************************************************************
504 */
505
506 /**
507 * Probe device
508 *
509 * @v func USB function
510 * @v config Configuration descriptor
511 * @ret rc Return status code
512 */
513 static int dm96xx_probe ( struct usb_function *func,
514 struct usb_configuration_descriptor *config ) {
515 struct usb_device *usb = func->usb;
516 struct net_device *netdev;
517 struct dm96xx_device *dm96xx;
518 int rc;
519
520 /* Allocate and initialise structure */
521 netdev = alloc_etherdev ( sizeof ( *dm96xx ) );
522 if ( ! netdev ) {
523 rc = -ENOMEM;
524 goto err_alloc;
525 }
526 netdev_init ( netdev, &dm96xx_operations );
527 netdev->dev = &func->dev;
528 dm96xx = netdev->priv;
529 memset ( dm96xx, 0, sizeof ( *dm96xx ) );
530 dm96xx->usb = usb;
531 dm96xx->bus = usb->port->hub->bus;
532 dm96xx->netdev = netdev;
533 usbnet_init ( &dm96xx->usbnet, func, &dm96xx_intr_operations,
534 &dm96xx_in_operations, &dm96xx_out_operations );
535 usb_refill_init ( &dm96xx->usbnet.intr, 0, DM96XX_INTR_MAX_FILL );
536 usb_refill_init ( &dm96xx->usbnet.in, DM96XX_IN_MTU,
537 DM96XX_IN_MAX_FILL );
538 DBGC ( dm96xx, "DM96XX %p on %s\n", dm96xx, func->name );
539
540 /* Describe USB network device */
541 if ( ( rc = usbnet_describe ( &dm96xx->usbnet, config ) ) != 0 ) {
542 DBGC ( dm96xx, "DM96XX %p could not describe: %s\n",
543 dm96xx, strerror ( rc ) );
544 goto err_describe;
545 }
546
547 /* Reset device */
548 if ( ( rc = dm96xx_reset ( dm96xx ) ) != 0 )
549 goto err_reset;
550
551 /* Read MAC address */
552 if ( ( rc = dm96xx_read_mac ( dm96xx, netdev->hw_addr ) ) != 0 )
553 goto err_read_mac;
554
555 /* Get initial link status */
556 if ( ( rc = dm96xx_check_link ( dm96xx ) ) != 0 )
557 goto err_check_link;
558
559 /* Register network device */
560 if ( ( rc = register_netdev ( netdev ) ) != 0 )
561 goto err_register;
562
563 usb_func_set_drvdata ( func, netdev );
564 return 0;
565
566 unregister_netdev ( netdev );
567 err_register:
568 err_check_link:
569 err_read_mac:
570 err_reset:
571 err_describe:
572 netdev_nullify ( netdev );
573 netdev_put ( netdev );
574 err_alloc:
575 return rc;
576 }
577
578 /**
579 * Remove device
580 *
581 * @v func USB function
582 */
583 static void dm96xx_remove ( struct usb_function *func ) {
584 struct net_device *netdev = usb_func_get_drvdata ( func );
585
586 unregister_netdev ( netdev );
587 netdev_nullify ( netdev );
588 netdev_put ( netdev );
589 }
590
591 /** DM96xx device IDs */
592 static struct usb_device_id dm96xx_ids[] = {
593 {
594 .name = "dm9601-corega",
595 .vendor = 0x07aa,
596 .product = 0x9601,
597 },
598 {
599 .name = "dm9601",
600 .vendor = 0x0a46,
601 .product = 0x9601,
602 },
603 {
604 .name = "zt6688",
605 .vendor = 0x0a46,
606 .product = 0x6688,
607 },
608 {
609 .name = "st268",
610 .vendor = 0x0a46,
611 .product = 0x0268,
612 },
613 {
614 .name = "adm8515",
615 .vendor = 0x0a46,
616 .product = 0x8515,
617 },
618 {
619 .name = "dm9601-hirose",
620 .vendor = 0x0a47,
621 .product = 0x9601,
622 },
623 {
624 .name = "dm9601-8101",
625 .vendor = 0x0fe6,
626 .product = 0x8101,
627 },
628 {
629 .name = "dm9601-9700",
630 .vendor = 0x0fe6,
631 .product = 0x9700,
632 },
633 {
634 .name = "dm9000e",
635 .vendor = 0x0a46,
636 .product = 0x9000,
637 },
638 {
639 .name = "dm9620",
640 .vendor = 0x0a46,
641 .product = 0x9620,
642 },
643 {
644 .name = "dm9621A",
645 .vendor = 0x0a46,
646 .product = 0x9621,
647 },
648 {
649 .name = "dm9622",
650 .vendor = 0x0a46,
651 .product = 0x9622,
652 },
653 {
654 .name = "dm962Oa",
655 .vendor = 0x0a46,
656 .product = 0x0269,
657 },
658 {
659 .name = "dm9621a",
660 .vendor = 0x0a46,
661 .product = 0x1269,
662 },
663 };
664
665 /** Davicom DM96xx driver */
666 struct usb_driver dm96xx_driver __usb_driver = {
667 .ids = dm96xx_ids,
668 .id_count = ( sizeof ( dm96xx_ids ) / sizeof ( dm96xx_ids[0] ) ),
669 .score = USB_SCORE_NORMAL,
670 .probe = dm96xx_probe,
671 .remove = dm96xx_remove,
672 };