2 * Freescale Ethernet controllers
4 * Copyright (c) 2005 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/slab.h>
23 #include <linux/interrupt.h>
24 #include <linux/init.h>
25 #include <linux/delay.h>
26 #include <linux/netdevice.h>
27 #include <linux/etherdevice.h>
28 #include <linux/skbuff.h>
29 #include <linux/spinlock.h>
30 #include <linux/mii.h>
31 #include <linux/ethtool.h>
32 #include <linux/bitops.h>
34 #include <linux/platform_device.h>
35 #include <linux/of_device.h>
38 #include <asm/uaccess.h>
41 #include <asm/8xx_immap.h>
42 #include <asm/pgtable.h>
43 #include <asm/mpc8xx.h>
50 /*************************************************/
52 #if defined(CONFIG_CPM1)
53 /* for a CPM1 __raw_xxx's are sufficient */
54 #define __fs_out32(addr, x) __raw_writel(x, addr)
55 #define __fs_out16(addr, x) __raw_writew(x, addr)
56 #define __fs_in32(addr) __raw_readl(addr)
57 #define __fs_in16(addr) __raw_readw(addr)
59 /* for others play it safe */
60 #define __fs_out32(addr, x) out_be32(addr, x)
61 #define __fs_out16(addr, x) out_be16(addr, x)
62 #define __fs_in32(addr) in_be32(addr)
63 #define __fs_in16(addr) in_be16(addr)
67 #define FW(_fecp, _reg, _v) __fs_out32(&(_fecp)->fec_ ## _reg, (_v))
70 #define FR(_fecp, _reg) __fs_in32(&(_fecp)->fec_ ## _reg)
73 #define FS(_fecp, _reg, _v) FW(_fecp, _reg, FR(_fecp, _reg) | (_v))
76 #define FC(_fecp, _reg, _v) FW(_fecp, _reg, FR(_fecp, _reg) & ~(_v))
79 * Delay to wait for FEC reset command to complete (in us)
81 #define FEC_RESET_DELAY 50
83 static int whack_reset(fec_t __iomem
*fecp
)
87 FW(fecp
, ecntrl
, FEC_ECNTRL_PINMUX
| FEC_ECNTRL_RESET
);
88 for (i
= 0; i
< FEC_RESET_DELAY
; i
++) {
89 if ((FR(fecp
, ecntrl
) & FEC_ECNTRL_RESET
) == 0)
97 static int do_pd_setup(struct fs_enet_private
*fep
)
99 struct of_device
*ofdev
= to_of_device(fep
->dev
);
101 fep
->interrupt
= of_irq_to_resource(ofdev
->node
, 0, NULL
);
102 if (fep
->interrupt
== NO_IRQ
)
105 fep
->fec
.fecp
= of_iomap(ofdev
->node
, 0);
112 #define FEC_NAPI_RX_EVENT_MSK (FEC_ENET_RXF | FEC_ENET_RXB)
113 #define FEC_RX_EVENT (FEC_ENET_RXF)
114 #define FEC_TX_EVENT (FEC_ENET_TXF)
115 #define FEC_ERR_EVENT_MSK (FEC_ENET_HBERR | FEC_ENET_BABR | \
116 FEC_ENET_BABT | FEC_ENET_EBERR)
118 static int setup_data(struct net_device
*dev
)
120 struct fs_enet_private
*fep
= netdev_priv(dev
);
122 if (do_pd_setup(fep
) != 0)
128 fep
->ev_napi_rx
= FEC_NAPI_RX_EVENT_MSK
;
129 fep
->ev_rx
= FEC_RX_EVENT
;
130 fep
->ev_tx
= FEC_TX_EVENT
;
131 fep
->ev_err
= FEC_ERR_EVENT_MSK
;
136 static int allocate_bd(struct net_device
*dev
)
138 struct fs_enet_private
*fep
= netdev_priv(dev
);
139 const struct fs_platform_info
*fpi
= fep
->fpi
;
141 fep
->ring_base
= (void __force __iomem
*)dma_alloc_coherent(fep
->dev
,
142 (fpi
->tx_ring
+ fpi
->rx_ring
) *
143 sizeof(cbd_t
), &fep
->ring_mem_addr
,
145 if (fep
->ring_base
== NULL
)
151 static void free_bd(struct net_device
*dev
)
153 struct fs_enet_private
*fep
= netdev_priv(dev
);
154 const struct fs_platform_info
*fpi
= fep
->fpi
;
157 dma_free_coherent(fep
->dev
, (fpi
->tx_ring
+ fpi
->rx_ring
)
159 (void __force
*)fep
->ring_base
,
163 static void cleanup_data(struct net_device
*dev
)
168 static void set_promiscuous_mode(struct net_device
*dev
)
170 struct fs_enet_private
*fep
= netdev_priv(dev
);
171 fec_t __iomem
*fecp
= fep
->fec
.fecp
;
173 FS(fecp
, r_cntrl
, FEC_RCNTRL_PROM
);
176 static void set_multicast_start(struct net_device
*dev
)
178 struct fs_enet_private
*fep
= netdev_priv(dev
);
184 static void set_multicast_one(struct net_device
*dev
, const u8
*mac
)
186 struct fs_enet_private
*fep
= netdev_priv(dev
);
187 int temp
, hash_index
, i
, j
;
192 for (i
= 0; i
< 6; i
++) {
194 for (j
= 0; j
< 8; j
++) {
197 if (msb
^ (byte
& 0x1))
203 temp
= (crc
& 0x3f) >> 1;
204 hash_index
= ((temp
& 0x01) << 4) |
205 ((temp
& 0x02) << 2) |
207 ((temp
& 0x08) >> 2) |
208 ((temp
& 0x10) >> 4);
209 csrVal
= 1 << hash_index
;
211 fep
->fec
.hthi
|= csrVal
;
213 fep
->fec
.htlo
|= csrVal
;
216 static void set_multicast_finish(struct net_device
*dev
)
218 struct fs_enet_private
*fep
= netdev_priv(dev
);
219 fec_t __iomem
*fecp
= fep
->fec
.fecp
;
221 /* if all multi or too many multicasts; just enable all */
222 if ((dev
->flags
& IFF_ALLMULTI
) != 0 ||
223 dev
->mc_count
> FEC_MAX_MULTICAST_ADDRS
) {
224 fep
->fec
.hthi
= 0xffffffffU
;
225 fep
->fec
.htlo
= 0xffffffffU
;
228 FC(fecp
, r_cntrl
, FEC_RCNTRL_PROM
);
229 FW(fecp
, hash_table_high
, fep
->fec
.hthi
);
230 FW(fecp
, hash_table_low
, fep
->fec
.htlo
);
233 static void set_multicast_list(struct net_device
*dev
)
235 struct dev_mc_list
*pmc
;
237 if ((dev
->flags
& IFF_PROMISC
) == 0) {
238 set_multicast_start(dev
);
239 for (pmc
= dev
->mc_list
; pmc
!= NULL
; pmc
= pmc
->next
)
240 set_multicast_one(dev
, pmc
->dmi_addr
);
241 set_multicast_finish(dev
);
243 set_promiscuous_mode(dev
);
246 static void restart(struct net_device
*dev
)
249 immap_t
*immap
= fs_enet_immap
;
252 struct fs_enet_private
*fep
= netdev_priv(dev
);
253 fec_t __iomem
*fecp
= fep
->fec
.fecp
;
254 const struct fs_platform_info
*fpi
= fep
->fpi
;
255 dma_addr_t rx_bd_base_phys
, tx_bd_base_phys
;
259 struct mii_bus
* mii
= fep
->phydev
->bus
;
260 struct fec_info
* fec_inf
= mii
->priv
;
262 r
= whack_reset(fep
->fec
.fecp
);
264 printk(KERN_ERR DRV_MODULE_NAME
265 ": %s FEC Reset FAILED!\n", dev
->name
);
267 * Set station address.
269 addrhi
= ((u32
) dev
->dev_addr
[0] << 24) |
270 ((u32
) dev
->dev_addr
[1] << 16) |
271 ((u32
) dev
->dev_addr
[2] << 8) |
272 (u32
) dev
->dev_addr
[3];
273 addrlo
= ((u32
) dev
->dev_addr
[4] << 24) |
274 ((u32
) dev
->dev_addr
[5] << 16);
275 FW(fecp
, addr_low
, addrhi
);
276 FW(fecp
, addr_high
, addrlo
);
279 * Reset all multicast.
281 FW(fecp
, hash_table_high
, fep
->fec
.hthi
);
282 FW(fecp
, hash_table_low
, fep
->fec
.htlo
);
285 * Set maximum receive buffer size.
287 FW(fecp
, r_buff_size
, PKT_MAXBLR_SIZE
);
288 FW(fecp
, r_hash
, PKT_MAXBUF_SIZE
);
290 /* get physical address */
291 rx_bd_base_phys
= fep
->ring_mem_addr
;
292 tx_bd_base_phys
= rx_bd_base_phys
+ sizeof(cbd_t
) * fpi
->rx_ring
;
295 * Set receive and transmit descriptor base.
297 FW(fecp
, r_des_start
, rx_bd_base_phys
);
298 FW(fecp
, x_des_start
, tx_bd_base_phys
);
303 * Enable big endian and don't care about SDMA FC.
305 FW(fecp
, fun_code
, 0x78000000);
310 FW(fecp
, mii_speed
, fec_inf
->mii_speed
);
313 * Clear any outstanding interrupt.
315 FW(fecp
, ievent
, 0xffc0);
316 FW(fecp
, ivec
, (virq_to_hw(fep
->interrupt
) / 2) << 29);
319 * adjust to speed (only for DUET & RMII)
323 cptr
= in_be32(&immap
->im_cpm
.cp_cptr
);
324 switch (fs_get_fec_index(fpi
->fs_no
)) {
327 if (fep
->speed
== 10)
329 else if (fep
->speed
== 100)
334 if (fep
->speed
== 10)
336 else if (fep
->speed
== 100)
340 BUG(); /* should never happen */
343 out_be32(&immap
->im_cpm
.cp_cptr
, cptr
);
348 FW(fecp
, r_cntrl
, FEC_RCNTRL_MII_MODE
); /* MII enable */
350 * adjust to duplex mode
352 if (fep
->phydev
->duplex
) {
353 FC(fecp
, r_cntrl
, FEC_RCNTRL_DRT
);
354 FS(fecp
, x_cntrl
, FEC_TCNTRL_FDEN
); /* FD enable */
356 FS(fecp
, r_cntrl
, FEC_RCNTRL_DRT
);
357 FC(fecp
, x_cntrl
, FEC_TCNTRL_FDEN
); /* FD disable */
361 * Enable interrupts we wish to service.
363 FW(fecp
, imask
, FEC_ENET_TXF
| FEC_ENET_TXB
|
364 FEC_ENET_RXF
| FEC_ENET_RXB
);
367 * And last, enable the transmit and receive processing.
369 FW(fecp
, ecntrl
, FEC_ECNTRL_PINMUX
| FEC_ECNTRL_ETHER_EN
);
370 FW(fecp
, r_des_active
, 0x01000000);
373 static void stop(struct net_device
*dev
)
375 struct fs_enet_private
*fep
= netdev_priv(dev
);
376 const struct fs_platform_info
*fpi
= fep
->fpi
;
377 fec_t __iomem
*fecp
= fep
->fec
.fecp
;
379 struct fec_info
* feci
= fep
->phydev
->bus
->priv
;
383 if ((FR(fecp
, ecntrl
) & FEC_ECNTRL_ETHER_EN
) == 0)
384 return; /* already down */
386 FW(fecp
, x_cntrl
, 0x01); /* Graceful transmit stop */
387 for (i
= 0; ((FR(fecp
, ievent
) & 0x10000000) == 0) &&
388 i
< FEC_RESET_DELAY
; i
++)
391 if (i
== FEC_RESET_DELAY
)
392 printk(KERN_WARNING DRV_MODULE_NAME
393 ": %s FEC timeout on graceful transmit stop\n",
396 * Disable FEC. Let only MII interrupts.
399 FC(fecp
, ecntrl
, FEC_ECNTRL_ETHER_EN
);
403 /* shut down FEC1? that's where the mii bus is */
405 FS(fecp
, r_cntrl
, FEC_RCNTRL_MII_MODE
); /* MII enable */
406 FS(fecp
, ecntrl
, FEC_ECNTRL_PINMUX
| FEC_ECNTRL_ETHER_EN
);
407 FW(fecp
, ievent
, FEC_ENET_MII
);
408 FW(fecp
, mii_speed
, feci
->mii_speed
);
412 static void napi_clear_rx_event(struct net_device
*dev
)
414 struct fs_enet_private
*fep
= netdev_priv(dev
);
415 fec_t __iomem
*fecp
= fep
->fec
.fecp
;
417 FW(fecp
, ievent
, FEC_NAPI_RX_EVENT_MSK
);
420 static void napi_enable_rx(struct net_device
*dev
)
422 struct fs_enet_private
*fep
= netdev_priv(dev
);
423 fec_t __iomem
*fecp
= fep
->fec
.fecp
;
425 FS(fecp
, imask
, FEC_NAPI_RX_EVENT_MSK
);
428 static void napi_disable_rx(struct net_device
*dev
)
430 struct fs_enet_private
*fep
= netdev_priv(dev
);
431 fec_t __iomem
*fecp
= fep
->fec
.fecp
;
433 FC(fecp
, imask
, FEC_NAPI_RX_EVENT_MSK
);
436 static void rx_bd_done(struct net_device
*dev
)
438 struct fs_enet_private
*fep
= netdev_priv(dev
);
439 fec_t __iomem
*fecp
= fep
->fec
.fecp
;
441 FW(fecp
, r_des_active
, 0x01000000);
444 static void tx_kickstart(struct net_device
*dev
)
446 struct fs_enet_private
*fep
= netdev_priv(dev
);
447 fec_t __iomem
*fecp
= fep
->fec
.fecp
;
449 FW(fecp
, x_des_active
, 0x01000000);
452 static u32
get_int_events(struct net_device
*dev
)
454 struct fs_enet_private
*fep
= netdev_priv(dev
);
455 fec_t __iomem
*fecp
= fep
->fec
.fecp
;
457 return FR(fecp
, ievent
) & FR(fecp
, imask
);
460 static void clear_int_events(struct net_device
*dev
, u32 int_events
)
462 struct fs_enet_private
*fep
= netdev_priv(dev
);
463 fec_t __iomem
*fecp
= fep
->fec
.fecp
;
465 FW(fecp
, ievent
, int_events
);
468 static void ev_error(struct net_device
*dev
, u32 int_events
)
470 printk(KERN_WARNING DRV_MODULE_NAME
471 ": %s FEC ERROR(s) 0x%x\n", dev
->name
, int_events
);
474 static int get_regs(struct net_device
*dev
, void *p
, int *sizep
)
476 struct fs_enet_private
*fep
= netdev_priv(dev
);
478 if (*sizep
< sizeof(fec_t
))
481 memcpy_fromio(p
, fep
->fec
.fecp
, sizeof(fec_t
));
486 static int get_regs_len(struct net_device
*dev
)
488 return sizeof(fec_t
);
491 static void tx_restart(struct net_device
*dev
)
496 /*************************************************************************/
498 const struct fs_ops fs_fec_ops
= {
499 .setup_data
= setup_data
,
500 .cleanup_data
= cleanup_data
,
501 .set_multicast_list
= set_multicast_list
,
504 .napi_clear_rx_event
= napi_clear_rx_event
,
505 .napi_enable_rx
= napi_enable_rx
,
506 .napi_disable_rx
= napi_disable_rx
,
507 .rx_bd_done
= rx_bd_done
,
508 .tx_kickstart
= tx_kickstart
,
509 .get_int_events
= get_int_events
,
510 .clear_int_events
= clear_int_events
,
511 .ev_error
= ev_error
,
512 .get_regs
= get_regs
,
513 .get_regs_len
= get_regs_len
,
514 .tx_restart
= tx_restart
,
515 .allocate_bd
= allocate_bd
,