net:wireless:bcmdhd: rename bcmsdh_remove & bcmsdh_probe
[linux-2.6.git] / drivers / net / ibm_newemac / rgmii.c
1 /*
2  * drivers/net/ibm_newemac/rgmii.c
3  *
4  * Driver for PowerPC 4xx on-chip ethernet controller, RGMII bridge support.
5  *
6  * Copyright 2007 Benjamin Herrenschmidt, IBM Corp.
7  *                <benh@kernel.crashing.org>
8  *
9  * Based on the arch/ppc version of the driver:
10  *
11  * Copyright (c) 2004, 2005 Zultys Technologies.
12  * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
13  *
14  * Based on original work by
15  *      Matt Porter <mporter@kernel.crashing.org>
16  *      Copyright 2004 MontaVista Software, Inc.
17  *
18  * This program is free software; you can redistribute  it and/or modify it
19  * under  the terms of  the GNU General  Public License as published by the
20  * Free Software Foundation;  either version 2 of the  License, or (at your
21  * option) any later version.
22  *
23  */
24 #include <linux/slab.h>
25 #include <linux/kernel.h>
26 #include <linux/ethtool.h>
27 #include <asm/io.h>
28
29 #include "emac.h"
30 #include "debug.h"
31
32 // XXX FIXME: Axon seems to support a subset of the RGMII, we
33 // thus need to take that into account and possibly change some
34 // of the bit settings below that don't seem to quite match the
35 // AXON spec
36
37 /* RGMIIx_FER */
38 #define RGMII_FER_MASK(idx)     (0x7 << ((idx) * 4))
39 #define RGMII_FER_RTBI(idx)     (0x4 << ((idx) * 4))
40 #define RGMII_FER_RGMII(idx)    (0x5 << ((idx) * 4))
41 #define RGMII_FER_TBI(idx)      (0x6 << ((idx) * 4))
42 #define RGMII_FER_GMII(idx)     (0x7 << ((idx) * 4))
43 #define RGMII_FER_MII(idx)      RGMII_FER_GMII(idx)
44
45 /* RGMIIx_SSR */
46 #define RGMII_SSR_MASK(idx)     (0x7 << ((idx) * 8))
47 #define RGMII_SSR_100(idx)      (0x2 << ((idx) * 8))
48 #define RGMII_SSR_1000(idx)     (0x4 << ((idx) * 8))
49
50 /* RGMII bridge supports only GMII/TBI and RGMII/RTBI PHYs */
51 static inline int rgmii_valid_mode(int phy_mode)
52 {
53         return  phy_mode == PHY_MODE_GMII ||
54                 phy_mode == PHY_MODE_MII ||
55                 phy_mode == PHY_MODE_RGMII ||
56                 phy_mode == PHY_MODE_TBI ||
57                 phy_mode == PHY_MODE_RTBI;
58 }
59
60 static inline const char *rgmii_mode_name(int mode)
61 {
62         switch (mode) {
63         case PHY_MODE_RGMII:
64                 return "RGMII";
65         case PHY_MODE_TBI:
66                 return "TBI";
67         case PHY_MODE_GMII:
68                 return "GMII";
69         case PHY_MODE_MII:
70                 return "MII";
71         case PHY_MODE_RTBI:
72                 return "RTBI";
73         default:
74                 BUG();
75         }
76 }
77
78 static inline u32 rgmii_mode_mask(int mode, int input)
79 {
80         switch (mode) {
81         case PHY_MODE_RGMII:
82                 return RGMII_FER_RGMII(input);
83         case PHY_MODE_TBI:
84                 return RGMII_FER_TBI(input);
85         case PHY_MODE_GMII:
86                 return RGMII_FER_GMII(input);
87         case PHY_MODE_MII:
88                 return RGMII_FER_MII(input);
89         case PHY_MODE_RTBI:
90                 return RGMII_FER_RTBI(input);
91         default:
92                 BUG();
93         }
94 }
95
96 int __devinit rgmii_attach(struct platform_device *ofdev, int input, int mode)
97 {
98         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
99         struct rgmii_regs __iomem *p = dev->base;
100
101         RGMII_DBG(dev, "attach(%d)" NL, input);
102
103         /* Check if we need to attach to a RGMII */
104         if (input < 0 || !rgmii_valid_mode(mode)) {
105                 printk(KERN_ERR "%s: unsupported settings !\n",
106                        ofdev->dev.of_node->full_name);
107                 return -ENODEV;
108         }
109
110         mutex_lock(&dev->lock);
111
112         /* Enable this input */
113         out_be32(&p->fer, in_be32(&p->fer) | rgmii_mode_mask(mode, input));
114
115         printk(KERN_NOTICE "%s: input %d in %s mode\n",
116                ofdev->dev.of_node->full_name, input, rgmii_mode_name(mode));
117
118         ++dev->users;
119
120         mutex_unlock(&dev->lock);
121
122         return 0;
123 }
124
125 void rgmii_set_speed(struct platform_device *ofdev, int input, int speed)
126 {
127         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
128         struct rgmii_regs __iomem *p = dev->base;
129         u32 ssr;
130
131         mutex_lock(&dev->lock);
132
133         ssr = in_be32(&p->ssr) & ~RGMII_SSR_MASK(input);
134
135         RGMII_DBG(dev, "speed(%d, %d)" NL, input, speed);
136
137         if (speed == SPEED_1000)
138                 ssr |= RGMII_SSR_1000(input);
139         else if (speed == SPEED_100)
140                 ssr |= RGMII_SSR_100(input);
141
142         out_be32(&p->ssr, ssr);
143
144         mutex_unlock(&dev->lock);
145 }
146
147 void rgmii_get_mdio(struct platform_device *ofdev, int input)
148 {
149         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
150         struct rgmii_regs __iomem *p = dev->base;
151         u32 fer;
152
153         RGMII_DBG2(dev, "get_mdio(%d)" NL, input);
154
155         if (!(dev->flags & EMAC_RGMII_FLAG_HAS_MDIO))
156                 return;
157
158         mutex_lock(&dev->lock);
159
160         fer = in_be32(&p->fer);
161         fer |= 0x00080000u >> input;
162         out_be32(&p->fer, fer);
163         (void)in_be32(&p->fer);
164
165         DBG2(dev, " fer = 0x%08x\n", fer);
166 }
167
168 void rgmii_put_mdio(struct platform_device *ofdev, int input)
169 {
170         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
171         struct rgmii_regs __iomem *p = dev->base;
172         u32 fer;
173
174         RGMII_DBG2(dev, "put_mdio(%d)" NL, input);
175
176         if (!(dev->flags & EMAC_RGMII_FLAG_HAS_MDIO))
177                 return;
178
179         fer = in_be32(&p->fer);
180         fer &= ~(0x00080000u >> input);
181         out_be32(&p->fer, fer);
182         (void)in_be32(&p->fer);
183
184         DBG2(dev, " fer = 0x%08x\n", fer);
185
186         mutex_unlock(&dev->lock);
187 }
188
189 void rgmii_detach(struct platform_device *ofdev, int input)
190 {
191         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
192         struct rgmii_regs __iomem *p;
193
194         BUG_ON(!dev || dev->users == 0);
195         p = dev->base;
196
197         mutex_lock(&dev->lock);
198
199         RGMII_DBG(dev, "detach(%d)" NL, input);
200
201         /* Disable this input */
202         out_be32(&p->fer, in_be32(&p->fer) & ~RGMII_FER_MASK(input));
203
204         --dev->users;
205
206         mutex_unlock(&dev->lock);
207 }
208
209 int rgmii_get_regs_len(struct platform_device *ofdev)
210 {
211         return sizeof(struct emac_ethtool_regs_subhdr) +
212                 sizeof(struct rgmii_regs);
213 }
214
215 void *rgmii_dump_regs(struct platform_device *ofdev, void *buf)
216 {
217         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
218         struct emac_ethtool_regs_subhdr *hdr = buf;
219         struct rgmii_regs *regs = (struct rgmii_regs *)(hdr + 1);
220
221         hdr->version = 0;
222         hdr->index = 0; /* for now, are there chips with more than one
223                          * rgmii ? if yes, then we'll add a cell_index
224                          * like we do for emac
225                          */
226         memcpy_fromio(regs, dev->base, sizeof(struct rgmii_regs));
227         return regs + 1;
228 }
229
230
231 static int __devinit rgmii_probe(struct platform_device *ofdev)
232 {
233         struct device_node *np = ofdev->dev.of_node;
234         struct rgmii_instance *dev;
235         struct resource regs;
236         int rc;
237
238         rc = -ENOMEM;
239         dev = kzalloc(sizeof(struct rgmii_instance), GFP_KERNEL);
240         if (dev == NULL) {
241                 printk(KERN_ERR "%s: could not allocate RGMII device!\n",
242                        np->full_name);
243                 goto err_gone;
244         }
245
246         mutex_init(&dev->lock);
247         dev->ofdev = ofdev;
248
249         rc = -ENXIO;
250         if (of_address_to_resource(np, 0, &regs)) {
251                 printk(KERN_ERR "%s: Can't get registers address\n",
252                        np->full_name);
253                 goto err_free;
254         }
255
256         rc = -ENOMEM;
257         dev->base = (struct rgmii_regs __iomem *)ioremap(regs.start,
258                                                  sizeof(struct rgmii_regs));
259         if (dev->base == NULL) {
260                 printk(KERN_ERR "%s: Can't map device registers!\n",
261                        np->full_name);
262                 goto err_free;
263         }
264
265         /* Check for RGMII flags */
266         if (of_get_property(ofdev->dev.of_node, "has-mdio", NULL))
267                 dev->flags |= EMAC_RGMII_FLAG_HAS_MDIO;
268
269         /* CAB lacks the right properties, fix this up */
270         if (of_device_is_compatible(ofdev->dev.of_node, "ibm,rgmii-axon"))
271                 dev->flags |= EMAC_RGMII_FLAG_HAS_MDIO;
272
273         DBG2(dev, " Boot FER = 0x%08x, SSR = 0x%08x\n",
274              in_be32(&dev->base->fer), in_be32(&dev->base->ssr));
275
276         /* Disable all inputs by default */
277         out_be32(&dev->base->fer, 0);
278
279         printk(KERN_INFO
280                "RGMII %s initialized with%s MDIO support\n",
281                ofdev->dev.of_node->full_name,
282                (dev->flags & EMAC_RGMII_FLAG_HAS_MDIO) ? "" : "out");
283
284         wmb();
285         dev_set_drvdata(&ofdev->dev, dev);
286
287         return 0;
288
289  err_free:
290         kfree(dev);
291  err_gone:
292         return rc;
293 }
294
295 static int __devexit rgmii_remove(struct platform_device *ofdev)
296 {
297         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
298
299         dev_set_drvdata(&ofdev->dev, NULL);
300
301         WARN_ON(dev->users != 0);
302
303         iounmap(dev->base);
304         kfree(dev);
305
306         return 0;
307 }
308
309 static struct of_device_id rgmii_match[] =
310 {
311         {
312                 .compatible     = "ibm,rgmii",
313         },
314         {
315                 .type           = "emac-rgmii",
316         },
317         {},
318 };
319
320 static struct platform_driver rgmii_driver = {
321         .driver = {
322                 .name = "emac-rgmii",
323                 .owner = THIS_MODULE,
324                 .of_match_table = rgmii_match,
325         },
326         .probe = rgmii_probe,
327         .remove = rgmii_remove,
328 };
329
330 int __init rgmii_init(void)
331 {
332         return platform_driver_register(&rgmii_driver);
333 }
334
335 void rgmii_exit(void)
336 {
337         platform_driver_unregister(&rgmii_driver);
338 }