Pull error-inject into release branch
[linux-2.6] / drivers / net / fs_enet / mii-bitbang.c
1 /*
2  * Combined Ethernet driver for Motorola MPC8xx and MPC82xx.
3  *
4  * Copyright (c) 2003 Intracom S.A. 
5  *  by Pantelis Antoniou <panto@intracom.gr>
6  * 
7  * 2005 (c) MontaVista Software, Inc. 
8  * Vitaly Bordug <vbordug@ru.mvista.com>
9  *
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.
13  */
14
15
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/pci.h>
26 #include <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/netdevice.h>
29 #include <linux/etherdevice.h>
30 #include <linux/skbuff.h>
31 #include <linux/spinlock.h>
32 #include <linux/mii.h>
33 #include <linux/ethtool.h>
34 #include <linux/bitops.h>
35 #include <linux/platform_device.h>
36
37 #include <asm/pgtable.h>
38 #include <asm/irq.h>
39 #include <asm/uaccess.h>
40
41 #include "fs_enet.h"
42
43 static int bitbang_prep_bit(u8 **datp, u8 *mskp,
44                 struct fs_mii_bit *mii_bit)
45 {
46         void *dat;
47         int adv;
48         u8 msk;
49
50         dat = (void*) mii_bit->offset;
51
52         adv = mii_bit->bit >> 3;
53         dat = (char *)dat + adv;
54
55         msk = 1 << (7 - (mii_bit->bit & 7));
56
57         *datp = dat;
58         *mskp = msk;
59
60         return 0;
61 }
62
63 static inline void bb_set(u8 *p, u8 m)
64 {
65         out_8(p, in_8(p) | m);
66 }
67
68 static inline void bb_clr(u8 *p, u8 m)
69 {
70         out_8(p, in_8(p) & ~m);
71 }
72
73 static inline int bb_read(u8 *p, u8 m)
74 {
75         return (in_8(p) & m) != 0;
76 }
77
78 static inline void mdio_active(struct bb_info *bitbang)
79 {
80         bb_set(bitbang->mdio_dir, bitbang->mdio_dir_msk);
81 }
82
83 static inline void mdio_tristate(struct bb_info *bitbang )
84 {
85         bb_clr(bitbang->mdio_dir, bitbang->mdio_dir_msk);
86 }
87
88 static inline int mdio_read(struct bb_info *bitbang )
89 {
90         return bb_read(bitbang->mdio_dat, bitbang->mdio_dat_msk);
91 }
92
93 static inline void mdio(struct bb_info *bitbang , int what)
94 {
95         if (what)
96                 bb_set(bitbang->mdio_dat, bitbang->mdio_dat_msk);
97         else
98                 bb_clr(bitbang->mdio_dat, bitbang->mdio_dat_msk);
99 }
100
101 static inline void mdc(struct bb_info *bitbang , int what)
102 {
103         if (what)
104                 bb_set(bitbang->mdc_dat, bitbang->mdc_msk);
105         else
106                 bb_clr(bitbang->mdc_dat, bitbang->mdc_msk);
107 }
108
109 static inline void mii_delay(struct bb_info *bitbang )
110 {
111         udelay(bitbang->delay);
112 }
113
114 /* Utility to send the preamble, address, and register (common to read and write). */
115 static void bitbang_pre(struct bb_info *bitbang , int read, u8 addr, u8 reg)
116 {
117         int j;
118
119         /*
120          * Send a 32 bit preamble ('1's) with an extra '1' bit for good measure.
121          * The IEEE spec says this is a PHY optional requirement.  The AMD
122          * 79C874 requires one after power up and one after a MII communications
123          * error.  This means that we are doing more preambles than we need,
124          * but it is safer and will be much more robust.
125          */
126
127         mdio_active(bitbang);
128         mdio(bitbang, 1);
129         for (j = 0; j < 32; j++) {
130                 mdc(bitbang, 0);
131                 mii_delay(bitbang);
132                 mdc(bitbang, 1);
133                 mii_delay(bitbang);
134         }
135
136         /* send the start bit (01) and the read opcode (10) or write (10) */
137         mdc(bitbang, 0);
138         mdio(bitbang, 0);
139         mii_delay(bitbang);
140         mdc(bitbang, 1);
141         mii_delay(bitbang);
142         mdc(bitbang, 0);
143         mdio(bitbang, 1);
144         mii_delay(bitbang);
145         mdc(bitbang, 1);
146         mii_delay(bitbang);
147         mdc(bitbang, 0);
148         mdio(bitbang, read);
149         mii_delay(bitbang);
150         mdc(bitbang, 1);
151         mii_delay(bitbang);
152         mdc(bitbang, 0);
153         mdio(bitbang, !read);
154         mii_delay(bitbang);
155         mdc(bitbang, 1);
156         mii_delay(bitbang);
157
158         /* send the PHY address */
159         for (j = 0; j < 5; j++) {
160                 mdc(bitbang, 0);
161                 mdio(bitbang, (addr & 0x10) != 0);
162                 mii_delay(bitbang);
163                 mdc(bitbang, 1);
164                 mii_delay(bitbang);
165                 addr <<= 1;
166         }
167
168         /* send the register address */
169         for (j = 0; j < 5; j++) {
170                 mdc(bitbang, 0);
171                 mdio(bitbang, (reg & 0x10) != 0);
172                 mii_delay(bitbang);
173                 mdc(bitbang, 1);
174                 mii_delay(bitbang);
175                 reg <<= 1;
176         }
177 }
178
179 static int fs_enet_mii_bb_read(struct mii_bus *bus , int phy_id, int location)
180 {
181         u16 rdreg;
182         int ret, j;
183         u8 addr = phy_id & 0xff;
184         u8 reg = location & 0xff;
185         struct bb_info* bitbang = bus->priv;
186
187         bitbang_pre(bitbang, 1, addr, reg);
188
189         /* tri-state our MDIO I/O pin so we can read */
190         mdc(bitbang, 0);
191         mdio_tristate(bitbang);
192         mii_delay(bitbang);
193         mdc(bitbang, 1);
194         mii_delay(bitbang);
195
196         /* check the turnaround bit: the PHY should be driving it to zero */
197         if (mdio_read(bitbang) != 0) {
198                 /* PHY didn't drive TA low */
199                 for (j = 0; j < 32; j++) {
200                         mdc(bitbang, 0);
201                         mii_delay(bitbang);
202                         mdc(bitbang, 1);
203                         mii_delay(bitbang);
204                 }
205                 ret = -1;
206                 goto out;
207         }
208
209         mdc(bitbang, 0);
210         mii_delay(bitbang);
211
212         /* read 16 bits of register data, MSB first */
213         rdreg = 0;
214         for (j = 0; j < 16; j++) {
215                 mdc(bitbang, 1);
216                 mii_delay(bitbang);
217                 rdreg <<= 1;
218                 rdreg |= mdio_read(bitbang);
219                 mdc(bitbang, 0);
220                 mii_delay(bitbang);
221         }
222
223         mdc(bitbang, 1);
224         mii_delay(bitbang);
225         mdc(bitbang, 0);
226         mii_delay(bitbang);
227         mdc(bitbang, 1);
228         mii_delay(bitbang);
229
230         ret = rdreg;
231 out:
232         return ret;
233 }
234
235 static int fs_enet_mii_bb_write(struct mii_bus *bus, int phy_id, int location, u16 val)
236 {
237         int j;
238         struct bb_info* bitbang = bus->priv;
239
240         u8 addr = phy_id & 0xff;
241         u8 reg = location & 0xff;
242         u16 value = val & 0xffff;
243
244         bitbang_pre(bitbang, 0, addr, reg);
245
246         /* send the turnaround (10) */
247         mdc(bitbang, 0);
248         mdio(bitbang, 1);
249         mii_delay(bitbang);
250         mdc(bitbang, 1);
251         mii_delay(bitbang);
252         mdc(bitbang, 0);
253         mdio(bitbang, 0);
254         mii_delay(bitbang);
255         mdc(bitbang, 1);
256         mii_delay(bitbang);
257
258         /* write 16 bits of register data, MSB first */
259         for (j = 0; j < 16; j++) {
260                 mdc(bitbang, 0);
261                 mdio(bitbang, (value & 0x8000) != 0);
262                 mii_delay(bitbang);
263                 mdc(bitbang, 1);
264                 mii_delay(bitbang);
265                 value <<= 1;
266         }
267
268         /*
269          * Tri-state the MDIO line.
270          */
271         mdio_tristate(bitbang);
272         mdc(bitbang, 0);
273         mii_delay(bitbang);
274         mdc(bitbang, 1);
275         mii_delay(bitbang);
276         return 0;
277 }
278
279 static int fs_enet_mii_bb_reset(struct mii_bus *bus)
280 {
281         /*nothing here - dunno how to reset it*/
282         return 0;
283 }
284
285 static int fs_mii_bitbang_init(struct bb_info *bitbang, struct fs_mii_bb_platform_info* fmpi)
286 {
287         int r;
288
289         bitbang->delay = fmpi->delay;
290
291         r = bitbang_prep_bit(&bitbang->mdio_dir,
292                          &bitbang->mdio_dir_msk,
293                          &fmpi->mdio_dir);
294         if (r != 0)
295                 return r;
296
297         r = bitbang_prep_bit(&bitbang->mdio_dat,
298                          &bitbang->mdio_dat_msk,
299                          &fmpi->mdio_dat);
300         if (r != 0)
301                 return r;
302
303         r = bitbang_prep_bit(&bitbang->mdc_dat,
304                          &bitbang->mdc_msk,
305                          &fmpi->mdc_dat);
306         if (r != 0)
307                 return r;
308
309         return 0;
310 }
311
312
313 static int __devinit fs_enet_mdio_probe(struct device *dev)
314 {
315         struct platform_device *pdev = to_platform_device(dev);
316         struct fs_mii_bb_platform_info *pdata;
317         struct mii_bus *new_bus;
318         struct bb_info *bitbang;
319         int err = 0;
320
321         if (NULL == dev)
322                 return -EINVAL;
323
324         new_bus = kzalloc(sizeof(struct mii_bus), GFP_KERNEL);
325
326         if (NULL == new_bus)
327                 return -ENOMEM;
328
329         bitbang = kzalloc(sizeof(struct bb_info), GFP_KERNEL);
330
331         if (NULL == bitbang)
332                 return -ENOMEM;
333
334         new_bus->name = "BB MII Bus",
335         new_bus->read = &fs_enet_mii_bb_read,
336         new_bus->write = &fs_enet_mii_bb_write,
337         new_bus->reset = &fs_enet_mii_bb_reset,
338         new_bus->id = pdev->id;
339
340         new_bus->phy_mask = ~0x9;
341         pdata = (struct fs_mii_bb_platform_info *)pdev->dev.platform_data;
342
343         if (NULL == pdata) {
344                 printk(KERN_ERR "gfar mdio %d: Missing platform data!\n", pdev->id);
345                 return -ENODEV;
346         }
347
348         /*set up workspace*/
349         fs_mii_bitbang_init(bitbang, pdata);
350
351         new_bus->priv = bitbang;
352
353         new_bus->irq = pdata->irq;
354
355         new_bus->dev = dev;
356         dev_set_drvdata(dev, new_bus);
357
358         err = mdiobus_register(new_bus);
359
360         if (0 != err) {
361                 printk (KERN_ERR "%s: Cannot register as MDIO bus\n",
362                                 new_bus->name);
363                 goto bus_register_fail;
364         }
365
366         return 0;
367
368 bus_register_fail:
369         kfree(bitbang);
370         kfree(new_bus);
371
372         return err;
373 }
374
375
376 static int fs_enet_mdio_remove(struct device *dev)
377 {
378         struct mii_bus *bus = dev_get_drvdata(dev);
379
380         mdiobus_unregister(bus);
381
382         dev_set_drvdata(dev, NULL);
383
384         iounmap((void *) (&bus->priv));
385         bus->priv = NULL;
386         kfree(bus);
387
388         return 0;
389 }
390
391 static struct device_driver fs_enet_bb_mdio_driver = {
392         .name = "fsl-bb-mdio",
393         .bus = &platform_bus_type,
394         .probe = fs_enet_mdio_probe,
395         .remove = fs_enet_mdio_remove,
396 };
397
398 int fs_enet_mdio_bb_init(void)
399 {
400         return driver_register(&fs_enet_bb_mdio_driver);
401 }
402
403 void fs_enet_mdio_bb_exit(void)
404 {
405         driver_unregister(&fs_enet_bb_mdio_driver);
406 }
407