ks8851_mll.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Micrel KS8851_MLL 16bit Network driver
  4. * Copyright (c) 2011 Roberto Cerati <roberto.cerati@bticino.it>
  5. */
  6. #include <log.h>
  7. #include <asm/io.h>
  8. #include <common.h>
  9. #include <command.h>
  10. #include <malloc.h>
  11. #include <net.h>
  12. #include <miiphy.h>
  13. #include <linux/delay.h>
  14. #include "ks8851_mll.h"
  15. #define DRIVERNAME "ks8851_mll"
  16. #define RX_BUF_SIZE 2000
  17. /*
  18. * struct ks_net - KS8851 driver private data
  19. * @dev : legacy non-DM ethernet device structure
  20. * @iobase : register base
  21. * @bus_width : i/o bus width.
  22. * @sharedbus : Multipex(addr and data bus) mode indicator.
  23. * @extra_byte : number of extra byte prepended rx pkt.
  24. */
  25. struct ks_net {
  26. #ifndef CONFIG_DM_ETH
  27. struct eth_device dev;
  28. #endif
  29. phys_addr_t iobase;
  30. int bus_width;
  31. u16 sharedbus;
  32. u16 rxfc;
  33. u8 extra_byte;
  34. };
  35. #define BE3 0x8000 /* Byte Enable 3 */
  36. #define BE2 0x4000 /* Byte Enable 2 */
  37. #define BE1 0x2000 /* Byte Enable 1 */
  38. #define BE0 0x1000 /* Byte Enable 0 */
  39. static u8 ks_rdreg8(struct ks_net *ks, u16 offset)
  40. {
  41. u8 shift_bit = offset & 0x03;
  42. u8 shift_data = (offset & 1) << 3;
  43. writew(offset | (BE0 << shift_bit), ks->iobase + 2);
  44. return (u8)(readw(ks->iobase) >> shift_data);
  45. }
  46. static u16 ks_rdreg16(struct ks_net *ks, u16 offset)
  47. {
  48. writew(offset | ((BE1 | BE0) << (offset & 0x02)), ks->iobase + 2);
  49. return readw(ks->iobase);
  50. }
  51. static void ks_wrreg16(struct ks_net *ks, u16 offset, u16 val)
  52. {
  53. writew(offset | ((BE1 | BE0) << (offset & 0x02)), ks->iobase + 2);
  54. writew(val, ks->iobase);
  55. }
  56. /*
  57. * ks_inblk - read a block of data from QMU. This is called after sudo DMA mode
  58. * enabled.
  59. * @ks: The chip state
  60. * @wptr: buffer address to save data
  61. * @len: length in byte to read
  62. */
  63. static inline void ks_inblk(struct ks_net *ks, u16 *wptr, u32 len)
  64. {
  65. len >>= 1;
  66. while (len--)
  67. *wptr++ = readw(ks->iobase);
  68. }
  69. /*
  70. * ks_outblk - write data to QMU. This is called after sudo DMA mode enabled.
  71. * @ks: The chip information
  72. * @wptr: buffer address
  73. * @len: length in byte to write
  74. */
  75. static inline void ks_outblk(struct ks_net *ks, u16 *wptr, u32 len)
  76. {
  77. len >>= 1;
  78. while (len--)
  79. writew(*wptr++, ks->iobase);
  80. }
  81. static void ks_enable_int(struct ks_net *ks)
  82. {
  83. ks_wrreg16(ks, KS_IER, IRQ_LCI | IRQ_TXI | IRQ_RXI);
  84. }
  85. static void ks_set_powermode(struct ks_net *ks, unsigned int pwrmode)
  86. {
  87. unsigned int pmecr;
  88. ks_rdreg16(ks, KS_GRR);
  89. pmecr = ks_rdreg16(ks, KS_PMECR);
  90. pmecr &= ~PMECR_PM_MASK;
  91. pmecr |= pwrmode;
  92. ks_wrreg16(ks, KS_PMECR, pmecr);
  93. }
  94. /*
  95. * ks_read_config - read chip configuration of bus width.
  96. * @ks: The chip information
  97. */
  98. static void ks_read_config(struct ks_net *ks)
  99. {
  100. u16 reg_data = 0;
  101. /* Regardless of bus width, 8 bit read should always work. */
  102. reg_data = ks_rdreg8(ks, KS_CCR) & 0x00FF;
  103. reg_data |= ks_rdreg8(ks, KS_CCR + 1) << 8;
  104. /* addr/data bus are multiplexed */
  105. ks->sharedbus = (reg_data & CCR_SHARED) == CCR_SHARED;
  106. /*
  107. * There are garbage data when reading data from QMU,
  108. * depending on bus-width.
  109. */
  110. if (reg_data & CCR_8BIT) {
  111. ks->bus_width = ENUM_BUS_8BIT;
  112. ks->extra_byte = 1;
  113. } else if (reg_data & CCR_16BIT) {
  114. ks->bus_width = ENUM_BUS_16BIT;
  115. ks->extra_byte = 2;
  116. } else {
  117. ks->bus_width = ENUM_BUS_32BIT;
  118. ks->extra_byte = 4;
  119. }
  120. }
  121. /*
  122. * ks_soft_reset - issue one of the soft reset to the device
  123. * @ks: The device state.
  124. * @op: The bit(s) to set in the GRR
  125. *
  126. * Issue the relevant soft-reset command to the device's GRR register
  127. * specified by @op.
  128. *
  129. * Note, the delays are in there as a caution to ensure that the reset
  130. * has time to take effect and then complete. Since the datasheet does
  131. * not currently specify the exact sequence, we have chosen something
  132. * that seems to work with our device.
  133. */
  134. static void ks_soft_reset(struct ks_net *ks, unsigned int op)
  135. {
  136. /* Disable interrupt first */
  137. ks_wrreg16(ks, KS_IER, 0x0000);
  138. ks_wrreg16(ks, KS_GRR, op);
  139. mdelay(10); /* wait a short time to effect reset */
  140. ks_wrreg16(ks, KS_GRR, 0);
  141. mdelay(1); /* wait for condition to clear */
  142. }
  143. void ks_enable_qmu(struct ks_net *ks)
  144. {
  145. u16 w;
  146. w = ks_rdreg16(ks, KS_TXCR);
  147. /* Enables QMU Transmit (TXCR). */
  148. ks_wrreg16(ks, KS_TXCR, w | TXCR_TXE);
  149. /* Enable RX Frame Count Threshold and Auto-Dequeue RXQ Frame */
  150. w = ks_rdreg16(ks, KS_RXQCR);
  151. ks_wrreg16(ks, KS_RXQCR, w | RXQCR_RXFCTE);
  152. /* Enables QMU Receive (RXCR1). */
  153. w = ks_rdreg16(ks, KS_RXCR1);
  154. ks_wrreg16(ks, KS_RXCR1, w | RXCR1_RXE);
  155. }
  156. static void ks_disable_qmu(struct ks_net *ks)
  157. {
  158. u16 w;
  159. w = ks_rdreg16(ks, KS_TXCR);
  160. /* Disables QMU Transmit (TXCR). */
  161. w &= ~TXCR_TXE;
  162. ks_wrreg16(ks, KS_TXCR, w);
  163. /* Disables QMU Receive (RXCR1). */
  164. w = ks_rdreg16(ks, KS_RXCR1);
  165. w &= ~RXCR1_RXE;
  166. ks_wrreg16(ks, KS_RXCR1, w);
  167. }
  168. static inline void ks_read_qmu(struct ks_net *ks, u16 *buf, u32 len)
  169. {
  170. u32 r = ks->extra_byte & 0x1;
  171. u32 w = ks->extra_byte - r;
  172. /* 1. set sudo DMA mode */
  173. ks_wrreg16(ks, KS_RXFDPR, RXFDPR_RXFPAI);
  174. ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL | RXQCR_SDA);
  175. /*
  176. * 2. read prepend data
  177. *
  178. * read 4 + extra bytes and discard them.
  179. * extra bytes for dummy, 2 for status, 2 for len
  180. */
  181. if (r)
  182. ks_rdreg8(ks, 0);
  183. ks_inblk(ks, buf, w + 2 + 2);
  184. /* 3. read pkt data */
  185. ks_inblk(ks, buf, ALIGN(len, 4));
  186. /* 4. reset sudo DMA Mode */
  187. ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL);
  188. }
  189. static int ks_rcv(struct ks_net *ks, uchar *data)
  190. {
  191. u16 sts, len;
  192. if (!ks->rxfc)
  193. ks->rxfc = ks_rdreg16(ks, KS_RXFCTR) >> 8;
  194. if (!ks->rxfc)
  195. return 0;
  196. /* Checking Received packet status */
  197. sts = ks_rdreg16(ks, KS_RXFHSR);
  198. /* Get packet len from hardware */
  199. len = ks_rdreg16(ks, KS_RXFHBCR);
  200. if ((sts & RXFSHR_RXFV) && len && (len < RX_BUF_SIZE)) {
  201. /* read data block including CRC 4 bytes */
  202. ks_read_qmu(ks, (u16 *)data, len);
  203. ks->rxfc--;
  204. return len - 4;
  205. }
  206. ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL | RXQCR_RRXEF);
  207. printf(DRIVERNAME ": bad packet (sts=0x%04x len=0x%04x)\n", sts, len);
  208. ks->rxfc = 0;
  209. return 0;
  210. }
  211. /*
  212. * ks_read_selftest - read the selftest memory info.
  213. * @ks: The device state
  214. *
  215. * Read and check the TX/RX memory selftest information.
  216. */
  217. static int ks_read_selftest(struct ks_net *ks)
  218. {
  219. u16 both_done = MBIR_TXMBF | MBIR_RXMBF;
  220. u16 mbir;
  221. int ret = 0;
  222. mbir = ks_rdreg16(ks, KS_MBIR);
  223. if ((mbir & both_done) != both_done) {
  224. printf(DRIVERNAME ": Memory selftest not finished\n");
  225. return 0;
  226. }
  227. if (mbir & MBIR_TXMBFA) {
  228. printf(DRIVERNAME ": TX memory selftest fails\n");
  229. ret |= 1;
  230. }
  231. if (mbir & MBIR_RXMBFA) {
  232. printf(DRIVERNAME ": RX memory selftest fails\n");
  233. ret |= 2;
  234. }
  235. debug(DRIVERNAME ": the selftest passes\n");
  236. return ret;
  237. }
  238. static void ks_setup(struct ks_net *ks)
  239. {
  240. u16 w;
  241. /* Setup Transmit Frame Data Pointer Auto-Increment (TXFDPR) */
  242. ks_wrreg16(ks, KS_TXFDPR, TXFDPR_TXFPAI);
  243. /* Setup Receive Frame Data Pointer Auto-Increment */
  244. ks_wrreg16(ks, KS_RXFDPR, RXFDPR_RXFPAI);
  245. /* Setup Receive Frame Threshold - 1 frame (RXFCTFC) */
  246. ks_wrreg16(ks, KS_RXFCTR, 1 & RXFCTR_THRESHOLD_MASK);
  247. /* Setup RxQ Command Control (RXQCR) */
  248. ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL);
  249. /*
  250. * set the force mode to half duplex, default is full duplex
  251. * because if the auto-negotiation fails, most switch uses
  252. * half-duplex.
  253. */
  254. w = ks_rdreg16(ks, KS_P1MBCR);
  255. w &= ~P1MBCR_FORCE_FDX;
  256. ks_wrreg16(ks, KS_P1MBCR, w);
  257. w = TXCR_TXFCE | TXCR_TXPE | TXCR_TXCRC | TXCR_TCGIP;
  258. ks_wrreg16(ks, KS_TXCR, w);
  259. w = RXCR1_RXFCE | RXCR1_RXBE | RXCR1_RXUE | RXCR1_RXME | RXCR1_RXIPFCC;
  260. /* Normal mode */
  261. w |= RXCR1_RXPAFMA;
  262. ks_wrreg16(ks, KS_RXCR1, w);
  263. }
  264. static void ks_setup_int(struct ks_net *ks)
  265. {
  266. /* Clear the interrupts status of the hardware. */
  267. ks_wrreg16(ks, KS_ISR, 0xffff);
  268. }
  269. static int ks8851_mll_detect_chip(struct ks_net *ks)
  270. {
  271. unsigned short val;
  272. ks_read_config(ks);
  273. val = ks_rdreg16(ks, KS_CIDER);
  274. if (val == 0xffff) {
  275. /* Special case -- no chip present */
  276. printf(DRIVERNAME ": is chip mounted ?\n");
  277. return -1;
  278. } else if ((val & 0xfff0) != CIDER_ID) {
  279. printf(DRIVERNAME ": Invalid chip id 0x%04x\n", val);
  280. return -1;
  281. }
  282. debug("Read back KS8851 id 0x%x\n", val);
  283. if ((val & 0xfff0) != CIDER_ID) {
  284. printf(DRIVERNAME ": Unknown chip ID %04x\n", val);
  285. return -1;
  286. }
  287. return 0;
  288. }
  289. static void ks8851_mll_reset(struct ks_net *ks)
  290. {
  291. /* wake up powermode to normal mode */
  292. ks_set_powermode(ks, PMECR_PM_NORMAL);
  293. mdelay(1); /* wait for normal mode to take effect */
  294. /* Disable interrupt and reset */
  295. ks_soft_reset(ks, GRR_GSR);
  296. /* turn off the IRQs and ack any outstanding */
  297. ks_wrreg16(ks, KS_IER, 0x0000);
  298. ks_wrreg16(ks, KS_ISR, 0xffff);
  299. /* shutdown RX/TX QMU */
  300. ks_disable_qmu(ks);
  301. }
  302. static void ks8851_mll_phy_configure(struct ks_net *ks)
  303. {
  304. u16 data;
  305. ks_setup(ks);
  306. ks_setup_int(ks);
  307. /* Probing the phy */
  308. data = ks_rdreg16(ks, KS_OBCR);
  309. ks_wrreg16(ks, KS_OBCR, data | OBCR_ODS_16MA);
  310. debug(DRIVERNAME ": phy initialized\n");
  311. }
  312. static void ks8851_mll_enable(struct ks_net *ks)
  313. {
  314. ks_wrreg16(ks, KS_ISR, 0xffff);
  315. ks_enable_int(ks);
  316. ks_enable_qmu(ks);
  317. }
  318. static int ks8851_mll_init_common(struct ks_net *ks)
  319. {
  320. if (ks_read_selftest(ks)) {
  321. printf(DRIVERNAME ": Selftest failed\n");
  322. return -1;
  323. }
  324. ks8851_mll_reset(ks);
  325. /* Configure the PHY, initialize the link state */
  326. ks8851_mll_phy_configure(ks);
  327. ks->rxfc = 0;
  328. /* Turn on Tx + Rx */
  329. ks8851_mll_enable(ks);
  330. return 0;
  331. }
  332. static void ks_write_qmu(struct ks_net *ks, u8 *pdata, u16 len)
  333. {
  334. __le16 txw[2];
  335. /* start header at txb[0] to align txw entries */
  336. txw[0] = 0;
  337. txw[1] = cpu_to_le16(len);
  338. /* 1. set sudo-DMA mode */
  339. ks_wrreg16(ks, KS_TXFDPR, TXFDPR_TXFPAI);
  340. ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL | RXQCR_SDA);
  341. /* 2. write status/length info */
  342. ks_outblk(ks, txw, 4);
  343. /* 3. write pkt data */
  344. ks_outblk(ks, (u16 *)pdata, ALIGN(len, 4));
  345. /* 4. reset sudo-DMA mode */
  346. ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL);
  347. /* 5. Enqueue Tx(move the pkt from TX buffer into TXQ) */
  348. ks_wrreg16(ks, KS_TXQCR, TXQCR_METFE);
  349. /* 6. wait until TXQCR_METFE is auto-cleared */
  350. do { } while (ks_rdreg16(ks, KS_TXQCR) & TXQCR_METFE);
  351. }
  352. static int ks8851_mll_send_common(struct ks_net *ks, void *packet, int length)
  353. {
  354. u8 *data = (u8 *)packet;
  355. u16 tmplen = (u16)length;
  356. u16 retv;
  357. /*
  358. * Extra space are required:
  359. * 4 byte for alignment, 4 for status/length, 4 for CRC
  360. */
  361. retv = ks_rdreg16(ks, KS_TXMIR) & 0x1fff;
  362. if (retv >= tmplen + 12) {
  363. ks_write_qmu(ks, data, tmplen);
  364. return 0;
  365. }
  366. printf(DRIVERNAME ": failed to send packet: No buffer\n");
  367. return -1;
  368. }
  369. static void ks8851_mll_halt_common(struct ks_net *ks)
  370. {
  371. ks8851_mll_reset(ks);
  372. }
  373. /*
  374. * Maximum receive ring size; that is, the number of packets
  375. * we can buffer before overflow happens. Basically, this just
  376. * needs to be enough to prevent a packet being discarded while
  377. * we are processing the previous one.
  378. */
  379. static int ks8851_mll_recv_common(struct ks_net *ks, uchar *data)
  380. {
  381. u16 status;
  382. int ret = 0;
  383. status = ks_rdreg16(ks, KS_ISR);
  384. ks_wrreg16(ks, KS_ISR, status);
  385. if (ks->rxfc || (status & IRQ_RXI))
  386. ret = ks_rcv(ks, data);
  387. if (status & IRQ_LDI) {
  388. u16 pmecr = ks_rdreg16(ks, KS_PMECR);
  389. pmecr &= ~PMECR_WKEVT_MASK;
  390. ks_wrreg16(ks, KS_PMECR, pmecr | PMECR_WKEVT_LINK);
  391. }
  392. return ret;
  393. }
  394. static void ks8851_mll_write_hwaddr_common(struct ks_net *ks, u8 enetaddr[6])
  395. {
  396. u16 addrl, addrm, addrh;
  397. addrh = (enetaddr[0] << 8) | enetaddr[1];
  398. addrm = (enetaddr[2] << 8) | enetaddr[3];
  399. addrl = (enetaddr[4] << 8) | enetaddr[5];
  400. ks_wrreg16(ks, KS_MARH, addrh);
  401. ks_wrreg16(ks, KS_MARM, addrm);
  402. ks_wrreg16(ks, KS_MARL, addrl);
  403. }
  404. #ifndef CONFIG_DM_ETH
  405. static int ks8851_mll_init(struct eth_device *dev, struct bd_info *bd)
  406. {
  407. struct ks_net *ks = container_of(dev, struct ks_net, dev);
  408. return ks8851_mll_init_common(ks);
  409. }
  410. static void ks8851_mll_halt(struct eth_device *dev)
  411. {
  412. struct ks_net *ks = container_of(dev, struct ks_net, dev);
  413. ks8851_mll_halt_common(ks);
  414. }
  415. static int ks8851_mll_send(struct eth_device *dev, void *packet, int length)
  416. {
  417. struct ks_net *ks = container_of(dev, struct ks_net, dev);
  418. return ks8851_mll_send_common(ks, packet, length);
  419. }
  420. static int ks8851_mll_recv(struct eth_device *dev)
  421. {
  422. struct ks_net *ks = container_of(dev, struct ks_net, dev);
  423. int ret;
  424. ret = ks8851_mll_recv_common(ks, net_rx_packets[0]);
  425. if (ret)
  426. net_process_received_packet(net_rx_packets[0], ret);
  427. return ret;
  428. }
  429. static int ks8851_mll_write_hwaddr(struct eth_device *dev)
  430. {
  431. struct ks_net *ks = container_of(dev, struct ks_net, dev);
  432. ks8851_mll_write_hwaddr_common(ks, ks->dev.enetaddr);
  433. return 0;
  434. }
  435. int ks8851_mll_initialize(u8 dev_num, int base_addr)
  436. {
  437. struct ks_net *ks;
  438. ks = calloc(1, sizeof(*ks));
  439. if (!ks)
  440. return -ENOMEM;
  441. ks->iobase = base_addr;
  442. /* Try to detect chip. Will fail if not present. */
  443. if (ks8851_mll_detect_chip(ks)) {
  444. free(ks);
  445. return -1;
  446. }
  447. ks->dev.init = ks8851_mll_init;
  448. ks->dev.halt = ks8851_mll_halt;
  449. ks->dev.send = ks8851_mll_send;
  450. ks->dev.recv = ks8851_mll_recv;
  451. ks->dev.write_hwaddr = ks8851_mll_write_hwaddr;
  452. sprintf(ks->dev.name, "%s-%hu", DRIVERNAME, dev_num);
  453. eth_register(&ks->dev);
  454. return 0;
  455. }
  456. #else /* ifdef CONFIG_DM_ETH */
  457. static int ks8851_start(struct udevice *dev)
  458. {
  459. struct ks_net *ks = dev_get_priv(dev);
  460. return ks8851_mll_init_common(ks);
  461. }
  462. static void ks8851_stop(struct udevice *dev)
  463. {
  464. struct ks_net *ks = dev_get_priv(dev);
  465. ks8851_mll_halt_common(ks);
  466. }
  467. static int ks8851_send(struct udevice *dev, void *packet, int length)
  468. {
  469. struct ks_net *ks = dev_get_priv(dev);
  470. int ret;
  471. ret = ks8851_mll_send_common(ks, packet, length);
  472. return ret ? 0 : -ETIMEDOUT;
  473. }
  474. static int ks8851_recv(struct udevice *dev, int flags, uchar **packetp)
  475. {
  476. struct ks_net *ks = dev_get_priv(dev);
  477. uchar *data = net_rx_packets[0];
  478. int ret;
  479. ret = ks8851_mll_recv_common(ks, data);
  480. if (ret)
  481. *packetp = (void *)data;
  482. return ret ? ret : -EAGAIN;
  483. }
  484. static int ks8851_write_hwaddr(struct udevice *dev)
  485. {
  486. struct ks_net *ks = dev_get_priv(dev);
  487. struct eth_pdata *pdata = dev_get_plat(dev);
  488. ks8851_mll_write_hwaddr_common(ks, pdata->enetaddr);
  489. return 0;
  490. }
  491. static int ks8851_read_rom_hwaddr(struct udevice *dev)
  492. {
  493. struct ks_net *ks = dev_get_priv(dev);
  494. struct eth_pdata *pdata = dev_get_plat(dev);
  495. u16 addrl, addrm, addrh;
  496. /* No EEPROM means no valid MAC address. */
  497. if (!(ks_rdreg16(ks, KS_CCR) & CCR_EEPROM))
  498. return -EINVAL;
  499. /*
  500. * If the EEPROM contains valid MAC address, it is loaded into
  501. * the NIC on power on. Read the MAC out of the NIC registers.
  502. */
  503. addrl = ks_rdreg16(ks, KS_MARL);
  504. addrm = ks_rdreg16(ks, KS_MARM);
  505. addrh = ks_rdreg16(ks, KS_MARH);
  506. pdata->enetaddr[0] = (addrh >> 8) & 0xff;
  507. pdata->enetaddr[1] = addrh & 0xff;
  508. pdata->enetaddr[2] = (addrm >> 8) & 0xff;
  509. pdata->enetaddr[3] = addrm & 0xff;
  510. pdata->enetaddr[4] = (addrl >> 8) & 0xff;
  511. pdata->enetaddr[5] = addrl & 0xff;
  512. return !is_valid_ethaddr(pdata->enetaddr);
  513. }
  514. static int ks8851_bind(struct udevice *dev)
  515. {
  516. return device_set_name(dev, dev->name);
  517. }
  518. static int ks8851_probe(struct udevice *dev)
  519. {
  520. struct ks_net *ks = dev_get_priv(dev);
  521. /* Try to detect chip. Will fail if not present. */
  522. ks8851_mll_detect_chip(ks);
  523. return 0;
  524. }
  525. static int ks8851_of_to_plat(struct udevice *dev)
  526. {
  527. struct ks_net *ks = dev_get_priv(dev);
  528. struct eth_pdata *pdata = dev_get_plat(dev);
  529. pdata->iobase = dev_read_addr(dev);
  530. ks->iobase = pdata->iobase;
  531. return 0;
  532. }
  533. static const struct eth_ops ks8851_ops = {
  534. .start = ks8851_start,
  535. .stop = ks8851_stop,
  536. .send = ks8851_send,
  537. .recv = ks8851_recv,
  538. .write_hwaddr = ks8851_write_hwaddr,
  539. .read_rom_hwaddr = ks8851_read_rom_hwaddr,
  540. };
  541. static const struct udevice_id ks8851_ids[] = {
  542. { .compatible = "micrel,ks8851-mll" },
  543. { }
  544. };
  545. U_BOOT_DRIVER(ks8851) = {
  546. .name = "eth_ks8851",
  547. .id = UCLASS_ETH,
  548. .of_match = ks8851_ids,
  549. .bind = ks8851_bind,
  550. .of_to_plat = ks8851_of_to_plat,
  551. .probe = ks8851_probe,
  552. .ops = &ks8851_ops,
  553. .priv_auto = sizeof(struct ks_net),
  554. .plat_auto = sizeof(struct eth_pdata),
  555. .flags = DM_FLAG_ALLOC_PRIV_DMA,
  556. };
  557. #endif