xref: /openbmc/u-boot/drivers/usb/eth/mcs7830.c (revision 4f42a0d7)
1 /*
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
5  *
6  * SPDX-License-Identifier:	GPL-2.0+
7  */
8 
9 /*
10  * MOSCHIP MCS7830 based (7730/7830/7832) USB 2.0 Ethernet Devices
11  */
12 
13 #include <common.h>
14 #include <dm.h>
15 #include <errno.h>
16 #include <linux/mii.h>
17 #include <malloc.h>
18 #include <memalign.h>
19 #include <usb.h>
20 
21 #include "usb_ether.h"
22 
23 #define MCS7830_BASE_NAME	"mcs"
24 
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 */
28 
29 #define MCS7830_RX_URB_SIZE	2048
30 
31 /* command opcodes */
32 #define MCS7830_WR_BREQ		0x0d
33 #define MCS7830_RD_BREQ		0x0e
34 
35 /* register layout, numerical offset specs for USB API calls */
36 struct mcs7830_regs {
37 	uint8_t multicast_hashes[8];
38 	uint8_t packet_gap[2];
39 	uint8_t phy_data[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;
45 };
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)
53 
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
58 
59 #define PHY_CMD2_PEND		0x80
60 #define PHY_CMD2_READY		0x40
61 
62 #define CONF_CFG		0x80
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
70 
71 #define PAUSE_THRESHOLD_DEFAULT	0
72 
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
80 
81 /*
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
85  */
86 struct mcs7830_private {
87 #ifdef CONFIG_DM_ETH
88 	uint8_t rx_buf[MCS7830_RX_URB_SIZE];
89 	struct ueth_data ueth;
90 #endif
91 	uint8_t config;
92 	uint8_t mchash[8];
93 };
94 
95 /*
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
102  */
103 static int mcs7830_read_reg(struct usb_device *udev, uint8_t idx,
104 			    uint16_t size, void *data)
105 {
106 	int len;
107 	ALLOC_CACHE_ALIGN_BUFFER(uint8_t, buf, size);
108 
109 	debug("%s() idx=0x%04X sz=%d\n", __func__, idx, size);
110 
111 	len = usb_control_msg(udev,
112 			      usb_rcvctrlpipe(udev, 0),
113 			      MCS7830_RD_BREQ,
114 			      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
115 			      0, idx, buf, size,
116 			      USBCALL_TIMEOUT);
117 	if (len != size) {
118 		debug("%s() len=%d != sz=%d\n", __func__, len, size);
119 		return -EIO;
120 	}
121 	memcpy(data, buf, size);
122 	return 0;
123 }
124 
125 /*
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
132  */
133 static int mcs7830_write_reg(struct usb_device *udev, uint8_t idx,
134 			     uint16_t size, void *data)
135 {
136 	int len;
137 	ALLOC_CACHE_ALIGN_BUFFER(uint8_t, buf, size);
138 
139 	debug("%s() idx=0x%04X sz=%d\n", __func__, idx, size);
140 
141 	memcpy(buf, data, size);
142 	len = usb_control_msg(udev,
143 			      usb_sndctrlpipe(udev, 0),
144 			      MCS7830_WR_BREQ,
145 			      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
146 			      0, idx, buf, size,
147 			      USBCALL_TIMEOUT);
148 	if (len != size) {
149 		debug("%s() len=%d != sz=%d\n", __func__, len, size);
150 		return -EIO;
151 	}
152 	return 0;
153 }
154 
155 /*
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
161  */
162 static int mcs7830_phy_emit_wait(struct usb_device *udev,
163 				 uint8_t rwflag, uint8_t index)
164 {
165 	int rc;
166 	int retry;
167 	uint8_t cmd[2];
168 
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);
173 	if (rc < 0)
174 		return rc;
175 
176 	/* wait for the response to become available (usually < 1ms) */
177 	retry = 10;
178 	do {
179 		rc = mcs7830_read_reg(udev, REG_PHY_CMD, sizeof(cmd), cmd);
180 		if (rc < 0)
181 			return rc;
182 		if (cmd[1] & PHY_CMD2_READY)
183 			return 0;
184 		if (!retry--)
185 			return -ETIMEDOUT;
186 		mdelay(1);
187 	} while (1);
188 	/* UNREACH */
189 }
190 
191 /*
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
196  */
197 static int mcs7830_read_phy(struct usb_device *udev, uint8_t index)
198 {
199 	int rc;
200 	uint16_t val;
201 
202 	/* issue the PHY read request and wait for its execution */
203 	rc = mcs7830_phy_emit_wait(udev, PHY_CMD1_READ, index);
204 	if (rc < 0)
205 		return rc;
206 
207 	/* fetch the PHY data which was read */
208 	rc = mcs7830_read_reg(udev, REG_PHY_DATA, sizeof(val), &val);
209 	if (rc < 0)
210 		return rc;
211 	rc = le16_to_cpu(val);
212 	debug("%s(%d) => 0x%04X\n", __func__, index, rc);
213 	return rc;
214 }
215 
216 /*
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
222  */
223 static int mcs7830_write_phy(struct usb_device *udev, uint8_t index,
224 			     uint16_t val)
225 {
226 	int rc;
227 
228 	debug("%s(%d, 0x%04X)\n", __func__, index, val);
229 
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);
233 	if (rc < 0)
234 		return rc;
235 
236 	/* issue the PHY write request and wait for its execution */
237 	rc = mcs7830_phy_emit_wait(udev, PHY_CMD1_WRITE, index);
238 	if (rc < 0)
239 		return rc;
240 
241 	return 0;
242 }
243 
244 /*
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
249  *
250  * the data which gets written is taken from the shadow config register
251  * within the device driver's private data
252  */
253 static int mcs7830_write_config(struct usb_device *udev,
254 				struct mcs7830_private *priv)
255 {
256 	int rc;
257 
258 	debug("%s()\n", __func__);
259 
260 	rc = mcs7830_write_reg(udev, REG_CONFIG,
261 			       sizeof(priv->config), &priv->config);
262 	if (rc < 0) {
263 		debug("writing config to adapter failed\n");
264 		return rc;
265 	}
266 
267 	return 0;
268 }
269 
270 /*
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
275  *
276  * the data which gets written is taken from the shadow multicast hashes
277  * within the device driver's private data
278  */
279 static int mcs7830_write_mchash(struct usb_device *udev,
280 				struct mcs7830_private *priv)
281 {
282 	int rc;
283 
284 	debug("%s()\n", __func__);
285 
286 	rc = mcs7830_write_reg(udev, REG_MULTICAST_HASH,
287 			       sizeof(priv->mchash), &priv->mchash);
288 	if (rc < 0) {
289 		debug("writing multicast hash to adapter failed\n");
290 		return rc;
291 	}
292 
293 	return 0;
294 }
295 
296 /*
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
300  *
301  * the routine advertises available media and starts autonegotiation
302  */
303 static int mcs7830_set_autoneg(struct usb_device *udev)
304 {
305 	int adv, flg;
306 	int rc;
307 
308 	debug("%s()\n", __func__);
309 
310 	/*
311 	 * algorithm taken from the Linux driver, which took it from
312 	 * "the original mcs7830 version 1.4 driver":
313 	 *
314 	 * enable all media, reset BMCR, enable auto neg, restart
315 	 * auto neg while keeping the enable auto neg flag set
316 	 */
317 
318 	adv = ADVERTISE_PAUSE_CAP | ADVERTISE_ALL | ADVERTISE_CSMA;
319 	rc = mcs7830_write_phy(udev, MII_ADVERTISE, adv);
320 
321 	flg = 0;
322 	if (!rc)
323 		rc = mcs7830_write_phy(udev, MII_BMCR, flg);
324 
325 	flg |= BMCR_ANENABLE;
326 	if (!rc)
327 		rc = mcs7830_write_phy(udev, MII_BMCR, flg);
328 
329 	flg |= BMCR_ANRESTART;
330 	if (!rc)
331 		rc = mcs7830_write_phy(udev, MII_BMCR, flg);
332 
333 	return rc;
334 }
335 
336 /*
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
340  *
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"
343  */
344 static int mcs7830_get_rev(struct usb_device *udev)
345 {
346 	uint8_t buf[2];
347 	int rc;
348 	int rev;
349 
350 	/* register 22 is readable in rev C and higher */
351 	rc = mcs7830_read_reg(udev, REG_FRAME_DROP_COUNTER, sizeof(buf), buf);
352 	if (rc < 0)
353 		rev = 1;
354 	else
355 		rev = 2;
356 	debug("%s() rc=%d, rev=%d\n", __func__, rc, rev);
357 	return rev;
358 }
359 
360 /*
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)
364  *
365  * this routine identifies the network adapter's chip revision, and applies
366  * fixups for known issues
367  */
368 static int mcs7830_apply_fixup(struct usb_device *udev)
369 {
370 	int rev;
371 	int i;
372 	uint8_t thr;
373 
374 	rev = mcs7830_get_rev(udev);
375 	debug("%s() rev=%d\n", __func__, rev);
376 
377 	/*
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")
381 	 */
382 	if (rev == 2) {
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,
387 						sizeof(thr), &thr);
388 			mdelay(1);
389 		}
390 	}
391 
392 	return 0;
393 }
394 
395 /*
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
399  *
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
403  */
404 static int mcs7830_basic_reset(struct usb_device *udev,
405 			       struct mcs7830_private *priv)
406 {
407 	int rc;
408 
409 	debug("%s()\n", __func__);
410 
411 	/*
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
415 	 */
416 	priv->config = CONF_TXENABLE;
417 	priv->config |= CONF_ALLMULTICAST;
418 
419 	rc = mcs7830_set_autoneg(udev);
420 	if (rc < 0) {
421 		pr_err("setting autoneg failed\n");
422 		return rc;
423 	}
424 
425 	rc = mcs7830_write_mchash(udev, priv);
426 	if (rc < 0) {
427 		pr_err("failed to set multicast hash\n");
428 		return rc;
429 	}
430 
431 	rc = mcs7830_write_config(udev, priv);
432 	if (rc < 0) {
433 		pr_err("failed to set configuration\n");
434 		return rc;
435 	}
436 
437 	rc = mcs7830_apply_fixup(udev);
438 	if (rc < 0) {
439 		pr_err("fixup application failed\n");
440 		return rc;
441 	}
442 
443 	return 0;
444 }
445 
446 /*
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
451  *
452  * this routine fetches the MAC address stored within the ethernet adapter,
453  * and stores it in the ethernet interface's data structure
454  */
455 static int mcs7830_read_mac(struct usb_device *udev, unsigned char enetaddr[])
456 {
457 	int rc;
458 	uint8_t buf[ETH_ALEN];
459 
460 	debug("%s()\n", __func__);
461 
462 	rc = mcs7830_read_reg(udev, REG_ETHER_ADDR, ETH_ALEN, buf);
463 	if (rc < 0) {
464 		debug("reading MAC from adapter failed\n");
465 		return rc;
466 	}
467 
468 	memcpy(enetaddr, buf, ETH_ALEN);
469 	return 0;
470 }
471 
472 static int mcs7830_write_mac_common(struct usb_device *udev,
473 				    unsigned char enetaddr[])
474 {
475 	int rc;
476 
477 	debug("%s()\n", __func__);
478 
479 	rc = mcs7830_write_reg(udev, REG_ETHER_ADDR, ETH_ALEN, enetaddr);
480 	if (rc < 0) {
481 		debug("writing MAC to adapter failed\n");
482 		return rc;
483 	}
484 	return 0;
485 }
486 
487 static int mcs7830_init_common(struct usb_device *udev)
488 {
489 	int timeout;
490 	int have_link;
491 
492 	debug("%s()\n", __func__);
493 
494 	timeout = 0;
495 	do {
496 		have_link = mcs7830_read_phy(udev, MII_BMSR) & BMSR_LSTATUS;
497 		if (have_link)
498 			break;
499 		udelay(LINKSTATUS_TIMEOUT_RES * 1000);
500 		timeout += LINKSTATUS_TIMEOUT_RES;
501 	} while (timeout < LINKSTATUS_TIMEOUT);
502 	if (!have_link) {
503 		debug("ethernet link is down\n");
504 		return -ETIMEDOUT;
505 	}
506 	return 0;
507 }
508 
509 static int mcs7830_send_common(struct ueth_data *ueth, void *packet,
510 			       int length)
511 {
512 	struct usb_device *udev = ueth->pusb_dev;
513 	int rc;
514 	int gotlen;
515 	/* there is a status byte after the ethernet frame */
516 	ALLOC_CACHE_ALIGN_BUFFER(uint8_t, buf, PKTSIZE + sizeof(uint8_t));
517 
518 	memcpy(buf, packet, length);
519 	rc = usb_bulk_msg(udev,
520 			  usb_sndbulkpipe(udev, ueth->ep_out),
521 			  &buf[0], length, &gotlen,
522 			  USBCALL_TIMEOUT);
523 	debug("%s() TX want len %d, got len %d, rc %d\n",
524 	      __func__, length, gotlen, rc);
525 	return rc;
526 }
527 
528 static int mcs7830_recv_common(struct ueth_data *ueth, uint8_t *buf)
529 {
530 	int rc, wantlen, gotlen;
531 	uint8_t sts;
532 
533 	debug("%s()\n", __func__);
534 
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,
540 			  USBCALL_TIMEOUT);
541 	debug("%s() RX want len %d, got len %d, rc %d\n",
542 	      __func__, wantlen, gotlen, rc);
543 	if (rc != 0) {
544 		pr_err("RX: failed to receive\n");
545 		return rc;
546 	}
547 	if (gotlen > wantlen) {
548 		pr_err("RX: got too many bytes (%d)\n", gotlen);
549 		return -EIO;
550 	}
551 
552 	/*
553 	 * the bulk message that we received from USB contains exactly
554 	 * one ethernet frame and a trailing status byte
555 	 */
556 	if (gotlen < sizeof(sts))
557 		return -EIO;
558 	gotlen -= sizeof(sts);
559 	sts = buf[gotlen];
560 
561 	if (sts == STAT_RX_FRAME_CORRECT) {
562 		debug("%s() got a frame, len=%d\n", __func__, gotlen);
563 		return gotlen;
564 	}
565 
566 	debug("RX: frame error (sts 0x%02X, %s %s %s %s %s)\n",
567 	      sts,
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" : "-");
573 	return -EIO;
574 }
575 
576 #ifndef CONFIG_DM_ETH
577 /*
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
582  *
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
586  */
587 static int mcs7830_init(struct eth_device *eth, bd_t *bd)
588 {
589 	struct ueth_data *dev = eth->priv;
590 
591 	return mcs7830_init_common(dev->pusb_dev);
592 }
593 
594 /*
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
600  *
601  * this routine send an ethernet frame out of the network interface
602  */
603 static int mcs7830_send(struct eth_device *eth, void *packet, int length)
604 {
605 	struct ueth_data *dev = eth->priv;
606 
607 	return mcs7830_send_common(dev, packet, length);
608 }
609 
610 /*
611  * mcs7830_recv() - network interface's recv callback
612  * @eth:	network device to receive frames from
613  * Return: zero upon success, negative upon error
614  *
615  * this routine checks for available ethernet frames that the network
616  * interface might have received, and notifies the network stack
617  */
618 static int mcs7830_recv(struct eth_device *eth)
619 {
620 	ALLOC_CACHE_ALIGN_BUFFER(uint8_t, buf, MCS7830_RX_URB_SIZE);
621 	struct ueth_data *ueth = eth->priv;
622 	int len;
623 
624 	len = mcs7830_recv_common(ueth, buf);
625 	if (len >= 0) {
626 		net_process_received_packet(buf, len);
627 		return 0;
628 	}
629 
630 	return len;
631 }
632 
633 /*
634  * mcs7830_halt() - network interface's halt callback
635  * @eth:	network device to cease operation of
636  * Return: none
637  *
638  * this routine is supposed to undo the effect of previous initialization and
639  * ethernet frames exchange; in this implementation it's a NOP
640  */
641 static void mcs7830_halt(struct eth_device *eth)
642 {
643 	debug("%s()\n", __func__);
644 }
645 
646 /*
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
650  *
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
654  */
655 static int mcs7830_write_mac(struct eth_device *eth)
656 {
657 	struct ueth_data *ueth = eth->priv;
658 
659 	return mcs7830_write_mac_common(ueth->pusb_dev, eth->enetaddr);
660 }
661 
662 /*
663  * mcs7830_iface_idx - index of detected network interfaces
664  *
665  * this counter keeps track of identified supported interfaces,
666  * to assign unique names as more interfaces are found
667  */
668 static int mcs7830_iface_idx;
669 
670 /*
671  * mcs7830_eth_before_probe() - network driver's before_probe callback
672  * Return: none
673  *
674  * this routine initializes driver's internal data in preparation of
675  * subsequent probe callbacks
676  */
677 void mcs7830_eth_before_probe(void)
678 {
679 	mcs7830_iface_idx = 0;
680 }
681 
682 /*
683  * struct mcs7830_dongle - description of a supported Moschip ethernet dongle
684  * @vendor:	16bit USB vendor identification
685  * @product:	16bit USB product identification
686  *
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
691  * needed
692  */
693 struct mcs7830_dongle {
694 	uint16_t vendor;
695 	uint16_t product;
696 };
697 
698 /*
699  * mcs7830_dongles - the list of supported Moschip based USB ethernet dongles
700  */
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 */
706 };
707 
708 /*
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
714  *
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
718  */
719 int mcs7830_eth_probe(struct usb_device *dev, unsigned int ifnum,
720 		      struct ueth_data *ss)
721 {
722 	struct usb_interface *iface;
723 	struct usb_interface_descriptor *iface_desc;
724 	int i;
725 	struct mcs7830_private *priv;
726 	int ep_in_found, ep_out_found, ep_intr_found;
727 
728 	debug("%s()\n", __func__);
729 
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)
736 			break;
737 	}
738 	if (i == ARRAY_SIZE(mcs7830_dongles))
739 		return 0;
740 	debug("detected USB ethernet device: %04X:%04X\n",
741 	      dev->descriptor.idVendor, dev->descriptor.idProduct);
742 
743 	/* fill in driver private data */
744 	priv = calloc(1, sizeof(*priv));
745 	if (!priv)
746 		return 0;
747 
748 	/* fill in the ueth_data structure, attach private data */
749 	memset(ss, 0, sizeof(*ss));
750 	ss->ifnum = ifnum;
751 	ss->pusb_dev = dev;
752 	ss->subclass = iface_desc->bInterfaceSubClass;
753 	ss->protocol = iface_desc->bInterfaceProtocol;
754 	ss->dev_priv = priv;
755 
756 	/*
757 	 * a minimum of three endpoints is expected: in (bulk),
758 	 * out (bulk), and interrupt; ignore all others
759 	 */
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;
763 		bool is_input;
764 
765 		eptype = iface->ep_desc[i].bmAttributes;
766 		eptype &= USB_ENDPOINT_XFERTYPE_MASK;
767 
768 		epaddr = iface->ep_desc[i].bEndpointAddress;
769 		is_input = epaddr & USB_DIR_IN;
770 		epaddr &= USB_ENDPOINT_NUMBER_MASK;
771 
772 		if (eptype == USB_ENDPOINT_XFER_BULK) {
773 			if (is_input && !ep_in_found) {
774 				ss->ep_in = epaddr;
775 				ep_in_found++;
776 			}
777 			if (!is_input && !ep_out_found) {
778 				ss->ep_out = epaddr;
779 				ep_out_found++;
780 			}
781 		}
782 
783 		if (eptype == USB_ENDPOINT_XFER_INT) {
784 			if (is_input && !ep_intr_found) {
785 				ss->ep_int = epaddr;
786 				ss->irqinterval = iface->ep_desc[i].bInterval;
787 				ep_intr_found++;
788 			}
789 		}
790 	}
791 	debug("endpoints: in %d, out %d, intr %d\n",
792 	      ss->ep_in, ss->ep_out, ss->ep_int);
793 
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");
798 		return 0;
799 	}
800 
801 	dev->privptr = ss;
802 	return 1;
803 }
804 
805 /*
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
811  *
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
817  */
818 int mcs7830_eth_get_info(struct usb_device *dev, struct ueth_data *ss,
819 			 struct eth_device *eth)
820 {
821 	debug("%s()\n", __func__);
822 	if (!eth) {
823 		debug("%s: missing parameter.\n", __func__);
824 		return 0;
825 	}
826 
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;
834 	eth->priv = ss;
835 
836 	if (mcs7830_basic_reset(ss->pusb_dev, ss->dev_priv))
837 		return 0;
838 
839 	if (mcs7830_read_mac(ss->pusb_dev, eth->enetaddr))
840 		return 0;
841 	debug("MAC %pM\n", eth->enetaddr);
842 
843 	return 1;
844 }
845 #endif
846 
847 
848 #ifdef CONFIG_DM_ETH
849 static int mcs7830_eth_start(struct udevice *dev)
850 {
851 	struct usb_device *udev = dev_get_parent_priv(dev);
852 
853 	return mcs7830_init_common(udev);
854 }
855 
856 void mcs7830_eth_stop(struct udevice *dev)
857 {
858 	debug("** %s()\n", __func__);
859 }
860 
861 int mcs7830_eth_send(struct udevice *dev, void *packet, int length)
862 {
863 	struct mcs7830_private *priv = dev_get_priv(dev);
864 	struct ueth_data *ueth = &priv->ueth;
865 
866 	return mcs7830_send_common(ueth, packet, length);
867 }
868 
869 int mcs7830_eth_recv(struct udevice *dev, int flags, uchar **packetp)
870 {
871 	struct mcs7830_private *priv = dev_get_priv(dev);
872 	struct ueth_data *ueth = &priv->ueth;
873 	int len;
874 
875 	len = mcs7830_recv_common(ueth, priv->rx_buf);
876 	*packetp = priv->rx_buf;
877 
878 	return len;
879 }
880 
881 static int mcs7830_free_pkt(struct udevice *dev, uchar *packet, int packet_len)
882 {
883 	struct mcs7830_private *priv = dev_get_priv(dev);
884 
885 	packet_len = ALIGN(packet_len, 4);
886 	usb_ether_advance_rxbuf(&priv->ueth, sizeof(u32) + packet_len);
887 
888 	return 0;
889 }
890 
891 int mcs7830_write_hwaddr(struct udevice *dev)
892 {
893 	struct usb_device *udev = dev_get_parent_priv(dev);
894 	struct eth_pdata *pdata = dev_get_platdata(dev);
895 
896 	return mcs7830_write_mac_common(udev, pdata->enetaddr);
897 }
898 
899 static int mcs7830_eth_probe(struct udevice *dev)
900 {
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;
905 
906 	if (mcs7830_basic_reset(udev, priv))
907 		return 0;
908 
909 	if (mcs7830_read_mac(udev, pdata->enetaddr))
910 		return 0;
911 
912 	return usb_ether_register(dev, ueth, MCS7830_RX_URB_SIZE);
913 }
914 
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,
922 };
923 
924 U_BOOT_DRIVER(mcs7830_eth) = {
925 	.name	= "mcs7830_eth",
926 	.id	= UCLASS_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,
932 };
933 
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 */
940 };
941 
942 U_BOOT_USB_DEVICE(mcs7830_eth, mcs7830_eth_id_table);
943 #endif
944