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