2 * Copyright (c) 2013 Gerhard Sittig <gsi@denx.de>
3 * based on the U-Boot Asix driver as well as information
4 * from the Linux Moschip driver
6 * SPDX-License-Identifier: GPL-2.0+
10 * MOSCHIP MCS7830 based (7730/7830/7832) USB 2.0 Ethernet Devices
16 #include <linux/mii.h>
21 #include "usb_ether.h"
23 #define MCS7830_BASE_NAME "mcs"
25 #define USBCALL_TIMEOUT 1000
26 #define LINKSTATUS_TIMEOUT 5000 /* link status, connect timeout */
27 #define LINKSTATUS_TIMEOUT_RES 50 /* link status, resolution in msec */
29 #define MCS7830_RX_URB_SIZE 2048
32 #define MCS7830_WR_BREQ 0x0d
33 #define MCS7830_RD_BREQ 0x0e
35 /* register layout, numerical offset specs for USB API calls */
37 uint8_t multicast_hashes
[8];
38 uint8_t packet_gap
[2];
40 uint8_t phy_command
[2];
41 uint8_t configuration
;
42 uint8_t ether_address
[6];
43 uint8_t frame_drop_count
;
44 uint8_t pause_threshold
;
46 #define REG_MULTICAST_HASH offsetof(struct mcs7830_regs, multicast_hashes)
47 #define REG_PHY_DATA offsetof(struct mcs7830_regs, phy_data)
48 #define REG_PHY_CMD offsetof(struct mcs7830_regs, phy_command)
49 #define REG_CONFIG offsetof(struct mcs7830_regs, configuration)
50 #define REG_ETHER_ADDR offsetof(struct mcs7830_regs, ether_address)
51 #define REG_FRAME_DROP_COUNTER offsetof(struct mcs7830_regs, frame_drop_count)
52 #define REG_PAUSE_THRESHOLD offsetof(struct mcs7830_regs, pause_threshold)
54 /* bit masks and default values for the above registers */
55 #define PHY_CMD1_READ 0x40
56 #define PHY_CMD1_WRITE 0x20
57 #define PHY_CMD1_PHYADDR 0x01
59 #define PHY_CMD2_PEND 0x80
60 #define PHY_CMD2_READY 0x40
63 #define CONF_SPEED100 0x40
64 #define CONF_FDX_ENABLE 0x20
65 #define CONF_RXENABLE 0x10
66 #define CONF_TXENABLE 0x08
67 #define CONF_SLEEPMODE 0x04
68 #define CONF_ALLMULTICAST 0x02
69 #define CONF_PROMISCUOUS 0x01
71 #define PAUSE_THRESHOLD_DEFAULT 0
73 /* bit masks for the status byte which follows received ethernet frames */
74 #define STAT_RX_FRAME_CORRECT 0x20
75 #define STAT_RX_LARGE_FRAME 0x10
76 #define STAT_RX_CRC_ERROR 0x08
77 #define STAT_RX_ALIGNMENT_ERROR 0x04
78 #define STAT_RX_LENGTH_ERROR 0x02
79 #define STAT_RX_SHORT_FRAME 0x01
82 * struct mcs7830_private - private driver data for an individual adapter
83 * @config: shadow for the network adapter's configuration register
84 * @mchash: shadow for the network adapter's multicast hash registers
86 struct mcs7830_private
{
88 uint8_t rx_buf
[MCS7830_RX_URB_SIZE
];
89 struct ueth_data ueth
;
96 * mcs7830_read_reg() - read a register of the network adapter
97 * @udev: network device to read from
98 * @idx: index of the register to start reading from
99 * @size: number of bytes to read
100 * @data: buffer to read into
101 * Return: zero upon success, negative upon error
103 static int mcs7830_read_reg(struct usb_device
*udev
, uint8_t idx
,
104 uint16_t size
, void *data
)
107 ALLOC_CACHE_ALIGN_BUFFER(uint8_t, buf
, size
);
109 debug("%s() idx=0x%04X sz=%d\n", __func__
, idx
, size
);
111 len
= usb_control_msg(udev
,
112 usb_rcvctrlpipe(udev
, 0),
114 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
118 debug("%s() len=%d != sz=%d\n", __func__
, len
, size
);
121 memcpy(data
, buf
, size
);
126 * mcs7830_write_reg() - write a register of the network adapter
127 * @udev: network device to write to
128 * @idx: index of the register to start writing to
129 * @size: number of bytes to write
130 * @data: buffer holding the data to write
131 * Return: zero upon success, negative upon error
133 static int mcs7830_write_reg(struct usb_device
*udev
, uint8_t idx
,
134 uint16_t size
, void *data
)
137 ALLOC_CACHE_ALIGN_BUFFER(uint8_t, buf
, size
);
139 debug("%s() idx=0x%04X sz=%d\n", __func__
, idx
, size
);
141 memcpy(buf
, data
, size
);
142 len
= usb_control_msg(udev
,
143 usb_sndctrlpipe(udev
, 0),
145 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
149 debug("%s() len=%d != sz=%d\n", __func__
, len
, size
);
156 * mcs7830_phy_emit_wait() - emit PHY read/write access, wait for its execution
157 * @udev: network device to talk to
158 * @rwflag: PHY_CMD1_READ or PHY_CMD1_WRITE opcode
159 * @index: number of the PHY register to read or write
160 * Return: zero upon success, negative upon error
162 static int mcs7830_phy_emit_wait(struct usb_device
*udev
,
163 uint8_t rwflag
, uint8_t index
)
169 /* send the PHY read/write request */
170 cmd
[0] = rwflag
| PHY_CMD1_PHYADDR
;
171 cmd
[1] = PHY_CMD2_PEND
| (index
& 0x1f);
172 rc
= mcs7830_write_reg(udev
, REG_PHY_CMD
, sizeof(cmd
), cmd
);
176 /* wait for the response to become available (usually < 1ms) */
179 rc
= mcs7830_read_reg(udev
, REG_PHY_CMD
, sizeof(cmd
), cmd
);
182 if (cmd
[1] & PHY_CMD2_READY
)
192 * mcs7830_read_phy() - read a PHY register of the network adapter
193 * @udev: network device to read from
194 * @index: index of the PHY register to read from
195 * Return: non-negative 16bit register content, negative upon error
197 static int mcs7830_read_phy(struct usb_device
*udev
, uint8_t index
)
202 /* issue the PHY read request and wait for its execution */
203 rc
= mcs7830_phy_emit_wait(udev
, PHY_CMD1_READ
, index
);
207 /* fetch the PHY data which was read */
208 rc
= mcs7830_read_reg(udev
, REG_PHY_DATA
, sizeof(val
), &val
);
211 rc
= le16_to_cpu(val
);
212 debug("%s(%d) => 0x%04X\n", __func__
, index
, rc
);
217 * mcs7830_write_phy() - write a PHY register of the network adapter
218 * @udev: network device to write to
219 * @index: index of the PHY register to write to
220 * @val: value to write to the PHY register
221 * Return: zero upon success, negative upon error
223 static int mcs7830_write_phy(struct usb_device
*udev
, uint8_t index
,
228 debug("%s(%d, 0x%04X)\n", __func__
, index
, val
);
230 /* setup the PHY data which is to get written */
231 val
= cpu_to_le16(val
);
232 rc
= mcs7830_write_reg(udev
, REG_PHY_DATA
, sizeof(val
), &val
);
236 /* issue the PHY write request and wait for its execution */
237 rc
= mcs7830_phy_emit_wait(udev
, PHY_CMD1_WRITE
, index
);
245 * mcs7830_write_config() - write to the network adapter's config register
246 * @udev: network device to write to
247 * @priv: private data
248 * Return: zero upon success, negative upon error
250 * the data which gets written is taken from the shadow config register
251 * within the device driver's private data
253 static int mcs7830_write_config(struct usb_device
*udev
,
254 struct mcs7830_private
*priv
)
258 debug("%s()\n", __func__
);
260 rc
= mcs7830_write_reg(udev
, REG_CONFIG
,
261 sizeof(priv
->config
), &priv
->config
);
263 debug("writing config to adapter failed\n");
271 * mcs7830_write_mchash() - write the network adapter's multicast filter
272 * @udev: network device to write to
273 * @priv: private data
274 * Return: zero upon success, negative upon error
276 * the data which gets written is taken from the shadow multicast hashes
277 * within the device driver's private data
279 static int mcs7830_write_mchash(struct usb_device
*udev
,
280 struct mcs7830_private
*priv
)
284 debug("%s()\n", __func__
);
286 rc
= mcs7830_write_reg(udev
, REG_MULTICAST_HASH
,
287 sizeof(priv
->mchash
), &priv
->mchash
);
289 debug("writing multicast hash to adapter failed\n");
297 * mcs7830_set_autoneg() - setup and trigger ethernet link autonegotiation
298 * @udev: network device to run link negotiation on
299 * Return: zero upon success, negative upon error
301 * the routine advertises available media and starts autonegotiation
303 static int mcs7830_set_autoneg(struct usb_device
*udev
)
308 debug("%s()\n", __func__
);
311 * algorithm taken from the Linux driver, which took it from
312 * "the original mcs7830 version 1.4 driver":
314 * enable all media, reset BMCR, enable auto neg, restart
315 * auto neg while keeping the enable auto neg flag set
318 adv
= ADVERTISE_PAUSE_CAP
| ADVERTISE_ALL
| ADVERTISE_CSMA
;
319 rc
= mcs7830_write_phy(udev
, MII_ADVERTISE
, adv
);
323 rc
= mcs7830_write_phy(udev
, MII_BMCR
, flg
);
325 flg
|= BMCR_ANENABLE
;
327 rc
= mcs7830_write_phy(udev
, MII_BMCR
, flg
);
329 flg
|= BMCR_ANRESTART
;
331 rc
= mcs7830_write_phy(udev
, MII_BMCR
, flg
);
337 * mcs7830_get_rev() - identify a network adapter's chip revision
338 * @udev: network device to identify
339 * Return: non-negative number, reflecting the revision number
341 * currently, only "rev C and higher" and "below rev C" are needed, so
342 * the return value is #1 for "below rev C", and #2 for "rev C and above"
344 static int mcs7830_get_rev(struct usb_device
*udev
)
350 /* register 22 is readable in rev C and higher */
351 rc
= mcs7830_read_reg(udev
, REG_FRAME_DROP_COUNTER
, sizeof(buf
), buf
);
356 debug("%s() rc=%d, rev=%d\n", __func__
, rc
, rev
);
361 * mcs7830_apply_fixup() - identify an adapter and potentially apply fixups
362 * @udev: network device to identify and apply fixups to
363 * Return: zero upon success (no errors emitted from here)
365 * this routine identifies the network adapter's chip revision, and applies
366 * fixups for known issues
368 static int mcs7830_apply_fixup(struct usb_device
*udev
)
374 rev
= mcs7830_get_rev(udev
);
375 debug("%s() rev=%d\n", __func__
, rev
);
378 * rev C requires setting the pause threshold (the Linux driver
379 * is inconsistent, the implementation does it for "rev C
380 * exactly", the introductory comment says "rev C and above")
383 debug("%s: applying rev C fixup\n", __func__
);
384 thr
= PAUSE_THRESHOLD_DEFAULT
;
385 for (i
= 0; i
< 2; i
++) {
386 (void)mcs7830_write_reg(udev
, REG_PAUSE_THRESHOLD
,
396 * mcs7830_basic_reset() - bring the network adapter into a known first state
397 * @eth: network device to act upon
398 * Return: zero upon success, negative upon error
400 * this routine initializes the network adapter such that subsequent invocations
401 * of the interface callbacks can exchange ethernet frames; link negotiation is
402 * triggered from here already and continues in background
404 static int mcs7830_basic_reset(struct usb_device
*udev
,
405 struct mcs7830_private
*priv
)
409 debug("%s()\n", __func__
);
412 * comment from the respective Linux driver, which
413 * unconditionally sets the ALLMULTICAST flag as well:
414 * should not be needed, but does not work otherwise
416 priv
->config
= CONF_TXENABLE
;
417 priv
->config
|= CONF_ALLMULTICAST
;
419 rc
= mcs7830_set_autoneg(udev
);
421 pr_err("setting autoneg failed\n");
425 rc
= mcs7830_write_mchash(udev
, priv
);
427 pr_err("failed to set multicast hash\n");
431 rc
= mcs7830_write_config(udev
, priv
);
433 pr_err("failed to set configuration\n");
437 rc
= mcs7830_apply_fixup(udev
);
439 pr_err("fixup application failed\n");
447 * mcs7830_read_mac() - read an ethernet adapter's MAC address
448 * @udev: network device to read from
449 * @enetaddr: place to put ethernet MAC address
450 * Return: zero upon success, negative upon error
452 * this routine fetches the MAC address stored within the ethernet adapter,
453 * and stores it in the ethernet interface's data structure
455 static int mcs7830_read_mac(struct usb_device
*udev
, unsigned char enetaddr
[])
458 uint8_t buf
[ETH_ALEN
];
460 debug("%s()\n", __func__
);
462 rc
= mcs7830_read_reg(udev
, REG_ETHER_ADDR
, ETH_ALEN
, buf
);
464 debug("reading MAC from adapter failed\n");
468 memcpy(enetaddr
, buf
, ETH_ALEN
);
472 static int mcs7830_write_mac_common(struct usb_device
*udev
,
473 unsigned char enetaddr
[])
477 debug("%s()\n", __func__
);
479 rc
= mcs7830_write_reg(udev
, REG_ETHER_ADDR
, ETH_ALEN
, enetaddr
);
481 debug("writing MAC to adapter failed\n");
487 static int mcs7830_init_common(struct usb_device
*udev
)
492 debug("%s()\n", __func__
);
496 have_link
= mcs7830_read_phy(udev
, MII_BMSR
) & BMSR_LSTATUS
;
499 udelay(LINKSTATUS_TIMEOUT_RES
* 1000);
500 timeout
+= LINKSTATUS_TIMEOUT_RES
;
501 } while (timeout
< LINKSTATUS_TIMEOUT
);
503 debug("ethernet link is down\n");
509 static int mcs7830_send_common(struct ueth_data
*ueth
, void *packet
,
512 struct usb_device
*udev
= ueth
->pusb_dev
;
515 /* there is a status byte after the ethernet frame */
516 ALLOC_CACHE_ALIGN_BUFFER(uint8_t, buf
, PKTSIZE
+ sizeof(uint8_t));
518 memcpy(buf
, packet
, length
);
519 rc
= usb_bulk_msg(udev
,
520 usb_sndbulkpipe(udev
, ueth
->ep_out
),
521 &buf
[0], length
, &gotlen
,
523 debug("%s() TX want len %d, got len %d, rc %d\n",
524 __func__
, length
, gotlen
, rc
);
528 static int mcs7830_recv_common(struct ueth_data
*ueth
, uint8_t *buf
)
530 int rc
, wantlen
, gotlen
;
533 debug("%s()\n", __func__
);
535 /* fetch input data from the adapter */
536 wantlen
= MCS7830_RX_URB_SIZE
;
537 rc
= usb_bulk_msg(ueth
->pusb_dev
,
538 usb_rcvbulkpipe(ueth
->pusb_dev
, ueth
->ep_in
),
539 &buf
[0], wantlen
, &gotlen
,
541 debug("%s() RX want len %d, got len %d, rc %d\n",
542 __func__
, wantlen
, gotlen
, rc
);
544 pr_err("RX: failed to receive\n");
547 if (gotlen
> wantlen
) {
548 pr_err("RX: got too many bytes (%d)\n", gotlen
);
553 * the bulk message that we received from USB contains exactly
554 * one ethernet frame and a trailing status byte
556 if (gotlen
< sizeof(sts
))
558 gotlen
-= sizeof(sts
);
561 if (sts
== STAT_RX_FRAME_CORRECT
) {
562 debug("%s() got a frame, len=%d\n", __func__
, gotlen
);
566 debug("RX: frame error (sts 0x%02X, %s %s %s %s %s)\n",
568 (sts
& STAT_RX_LARGE_FRAME
) ? "large" : "-",
569 (sts
& STAT_RX_LENGTH_ERROR
) ? "length" : "-",
570 (sts
& STAT_RX_SHORT_FRAME
) ? "short" : "-",
571 (sts
& STAT_RX_CRC_ERROR
) ? "crc" : "-",
572 (sts
& STAT_RX_ALIGNMENT_ERROR
) ? "align" : "-");
576 #ifndef CONFIG_DM_ETH
578 * mcs7830_init() - network interface's init callback
579 * @udev: network device to initialize
580 * @bd: board information
581 * Return: zero upon success, negative upon error
583 * after initial setup during probe() and get_info(), this init() callback
584 * ensures that the link is up and subsequent send() and recv() calls can
585 * exchange ethernet frames
587 static int mcs7830_init(struct eth_device
*eth
, bd_t
*bd
)
589 struct ueth_data
*dev
= eth
->priv
;
591 return mcs7830_init_common(dev
->pusb_dev
);
595 * mcs7830_send() - network interface's send callback
596 * @eth: network device to send the frame from
597 * @packet: ethernet frame content
598 * @length: ethernet frame length
599 * Return: zero upon success, negative upon error
601 * this routine send an ethernet frame out of the network interface
603 static int mcs7830_send(struct eth_device
*eth
, void *packet
, int length
)
605 struct ueth_data
*dev
= eth
->priv
;
607 return mcs7830_send_common(dev
, packet
, length
);
611 * mcs7830_recv() - network interface's recv callback
612 * @eth: network device to receive frames from
613 * Return: zero upon success, negative upon error
615 * this routine checks for available ethernet frames that the network
616 * interface might have received, and notifies the network stack
618 static int mcs7830_recv(struct eth_device
*eth
)
620 ALLOC_CACHE_ALIGN_BUFFER(uint8_t, buf
, MCS7830_RX_URB_SIZE
);
621 struct ueth_data
*ueth
= eth
->priv
;
624 len
= mcs7830_recv_common(ueth
, buf
);
626 net_process_received_packet(buf
, len
);
634 * mcs7830_halt() - network interface's halt callback
635 * @eth: network device to cease operation of
638 * this routine is supposed to undo the effect of previous initialization and
639 * ethernet frames exchange; in this implementation it's a NOP
641 static void mcs7830_halt(struct eth_device
*eth
)
643 debug("%s()\n", __func__
);
647 * mcs7830_write_mac() - write an ethernet adapter's MAC address
648 * @eth: network device to write to
649 * Return: zero upon success, negative upon error
651 * this routine takes the MAC address from the ethernet interface's data
652 * structure, and writes it into the ethernet adapter such that subsequent
653 * exchange of ethernet frames uses this address
655 static int mcs7830_write_mac(struct eth_device
*eth
)
657 struct ueth_data
*ueth
= eth
->priv
;
659 return mcs7830_write_mac_common(ueth
->pusb_dev
, eth
->enetaddr
);
663 * mcs7830_iface_idx - index of detected network interfaces
665 * this counter keeps track of identified supported interfaces,
666 * to assign unique names as more interfaces are found
668 static int mcs7830_iface_idx
;
671 * mcs7830_eth_before_probe() - network driver's before_probe callback
674 * this routine initializes driver's internal data in preparation of
675 * subsequent probe callbacks
677 void mcs7830_eth_before_probe(void)
679 mcs7830_iface_idx
= 0;
683 * struct mcs7830_dongle - description of a supported Moschip ethernet dongle
684 * @vendor: 16bit USB vendor identification
685 * @product: 16bit USB product identification
687 * this structure describes a supported USB ethernet dongle by means of the
688 * vendor and product codes found during USB enumeration; no flags are held
689 * here since all supported dongles have identical behaviour, and required
690 * fixups get determined at runtime, such that no manual configuration is
693 struct mcs7830_dongle
{
699 * mcs7830_dongles - the list of supported Moschip based USB ethernet dongles
701 static const struct mcs7830_dongle mcs7830_dongles
[] = {
702 { 0x9710, 0x7832, }, /* Moschip 7832 */
703 { 0x9710, 0x7830, }, /* Moschip 7830 */
704 { 0x9710, 0x7730, }, /* Moschip 7730 */
705 { 0x0df6, 0x0021, }, /* Sitecom LN 30 */
709 * mcs7830_eth_probe() - network driver's probe callback
710 * @dev: detected USB device to check
711 * @ifnum: detected USB interface to check
712 * @ss: USB ethernet data structure to fill in upon match
713 * Return: #1 upon match, #0 upon mismatch or error
715 * this routine checks whether the found USB device is supported by
716 * this ethernet driver, and upon match fills in the USB ethernet
717 * data structure which later is passed to the get_info callback
719 int mcs7830_eth_probe(struct usb_device
*dev
, unsigned int ifnum
,
720 struct ueth_data
*ss
)
722 struct usb_interface
*iface
;
723 struct usb_interface_descriptor
*iface_desc
;
725 struct mcs7830_private
*priv
;
726 int ep_in_found
, ep_out_found
, ep_intr_found
;
728 debug("%s()\n", __func__
);
730 /* iterate the list of supported dongles */
731 iface
= &dev
->config
.if_desc
[ifnum
];
732 iface_desc
= &iface
->desc
;
733 for (i
= 0; i
< ARRAY_SIZE(mcs7830_dongles
); i
++) {
734 if (dev
->descriptor
.idVendor
== mcs7830_dongles
[i
].vendor
&&
735 dev
->descriptor
.idProduct
== mcs7830_dongles
[i
].product
)
738 if (i
== ARRAY_SIZE(mcs7830_dongles
))
740 debug("detected USB ethernet device: %04X:%04X\n",
741 dev
->descriptor
.idVendor
, dev
->descriptor
.idProduct
);
743 /* fill in driver private data */
744 priv
= calloc(1, sizeof(*priv
));
748 /* fill in the ueth_data structure, attach private data */
749 memset(ss
, 0, sizeof(*ss
));
752 ss
->subclass
= iface_desc
->bInterfaceSubClass
;
753 ss
->protocol
= iface_desc
->bInterfaceProtocol
;
757 * a minimum of three endpoints is expected: in (bulk),
758 * out (bulk), and interrupt; ignore all others
760 ep_in_found
= ep_out_found
= ep_intr_found
= 0;
761 for (i
= 0; i
< iface_desc
->bNumEndpoints
; i
++) {
762 uint8_t eptype
, epaddr
;
765 eptype
= iface
->ep_desc
[i
].bmAttributes
;
766 eptype
&= USB_ENDPOINT_XFERTYPE_MASK
;
768 epaddr
= iface
->ep_desc
[i
].bEndpointAddress
;
769 is_input
= epaddr
& USB_DIR_IN
;
770 epaddr
&= USB_ENDPOINT_NUMBER_MASK
;
772 if (eptype
== USB_ENDPOINT_XFER_BULK
) {
773 if (is_input
&& !ep_in_found
) {
777 if (!is_input
&& !ep_out_found
) {
783 if (eptype
== USB_ENDPOINT_XFER_INT
) {
784 if (is_input
&& !ep_intr_found
) {
786 ss
->irqinterval
= iface
->ep_desc
[i
].bInterval
;
791 debug("endpoints: in %d, out %d, intr %d\n",
792 ss
->ep_in
, ss
->ep_out
, ss
->ep_int
);
794 /* apply basic sanity checks */
795 if (usb_set_interface(dev
, iface_desc
->bInterfaceNumber
, 0) ||
796 !ss
->ep_in
|| !ss
->ep_out
|| !ss
->ep_int
) {
797 debug("device probe incomplete\n");
806 * mcs7830_eth_get_info() - network driver's get_info callback
807 * @dev: detected USB device
808 * @ss: USB ethernet data structure filled in at probe()
809 * @eth: ethernet interface data structure to fill in
810 * Return: #1 upon success, #0 upon error
812 * this routine registers the mandatory init(), send(), recv(), and
813 * halt() callbacks with the ethernet interface, can register the
814 * optional write_hwaddr() callback with the ethernet interface,
815 * and initiates configuration of the interface such that subsequent
816 * calls to those callbacks results in network communication
818 int mcs7830_eth_get_info(struct usb_device
*dev
, struct ueth_data
*ss
,
819 struct eth_device
*eth
)
821 debug("%s()\n", __func__
);
823 debug("%s: missing parameter.\n", __func__
);
827 snprintf(eth
->name
, sizeof(eth
->name
), "%s%d",
828 MCS7830_BASE_NAME
, mcs7830_iface_idx
++);
829 eth
->init
= mcs7830_init
;
830 eth
->send
= mcs7830_send
;
831 eth
->recv
= mcs7830_recv
;
832 eth
->halt
= mcs7830_halt
;
833 eth
->write_hwaddr
= mcs7830_write_mac
;
836 if (mcs7830_basic_reset(ss
->pusb_dev
, ss
->dev_priv
))
839 if (mcs7830_read_mac(ss
->pusb_dev
, eth
->enetaddr
))
841 debug("MAC %pM\n", eth
->enetaddr
);
849 static int mcs7830_eth_start(struct udevice
*dev
)
851 struct usb_device
*udev
= dev_get_parent_priv(dev
);
853 return mcs7830_init_common(udev
);
856 void mcs7830_eth_stop(struct udevice
*dev
)
858 debug("** %s()\n", __func__
);
861 int mcs7830_eth_send(struct udevice
*dev
, void *packet
, int length
)
863 struct mcs7830_private
*priv
= dev_get_priv(dev
);
864 struct ueth_data
*ueth
= &priv
->ueth
;
866 return mcs7830_send_common(ueth
, packet
, length
);
869 int mcs7830_eth_recv(struct udevice
*dev
, int flags
, uchar
**packetp
)
871 struct mcs7830_private
*priv
= dev_get_priv(dev
);
872 struct ueth_data
*ueth
= &priv
->ueth
;
875 len
= mcs7830_recv_common(ueth
, priv
->rx_buf
);
876 *packetp
= priv
->rx_buf
;
881 static int mcs7830_free_pkt(struct udevice
*dev
, uchar
*packet
, int packet_len
)
883 struct mcs7830_private
*priv
= dev_get_priv(dev
);
885 packet_len
= ALIGN(packet_len
, 4);
886 usb_ether_advance_rxbuf(&priv
->ueth
, sizeof(u32
) + packet_len
);
891 int mcs7830_write_hwaddr(struct udevice
*dev
)
893 struct usb_device
*udev
= dev_get_parent_priv(dev
);
894 struct eth_pdata
*pdata
= dev_get_platdata(dev
);
896 return mcs7830_write_mac_common(udev
, pdata
->enetaddr
);
899 static int mcs7830_eth_probe(struct udevice
*dev
)
901 struct usb_device
*udev
= dev_get_parent_priv(dev
);
902 struct mcs7830_private
*priv
= dev_get_priv(dev
);
903 struct eth_pdata
*pdata
= dev_get_platdata(dev
);
904 struct ueth_data
*ueth
= &priv
->ueth
;
906 if (mcs7830_basic_reset(udev
, priv
))
909 if (mcs7830_read_mac(udev
, pdata
->enetaddr
))
912 return usb_ether_register(dev
, ueth
, MCS7830_RX_URB_SIZE
);
915 static const struct eth_ops mcs7830_eth_ops
= {
916 .start
= mcs7830_eth_start
,
917 .send
= mcs7830_eth_send
,
918 .recv
= mcs7830_eth_recv
,
919 .free_pkt
= mcs7830_free_pkt
,
920 .stop
= mcs7830_eth_stop
,
921 .write_hwaddr
= mcs7830_write_hwaddr
,
924 U_BOOT_DRIVER(mcs7830_eth
) = {
925 .name
= "mcs7830_eth",
927 .probe
= mcs7830_eth_probe
,
928 .ops
= &mcs7830_eth_ops
,
929 .priv_auto_alloc_size
= sizeof(struct mcs7830_private
),
930 .platdata_auto_alloc_size
= sizeof(struct eth_pdata
),
931 .flags
= DM_FLAG_ALLOC_PRIV_DMA
,
934 static const struct usb_device_id mcs7830_eth_id_table
[] = {
935 { USB_DEVICE(0x9710, 0x7832) }, /* Moschip 7832 */
936 { USB_DEVICE(0x9710, 0x7830), }, /* Moschip 7830 */
937 { USB_DEVICE(0x9710, 0x7730), }, /* Moschip 7730 */
938 { USB_DEVICE(0x0df6, 0x0021), }, /* Sitecom LN 30 */
939 { } /* Terminating entry */
942 U_BOOT_USB_DEVICE(mcs7830_eth
, mcs7830_eth_id_table
);