[deliverable/linux.git] / drivers / net / phy / mdio-mux-gpio.c

/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 2011, 2012 Cavium, Inc.
 */

#include <linux/platform_device.h>
#include <linux/device.h>
#include <linux/of_mdio.h>
#include <linux/module.h>
#include <linux/phy.h>
#include <linux/mdio-mux.h>
#include <linux/of_gpio.h>

#define DRV_VERSION "1.1"
#define DRV_DESCRIPTION "GPIO controlled MDIO bus multiplexer driver"

#define MDIO_MUX_GPIO_MAX_BITS 8

struct mdio_mux_gpio_state {
	struct gpio_desc *gpio[MDIO_MUX_GPIO_MAX_BITS];
	unsigned int num_gpios;
	void *mux_handle;
};

static int mdio_mux_gpio_switch_fn(int current_child, int desired_child,
				   void *data)
{
	int values[MDIO_MUX_GPIO_MAX_BITS];
	unsigned int n;
	struct mdio_mux_gpio_state *s = data;

	if (current_child == desired_child)
		return 0;

	for (n = 0; n < s->num_gpios; n++) {
		values[n] = (desired_child >> n) & 1;
	}
	gpiod_set_array_cansleep(s->num_gpios, s->gpio, values);

	return 0;
}

static int mdio_mux_gpio_probe(struct platform_device *pdev)
{
	struct mdio_mux_gpio_state *s;
	int num_gpios;
	unsigned int n;
	int r;

	if (!pdev->dev.of_node)
		return -ENODEV;

	num_gpios = of_gpio_count(pdev->dev.of_node);
	if (num_gpios <= 0 || num_gpios > MDIO_MUX_GPIO_MAX_BITS)
		return -ENODEV;

	s = devm_kzalloc(&pdev->dev, sizeof(*s), GFP_KERNEL);
	if (!s)
		return -ENOMEM;

	s->num_gpios = num_gpios;

	for (n = 0; n < num_gpios; ) {
		struct gpio_desc *gpio = gpiod_get_index(&pdev->dev, NULL, n,
							 GPIOD_OUT_LOW);
		if (IS_ERR(gpio)) {
			r = PTR_ERR(gpio);
			goto err;
		}
		s->gpio[n] = gpio;
		n++;
	}

	r = mdio_mux_init(&pdev->dev,
			  mdio_mux_gpio_switch_fn, &s->mux_handle, s);

	if (r == 0) {
		pdev->dev.platform_data = s;
		return 0;
	}
err:
	while (n) {
		n--;
		gpiod_put(s->gpio[n]);
	}
	return r;
}

static int mdio_mux_gpio_remove(struct platform_device *pdev)
{
	unsigned int n;
	struct mdio_mux_gpio_state *s = dev_get_platdata(&pdev->dev);
	mdio_mux_uninit(s->mux_handle);
	for (n = 0; n < s->num_gpios; n++)
		gpiod_put(s->gpio[n]);
	return 0;
}

static const struct of_device_id mdio_mux_gpio_match[] = {
	{
		.compatible = "mdio-mux-gpio",
	},
	{
		/* Legacy compatible property. */
		.compatible = "cavium,mdio-mux-sn74cbtlv3253",
	},
	{},
};
MODULE_DEVICE_TABLE(of, mdio_mux_gpio_match);

static struct platform_driver mdio_mux_gpio_driver = {
	.driver = {
		.name		= "mdio-mux-gpio",
		.of_match_table = mdio_mux_gpio_match,
	},
	.probe		= mdio_mux_gpio_probe,
	.remove		= mdio_mux_gpio_remove,
};

module_platform_driver(mdio_mux_gpio_driver);

MODULE_DESCRIPTION(DRV_DESCRIPTION);
MODULE_VERSION(DRV_VERSION);
MODULE_AUTHOR("David Daney");
MODULE_LICENSE("GPL");
Commit	Line	Data
416912a1 DD	1	/*
	2	* This file is subject to the terms and conditions of the GNU General Public
	3	* License. See the file "COPYING" in the main directory of this archive
	4	* for more details.
	5	*
	6	* Copyright (C) 2011, 2012 Cavium, Inc.
	7	*/
	8
	9	#include <linux/platform_device.h>
	10	#include <linux/device.h>
	11	#include <linux/of_mdio.h>
	12	#include <linux/module.h>
416912a1 DD	13	#include <linux/phy.h>
	14	#include <linux/mdio-mux.h>
	15	#include <linux/of_gpio.h>
	16
