Commit | Line | Data |
---|---|---|
1d3bb996 DG |
1 | /* |
2 | * drivers/net/ibm_newemac/zmii.c | |
3 | * | |
4 | * Driver for PowerPC 4xx on-chip ethernet controller, ZMII bridge support. | |
5 | * | |
17cf803a BH |
6 | * Copyright 2007 Benjamin Herrenschmidt, IBM Corp. |
7 | * <benh@kernel.crashing.org> | |
8 | * | |
9 | * Based on the arch/ppc version of the driver: | |
10 | * | |
1d3bb996 DG |
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 | * Armin Kuster <akuster@mvista.com> | |
16 | * Copyright 2001 MontaVista Softare 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 | */ | |
5a0e3ad6 | 24 | #include <linux/slab.h> |
1d3bb996 DG |
25 | #include <linux/kernel.h> |
26 | #include <linux/ethtool.h> | |
27 | #include <asm/io.h> | |
28 | ||
29 | #include "emac.h" | |
30 | #include "core.h" | |
31 | ||
32 | /* ZMIIx_FER */ | |
33 | #define ZMII_FER_MDI(idx) (0x80000000 >> ((idx) * 4)) | |
34 | #define ZMII_FER_MDI_ALL (ZMII_FER_MDI(0) | ZMII_FER_MDI(1) | \ | |
35 | ZMII_FER_MDI(2) | ZMII_FER_MDI(3)) | |
36 | ||
37 | #define ZMII_FER_SMII(idx) (0x40000000 >> ((idx) * 4)) | |
38 | #define ZMII_FER_RMII(idx) (0x20000000 >> ((idx) * 4)) | |
39 | #define ZMII_FER_MII(idx) (0x10000000 >> ((idx) * 4)) | |
40 | ||
41 | /* ZMIIx_SSR */ | |
42 | #define ZMII_SSR_SCI(idx) (0x40000000 >> ((idx) * 4)) | |
43 | #define ZMII_SSR_FSS(idx) (0x20000000 >> ((idx) * 4)) | |
44 | #define ZMII_SSR_SP(idx) (0x10000000 >> ((idx) * 4)) | |
45 | ||
46 | /* ZMII only supports MII, RMII and SMII | |
47 | * we also support autodetection for backward compatibility | |
48 | */ | |
49 | static inline int zmii_valid_mode(int mode) | |
50 | { | |
51 | return mode == PHY_MODE_MII || | |
52 | mode == PHY_MODE_RMII || | |
53 | mode == PHY_MODE_SMII || | |
54 | mode == PHY_MODE_NA; | |
55 | } | |
56 | ||
57 | static inline const char *zmii_mode_name(int mode) | |
58 | { | |
59 | switch (mode) { | |
60 | case PHY_MODE_MII: | |
61 | return "MII"; | |
62 | case PHY_MODE_RMII: | |
63 | return "RMII"; | |
64 | case PHY_MODE_SMII: | |
65 | return "SMII"; | |
66 | default: | |
67 | BUG(); | |
68 | } | |
69 | } | |
70 | ||
71 | static inline u32 zmii_mode_mask(int mode, int input) | |
72 | { | |
73 | switch (mode) { | |
74 | case PHY_MODE_MII: | |
75 | return ZMII_FER_MII(input); | |
76 | case PHY_MODE_RMII: | |
77 | return ZMII_FER_RMII(input); | |
78 | case PHY_MODE_SMII: | |
79 | return ZMII_FER_SMII(input); | |
80 | default: | |
81 | return 0; | |
82 | } | |
83 | } | |
84 | ||
85 | int __devinit zmii_attach(struct of_device *ofdev, int input, int *mode) | |
86 | { | |
87 | struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev); | |
eb4d84f1 | 88 | struct zmii_regs __iomem *p = dev->base; |
1d3bb996 DG |
89 | |
90 | ZMII_DBG(dev, "init(%d, %d)" NL, input, *mode); | |
91 | ||
96853064 | 92 | if (!zmii_valid_mode(*mode)) { |
1d3bb996 DG |
93 | /* Probably an EMAC connected to RGMII, |
94 | * but it still may need ZMII for MDIO so | |
95 | * we don't fail here. | |
96 | */ | |
96853064 | 97 | dev->users++; |
1d3bb996 | 98 | return 0; |
96853064 | 99 | } |
1d3bb996 DG |
100 | |
101 | mutex_lock(&dev->lock); | |
102 | ||
103 | /* Autodetect ZMII mode if not specified. | |
104 | * This is only for backward compatibility with the old driver. | |
105 | * Please, always specify PHY mode in your board port to avoid | |
106 | * any surprises. | |
107 | */ | |
108 | if (dev->mode == PHY_MODE_NA) { | |
109 | if (*mode == PHY_MODE_NA) { | |
110 | u32 r = dev->fer_save; | |
111 | ||
112 | ZMII_DBG(dev, "autodetecting mode, FER = 0x%08x" NL, r); | |
113 | ||
114 | if (r & (ZMII_FER_MII(0) | ZMII_FER_MII(1))) | |
115 | dev->mode = PHY_MODE_MII; | |
116 | else if (r & (ZMII_FER_RMII(0) | ZMII_FER_RMII(1))) | |
117 | dev->mode = PHY_MODE_RMII; | |
118 | else | |
119 | dev->mode = PHY_MODE_SMII; | |
120 | } else | |
121 | dev->mode = *mode; | |
122 | ||
123 | printk(KERN_NOTICE "%s: bridge in %s mode\n", | |
124 | ofdev->node->full_name, zmii_mode_name(dev->mode)); | |
125 | } else { | |
126 | /* All inputs must use the same mode */ | |
127 | if (*mode != PHY_MODE_NA && *mode != dev->mode) { | |
128 | printk(KERN_ERR | |
129 | "%s: invalid mode %d specified for input %d\n", | |
130 | ofdev->node->full_name, *mode, input); | |
131 | mutex_unlock(&dev->lock); | |
132 | return -EINVAL; | |
133 | } | |
134 | } | |
135 | ||
136 | /* Report back correct PHY mode, | |
137 | * it may be used during PHY initialization. | |
138 | */ | |
139 | *mode = dev->mode; | |
140 | ||
141 | /* Enable this input */ | |
142 | out_be32(&p->fer, in_be32(&p->fer) | zmii_mode_mask(dev->mode, input)); | |
143 | ++dev->users; | |
144 | ||
145 | mutex_unlock(&dev->lock); | |
146 | ||
147 | return 0; | |
148 | } | |
149 | ||
150 | void zmii_get_mdio(struct of_device *ofdev, int input) | |
151 | { | |
152 | struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev); | |
153 | u32 fer; | |
154 | ||
155 | ZMII_DBG2(dev, "get_mdio(%d)" NL, input); | |
156 | ||
157 | mutex_lock(&dev->lock); | |
158 | ||
159 | fer = in_be32(&dev->base->fer) & ~ZMII_FER_MDI_ALL; | |
160 | out_be32(&dev->base->fer, fer | ZMII_FER_MDI(input)); | |
161 | } | |
162 | ||
163 | void zmii_put_mdio(struct of_device *ofdev, int input) | |
164 | { | |
165 | struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev); | |
166 | ||
167 | ZMII_DBG2(dev, "put_mdio(%d)" NL, input); | |
168 | mutex_unlock(&dev->lock); | |
169 | } | |
170 | ||
171 | ||
172 | void zmii_set_speed(struct of_device *ofdev, int input, int speed) | |
173 | { | |
174 | struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev); | |
175 | u32 ssr; | |
176 | ||
177 | mutex_lock(&dev->lock); | |
178 | ||
179 | ssr = in_be32(&dev->base->ssr); | |
180 | ||
181 | ZMII_DBG(dev, "speed(%d, %d)" NL, input, speed); | |
182 | ||
183 | if (speed == SPEED_100) | |
184 | ssr |= ZMII_SSR_SP(input); | |
185 | else | |
186 | ssr &= ~ZMII_SSR_SP(input); | |
187 | ||
188 | out_be32(&dev->base->ssr, ssr); | |
189 | ||
190 | mutex_unlock(&dev->lock); | |
191 | } | |
192 | ||
51d4a1cc | 193 | void zmii_detach(struct of_device *ofdev, int input) |
1d3bb996 DG |
194 | { |
195 | struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev); | |
196 | ||
197 | BUG_ON(!dev || dev->users == 0); | |
198 | ||
199 | mutex_lock(&dev->lock); | |
200 | ||
201 | ZMII_DBG(dev, "detach(%d)" NL, input); | |
202 | ||
203 | /* Disable this input */ | |
204 | out_be32(&dev->base->fer, | |
205 | in_be32(&dev->base->fer) & ~zmii_mode_mask(dev->mode, input)); | |
206 | ||
207 | --dev->users; | |
208 | ||
209 | mutex_unlock(&dev->lock); | |
210 | } | |
211 | ||
212 | int zmii_get_regs_len(struct of_device *ofdev) | |
213 | { | |
214 | return sizeof(struct emac_ethtool_regs_subhdr) + | |
215 | sizeof(struct zmii_regs); | |
216 | } | |
217 | ||
218 | void *zmii_dump_regs(struct of_device *ofdev, void *buf) | |
219 | { | |
220 | struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev); | |
221 | struct emac_ethtool_regs_subhdr *hdr = buf; | |
222 | struct zmii_regs *regs = (struct zmii_regs *)(hdr + 1); | |
223 | ||
224 | hdr->version = 0; | |
225 | hdr->index = 0; /* for now, are there chips with more than one | |
226 | * zmii ? if yes, then we'll add a cell_index | |
227 | * like we do for emac | |
228 | */ | |
229 | memcpy_fromio(regs, dev->base, sizeof(struct zmii_regs)); | |
230 | return regs + 1; | |
231 | } | |
232 | ||
233 | static int __devinit zmii_probe(struct of_device *ofdev, | |
234 | const struct of_device_id *match) | |
235 | { | |
236 | struct device_node *np = ofdev->node; | |
237 | struct zmii_instance *dev; | |
238 | struct resource regs; | |
239 | int rc; | |
240 | ||
241 | rc = -ENOMEM; | |
242 | dev = kzalloc(sizeof(struct zmii_instance), GFP_KERNEL); | |
243 | if (dev == NULL) { | |
244 | printk(KERN_ERR "%s: could not allocate ZMII device!\n", | |
245 | np->full_name); | |
246 | goto err_gone; | |
247 | } | |
248 | ||
249 | mutex_init(&dev->lock); | |
250 | dev->ofdev = ofdev; | |
251 | dev->mode = PHY_MODE_NA; | |
252 | ||
253 | rc = -ENXIO; | |
254 | if (of_address_to_resource(np, 0, ®s)) { | |
255 | printk(KERN_ERR "%s: Can't get registers address\n", | |
256 | np->full_name); | |
257 | goto err_free; | |
258 | } | |
259 | ||
260 | rc = -ENOMEM; | |
eb4d84f1 | 261 | dev->base = (struct zmii_regs __iomem *)ioremap(regs.start, |
1d3bb996 DG |
262 | sizeof(struct zmii_regs)); |
263 | if (dev->base == NULL) { | |
264 | printk(KERN_ERR "%s: Can't map device registers!\n", | |
265 | np->full_name); | |
266 | goto err_free; | |
267 | } | |
268 | ||
269 | /* We may need FER value for autodetection later */ | |
270 | dev->fer_save = in_be32(&dev->base->fer); | |
271 | ||
272 | /* Disable all inputs by default */ | |
273 | out_be32(&dev->base->fer, 0); | |
274 | ||
275 | printk(KERN_INFO | |
276 | "ZMII %s initialized\n", ofdev->node->full_name); | |
277 | wmb(); | |
278 | dev_set_drvdata(&ofdev->dev, dev); | |
279 | ||
280 | return 0; | |
281 | ||
282 | err_free: | |
283 | kfree(dev); | |
284 | err_gone: | |
285 | return rc; | |
286 | } | |
287 | ||
288 | static int __devexit zmii_remove(struct of_device *ofdev) | |
289 | { | |
290 | struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev); | |
291 | ||
292 | dev_set_drvdata(&ofdev->dev, NULL); | |
293 | ||
294 | WARN_ON(dev->users != 0); | |
295 | ||
296 | iounmap(dev->base); | |
297 | kfree(dev); | |
298 | ||
299 | return 0; | |
300 | } | |
301 | ||
302 | static struct of_device_id zmii_match[] = | |
303 | { | |
304 | { | |
305 | .compatible = "ibm,zmii", | |
306 | }, | |
307 | /* For backward compat with old DT */ | |
308 | { | |
309 | .type = "emac-zmii", | |
310 | }, | |
311 | {}, | |
312 | }; | |
313 | ||
314 | static struct of_platform_driver zmii_driver = { | |
315 | .name = "emac-zmii", | |
316 | .match_table = zmii_match, | |
317 | ||
318 | .probe = zmii_probe, | |
319 | .remove = zmii_remove, | |
320 | }; | |
321 | ||
322 | int __init zmii_init(void) | |
323 | { | |
324 | return of_register_platform_driver(&zmii_driver); | |
325 | } | |
326 | ||
327 | void zmii_exit(void) | |
328 | { | |
329 | of_unregister_platform_driver(&zmii_driver); | |
330 | } |