2 * FCC driver for Motorola MPC82xx (PQ2).
4 * Copyright (c) 2003 Intracom S.A.
5 * by Pantelis Antoniou <panto@intracom.gr>
7 * 2005 (c) MontaVista Software, Inc.
8 * Vitaly Bordug <vbordug@ru.mvista.com>
10 * This file is licensed under the terms of the GNU General Public License
11 * version 2. This program is licensed "as is" without any warranty of any
12 * kind, whether express or implied.
15 #include <linux/module.h>
16 #include <linux/kernel.h>
17 #include <linux/types.h>
18 #include <linux/string.h>
19 #include <linux/ptrace.h>
20 #include <linux/errno.h>
21 #include <linux/ioport.h>
22 #include <linux/interrupt.h>
23 #include <linux/init.h>
24 #include <linux/delay.h>
25 #include <linux/netdevice.h>
26 #include <linux/etherdevice.h>
27 #include <linux/skbuff.h>
28 #include <linux/spinlock.h>
29 #include <linux/mii.h>
30 #include <linux/ethtool.h>
31 #include <linux/bitops.h>
33 #include <linux/platform_device.h>
34 #include <linux/phy.h>
35 #include <linux/of_address.h>
36 #include <linux/of_device.h>
37 #include <linux/of_irq.h>
38 #include <linux/gfp.h>
40 #include <asm/immap_cpm2.h>
41 #include <asm/mpc8260.h>
44 #include <asm/pgtable.h>
46 #include <asm/uaccess.h>
50 /*************************************************/
52 /* FCC access macros */
54 /* write, read, set bits, clear bits */
55 #define W32(_p, _m, _v) out_be32(&(_p)->_m, (_v))
56 #define R32(_p, _m) in_be32(&(_p)->_m)
57 #define S32(_p, _m, _v) W32(_p, _m, R32(_p, _m) | (_v))
58 #define C32(_p, _m, _v) W32(_p, _m, R32(_p, _m) & ~(_v))
60 #define W16(_p, _m, _v) out_be16(&(_p)->_m, (_v))
61 #define R16(_p, _m) in_be16(&(_p)->_m)
62 #define S16(_p, _m, _v) W16(_p, _m, R16(_p, _m) | (_v))
63 #define C16(_p, _m, _v) W16(_p, _m, R16(_p, _m) & ~(_v))
65 #define W8(_p, _m, _v) out_8(&(_p)->_m, (_v))
66 #define R8(_p, _m) in_8(&(_p)->_m)
67 #define S8(_p, _m, _v) W8(_p, _m, R8(_p, _m) | (_v))
68 #define C8(_p, _m, _v) W8(_p, _m, R8(_p, _m) & ~(_v))
70 /*************************************************/
72 #define FCC_MAX_MULTICAST_ADDRS 64
74 #define mk_mii_read(REG) (0x60020000 | ((REG & 0x1f) << 18))
75 #define mk_mii_write(REG, VAL) (0x50020000 | ((REG & 0x1f) << 18) | (VAL & 0xffff))
78 #define MAX_CR_CMD_LOOPS 10000
80 static inline int fcc_cr_cmd(struct fs_enet_private
*fep
, u32 op
)
82 const struct fs_platform_info
*fpi
= fep
->fpi
;
84 return cpm_command(fpi
->cp_command
, op
);
87 static int do_pd_setup(struct fs_enet_private
*fep
)
89 struct platform_device
*ofdev
= to_platform_device(fep
->dev
);
90 struct fs_platform_info
*fpi
= fep
->fpi
;
93 fep
->interrupt
= of_irq_to_resource(ofdev
->dev
.of_node
, 0, NULL
);
94 if (fep
->interrupt
== NO_IRQ
)
97 fep
->fcc
.fccp
= of_iomap(ofdev
->dev
.of_node
, 0);
101 fep
->fcc
.ep
= of_iomap(ofdev
->dev
.of_node
, 1);
105 fep
->fcc
.fcccp
= of_iomap(ofdev
->dev
.of_node
, 2);
109 fep
->fcc
.mem
= (void __iomem
*)cpm2_immr
;
110 fpi
->dpram_offset
= cpm_dpalloc(128, 32);
111 if (IS_ERR_VALUE(fpi
->dpram_offset
)) {
112 ret
= fpi
->dpram_offset
;
119 iounmap(fep
->fcc
.fcccp
);
121 iounmap(fep
->fcc
.ep
);
123 iounmap(fep
->fcc
.fccp
);
128 #define FCC_NAPI_RX_EVENT_MSK (FCC_ENET_RXF | FCC_ENET_RXB)
129 #define FCC_RX_EVENT (FCC_ENET_RXF)
130 #define FCC_TX_EVENT (FCC_ENET_TXB)
131 #define FCC_ERR_EVENT_MSK (FCC_ENET_TXE)
133 static int setup_data(struct net_device
*dev
)
135 struct fs_enet_private
*fep
= netdev_priv(dev
);
137 if (do_pd_setup(fep
) != 0)
140 fep
->ev_napi_rx
= FCC_NAPI_RX_EVENT_MSK
;
141 fep
->ev_rx
= FCC_RX_EVENT
;
142 fep
->ev_tx
= FCC_TX_EVENT
;
143 fep
->ev_err
= FCC_ERR_EVENT_MSK
;
148 static int allocate_bd(struct net_device
*dev
)
150 struct fs_enet_private
*fep
= netdev_priv(dev
);
151 const struct fs_platform_info
*fpi
= fep
->fpi
;
153 fep
->ring_base
= (void __iomem __force
*)dma_alloc_coherent(fep
->dev
,
154 (fpi
->tx_ring
+ fpi
->rx_ring
) *
155 sizeof(cbd_t
), &fep
->ring_mem_addr
,
157 if (fep
->ring_base
== NULL
)
163 static void free_bd(struct net_device
*dev
)
165 struct fs_enet_private
*fep
= netdev_priv(dev
);
166 const struct fs_platform_info
*fpi
= fep
->fpi
;
169 dma_free_coherent(fep
->dev
,
170 (fpi
->tx_ring
+ fpi
->rx_ring
) * sizeof(cbd_t
),
171 (void __force
*)fep
->ring_base
, fep
->ring_mem_addr
);
174 static void cleanup_data(struct net_device
*dev
)
179 static void set_promiscuous_mode(struct net_device
*dev
)
181 struct fs_enet_private
*fep
= netdev_priv(dev
);
182 fcc_t __iomem
*fccp
= fep
->fcc
.fccp
;
184 S32(fccp
, fcc_fpsmr
, FCC_PSMR_PRO
);
187 static void set_multicast_start(struct net_device
*dev
)
189 struct fs_enet_private
*fep
= netdev_priv(dev
);
190 fcc_enet_t __iomem
*ep
= fep
->fcc
.ep
;
192 W32(ep
, fen_gaddrh
, 0);
193 W32(ep
, fen_gaddrl
, 0);
196 static void set_multicast_one(struct net_device
*dev
, const u8
*mac
)
198 struct fs_enet_private
*fep
= netdev_priv(dev
);
199 fcc_enet_t __iomem
*ep
= fep
->fcc
.ep
;
200 u16 taddrh
, taddrm
, taddrl
;
202 taddrh
= ((u16
)mac
[5] << 8) | mac
[4];
203 taddrm
= ((u16
)mac
[3] << 8) | mac
[2];
204 taddrl
= ((u16
)mac
[1] << 8) | mac
[0];
206 W16(ep
, fen_taddrh
, taddrh
);
207 W16(ep
, fen_taddrm
, taddrm
);
208 W16(ep
, fen_taddrl
, taddrl
);
209 fcc_cr_cmd(fep
, CPM_CR_SET_GADDR
);
212 static void set_multicast_finish(struct net_device
*dev
)
214 struct fs_enet_private
*fep
= netdev_priv(dev
);
215 fcc_t __iomem
*fccp
= fep
->fcc
.fccp
;
216 fcc_enet_t __iomem
*ep
= fep
->fcc
.ep
;
218 /* clear promiscuous always */
219 C32(fccp
, fcc_fpsmr
, FCC_PSMR_PRO
);
221 /* if all multi or too many multicasts; just enable all */
222 if ((dev
->flags
& IFF_ALLMULTI
) != 0 ||
223 netdev_mc_count(dev
) > FCC_MAX_MULTICAST_ADDRS
) {
225 W32(ep
, fen_gaddrh
, 0xffffffff);
226 W32(ep
, fen_gaddrl
, 0xffffffff);
230 fep
->fcc
.gaddrh
= R32(ep
, fen_gaddrh
);
231 fep
->fcc
.gaddrl
= R32(ep
, fen_gaddrl
);
234 static void set_multicast_list(struct net_device
*dev
)
236 struct netdev_hw_addr
*ha
;
238 if ((dev
->flags
& IFF_PROMISC
) == 0) {
239 set_multicast_start(dev
);
240 netdev_for_each_mc_addr(ha
, dev
)
241 set_multicast_one(dev
, ha
->addr
);
242 set_multicast_finish(dev
);
244 set_promiscuous_mode(dev
);
247 static void restart(struct net_device
*dev
)
249 struct fs_enet_private
*fep
= netdev_priv(dev
);
250 const struct fs_platform_info
*fpi
= fep
->fpi
;
251 fcc_t __iomem
*fccp
= fep
->fcc
.fccp
;
252 fcc_c_t __iomem
*fcccp
= fep
->fcc
.fcccp
;
253 fcc_enet_t __iomem
*ep
= fep
->fcc
.ep
;
254 dma_addr_t rx_bd_base_phys
, tx_bd_base_phys
;
255 u16 paddrh
, paddrm
, paddrl
;
256 const unsigned char *mac
;
259 C32(fccp
, fcc_gfmr
, FCC_GFMR_ENR
| FCC_GFMR_ENT
);
261 /* clear everything (slow & steady does it) */
262 for (i
= 0; i
< sizeof(*ep
); i
++)
263 out_8((u8 __iomem
*)ep
+ i
, 0);
265 /* get physical address */
266 rx_bd_base_phys
= fep
->ring_mem_addr
;
267 tx_bd_base_phys
= rx_bd_base_phys
+ sizeof(cbd_t
) * fpi
->rx_ring
;
270 W32(ep
, fen_genfcc
.fcc_rbase
, rx_bd_base_phys
);
271 W32(ep
, fen_genfcc
.fcc_tbase
, tx_bd_base_phys
);
273 /* Set maximum bytes per receive buffer.
274 * It must be a multiple of 32.
276 W16(ep
, fen_genfcc
.fcc_mrblr
, PKT_MAXBLR_SIZE
);
278 W32(ep
, fen_genfcc
.fcc_rstate
, (CPMFCR_GBL
| CPMFCR_EB
) << 24);
279 W32(ep
, fen_genfcc
.fcc_tstate
, (CPMFCR_GBL
| CPMFCR_EB
) << 24);
281 /* Allocate space in the reserved FCC area of DPRAM for the
282 * internal buffers. No one uses this space (yet), so we
283 * can do this. Later, we will add resource management for
287 W16(ep
, fen_genfcc
.fcc_riptr
, fpi
->dpram_offset
);
288 W16(ep
, fen_genfcc
.fcc_tiptr
, fpi
->dpram_offset
+ 32);
290 W16(ep
, fen_padptr
, fpi
->dpram_offset
+ 64);
292 /* fill with special symbol... */
293 memset_io(fep
->fcc
.mem
+ fpi
->dpram_offset
+ 64, 0x88, 32);
295 W32(ep
, fen_genfcc
.fcc_rbptr
, 0);
296 W32(ep
, fen_genfcc
.fcc_tbptr
, 0);
297 W32(ep
, fen_genfcc
.fcc_rcrc
, 0);
298 W32(ep
, fen_genfcc
.fcc_tcrc
, 0);
299 W16(ep
, fen_genfcc
.fcc_res1
, 0);
300 W32(ep
, fen_genfcc
.fcc_res2
, 0);
303 W32(ep
, fen_camptr
, 0);
305 /* Set CRC preset and mask */
306 W32(ep
, fen_cmask
, 0xdebb20e3);
307 W32(ep
, fen_cpres
, 0xffffffff);
309 W32(ep
, fen_crcec
, 0); /* CRC Error counter */
310 W32(ep
, fen_alec
, 0); /* alignment error counter */
311 W32(ep
, fen_disfc
, 0); /* discard frame counter */
312 W16(ep
, fen_retlim
, 15); /* Retry limit threshold */
313 W16(ep
, fen_pper
, 0); /* Normal persistence */
315 /* set group address */
316 W32(ep
, fen_gaddrh
, fep
->fcc
.gaddrh
);
317 W32(ep
, fen_gaddrl
, fep
->fcc
.gaddrh
);
319 /* Clear hash filter tables */
320 W32(ep
, fen_iaddrh
, 0);
321 W32(ep
, fen_iaddrl
, 0);
323 /* Clear the Out-of-sequence TxBD */
324 W16(ep
, fen_tfcstat
, 0);
325 W16(ep
, fen_tfclen
, 0);
326 W32(ep
, fen_tfcptr
, 0);
328 W16(ep
, fen_mflr
, PKT_MAXBUF_SIZE
); /* maximum frame length register */
329 W16(ep
, fen_minflr
, PKT_MINBUF_SIZE
); /* minimum frame length register */
333 paddrh
= ((u16
)mac
[5] << 8) | mac
[4];
334 paddrm
= ((u16
)mac
[3] << 8) | mac
[2];
335 paddrl
= ((u16
)mac
[1] << 8) | mac
[0];
337 W16(ep
, fen_paddrh
, paddrh
);
338 W16(ep
, fen_paddrm
, paddrm
);
339 W16(ep
, fen_paddrl
, paddrl
);
341 W16(ep
, fen_taddrh
, 0);
342 W16(ep
, fen_taddrm
, 0);
343 W16(ep
, fen_taddrl
, 0);
345 W16(ep
, fen_maxd1
, 1520); /* maximum DMA1 length */
346 W16(ep
, fen_maxd2
, 1520); /* maximum DMA2 length */
348 /* Clear stat counters, in case we ever enable RMON */
349 W32(ep
, fen_octc
, 0);
350 W32(ep
, fen_colc
, 0);
351 W32(ep
, fen_broc
, 0);
352 W32(ep
, fen_mulc
, 0);
353 W32(ep
, fen_uspc
, 0);
354 W32(ep
, fen_frgc
, 0);
355 W32(ep
, fen_ospc
, 0);
356 W32(ep
, fen_jbrc
, 0);
357 W32(ep
, fen_p64c
, 0);
358 W32(ep
, fen_p65c
, 0);
359 W32(ep
, fen_p128c
, 0);
360 W32(ep
, fen_p256c
, 0);
361 W32(ep
, fen_p512c
, 0);
362 W32(ep
, fen_p1024c
, 0);
364 W16(ep
, fen_rfthr
, 0); /* Suggested by manual */
365 W16(ep
, fen_rfcnt
, 0);
366 W16(ep
, fen_cftype
, 0);
370 /* adjust to speed (for RMII mode) */
372 if (fep
->phydev
->speed
== 100)
373 C8(fcccp
, fcc_gfemr
, 0x20);
375 S8(fcccp
, fcc_gfemr
, 0x20);
378 fcc_cr_cmd(fep
, CPM_CR_INIT_TRX
);
381 W16(fccp
, fcc_fcce
, 0xffff);
383 /* Enable interrupts we wish to service */
384 W16(fccp
, fcc_fccm
, FCC_ENET_TXE
| FCC_ENET_RXF
| FCC_ENET_TXB
);
386 /* Set GFMR to enable Ethernet operating mode */
387 W32(fccp
, fcc_gfmr
, FCC_GFMR_TCI
| FCC_GFMR_MODE_ENET
);
389 /* set sync/delimiters */
390 W16(fccp
, fcc_fdsr
, 0xd555);
392 W32(fccp
, fcc_fpsmr
, FCC_PSMR_ENCRC
);
395 S32(fccp
, fcc_fpsmr
, FCC_PSMR_RMII
);
397 /* adjust to duplex mode */
398 if (fep
->phydev
->duplex
)
399 S32(fccp
, fcc_fpsmr
, FCC_PSMR_FDE
| FCC_PSMR_LPB
);
401 C32(fccp
, fcc_fpsmr
, FCC_PSMR_FDE
| FCC_PSMR_LPB
);
403 /* Restore multicast and promiscuous settings */
404 set_multicast_list(dev
);
406 S32(fccp
, fcc_gfmr
, FCC_GFMR_ENR
| FCC_GFMR_ENT
);
409 static void stop(struct net_device
*dev
)
411 struct fs_enet_private
*fep
= netdev_priv(dev
);
412 fcc_t __iomem
*fccp
= fep
->fcc
.fccp
;
415 C32(fccp
, fcc_gfmr
, FCC_GFMR_ENR
| FCC_GFMR_ENT
);
418 W16(fccp
, fcc_fcce
, 0xffff);
420 /* clear interrupt mask */
421 W16(fccp
, fcc_fccm
, 0);
426 static void napi_clear_rx_event(struct net_device
*dev
)
428 struct fs_enet_private
*fep
= netdev_priv(dev
);
429 fcc_t __iomem
*fccp
= fep
->fcc
.fccp
;
431 W16(fccp
, fcc_fcce
, FCC_NAPI_RX_EVENT_MSK
);
434 static void napi_enable_rx(struct net_device
*dev
)
436 struct fs_enet_private
*fep
= netdev_priv(dev
);
437 fcc_t __iomem
*fccp
= fep
->fcc
.fccp
;
439 S16(fccp
, fcc_fccm
, FCC_NAPI_RX_EVENT_MSK
);
442 static void napi_disable_rx(struct net_device
*dev
)
444 struct fs_enet_private
*fep
= netdev_priv(dev
);
445 fcc_t __iomem
*fccp
= fep
->fcc
.fccp
;
447 C16(fccp
, fcc_fccm
, FCC_NAPI_RX_EVENT_MSK
);
450 static void rx_bd_done(struct net_device
*dev
)
455 static void tx_kickstart(struct net_device
*dev
)
457 struct fs_enet_private
*fep
= netdev_priv(dev
);
458 fcc_t __iomem
*fccp
= fep
->fcc
.fccp
;
460 S16(fccp
, fcc_ftodr
, 0x8000);
463 static u32
get_int_events(struct net_device
*dev
)
465 struct fs_enet_private
*fep
= netdev_priv(dev
);
466 fcc_t __iomem
*fccp
= fep
->fcc
.fccp
;
468 return (u32
)R16(fccp
, fcc_fcce
);
471 static void clear_int_events(struct net_device
*dev
, u32 int_events
)
473 struct fs_enet_private
*fep
= netdev_priv(dev
);
474 fcc_t __iomem
*fccp
= fep
->fcc
.fccp
;
476 W16(fccp
, fcc_fcce
, int_events
& 0xffff);
479 static void ev_error(struct net_device
*dev
, u32 int_events
)
481 struct fs_enet_private
*fep
= netdev_priv(dev
);
483 dev_warn(fep
->dev
, "FS_ENET ERROR(s) 0x%x\n", int_events
);
486 static int get_regs(struct net_device
*dev
, void *p
, int *sizep
)
488 struct fs_enet_private
*fep
= netdev_priv(dev
);
490 if (*sizep
< sizeof(fcc_t
) + sizeof(fcc_enet_t
) + 1)
493 memcpy_fromio(p
, fep
->fcc
.fccp
, sizeof(fcc_t
));
494 p
= (char *)p
+ sizeof(fcc_t
);
496 memcpy_fromio(p
, fep
->fcc
.ep
, sizeof(fcc_enet_t
));
497 p
= (char *)p
+ sizeof(fcc_enet_t
);
499 memcpy_fromio(p
, fep
->fcc
.fcccp
, 1);
503 static int get_regs_len(struct net_device
*dev
)
505 return sizeof(fcc_t
) + sizeof(fcc_enet_t
) + 1;
508 /* Some transmit errors cause the transmitter to shut
509 * down. We now issue a restart transmit.
510 * Also, to workaround 8260 device erratum CPM37, we must
511 * disable and then re-enable the transmitterfollowing a
512 * Late Collision, Underrun, or Retry Limit error.
513 * In addition, tbptr may point beyond BDs beyond still marked
514 * as ready due to internal pipelining, so we need to look back
515 * through the BDs and adjust tbptr to point to the last BD
516 * marked as ready. This may result in some buffers being
519 static void tx_restart(struct net_device
*dev
)
521 struct fs_enet_private
*fep
= netdev_priv(dev
);
522 fcc_t __iomem
*fccp
= fep
->fcc
.fccp
;
523 const struct fs_platform_info
*fpi
= fep
->fpi
;
524 fcc_enet_t __iomem
*ep
= fep
->fcc
.ep
;
525 cbd_t __iomem
*curr_tbptr
;
526 cbd_t __iomem
*recheck_bd
;
527 cbd_t __iomem
*prev_bd
;
528 cbd_t __iomem
*last_tx_bd
;
530 last_tx_bd
= fep
->tx_bd_base
+ (fpi
->tx_ring
* sizeof(cbd_t
));
532 /* get the current bd held in TBPTR and scan back from this point */
533 recheck_bd
= curr_tbptr
= (cbd_t __iomem
*)
534 ((R32(ep
, fen_genfcc
.fcc_tbptr
) - fep
->ring_mem_addr
) +
537 prev_bd
= (recheck_bd
== fep
->tx_bd_base
) ? last_tx_bd
: recheck_bd
- 1;
539 /* Move through the bds in reverse, look for the earliest buffer
540 * that is not ready. Adjust TBPTR to the following buffer */
541 while ((CBDR_SC(prev_bd
) & BD_ENET_TX_READY
) != 0) {
542 /* Go back one buffer */
543 recheck_bd
= prev_bd
;
545 /* update the previous buffer */
546 prev_bd
= (prev_bd
== fep
->tx_bd_base
) ? last_tx_bd
: prev_bd
- 1;
548 /* We should never see all bds marked as ready, check anyway */
549 if (recheck_bd
== curr_tbptr
)
552 /* Now update the TBPTR and dirty flag to the current buffer */
553 W32(ep
, fen_genfcc
.fcc_tbptr
,
554 (uint
) (((void *)recheck_bd
- fep
->ring_base
) +
555 fep
->ring_mem_addr
));
556 fep
->dirty_tx
= recheck_bd
;
558 C32(fccp
, fcc_gfmr
, FCC_GFMR_ENT
);
560 S32(fccp
, fcc_gfmr
, FCC_GFMR_ENT
);
562 fcc_cr_cmd(fep
, CPM_CR_RESTART_TX
);
565 /*************************************************************************/
567 const struct fs_ops fs_fcc_ops
= {
568 .setup_data
= setup_data
,
569 .cleanup_data
= cleanup_data
,
570 .set_multicast_list
= set_multicast_list
,
573 .napi_clear_rx_event
= napi_clear_rx_event
,
574 .napi_enable_rx
= napi_enable_rx
,
575 .napi_disable_rx
= napi_disable_rx
,
576 .rx_bd_done
= rx_bd_done
,
577 .tx_kickstart
= tx_kickstart
,
578 .get_int_events
= get_int_events
,
579 .clear_int_events
= clear_int_events
,
580 .ev_error
= ev_error
,
581 .get_regs
= get_regs
,
582 .get_regs_len
= get_regs_len
,
583 .tx_restart
= tx_restart
,
584 .allocate_bd
= allocate_bd
,