441e0026	17	#define DRV_VERSION "1.1"
416912a1 DD	18	#define DRV_DESCRIPTION "GPIO controlled MDIO bus multiplexer driver"
	19
	20	#define MDIO_MUX_GPIO_MAX_BITS 8
	21
	22	struct mdio_mux_gpio_state {
441e0026	23	struct gpio_desc *gpio[MDIO_MUX_GPIO_MAX_BITS];
416912a1 DD	24	unsigned int num_gpios;
	25	void *mux_handle;
	26	};
	27
	28	static int mdio_mux_gpio_switch_fn(int current_child, int desired_child,
	29	void *data)
	30	{
441e0026	31	int values[MDIO_MUX_GPIO_MAX_BITS];
416912a1 DD	32	unsigned int n;
	33	struct mdio_mux_gpio_state *s = data;
	34
	35	if (current_child == desired_child)
	36	return 0;
	37
416912a1	38	for (n = 0; n < s->num_gpios; n++) {
441e0026	39	values[n] = (desired_child >> n) & 1;
416912a1	40	}
441e0026	41	gpiod_set_array_cansleep(s->num_gpios, s->gpio, values);
416912a1 DD	42
	43	return 0;
	44	}
	45
633d1594	46	static int mdio_mux_gpio_probe(struct platform_device *pdev)
416912a1	47	{
416912a1	48	struct mdio_mux_gpio_state *s;
e80beb27	49	int num_gpios;
416912a1 DD	50	unsigned int n;
	51	int r;
	52
	53	if (!pdev->dev.of_node)
	54	return -ENODEV;
	55
	56	num_gpios = of_gpio_count(pdev->dev.of_node);
e80beb27	57	if (num_gpios <= 0 \|\| num_gpios > MDIO_MUX_GPIO_MAX_BITS)
416912a1 DD	58	return -ENODEV;
	59
	60	s = devm_kzalloc(&pdev->dev, sizeof(*s), GFP_KERNEL);
	61	if (!s)
	62	return -ENOMEM;
	63
	64	s->num_gpios = num_gpios;
	65
	66	for (n = 0; n < num_gpios; ) {
441e0026 RI	67	struct gpio_desc *gpio = gpiod_get_index(&pdev->dev, NULL, n,
	68	GPIOD_OUT_LOW);
	69	if (IS_ERR(gpio)) {
	70	r = PTR_ERR(gpio);
416912a1 DD	71	goto err;
	72	}
	73	s->gpio[n] = gpio;
416912a1	74	n++;
416912a1 DD	75	}
	76
	77	r = mdio_mux_init(&pdev->dev,
	78	mdio_mux_gpio_switch_fn, &s->mux_handle, s);
	79
	80	if (r == 0) {
	81	pdev->dev.platform_data = s;
	82	return 0;
	83	}
	84	err:
	85	while (n) {
	86	n--;
441e0026	87	gpiod_put(s->gpio[n]);
416912a1	88	}
416912a1 DD	89	return r;
	90	}
	91
633d1594	92	static int mdio_mux_gpio_remove(struct platform_device *pdev)
416912a1	93	{
441e0026	94	unsigned int n;
1b0e53a8	95	struct mdio_mux_gpio_state *s = dev_get_platdata(&pdev->dev);
416912a1	96	mdio_mux_uninit(s->mux_handle);
441e0026 RI	97	for (n = 0; n < s->num_gpios; n++)
441e0026 RI	98	gpiod_put(s->gpio[n]);
416912a1 DD	99	return 0;
	100	}
	101
d8a7dadb	102	static const struct of_device_id mdio_mux_gpio_match[] = {
416912a1 DD	103	{
	104	.compatible = "mdio-mux-gpio",
	105	},
	106	{
	107	/* Legacy compatible property. */
	108	.compatible = "cavium,mdio-mux-sn74cbtlv3253",
	109	},
	110	{},
	111	};
	112	MODULE_DEVICE_TABLE(of, mdio_mux_gpio_match);
	113
	114	static struct platform_driver mdio_mux_gpio_driver = {
	115	.driver = {
	116	.name = "mdio-mux-gpio",
416912a1 DD	117	.of_match_table = mdio_mux_gpio_match,
	118	},
	119	.probe = mdio_mux_gpio_probe,
633d1594	120	.remove = mdio_mux_gpio_remove,
416912a1 DD	121	};
	122
	123	module_platform_driver(mdio_mux_gpio_driver);
	124
	125	MODULE_DESCRIPTION(DRV_DESCRIPTION);
	126	MODULE_VERSION(DRV_VERSION);
	127	MODULE_AUTHOR("David Daney");
	128	MODULE_LICENSE("GPL");