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