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 */
 51static 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
 60static 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
 78static 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
 96int __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
125void 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
147void 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
168void 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
189void 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
209int rgmii_get_regs_len(struct platform_device *ofdev)
210{
211	return sizeof(struct emac_ethtool_regs_subhdr) +
212		sizeof(struct rgmii_regs);
213}
214
215void *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
231static 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
295static 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
309static struct of_device_id rgmii_match[] =
310{
311	{
312		.compatible	= "ibm,rgmii",
313	},
314	{
315		.type		= "emac-rgmii",
316	},
317	{},
318};
319
320static 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
330int __init rgmii_init(void)
331{
332	return platform_driver_register(&rgmii_driver);
333}
334
335void rgmii_exit(void)
336{
337	platform_driver_unregister(&rgmii_driver);
338}