1
2
3
4
5
6#include <dm.h>
7#include <log.h>
8#include <malloc.h>
9#include <miiphy.h>
10#include <memalign.h>
11#include <net.h>
12#include <usb.h>
13#include <linux/ethtool.h>
14#include <linux/mii.h>
15#include "usb_ether.h"
16#include "lan7x.h"
17
18
19
20
21int lan7x_write_reg(struct usb_device *udev, u32 index, u32 data)
22{
23 int len;
24 ALLOC_CACHE_ALIGN_BUFFER(u32, tmpbuf, 1);
25
26 cpu_to_le32s(&data);
27 tmpbuf[0] = data;
28
29 len = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
30 USB_VENDOR_REQUEST_WRITE_REGISTER,
31 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
32 0, index, tmpbuf, sizeof(data),
33 USB_CTRL_SET_TIMEOUT_MS);
34 if (len != sizeof(data)) {
35 debug("%s failed: index=%d, data=%d, len=%d",
36 __func__, index, data, len);
37 return -EIO;
38 }
39 return 0;
40}
41
42int lan7x_read_reg(struct usb_device *udev, u32 index, u32 *data)
43{
44 int len;
45 ALLOC_CACHE_ALIGN_BUFFER(u32, tmpbuf, 1);
46
47 len = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
48 USB_VENDOR_REQUEST_READ_REGISTER,
49 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
50 0, index, tmpbuf, sizeof(*data),
51 USB_CTRL_GET_TIMEOUT_MS);
52 *data = tmpbuf[0];
53 if (len != sizeof(*data)) {
54 debug("%s failed: index=%d, len=%d", __func__, index, len);
55 return -EIO;
56 }
57
58 le32_to_cpus(data);
59 return 0;
60}
61
62static int lan7x_phy_wait_not_busy(struct usb_device *udev)
63{
64 return lan7x_wait_for_bit(udev, __func__,
65 MII_ACC, MII_ACC_MII_BUSY,
66 false, 100, 0);
67}
68
69int lan7x_mdio_read(struct usb_device *udev, int phy_id, int idx)
70{
71 u32 val, addr;
72
73
74 if (lan7x_phy_wait_not_busy(udev)) {
75 debug("MII is busy in %s\n", __func__);
76 return -ETIMEDOUT;
77 }
78
79
80 addr = (phy_id << 11) | (idx << 6) |
81 MII_ACC_MII_READ | MII_ACC_MII_BUSY;
82 lan7x_write_reg(udev, MII_ACC, addr);
83
84 if (lan7x_phy_wait_not_busy(udev)) {
85 debug("Timed out reading MII reg %02X\n", idx);
86 return -ETIMEDOUT;
87 }
88
89 lan7x_read_reg(udev, MII_DATA, &val);
90
91 return val & 0xFFFF;
92}
93
94void lan7x_mdio_write(struct usb_device *udev, int phy_id, int idx, int regval)
95{
96 u32 addr;
97
98
99 if (lan7x_phy_wait_not_busy(udev)) {
100 debug("MII is busy in %s\n", __func__);
101 return;
102 }
103
104 lan7x_write_reg(udev, MII_DATA, regval);
105
106
107 addr = (phy_id << 11) | (idx << 6) |
108 MII_ACC_MII_WRITE | MII_ACC_MII_BUSY;
109 lan7x_write_reg(udev, MII_ACC, addr);
110
111 if (lan7x_phy_wait_not_busy(udev))
112 debug("Timed out writing MII reg %02X\n", idx);
113}
114
115
116
117
118static int lan7x_phylib_mdio_read(struct mii_dev *bus,
119 int addr, int devad, int reg)
120{
121 struct usb_device *udev = dev_get_parent_priv(bus->priv);
122
123 return lan7x_mdio_read(udev, addr, reg);
124}
125
126static int lan7x_phylib_mdio_write(struct mii_dev *bus,
127 int addr, int devad, int reg, u16 val)
128{
129 struct usb_device *udev = dev_get_parent_priv(bus->priv);
130
131 lan7x_mdio_write(udev, addr, reg, (int)val);
132
133 return 0;
134}
135
136
137
138
139static int lan7x_eeprom_confirm_not_busy(struct usb_device *udev)
140{
141 return lan7x_wait_for_bit(udev, __func__,
142 E2P_CMD, E2P_CMD_EPC_BUSY,
143 false, 100, 0);
144}
145
146static int lan7x_wait_eeprom(struct usb_device *udev)
147{
148 return lan7x_wait_for_bit(udev, __func__,
149 E2P_CMD,
150 (E2P_CMD_EPC_BUSY | E2P_CMD_EPC_TIMEOUT),
151 false, 100, 0);
152}
153
154static int lan7x_read_eeprom(struct usb_device *udev,
155 u32 offset, u32 length, u8 *data)
156{
157 u32 val;
158 int i, ret;
159
160 ret = lan7x_eeprom_confirm_not_busy(udev);
161 if (ret)
162 return ret;
163
164 for (i = 0; i < length; i++) {
165 val = E2P_CMD_EPC_BUSY | E2P_CMD_EPC_CMD_READ |
166 (offset & E2P_CMD_EPC_ADDR_MASK);
167 lan7x_write_reg(udev, E2P_CMD, val);
168
169 ret = lan7x_wait_eeprom(udev);
170 if (ret)
171 return ret;
172
173 lan7x_read_reg(udev, E2P_DATA, &val);
174 data[i] = val & 0xFF;
175 offset++;
176 }
177 return ret;
178}
179
180
181
182
183int lan7x_phylib_register(struct udevice *udev)
184{
185 struct usb_device *usbdev = dev_get_parent_priv(udev);
186 struct lan7x_private *priv = dev_get_priv(udev);
187 int ret;
188
189 priv->mdiobus = mdio_alloc();
190 if (!priv->mdiobus) {
191 printf("mdio_alloc failed\n");
192 return -ENOMEM;
193 }
194 priv->mdiobus->read = lan7x_phylib_mdio_read;
195 priv->mdiobus->write = lan7x_phylib_mdio_write;
196 sprintf(priv->mdiobus->name,
197 "lan7x_mdiobus-d%hu-p%hu", usbdev->devnum, usbdev->portnr);
198 priv->mdiobus->priv = (void *)udev;
199
200 ret = mdio_register(priv->mdiobus);
201 if (ret) {
202 printf("mdio_register failed\n");
203 free(priv->mdiobus);
204 return -ENOMEM;
205 }
206
207 return 0;
208}
209
210int lan7x_eth_phylib_connect(struct udevice *udev, struct ueth_data *dev)
211{
212 struct lan7x_private *priv = dev_get_priv(udev);
213
214 priv->phydev = phy_connect(priv->mdiobus, dev->phy_id,
215 udev, PHY_INTERFACE_MODE_MII);
216
217 if (!priv->phydev) {
218 printf("phy_connect failed\n");
219 return -ENODEV;
220 }
221 return 0;
222}
223
224int lan7x_eth_phylib_config_start(struct udevice *udev)
225{
226 struct lan7x_private *priv = dev_get_priv(udev);
227 int ret;
228
229
230 priv->phydev->supported = PHY_BASIC_FEATURES |
231 SUPPORTED_1000baseT_Full |
232 SUPPORTED_Pause |
233 SUPPORTED_Asym_Pause;
234
235 priv->phydev->advertising = ADVERTISED_10baseT_Half |
236 ADVERTISED_10baseT_Full |
237 ADVERTISED_100baseT_Half |
238 ADVERTISED_100baseT_Full |
239 ADVERTISED_1000baseT_Full |
240 ADVERTISED_Pause |
241 ADVERTISED_Asym_Pause |
242 ADVERTISED_Autoneg;
243
244 priv->phydev->autoneg = AUTONEG_ENABLE;
245
246 ret = genphy_config_aneg(priv->phydev);
247 if (ret) {
248 printf("genphy_config_aneg failed\n");
249 return ret;
250 }
251 ret = phy_startup(priv->phydev);
252 if (ret) {
253 printf("phy_startup failed\n");
254 return ret;
255 }
256
257 debug("** %s() speed %i duplex %i adv %X supp %X\n", __func__,
258 priv->phydev->speed, priv->phydev->duplex,
259 priv->phydev->advertising, priv->phydev->supported);
260
261 return 0;
262}
263
264int lan7x_update_flowcontrol(struct usb_device *udev,
265 struct ueth_data *dev,
266 uint32_t *flow, uint32_t *fct_flow)
267{
268 uint32_t lcladv, rmtadv;
269 u8 cap = 0;
270 struct lan7x_private *priv = dev_get_priv(udev->dev);
271
272 debug("** %s()\n", __func__);
273 debug("** %s() priv->phydev->speed %i duplex %i\n", __func__,
274 priv->phydev->speed, priv->phydev->duplex);
275
276 if (priv->phydev->duplex == DUPLEX_FULL) {
277 lcladv = lan7x_mdio_read(udev, dev->phy_id, MII_ADVERTISE);
278 rmtadv = lan7x_mdio_read(udev, dev->phy_id, MII_LPA);
279 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
280
281 debug("TX Flow ");
282 if (cap & FLOW_CTRL_TX) {
283 *flow = (FLOW_CR_TX_FCEN | 0xFFFF);
284
285 *fct_flow = ((MAX_RX_FIFO_SIZE * 2) / (10 * 512))
286 & 0x7FUL;
287 *fct_flow <<= 8UL;
288 *fct_flow |= ((MAX_RX_FIFO_SIZE * 8) / (10 * 512))
289 & 0x7FUL;
290 debug("EN ");
291 } else {
292 debug("DIS ");
293 }
294 debug("RX Flow ");
295 if (cap & FLOW_CTRL_RX) {
296 *flow |= FLOW_CR_RX_FCEN;
297 debug("EN");
298 } else {
299 debug("DIS");
300 }
301 }
302 debug("\n");
303 return 0;
304}
305
306int lan7x_read_eeprom_mac(unsigned char *enetaddr, struct usb_device *udev)
307{
308 int ret;
309
310 memset(enetaddr, 0, 6);
311
312 ret = lan7x_read_eeprom(udev, 0, 1, enetaddr);
313
314 if ((ret == 0) && (enetaddr[0] == EEPROM_INDICATOR)) {
315 ret = lan7x_read_eeprom(udev,
316 EEPROM_MAC_OFFSET, ETH_ALEN,
317 enetaddr);
318 if ((ret == 0) && is_valid_ethaddr(enetaddr)) {
319
320 debug("MAC address read from EEPROM %pM\n",
321 enetaddr);
322 return 0;
323 }
324 }
325 debug("MAC address read from EEPROM invalid %pM\n", enetaddr);
326
327 memset(enetaddr, 0, 6);
328 return -EINVAL;
329}
330
331int lan7x_pmt_phy_reset(struct usb_device *udev,
332 struct ueth_data *dev)
333{
334 int ret;
335 u32 data;
336
337 ret = lan7x_read_reg(udev, PMT_CTL, &data);
338 if (ret)
339 return ret;
340 ret = lan7x_write_reg(udev, PMT_CTL, data | PMT_CTL_PHY_RST);
341 if (ret)
342 return ret;
343
344
345 ret = lan7x_wait_for_bit(udev, "PMT_CTL_PHY_RST",
346 PMT_CTL, PMT_CTL_PHY_RST,
347 false, 1000, 0);
348 if (ret)
349 return ret;
350
351 return lan7x_wait_for_bit(udev, "PMT_CTL_READY",
352 PMT_CTL, PMT_CTL_READY,
353 true, 1000, 0);
354}
355
356int lan7x_basic_reset(struct usb_device *udev,
357 struct ueth_data *dev)
358{
359 int ret;
360
361 dev->phy_id = LAN7X_INTERNAL_PHY_ID;
362
363 ret = lan7x_write_reg(udev, HW_CFG, HW_CFG_LRST);
364 if (ret)
365 return ret;
366
367 ret = lan7x_wait_for_bit(udev, "HW_CFG_LRST",
368 HW_CFG, HW_CFG_LRST,
369 false, 1000, 0);
370 if (ret)
371 return ret;
372
373 debug("USB devnum %d portnr %d\n", udev->devnum, udev->portnr);
374
375 return lan7x_pmt_phy_reset(udev, dev);
376}
377
378void lan7x_eth_stop(struct udevice *dev)
379{
380 debug("** %s()\n", __func__);
381}
382
383int lan7x_eth_send(struct udevice *dev, void *packet, int length)
384{
385 struct lan7x_private *priv = dev_get_priv(dev);
386 struct ueth_data *ueth = &priv->ueth;
387 int err;
388 int actual_len;
389 u32 tx_cmd_a;
390 u32 tx_cmd_b;
391 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, msg,
392 PKTSIZE + sizeof(tx_cmd_a) + sizeof(tx_cmd_b));
393
394 debug("** %s(), len %d, buf %#x\n", __func__, length,
395 (unsigned int)(ulong) msg);
396 if (length > PKTSIZE)
397 return -ENOSPC;
398
399
400 tx_cmd_a = (u32) (length & TX_CMD_A_LEN_MASK) | TX_CMD_A_FCS;
401 tx_cmd_b = 0;
402 cpu_to_le32s(&tx_cmd_a);
403 cpu_to_le32s(&tx_cmd_b);
404
405
406 memcpy(msg, &tx_cmd_a, sizeof(tx_cmd_a));
407 memcpy(msg + sizeof(tx_cmd_a), &tx_cmd_b, sizeof(tx_cmd_b));
408 memcpy(msg + sizeof(tx_cmd_a) + sizeof(tx_cmd_b), (void *)packet,
409 length);
410 err = usb_bulk_msg(ueth->pusb_dev,
411 usb_sndbulkpipe(ueth->pusb_dev, ueth->ep_out),
412 (void *)msg,
413 length + sizeof(tx_cmd_a) +
414 sizeof(tx_cmd_b),
415 &actual_len, USB_BULK_SEND_TIMEOUT_MS);
416 debug("Tx: len = %u, actual = %u, err = %d\n",
417 (unsigned int)(length + sizeof(tx_cmd_a) + sizeof(tx_cmd_b)),
418 (unsigned int)actual_len, err);
419
420 return err;
421}
422
423int lan7x_eth_recv(struct udevice *dev, int flags, uchar **packetp)
424{
425 struct lan7x_private *priv = dev_get_priv(dev);
426 struct ueth_data *ueth = &priv->ueth;
427 uint8_t *ptr;
428 int ret, len;
429 u32 packet_len = 0;
430 u32 rx_cmd_a = 0;
431
432 len = usb_ether_get_rx_bytes(ueth, &ptr);
433 debug("%s: first try, len=%d\n", __func__, len);
434 if (!len) {
435 if (!(flags & ETH_RECV_CHECK_DEVICE))
436 return -EAGAIN;
437 ret = usb_ether_receive(ueth, RX_URB_SIZE);
438 if (ret == -EAGAIN)
439 return ret;
440
441 len = usb_ether_get_rx_bytes(ueth, &ptr);
442 debug("%s: second try, len=%d\n", __func__, len);
443 }
444
445
446
447
448
449 if (len < sizeof(packet_len)) {
450 debug("Rx: incomplete packet length\n");
451 goto err;
452 }
453 memcpy(&rx_cmd_a, ptr, sizeof(rx_cmd_a));
454 le32_to_cpus(&rx_cmd_a);
455 if (rx_cmd_a & RX_CMD_A_RXE) {
456 debug("Rx: Error header=%#x", rx_cmd_a);
457 goto err;
458 }
459 packet_len = (u16) (rx_cmd_a & RX_CMD_A_LEN_MASK);
460
461 if (packet_len > len - sizeof(packet_len)) {
462 debug("Rx: too large packet: %d\n", packet_len);
463 goto err;
464 }
465
466
467
468
469
470
471
472 *packetp = ptr + 10;
473 return packet_len;
474
475err:
476 usb_ether_advance_rxbuf(ueth, -1);
477 return -EINVAL;
478}
479
480int lan7x_free_pkt(struct udevice *dev, uchar *packet, int packet_len)
481{
482 struct lan7x_private *priv = dev_get_priv(dev);
483
484 packet_len = ALIGN(packet_len, 4);
485 usb_ether_advance_rxbuf(&priv->ueth, sizeof(u32) + packet_len);
486
487 return 0;
488}
489
490int lan7x_eth_remove(struct udevice *dev)
491{
492 struct lan7x_private *priv = dev_get_priv(dev);
493
494 debug("** %s()\n", __func__);
495 free(priv->phydev);
496 mdio_unregister(priv->mdiobus);
497 mdio_free(priv->mdiobus);
498
499 return 0;
500}
501
