1 // SPDX-License-Identifier: GPL-2.0+
2
3 #include <common.h>
4 #include <asm/io.h>
5 #include <dm.h>
6 #include <malloc.h>
7 #include <net.h>
8 #include <netdev.h>
9 #include <pci.h>
10 #include <linux/bitops.h>
11 #include <linux/delay.h>
12
13 #define SROM_DLEVEL 0
14
15 /* PCI Registers. */
16 #define PCI_CFDA_PSM 0x43
17
18 #define CFRV_RN 0x000000f0 /* Revision Number */
19
20 #define WAKEUP 0x00 /* Power Saving Wakeup */
21 #define SLEEP 0x80 /* Power Saving Sleep Mode */
22
23 #define DC2114x_BRK 0x0020 /* CFRV break between DC21142 & DC21143 */
24
25 /* Ethernet chip registers. */
26 #define DE4X5_BMR 0x000 /* Bus Mode Register */
27 #define DE4X5_TPD 0x008 /* Transmit Poll Demand Reg */
28 #define DE4X5_RRBA 0x018 /* RX Ring Base Address Reg */
29 #define DE4X5_TRBA 0x020 /* TX Ring Base Address Reg */
30 #define DE4X5_STS 0x028 /* Status Register */
31 #define DE4X5_OMR 0x030 /* Operation Mode Register */
32 #define DE4X5_SICR 0x068 /* SIA Connectivity Register */
33 #define DE4X5_APROM 0x048 /* Ethernet Address PROM */
34
35 /* Register bits. */
36 #define BMR_SWR 0x00000001 /* Software Reset */
37 #define STS_TS 0x00700000 /* Transmit Process State */
38 #define STS_RS 0x000e0000 /* Receive Process State */
39 #define OMR_ST 0x00002000 /* Start/Stop Transmission Command */
40 #define OMR_SR 0x00000002 /* Start/Stop Receive */
41 #define OMR_PS 0x00040000 /* Port Select */
42 #define OMR_SDP 0x02000000 /* SD Polarity - MUST BE ASSERTED */
43 #define OMR_PM 0x00000080 /* Pass All Multicast */
44
45 /* Descriptor bits. */
46 #define R_OWN 0x80000000 /* Own Bit */
47 #define RD_RER 0x02000000 /* Receive End Of Ring */
48 #define RD_LS 0x00000100 /* Last Descriptor */
49 #define RD_ES 0x00008000 /* Error Summary */
50 #define TD_TER 0x02000000 /* Transmit End Of Ring */
51 #define T_OWN 0x80000000 /* Own Bit */
52 #define TD_LS 0x40000000 /* Last Segment */
53 #define TD_FS 0x20000000 /* First Segment */
54 #define TD_ES 0x00008000 /* Error Summary */
55 #define TD_SET 0x08000000 /* Setup Packet */
56
57 /* The EEPROM commands include the alway-set leading bit. */
58 #define SROM_WRITE_CMD 5
59 #define SROM_READ_CMD 6
60 #define SROM_ERASE_CMD 7
61
62 #define SROM_HWADD 0x0014 /* Hardware Address offset in SROM */
63 #define SROM_RD 0x00004000 /* Read from Boot ROM */
64 #define EE_DATA_WRITE 0x04 /* EEPROM chip data in. */
65 #define EE_WRITE_0 0x4801
66 #define EE_WRITE_1 0x4805
67 #define EE_DATA_READ 0x08 /* EEPROM chip data out. */
68 #define SROM_SR 0x00000800 /* Select Serial ROM when set */
69
70 #define DT_IN 0x00000004 /* Serial Data In */
71 #define DT_CLK 0x00000002 /* Serial ROM Clock */
72 #define DT_CS 0x00000001 /* Serial ROM Chip Select */
73
74 #define POLL_DEMAND 1
75
76 #define phys_to_bus(dev, a) dm_pci_phys_to_mem((dev), (a))
77
78 #define NUM_RX_DESC PKTBUFSRX
79 #define NUM_TX_DESC 1 /* Number of TX descriptors */
80 #define RX_BUFF_SZ PKTSIZE_ALIGN
81
82 #define TOUT_LOOP 1000000
83
84 #define SETUP_FRAME_LEN 192
85
86 struct de4x5_desc {
87 volatile s32 status;
88 u32 des1;
89 u32 buf;
90 u32 next;
91 };
92
93 struct dc2114x_priv {
94 struct de4x5_desc rx_ring[NUM_RX_DESC] __aligned(32);
95 struct de4x5_desc tx_ring[NUM_TX_DESC] __aligned(32);
96 int rx_new; /* RX descriptor ring pointer */
97 int tx_new; /* TX descriptor ring pointer */
98 char rx_ring_size;
99 char tx_ring_size;
100 struct udevice *devno;
101 char *name;
102 void __iomem *iobase;
103 u8 *enetaddr;
104 };
105
106 /* RX and TX descriptor ring */
dc2114x_inl(struct dc2114x_priv * priv,u32 addr)107 static u32 dc2114x_inl(struct dc2114x_priv *priv, u32 addr)
108 {
109 return le32_to_cpu(readl(priv->iobase + addr));
110 }
111
dc2114x_outl(struct dc2114x_priv * priv,u32 command,u32 addr)112 static void dc2114x_outl(struct dc2114x_priv *priv, u32 command, u32 addr)
113 {
114 writel(cpu_to_le32(command), priv->iobase + addr);
115 }
116
reset_de4x5(struct dc2114x_priv * priv)117 static void reset_de4x5(struct dc2114x_priv *priv)
118 {
119 u32 i;
120
121 i = dc2114x_inl(priv, DE4X5_BMR);
122 mdelay(1);
123 dc2114x_outl(priv, i | BMR_SWR, DE4X5_BMR);
124 mdelay(1);
125 dc2114x_outl(priv, i, DE4X5_BMR);
126 mdelay(1);
127
128 for (i = 0; i < 5; i++) {
129 dc2114x_inl(priv, DE4X5_BMR);
130 mdelay(10);
131 }
132
133 mdelay(1);
134 }
135
start_de4x5(struct dc2114x_priv * priv)136 static void start_de4x5(struct dc2114x_priv *priv)
137 {
138 u32 omr;
139
140 omr = dc2114x_inl(priv, DE4X5_OMR);
141 omr |= OMR_ST | OMR_SR;
142 dc2114x_outl(priv, omr, DE4X5_OMR); /* Enable the TX and/or RX */
143 }
144
stop_de4x5(struct dc2114x_priv * priv)145 static void stop_de4x5(struct dc2114x_priv *priv)
146 {
147 u32 omr;
148
149 omr = dc2114x_inl(priv, DE4X5_OMR);
150 omr &= ~(OMR_ST | OMR_SR);
151 dc2114x_outl(priv, omr, DE4X5_OMR); /* Disable the TX and/or RX */
152 }
153
154 /* SROM Read and write routines. */
sendto_srom(struct dc2114x_priv * priv,u_int command,u_long addr)155 static void sendto_srom(struct dc2114x_priv *priv, u_int command, u_long addr)
156 {
157 dc2114x_outl(priv, command, addr);
158 udelay(1);
159 }
160
getfrom_srom(struct dc2114x_priv * priv,u_long addr)161 static int getfrom_srom(struct dc2114x_priv *priv, u_long addr)
162 {
163 u32 tmp = dc2114x_inl(priv, addr);
164
165 udelay(1);
166 return tmp;
167 }
168
169 /* Note: this routine returns extra data bits for size detection. */
do_read_eeprom(struct dc2114x_priv * priv,u_long ioaddr,int location,int addr_len)170 static int do_read_eeprom(struct dc2114x_priv *priv, u_long ioaddr, int location,
171 int addr_len)
172 {
173 int read_cmd = location | (SROM_READ_CMD << addr_len);
174 unsigned int retval = 0;
175 int i;
176
177 sendto_srom(priv, SROM_RD | SROM_SR, ioaddr);
178 sendto_srom(priv, SROM_RD | SROM_SR | DT_CS, ioaddr);
179
180 debug_cond(SROM_DLEVEL >= 1, " EEPROM read at %d ", location);
181
182 /* Shift the read command bits out. */
183 for (i = 4 + addr_len; i >= 0; i--) {
184 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
185
186 sendto_srom(priv, SROM_RD | SROM_SR | DT_CS | dataval,
187 ioaddr);
188 udelay(10);
189 sendto_srom(priv, SROM_RD | SROM_SR | DT_CS | dataval | DT_CLK,
190 ioaddr);
191 udelay(10);
192 debug_cond(SROM_DLEVEL >= 2, "%X",
193 getfrom_srom(priv, ioaddr) & 15);
194 retval = (retval << 1) |
195 !!(getfrom_srom(priv, ioaddr) & EE_DATA_READ);
196 }
197
198 sendto_srom(priv, SROM_RD | SROM_SR | DT_CS, ioaddr);
199
200 debug_cond(SROM_DLEVEL >= 2, " :%X:", getfrom_srom(priv, ioaddr) & 15);
201
202 for (i = 16; i > 0; i--) {
203 sendto_srom(priv, SROM_RD | SROM_SR | DT_CS | DT_CLK, ioaddr);
204 udelay(10);
205 debug_cond(SROM_DLEVEL >= 2, "%X",
206 getfrom_srom(priv, ioaddr) & 15);
207 retval = (retval << 1) |
208 !!(getfrom_srom(priv, ioaddr) & EE_DATA_READ);
209 sendto_srom(priv, SROM_RD | SROM_SR | DT_CS, ioaddr);
210 udelay(10);
211 }
212
213 /* Terminate the EEPROM access. */
214 sendto_srom(priv, SROM_RD | SROM_SR, ioaddr);
215
216 debug_cond(SROM_DLEVEL >= 2, " EEPROM value at %d is %5.5x.\n",
217 location, retval);
218
219 return retval;
220 }
221
222 /*
223 * This executes a generic EEPROM command, typically a write or write
224 * enable. It returns the data output from the EEPROM, and thus may
225 * also be used for reads.
226 */
do_eeprom_cmd(struct dc2114x_priv * priv,u_long ioaddr,int cmd,int cmd_len)227 static int do_eeprom_cmd(struct dc2114x_priv *priv, u_long ioaddr, int cmd,
228 int cmd_len)
229 {
230 unsigned int retval = 0;
231
232 debug_cond(SROM_DLEVEL >= 1, " EEPROM op 0x%x: ", cmd);
233
234 sendto_srom(priv, SROM_RD | SROM_SR | DT_CS | DT_CLK, ioaddr);
235
236 /* Shift the command bits out. */
237 do {
238 short dataval = (cmd & BIT(cmd_len)) ? EE_WRITE_1 : EE_WRITE_0;
239
240 sendto_srom(priv, dataval, ioaddr);
241 udelay(10);
242
243 debug_cond(SROM_DLEVEL >= 2, "%X",
244 getfrom_srom(priv, ioaddr) & 15);
245
246 sendto_srom(priv, dataval | DT_CLK, ioaddr);
247 udelay(10);
248 retval = (retval << 1) |
249 !!(getfrom_srom(priv, ioaddr) & EE_DATA_READ);
250 } while (--cmd_len >= 0);
251
252 sendto_srom(priv, SROM_RD | SROM_SR | DT_CS, ioaddr);
253
254 /* Terminate the EEPROM access. */
255 sendto_srom(priv, SROM_RD | SROM_SR, ioaddr);
256
257 debug_cond(SROM_DLEVEL >= 1, " EEPROM result is 0x%5.5x.\n", retval);
258
259 return retval;
260 }
261
read_srom(struct dc2114x_priv * priv,u_long ioaddr,int index)262 static int read_srom(struct dc2114x_priv *priv, u_long ioaddr, int index)
263 {
264 int ee_addr_size;
265
266 ee_addr_size = (do_read_eeprom(priv, ioaddr, 0xff, 8) & BIT(18)) ? 8 : 6;
267
268 return do_eeprom_cmd(priv, ioaddr, 0xffff |
269 (((SROM_READ_CMD << ee_addr_size) | index) << 16),
270 3 + ee_addr_size + 16);
271 }
272
send_setup_frame(struct dc2114x_priv * priv)273 static void send_setup_frame(struct dc2114x_priv *priv)
274 {
275 char setup_frame[SETUP_FRAME_LEN];
276 char *pa = &setup_frame[0];
277 int i;
278
279 memset(pa, 0xff, SETUP_FRAME_LEN);
280
281 for (i = 0; i < ETH_ALEN; i++) {
282 *(pa + (i & 1)) = priv->enetaddr[i];
283 if (i & 0x01)
284 pa += 4;
285 }
286
287 for (i = 0; priv->tx_ring[priv->tx_new].status & cpu_to_le32(T_OWN); i++) {
288 if (i < TOUT_LOOP)
289 continue;
290
291 printf("%s: tx error buffer not ready\n", priv->name);
292 return;
293 }
294
295 priv->tx_ring[priv->tx_new].buf = cpu_to_le32(phys_to_bus(priv->devno,
296 (u32)&setup_frame[0]));
297 priv->tx_ring[priv->tx_new].des1 = cpu_to_le32(TD_TER | TD_SET | SETUP_FRAME_LEN);
298 priv->tx_ring[priv->tx_new].status = cpu_to_le32(T_OWN);
299
300 dc2114x_outl(priv, POLL_DEMAND, DE4X5_TPD);
301
302 for (i = 0; priv->tx_ring[priv->tx_new].status & cpu_to_le32(T_OWN); i++) {
303 if (i < TOUT_LOOP)
304 continue;
305
306 printf("%s: tx buffer not ready\n", priv->name);
307 return;
308 }
309
310 if (le32_to_cpu(priv->tx_ring[priv->tx_new].status) != 0x7FFFFFFF) {
311 printf("TX error status2 = 0x%08X\n",
312 le32_to_cpu(priv->tx_ring[priv->tx_new].status));
313 }
314
315 priv->tx_new = (priv->tx_new + 1) % NUM_TX_DESC;
316 }
317
dc21x4x_send_common(struct dc2114x_priv * priv,void * packet,int length)318 static int dc21x4x_send_common(struct dc2114x_priv *priv, void *packet, int length)
319 {
320 int status = -1;
321 int i;
322
323 if (length <= 0) {
324 printf("%s: bad packet size: %d\n", priv->name, length);
325 goto done;
326 }
327
328 for (i = 0; priv->tx_ring[priv->tx_new].status & cpu_to_le32(T_OWN); i++) {
329 if (i < TOUT_LOOP)
330 continue;
331
332 printf("%s: tx error buffer not ready\n", priv->name);
333 goto done;
334 }
335
336 priv->tx_ring[priv->tx_new].buf = cpu_to_le32(phys_to_bus(priv->devno,
337 (u32)packet));
338 priv->tx_ring[priv->tx_new].des1 = cpu_to_le32(TD_TER | TD_LS | TD_FS | length);
339 priv->tx_ring[priv->tx_new].status = cpu_to_le32(T_OWN);
340
341 dc2114x_outl(priv, POLL_DEMAND, DE4X5_TPD);
342
343 for (i = 0; priv->tx_ring[priv->tx_new].status & cpu_to_le32(T_OWN); i++) {
344 if (i < TOUT_LOOP)
345 continue;
346
347 printf(".%s: tx buffer not ready\n", priv->name);
348 goto done;
349 }
350
351 if (le32_to_cpu(priv->tx_ring[priv->tx_new].status) & TD_ES) {
352 priv->tx_ring[priv->tx_new].status = 0x0;
353 goto done;
354 }
355
356 status = length;
357
358 done:
359 priv->tx_new = (priv->tx_new + 1) % NUM_TX_DESC;
360 return status;
361 }
362
dc21x4x_recv_check(struct dc2114x_priv * priv)363 static int dc21x4x_recv_check(struct dc2114x_priv *priv)
364 {
365 int length = 0;
366 u32 status;
367
368 status = le32_to_cpu(priv->rx_ring[priv->rx_new].status);
369
370 if (status & R_OWN)
371 return 0;
372
373 if (status & RD_LS) {
374 /* Valid frame status. */
375 if (status & RD_ES) {
376 /* There was an error. */
377 printf("RX error status = 0x%08X\n", status);
378 return -EINVAL;
379 } else {
380 /* A valid frame received. */
381 length = (le32_to_cpu(priv->rx_ring[priv->rx_new].status)
382 >> 16);
383
384 return length;
385 }
386 }
387
388 return -EAGAIN;
389 }
390
dc21x4x_init_common(struct dc2114x_priv * priv)391 static int dc21x4x_init_common(struct dc2114x_priv *priv)
392 {
393 int i;
394
395 reset_de4x5(priv);
396
397 if (dc2114x_inl(priv, DE4X5_STS) & (STS_TS | STS_RS)) {
398 printf("Error: Cannot reset ethernet controller.\n");
399 return -1;
400 }
401
402 dc2114x_outl(priv, OMR_SDP | OMR_PS | OMR_PM, DE4X5_OMR);
403
404 for (i = 0; i < NUM_RX_DESC; i++) {
405 priv->rx_ring[i].status = cpu_to_le32(R_OWN);
406 priv->rx_ring[i].des1 = cpu_to_le32(RX_BUFF_SZ);
407 priv->rx_ring[i].buf = cpu_to_le32(phys_to_bus(priv->devno,
408 (u32)net_rx_packets[i]));
409 priv->rx_ring[i].next = 0;
410 }
411
412 for (i = 0; i < NUM_TX_DESC; i++) {
413 priv->tx_ring[i].status = 0;
414 priv->tx_ring[i].des1 = 0;
415 priv->tx_ring[i].buf = 0;
416 priv->tx_ring[i].next = 0;
417 }
418
419 priv->rx_ring_size = NUM_RX_DESC;
420 priv->tx_ring_size = NUM_TX_DESC;
421
422 /* Write the end of list marker to the descriptor lists. */
423 priv->rx_ring[priv->rx_ring_size - 1].des1 |= cpu_to_le32(RD_RER);
424 priv->tx_ring[priv->tx_ring_size - 1].des1 |= cpu_to_le32(TD_TER);
425
426 /* Tell the adapter where the TX/RX rings are located. */
427 dc2114x_outl(priv, phys_to_bus(priv->devno, (u32)&priv->rx_ring),
428 DE4X5_RRBA);
429 dc2114x_outl(priv, phys_to_bus(priv->devno, (u32)&priv->tx_ring),
430 DE4X5_TRBA);
431
432 start_de4x5(priv);
433
434 priv->tx_new = 0;
435 priv->rx_new = 0;
436
437 send_setup_frame(priv);
438
439 return 0;
440 }
441
dc21x4x_halt_common(struct dc2114x_priv * priv)442 static void dc21x4x_halt_common(struct dc2114x_priv *priv)
443 {
444 stop_de4x5(priv);
445 dc2114x_outl(priv, 0, DE4X5_SICR);
446 }
447
read_hw_addr(struct dc2114x_priv * priv)448 static void read_hw_addr(struct dc2114x_priv *priv)
449 {
450 u_short tmp, *p = (u_short *)(&priv->enetaddr[0]);
451 int i, j = 0;
452
453 for (i = 0; i < (ETH_ALEN >> 1); i++) {
454 tmp = read_srom(priv, DE4X5_APROM, (SROM_HWADD >> 1) + i);
455 *p = le16_to_cpu(tmp);
456 j += *p++;
457 }
458
459 if (!j || j == 0x2fffd) {
460 memset(priv->enetaddr, 0, ETH_ALEN);
461 debug("Warning: can't read HW address from SROM.\n");
462 }
463 }
464
465 static struct pci_device_id supported[] = {
466 { PCI_DEVICE(PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_FAST) },
467 { PCI_DEVICE(PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_21142) },
468 { }
469 };
470
dc2114x_start(struct udevice * dev)471 static int dc2114x_start(struct udevice *dev)
472 {
473 struct eth_pdata *plat = dev_get_plat(dev);
474 struct dc2114x_priv *priv = dev_get_priv(dev);
475
476 memcpy(priv->enetaddr, plat->enetaddr, sizeof(plat->enetaddr));
477
478 /* Ensure we're not sleeping. */
479 dm_pci_write_config8(dev, PCI_CFDA_PSM, WAKEUP);
480
481 return dc21x4x_init_common(priv);
482 }
483
dc2114x_stop(struct udevice * dev)484 static void dc2114x_stop(struct udevice *dev)
485 {
486 struct dc2114x_priv *priv = dev_get_priv(dev);
487
488 dc21x4x_halt_common(priv);
489
490 dm_pci_write_config8(dev, PCI_CFDA_PSM, SLEEP);
491 }
492
dc2114x_send(struct udevice * dev,void * packet,int length)493 static int dc2114x_send(struct udevice *dev, void *packet, int length)
494 {
495 struct dc2114x_priv *priv = dev_get_priv(dev);
496 int ret;
497
498 ret = dc21x4x_send_common(priv, packet, length);
499
500 return ret ? 0 : -ETIMEDOUT;
501 }
502
dc2114x_recv(struct udevice * dev,int flags,uchar ** packetp)503 static int dc2114x_recv(struct udevice *dev, int flags, uchar **packetp)
504 {
505 struct dc2114x_priv *priv = dev_get_priv(dev);
506 int ret;
507
508 ret = dc21x4x_recv_check(priv);
509
510 if (ret < 0) {
511 /* Update entry information. */
512 priv->rx_new = (priv->rx_new + 1) % priv->rx_ring_size;
513 ret = 0;
514 }
515
516 if (!ret)
517 return 0;
518
519 *packetp = net_rx_packets[priv->rx_new];
520
521 return ret - 4;
522 }
523
dc2114x_free_pkt(struct udevice * dev,uchar * packet,int length)524 static int dc2114x_free_pkt(struct udevice *dev, uchar *packet, int length)
525 {
526 struct dc2114x_priv *priv = dev_get_priv(dev);
527
528 priv->rx_ring[priv->rx_new].status = cpu_to_le32(R_OWN);
529
530 /* Update entry information. */
531 priv->rx_new = (priv->rx_new + 1) % priv->rx_ring_size;
532
533 return 0;
534 }
535
dc2114x_read_rom_hwaddr(struct udevice * dev)536 static int dc2114x_read_rom_hwaddr(struct udevice *dev)
537 {
538 struct dc2114x_priv *priv = dev_get_priv(dev);
539
540 read_hw_addr(priv);
541
542 return 0;
543 }
544
dc2114x_bind(struct udevice * dev)545 static int dc2114x_bind(struct udevice *dev)
546 {
547 static int card_number;
548 char name[16];
549
550 sprintf(name, "dc2114x#%u", card_number++);
551
552 return device_set_name(dev, name);
553 }
554
dc2114x_probe(struct udevice * dev)555 static int dc2114x_probe(struct udevice *dev)
556 {
557 struct eth_pdata *plat = dev_get_plat(dev);
558 struct dc2114x_priv *priv = dev_get_priv(dev);
559 u16 command, status;
560 u32 iobase;
561
562 dm_pci_read_config32(dev, PCI_BASE_ADDRESS_1, &iobase);
563 iobase &= ~0xf;
564
565 debug("dc2114x: DEC 2114x PCI Device @0x%x\n", iobase);
566
567 priv->devno = dev;
568 priv->enetaddr = plat->enetaddr;
569 priv->iobase = (void __iomem *)dm_pci_mem_to_phys(dev, iobase);
570
571 command = PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
572 dm_pci_write_config16(dev, PCI_COMMAND, command);
573 dm_pci_read_config16(dev, PCI_COMMAND, &status);
574 if ((status & command) != command) {
575 printf("dc2114x: Couldn't enable IO access or Bus Mastering\n");
576 return -EINVAL;
577 }
578
579 dm_pci_write_config8(dev, PCI_LATENCY_TIMER, 0x60);
580
581 return 0;
582 }
583
584 static const struct eth_ops dc2114x_ops = {
585 .start = dc2114x_start,
586 .send = dc2114x_send,
587 .recv = dc2114x_recv,
588 .stop = dc2114x_stop,
589 .free_pkt = dc2114x_free_pkt,
590 .read_rom_hwaddr = dc2114x_read_rom_hwaddr,
591 };
592
593 U_BOOT_DRIVER(eth_dc2114x) = {
594 .name = "eth_dc2114x",
595 .id = UCLASS_ETH,
596 .bind = dc2114x_bind,
597 .probe = dc2114x_probe,
598 .ops = &dc2114x_ops,
599 .priv_auto = sizeof(struct dc2114x_priv),
600 .plat_auto = sizeof(struct eth_pdata),
601 };
602
603 U_BOOT_PCI_DEVICE(eth_dc2114x, supported);
604