1
2
3
4
5
6
7#include <log.h>
8#include <asm/io.h>
9#include <common.h>
10#include <command.h>
11#include <malloc.h>
12#include <net.h>
13#include <miiphy.h>
14#include <linux/delay.h>
15
16#include "ks8851_mll.h"
17
18#define DRIVERNAME "ks8851_mll"
19
20#define RX_BUF_SIZE 2000
21
22
23
24
25
26
27
28
29
30struct ks_net {
31#ifndef CONFIG_DM_ETH
32 struct eth_device dev;
33#endif
34 phys_addr_t iobase;
35 int bus_width;
36 u16 sharedbus;
37 u16 rxfc;
38 u8 extra_byte;
39};
40
41#define BE3 0x8000
42#define BE2 0x4000
43#define BE1 0x2000
44#define BE0 0x1000
45
46static u8 ks_rdreg8(struct ks_net *ks, u16 offset)
47{
48 u8 shift_bit = offset & 0x03;
49 u8 shift_data = (offset & 1) << 3;
50
51 writew(offset | (BE0 << shift_bit), ks->iobase + 2);
52
53 return (u8)(readw(ks->iobase) >> shift_data);
54}
55
56static u16 ks_rdreg16(struct ks_net *ks, u16 offset)
57{
58 writew(offset | ((BE1 | BE0) << (offset & 0x02)), ks->iobase + 2);
59
60 return readw(ks->iobase);
61}
62
63static void ks_wrreg16(struct ks_net *ks, u16 offset, u16 val)
64{
65 writew(offset | ((BE1 | BE0) << (offset & 0x02)), ks->iobase + 2);
66 writew(val, ks->iobase);
67}
68
69
70
71
72
73
74
75
76static inline void ks_inblk(struct ks_net *ks, u16 *wptr, u32 len)
77{
78 len >>= 1;
79
80 while (len--)
81 *wptr++ = readw(ks->iobase);
82}
83
84
85
86
87
88
89
90static inline void ks_outblk(struct ks_net *ks, u16 *wptr, u32 len)
91{
92 len >>= 1;
93
94 while (len--)
95 writew(*wptr++, ks->iobase);
96}
97
98static void ks_enable_int(struct ks_net *ks)
99{
100 ks_wrreg16(ks, KS_IER, IRQ_LCI | IRQ_TXI | IRQ_RXI);
101}
102
103static void ks_set_powermode(struct ks_net *ks, unsigned int pwrmode)
104{
105 unsigned int pmecr;
106
107 ks_rdreg16(ks, KS_GRR);
108 pmecr = ks_rdreg16(ks, KS_PMECR);
109 pmecr &= ~PMECR_PM_MASK;
110 pmecr |= pwrmode;
111
112 ks_wrreg16(ks, KS_PMECR, pmecr);
113}
114
115
116
117
118
119static void ks_read_config(struct ks_net *ks)
120{
121 u16 reg_data = 0;
122
123
124 reg_data = ks_rdreg8(ks, KS_CCR) & 0x00FF;
125 reg_data |= ks_rdreg8(ks, KS_CCR + 1) << 8;
126
127
128 ks->sharedbus = (reg_data & CCR_SHARED) == CCR_SHARED;
129
130
131
132
133
134 if (reg_data & CCR_8BIT) {
135 ks->bus_width = ENUM_BUS_8BIT;
136 ks->extra_byte = 1;
137 } else if (reg_data & CCR_16BIT) {
138 ks->bus_width = ENUM_BUS_16BIT;
139 ks->extra_byte = 2;
140 } else {
141 ks->bus_width = ENUM_BUS_32BIT;
142 ks->extra_byte = 4;
143 }
144}
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159static void ks_soft_reset(struct ks_net *ks, unsigned int op)
160{
161
162 ks_wrreg16(ks, KS_IER, 0x0000);
163 ks_wrreg16(ks, KS_GRR, op);
164 mdelay(10);
165 ks_wrreg16(ks, KS_GRR, 0);
166 mdelay(1);
167}
168
169void ks_enable_qmu(struct ks_net *ks)
170{
171 u16 w;
172
173 w = ks_rdreg16(ks, KS_TXCR);
174
175
176 ks_wrreg16(ks, KS_TXCR, w | TXCR_TXE);
177
178
179 w = ks_rdreg16(ks, KS_RXQCR);
180 ks_wrreg16(ks, KS_RXQCR, w | RXQCR_RXFCTE);
181
182
183 w = ks_rdreg16(ks, KS_RXCR1);
184 ks_wrreg16(ks, KS_RXCR1, w | RXCR1_RXE);
185}
186
187static void ks_disable_qmu(struct ks_net *ks)
188{
189 u16 w;
190
191 w = ks_rdreg16(ks, KS_TXCR);
192
193
194 w &= ~TXCR_TXE;
195 ks_wrreg16(ks, KS_TXCR, w);
196
197
198 w = ks_rdreg16(ks, KS_RXCR1);
199 w &= ~RXCR1_RXE;
200 ks_wrreg16(ks, KS_RXCR1, w);
201}
202
203static inline void ks_read_qmu(struct ks_net *ks, u16 *buf, u32 len)
204{
205 u32 r = ks->extra_byte & 0x1;
206 u32 w = ks->extra_byte - r;
207
208
209 ks_wrreg16(ks, KS_RXFDPR, RXFDPR_RXFPAI);
210 ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL | RXQCR_SDA);
211
212
213
214
215
216
217
218
219 if (r)
220 ks_rdreg8(ks, 0);
221
222 ks_inblk(ks, buf, w + 2 + 2);
223
224
225 ks_inblk(ks, buf, ALIGN(len, 4));
226
227
228 ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL);
229}
230
231static int ks_rcv(struct ks_net *ks, uchar *data)
232{
233 u16 sts, len;
234
235 if (!ks->rxfc)
236 ks->rxfc = ks_rdreg16(ks, KS_RXFCTR) >> 8;
237
238 if (!ks->rxfc)
239 return 0;
240
241
242 sts = ks_rdreg16(ks, KS_RXFHSR);
243
244 len = ks_rdreg16(ks, KS_RXFHBCR);
245
246 if ((sts & RXFSHR_RXFV) && len && (len < RX_BUF_SIZE)) {
247
248 ks_read_qmu(ks, (u16 *)data, len);
249 ks->rxfc--;
250 return len - 4;
251 }
252
253 ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL | RXQCR_RRXEF);
254 printf(DRIVERNAME ": bad packet (sts=0x%04x len=0x%04x)\n", sts, len);
255 ks->rxfc = 0;
256 return 0;
257}
258
259
260
261
262
263
264
265static int ks_read_selftest(struct ks_net *ks)
266{
267 u16 both_done = MBIR_TXMBF | MBIR_RXMBF;
268 u16 mbir;
269 int ret = 0;
270
271 mbir = ks_rdreg16(ks, KS_MBIR);
272
273 if ((mbir & both_done) != both_done) {
274 printf(DRIVERNAME ": Memory selftest not finished\n");
275 return 0;
276 }
277
278 if (mbir & MBIR_TXMBFA) {
279 printf(DRIVERNAME ": TX memory selftest fails\n");
280 ret |= 1;
281 }
282
283 if (mbir & MBIR_RXMBFA) {
284 printf(DRIVERNAME ": RX memory selftest fails\n");
285 ret |= 2;
286 }
287
288 debug(DRIVERNAME ": the selftest passes\n");
289
290 return ret;
291}
292
293static void ks_setup(struct ks_net *ks)
294{
295 u16 w;
296
297
298 ks_wrreg16(ks, KS_TXFDPR, TXFDPR_TXFPAI);
299
300
301 ks_wrreg16(ks, KS_RXFDPR, RXFDPR_RXFPAI);
302
303
304 ks_wrreg16(ks, KS_RXFCTR, 1 & RXFCTR_THRESHOLD_MASK);
305
306
307 ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL);
308
309
310
311
312
313
314 w = ks_rdreg16(ks, KS_P1MBCR);
315 w &= ~P1MBCR_FORCE_FDX;
316 ks_wrreg16(ks, KS_P1MBCR, w);
317
318 w = TXCR_TXFCE | TXCR_TXPE | TXCR_TXCRC | TXCR_TCGIP;
319 ks_wrreg16(ks, KS_TXCR, w);
320
321 w = RXCR1_RXFCE | RXCR1_RXBE | RXCR1_RXUE | RXCR1_RXME | RXCR1_RXIPFCC;
322
323
324 w |= RXCR1_RXPAFMA;
325
326 ks_wrreg16(ks, KS_RXCR1, w);
327}
328
329static void ks_setup_int(struct ks_net *ks)
330{
331
332 ks_wrreg16(ks, KS_ISR, 0xffff);
333}
334
335static int ks8851_mll_detect_chip(struct ks_net *ks)
336{
337 unsigned short val;
338
339 ks_read_config(ks);
340
341 val = ks_rdreg16(ks, KS_CIDER);
342
343 if (val == 0xffff) {
344
345 printf(DRIVERNAME ": is chip mounted ?\n");
346 return -1;
347 } else if ((val & 0xfff0) != CIDER_ID) {
348 printf(DRIVERNAME ": Invalid chip id 0x%04x\n", val);
349 return -1;
350 }
351
352 debug("Read back KS8851 id 0x%x\n", val);
353
354 if ((val & 0xfff0) != CIDER_ID) {
355 printf(DRIVERNAME ": Unknown chip ID %04x\n", val);
356 return -1;
357 }
358
359 return 0;
360}
361
362static void ks8851_mll_reset(struct ks_net *ks)
363{
364
365 ks_set_powermode(ks, PMECR_PM_NORMAL);
366 mdelay(1);
367
368
369 ks_soft_reset(ks, GRR_GSR);
370
371
372 ks_wrreg16(ks, KS_IER, 0x0000);
373 ks_wrreg16(ks, KS_ISR, 0xffff);
374
375
376 ks_disable_qmu(ks);
377}
378
379static void ks8851_mll_phy_configure(struct ks_net *ks)
380{
381 u16 data;
382
383 ks_setup(ks);
384 ks_setup_int(ks);
385
386
387 data = ks_rdreg16(ks, KS_OBCR);
388 ks_wrreg16(ks, KS_OBCR, data | OBCR_ODS_16MA);
389
390 debug(DRIVERNAME ": phy initialized\n");
391}
392
393static void ks8851_mll_enable(struct ks_net *ks)
394{
395 ks_wrreg16(ks, KS_ISR, 0xffff);
396 ks_enable_int(ks);
397 ks_enable_qmu(ks);
398}
399
400static int ks8851_mll_init_common(struct ks_net *ks)
401{
402 if (ks_read_selftest(ks)) {
403 printf(DRIVERNAME ": Selftest failed\n");
404 return -1;
405 }
406
407 ks8851_mll_reset(ks);
408
409
410 ks8851_mll_phy_configure(ks);
411
412 ks->rxfc = 0;
413
414
415 ks8851_mll_enable(ks);
416
417 return 0;
418}
419
420static void ks_write_qmu(struct ks_net *ks, u8 *pdata, u16 len)
421{
422 __le16 txw[2];
423
424 txw[0] = 0;
425 txw[1] = cpu_to_le16(len);
426
427
428 ks_wrreg16(ks, KS_TXFDPR, TXFDPR_TXFPAI);
429 ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL | RXQCR_SDA);
430
431 ks_outblk(ks, txw, 4);
432
433 ks_outblk(ks, (u16 *)pdata, ALIGN(len, 4));
434
435 ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL);
436
437 ks_wrreg16(ks, KS_TXQCR, TXQCR_METFE);
438
439 do { } while (ks_rdreg16(ks, KS_TXQCR) & TXQCR_METFE);
440}
441
442static int ks8851_mll_send_common(struct ks_net *ks, void *packet, int length)
443{
444 u8 *data = (u8 *)packet;
445 u16 tmplen = (u16)length;
446 u16 retv;
447
448
449
450
451
452 retv = ks_rdreg16(ks, KS_TXMIR) & 0x1fff;
453 if (retv >= tmplen + 12) {
454 ks_write_qmu(ks, data, tmplen);
455 return 0;
456 }
457
458 printf(DRIVERNAME ": failed to send packet: No buffer\n");
459 return -1;
460}
461
462static void ks8851_mll_halt_common(struct ks_net *ks)
463{
464 ks8851_mll_reset(ks);
465}
466
467
468
469
470
471
472
473static int ks8851_mll_recv_common(struct ks_net *ks, uchar *data)
474{
475 u16 status;
476 int ret = 0;
477
478 status = ks_rdreg16(ks, KS_ISR);
479
480 ks_wrreg16(ks, KS_ISR, status);
481
482 if (ks->rxfc || (status & IRQ_RXI))
483 ret = ks_rcv(ks, data);
484
485 if (status & IRQ_LDI) {
486 u16 pmecr = ks_rdreg16(ks, KS_PMECR);
487
488 pmecr &= ~PMECR_WKEVT_MASK;
489 ks_wrreg16(ks, KS_PMECR, pmecr | PMECR_WKEVT_LINK);
490 }
491
492 return ret;
493}
494
495static void ks8851_mll_write_hwaddr_common(struct ks_net *ks, u8 enetaddr[6])
496{
497 u16 addrl, addrm, addrh;
498
499 addrh = (enetaddr[0] << 8) | enetaddr[1];
500 addrm = (enetaddr[2] << 8) | enetaddr[3];
501 addrl = (enetaddr[4] << 8) | enetaddr[5];
502
503 ks_wrreg16(ks, KS_MARH, addrh);
504 ks_wrreg16(ks, KS_MARM, addrm);
505 ks_wrreg16(ks, KS_MARL, addrl);
506}
507
508#ifndef CONFIG_DM_ETH
509static int ks8851_mll_init(struct eth_device *dev, struct bd_info *bd)
510{
511 struct ks_net *ks = container_of(dev, struct ks_net, dev);
512
513 return ks8851_mll_init_common(ks);
514}
515
516static void ks8851_mll_halt(struct eth_device *dev)
517{
518 struct ks_net *ks = container_of(dev, struct ks_net, dev);
519
520 ks8851_mll_halt_common(ks);
521}
522
523static int ks8851_mll_send(struct eth_device *dev, void *packet, int length)
524{
525 struct ks_net *ks = container_of(dev, struct ks_net, dev);
526
527 return ks8851_mll_send_common(ks, packet, length);
528}
529
530static int ks8851_mll_recv(struct eth_device *dev)
531{
532 struct ks_net *ks = container_of(dev, struct ks_net, dev);
533 int ret;
534
535 ret = ks8851_mll_recv_common(ks, net_rx_packets[0]);
536 if (ret)
537 net_process_received_packet(net_rx_packets[0], ret);
538
539 return ret;
540}
541
542static int ks8851_mll_write_hwaddr(struct eth_device *dev)
543{
544 struct ks_net *ks = container_of(dev, struct ks_net, dev);
545
546 ks8851_mll_write_hwaddr_common(ks, ks->dev.enetaddr);
547
548 return 0;
549}
550
551int ks8851_mll_initialize(u8 dev_num, int base_addr)
552{
553 struct ks_net *ks;
554
555 ks = calloc(1, sizeof(*ks));
556 if (!ks)
557 return -ENOMEM;
558
559 ks->iobase = base_addr;
560
561
562 if (ks8851_mll_detect_chip(ks)) {
563 free(ks);
564 return -1;
565 }
566
567 ks->dev.init = ks8851_mll_init;
568 ks->dev.halt = ks8851_mll_halt;
569 ks->dev.send = ks8851_mll_send;
570 ks->dev.recv = ks8851_mll_recv;
571 ks->dev.write_hwaddr = ks8851_mll_write_hwaddr;
572 sprintf(ks->dev.name, "%s-%hu", DRIVERNAME, dev_num);
573
574 eth_register(&ks->dev);
575
576 return 0;
577}
578#else
579static int ks8851_start(struct udevice *dev)
580{
581 struct ks_net *ks = dev_get_priv(dev);
582
583 return ks8851_mll_init_common(ks);
584}
585
586static void ks8851_stop(struct udevice *dev)
587{
588 struct ks_net *ks = dev_get_priv(dev);
589
590 ks8851_mll_halt_common(ks);
591}
592
593static int ks8851_send(struct udevice *dev, void *packet, int length)
594{
595 struct ks_net *ks = dev_get_priv(dev);
596 int ret;
597
598 ret = ks8851_mll_send_common(ks, packet, length);
599
600 return ret ? 0 : -ETIMEDOUT;
601}
602
603static int ks8851_recv(struct udevice *dev, int flags, uchar **packetp)
604{
605 struct ks_net *ks = dev_get_priv(dev);
606 uchar *data = net_rx_packets[0];
607 int ret;
608
609 ret = ks8851_mll_recv_common(ks, data);
610 if (ret)
611 *packetp = (void *)data;
612
613 return ret ? ret : -EAGAIN;
614}
615
616static int ks8851_write_hwaddr(struct udevice *dev)
617{
618 struct ks_net *ks = dev_get_priv(dev);
619 struct eth_pdata *pdata = dev_get_plat(dev);
620
621 ks8851_mll_write_hwaddr_common(ks, pdata->enetaddr);
622
623 return 0;
624}
625
626static int ks8851_read_rom_hwaddr(struct udevice *dev)
627{
628 struct ks_net *ks = dev_get_priv(dev);
629 struct eth_pdata *pdata = dev_get_plat(dev);
630 u16 addrl, addrm, addrh;
631
632
633 if (!(ks_rdreg16(ks, KS_CCR) & CCR_EEPROM))
634 return -EINVAL;
635
636
637
638
639
640 addrl = ks_rdreg16(ks, KS_MARL);
641 addrm = ks_rdreg16(ks, KS_MARM);
642 addrh = ks_rdreg16(ks, KS_MARH);
643
644 pdata->enetaddr[0] = (addrh >> 8) & 0xff;
645 pdata->enetaddr[1] = addrh & 0xff;
646 pdata->enetaddr[2] = (addrm >> 8) & 0xff;
647 pdata->enetaddr[3] = addrm & 0xff;
648 pdata->enetaddr[4] = (addrl >> 8) & 0xff;
649 pdata->enetaddr[5] = addrl & 0xff;
650
651 return !is_valid_ethaddr(pdata->enetaddr);
652}
653
654static int ks8851_bind(struct udevice *dev)
655{
656 return device_set_name(dev, dev->name);
657}
658
659static int ks8851_probe(struct udevice *dev)
660{
661 struct ks_net *ks = dev_get_priv(dev);
662
663
664 ks8851_mll_detect_chip(ks);
665
666 return 0;
667}
668
669static int ks8851_of_to_plat(struct udevice *dev)
670{
671 struct ks_net *ks = dev_get_priv(dev);
672 struct eth_pdata *pdata = dev_get_plat(dev);
673
674 pdata->iobase = dev_read_addr(dev);
675 ks->iobase = pdata->iobase;
676
677 return 0;
678}
679
680static const struct eth_ops ks8851_ops = {
681 .start = ks8851_start,
682 .stop = ks8851_stop,
683 .send = ks8851_send,
684 .recv = ks8851_recv,
685 .write_hwaddr = ks8851_write_hwaddr,
686 .read_rom_hwaddr = ks8851_read_rom_hwaddr,
687};
688
689static const struct udevice_id ks8851_ids[] = {
690 { .compatible = "micrel,ks8851-mll" },
691 { }
692};
693
694U_BOOT_DRIVER(ks8851) = {
695 .name = "eth_ks8851",
696 .id = UCLASS_ETH,
697 .of_match = ks8851_ids,
698 .bind = ks8851_bind,
699 .of_to_plat = ks8851_of_to_plat,
700 .probe = ks8851_probe,
701 .ops = &ks8851_ops,
702 .priv_auto = sizeof(struct ks_net),
703 .plat_auto = sizeof(struct eth_pdata),
704 .flags = DM_FLAG_ALLOC_PRIV_DMA,
705};
706#endif
707