2 * Combined Ethernet driver for Motorola MPC8xx and MPC82xx.
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.
16 #include <linux/module.h>
17 #include <linux/types.h>
18 #include <linux/kernel.h>
19 #include <linux/string.h>
20 #include <linux/ptrace.h>
21 #include <linux/errno.h>
22 #include <linux/ioport.h>
23 #include <linux/slab.h>
24 #include <linux/interrupt.h>
25 #include <linux/init.h>
26 #include <linux/delay.h>
27 #include <linux/netdevice.h>
28 #include <linux/etherdevice.h>
29 #include <linux/skbuff.h>
30 #include <linux/spinlock.h>
31 #include <linux/mii.h>
32 #include <linux/ethtool.h>
33 #include <linux/bitops.h>
34 #include <linux/platform_device.h>
36 #include <asm/pgtable.h>
38 #include <asm/uaccess.h>
42 static int bitbang_prep_bit(u8
**datp
, u8
*mskp
,
43 struct fs_mii_bit
*mii_bit
)
49 dat
= (void*) mii_bit
->offset
;
51 adv
= mii_bit
->bit
>> 3;
52 dat
= (char *)dat
+ adv
;
54 msk
= 1 << (7 - (mii_bit
->bit
& 7));
62 static inline void bb_set(u8
*p
, u8 m
)
64 out_8(p
, in_8(p
) | m
);
67 static inline void bb_clr(u8
*p
, u8 m
)
69 out_8(p
, in_8(p
) & ~m
);
72 static inline int bb_read(u8
*p
, u8 m
)
74 return (in_8(p
) & m
) != 0;
77 static inline void mdio_active(struct bb_info
*bitbang
)
79 bb_set(bitbang
->mdio_dir
, bitbang
->mdio_dir_msk
);
82 static inline void mdio_tristate(struct bb_info
*bitbang
)
84 bb_clr(bitbang
->mdio_dir
, bitbang
->mdio_dir_msk
);
87 static inline int mdio_read(struct bb_info
*bitbang
)
89 return bb_read(bitbang
->mdio_dat
, bitbang
->mdio_dat_msk
);
92 static inline void mdio(struct bb_info
*bitbang
, int what
)
95 bb_set(bitbang
->mdio_dat
, bitbang
->mdio_dat_msk
);
97 bb_clr(bitbang
->mdio_dat
, bitbang
->mdio_dat_msk
);
100 static inline void mdc(struct bb_info
*bitbang
, int what
)
103 bb_set(bitbang
->mdc_dat
, bitbang
->mdc_msk
);
105 bb_clr(bitbang
->mdc_dat
, bitbang
->mdc_msk
);
108 static inline void mii_delay(struct bb_info
*bitbang
)
110 udelay(bitbang
->delay
);
113 /* Utility to send the preamble, address, and register (common to read and write). */
114 static void bitbang_pre(struct bb_info
*bitbang
, int read
, u8 addr
, u8 reg
)
119 * Send a 32 bit preamble ('1's) with an extra '1' bit for good measure.
120 * The IEEE spec says this is a PHY optional requirement. The AMD
121 * 79C874 requires one after power up and one after a MII communications
122 * error. This means that we are doing more preambles than we need,
123 * but it is safer and will be much more robust.
126 mdio_active(bitbang
);
128 for (j
= 0; j
< 32; j
++) {
135 /* send the start bit (01) and the read opcode (10) or write (10) */
152 mdio(bitbang
, !read
);
157 /* send the PHY address */
158 for (j
= 0; j
< 5; j
++) {
160 mdio(bitbang
, (addr
& 0x10) != 0);
167 /* send the register address */
168 for (j
= 0; j
< 5; j
++) {
170 mdio(bitbang
, (reg
& 0x10) != 0);
178 static int fs_enet_mii_bb_read(struct mii_bus
*bus
, int phy_id
, int location
)
182 u8 addr
= phy_id
& 0xff;
183 u8 reg
= location
& 0xff;
184 struct bb_info
* bitbang
= bus
->priv
;
186 bitbang_pre(bitbang
, 1, addr
, reg
);
188 /* tri-state our MDIO I/O pin so we can read */
190 mdio_tristate(bitbang
);
195 /* check the turnaround bit: the PHY should be driving it to zero */
196 if (mdio_read(bitbang
) != 0) {
197 /* PHY didn't drive TA low */
198 for (j
= 0; j
< 32; j
++) {
211 /* read 16 bits of register data, MSB first */
213 for (j
= 0; j
< 16; j
++) {
217 rdreg
|= mdio_read(bitbang
);
234 static int fs_enet_mii_bb_write(struct mii_bus
*bus
, int phy_id
, int location
, u16 val
)
237 struct bb_info
* bitbang
= bus
->priv
;
239 u8 addr
= phy_id
& 0xff;
240 u8 reg
= location
& 0xff;
241 u16 value
= val
& 0xffff;
243 bitbang_pre(bitbang
, 0, addr
, reg
);
245 /* send the turnaround (10) */
257 /* write 16 bits of register data, MSB first */
258 for (j
= 0; j
< 16; j
++) {
260 mdio(bitbang
, (value
& 0x8000) != 0);
268 * Tri-state the MDIO line.
270 mdio_tristate(bitbang
);
278 static int fs_enet_mii_bb_reset(struct mii_bus
*bus
)
280 /*nothing here - dunno how to reset it*/
284 static int fs_mii_bitbang_init(struct bb_info
*bitbang
, struct fs_mii_bb_platform_info
* fmpi
)
288 bitbang
->delay
= fmpi
->delay
;
290 r
= bitbang_prep_bit(&bitbang
->mdio_dir
,
291 &bitbang
->mdio_dir_msk
,
296 r
= bitbang_prep_bit(&bitbang
->mdio_dat
,
297 &bitbang
->mdio_dat_msk
,
302 r
= bitbang_prep_bit(&bitbang
->mdc_dat
,
312 static int __devinit
fs_enet_mdio_probe(struct device
*dev
)
314 struct platform_device
*pdev
= to_platform_device(dev
);
315 struct fs_mii_bb_platform_info
*pdata
;
316 struct mii_bus
*new_bus
;
317 struct bb_info
*bitbang
;
323 new_bus
= kzalloc(sizeof(struct mii_bus
), GFP_KERNEL
);
328 bitbang
= kzalloc(sizeof(struct bb_info
), GFP_KERNEL
);
333 new_bus
->name
= "BB MII Bus",
334 new_bus
->read
= &fs_enet_mii_bb_read
,
335 new_bus
->write
= &fs_enet_mii_bb_write
,
336 new_bus
->reset
= &fs_enet_mii_bb_reset
,
337 new_bus
->id
= pdev
->id
;
339 new_bus
->phy_mask
= ~0x9;
340 pdata
= (struct fs_mii_bb_platform_info
*)pdev
->dev
.platform_data
;
343 printk(KERN_ERR
"gfar mdio %d: Missing platform data!\n", pdev
->id
);
348 fs_mii_bitbang_init(bitbang
, pdata
);
350 new_bus
->priv
= bitbang
;
352 new_bus
->irq
= pdata
->irq
;
355 dev_set_drvdata(dev
, new_bus
);
357 err
= mdiobus_register(new_bus
);
360 printk (KERN_ERR
"%s: Cannot register as MDIO bus\n",
362 goto bus_register_fail
;
375 static int fs_enet_mdio_remove(struct device
*dev
)
377 struct mii_bus
*bus
= dev_get_drvdata(dev
);
379 mdiobus_unregister(bus
);
381 dev_set_drvdata(dev
, NULL
);
383 iounmap((void *) (&bus
->priv
));
390 static struct device_driver fs_enet_bb_mdio_driver
= {
391 .name
= "fsl-bb-mdio",
392 .bus
= &platform_bus_type
,
393 .probe
= fs_enet_mdio_probe
,
394 .remove
= fs_enet_mdio_remove
,
397 int fs_enet_mdio_bb_init(void)
399 return driver_register(&fs_enet_bb_mdio_driver
);
402 void fs_enet_mdio_bb_exit(void)
404 driver_unregister(&fs_enet_bb_mdio_driver
);