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