Timur Tabi | 6cc2ff8 | 2012-08-24 09:10:53 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Simple memory-mapped device MDIO MUX driver |
| 3 | * |
| 4 | * Author: Timur Tabi <timur@freescale.com> |
| 5 | * |
| 6 | * Copyright 2012 Freescale Semiconductor, Inc. |
| 7 | * |
| 8 | * This file is licensed under the terms of the GNU General Public License |
| 9 | * version 2. This program is licensed "as is" without any warranty of any |
| 10 | * kind, whether express or implied. |
| 11 | */ |
| 12 | |
| 13 | #include <linux/platform_device.h> |
| 14 | #include <linux/device.h> |
Timur Tabi | 16fa9e1 | 2012-09-07 16:30:57 -0500 | [diff] [blame] | 15 | #include <linux/of_address.h> |
Timur Tabi | 6cc2ff8 | 2012-08-24 09:10:53 +0000 | [diff] [blame] | 16 | #include <linux/of_mdio.h> |
| 17 | #include <linux/module.h> |
Timur Tabi | 6cc2ff8 | 2012-08-24 09:10:53 +0000 | [diff] [blame] | 18 | #include <linux/phy.h> |
| 19 | #include <linux/mdio-mux.h> |
| 20 | |
| 21 | struct mdio_mux_mmioreg_state { |
| 22 | void *mux_handle; |
| 23 | phys_addr_t phys; |
| 24 | uint8_t mask; |
| 25 | }; |
| 26 | |
| 27 | /* |
| 28 | * MDIO multiplexing switch function |
| 29 | * |
| 30 | * This function is called by the mdio-mux layer when it thinks the mdio bus |
| 31 | * multiplexer needs to switch. |
| 32 | * |
| 33 | * 'current_child' is the current value of the mux register (masked via |
| 34 | * s->mask). |
| 35 | * |
| 36 | * 'desired_child' is the value of the 'reg' property of the target child MDIO |
| 37 | * node. |
| 38 | * |
| 39 | * The first time this function is called, current_child == -1. |
| 40 | * |
| 41 | * If current_child == desired_child, then the mux is already set to the |
| 42 | * correct bus. |
| 43 | */ |
| 44 | static int mdio_mux_mmioreg_switch_fn(int current_child, int desired_child, |
| 45 | void *data) |
| 46 | { |
| 47 | struct mdio_mux_mmioreg_state *s = data; |
| 48 | |
| 49 | if (current_child ^ desired_child) { |
Jingoo Han | 16dda49 | 2013-08-06 17:32:58 +0900 | [diff] [blame] | 50 | void __iomem *p = ioremap(s->phys, 1); |
Timur Tabi | 6cc2ff8 | 2012-08-24 09:10:53 +0000 | [diff] [blame] | 51 | uint8_t x, y; |
| 52 | |
| 53 | if (!p) |
| 54 | return -ENOMEM; |
| 55 | |
| 56 | x = ioread8(p); |
| 57 | y = (x & ~s->mask) | desired_child; |
| 58 | if (x != y) { |
| 59 | iowrite8((x & ~s->mask) | desired_child, p); |
| 60 | pr_debug("%s: %02x -> %02x\n", __func__, x, y); |
| 61 | } |
| 62 | |
| 63 | iounmap(p); |
| 64 | } |
| 65 | |
| 66 | return 0; |
| 67 | } |
| 68 | |
Bill Pemberton | 633d159 | 2012-12-03 09:24:14 -0500 | [diff] [blame] | 69 | static int mdio_mux_mmioreg_probe(struct platform_device *pdev) |
Timur Tabi | 6cc2ff8 | 2012-08-24 09:10:53 +0000 | [diff] [blame] | 70 | { |
| 71 | struct device_node *np2, *np = pdev->dev.of_node; |
| 72 | struct mdio_mux_mmioreg_state *s; |
| 73 | struct resource res; |
| 74 | const __be32 *iprop; |
| 75 | int len, ret; |
| 76 | |
| 77 | dev_dbg(&pdev->dev, "probing node %s\n", np->full_name); |
| 78 | |
| 79 | s = devm_kzalloc(&pdev->dev, sizeof(*s), GFP_KERNEL); |
| 80 | if (!s) |
| 81 | return -ENOMEM; |
| 82 | |
| 83 | ret = of_address_to_resource(np, 0, &res); |
| 84 | if (ret) { |
| 85 | dev_err(&pdev->dev, "could not obtain memory map for node %s\n", |
| 86 | np->full_name); |
| 87 | return ret; |
| 88 | } |
| 89 | s->phys = res.start; |
| 90 | |
| 91 | if (resource_size(&res) != sizeof(uint8_t)) { |
| 92 | dev_err(&pdev->dev, "only 8-bit registers are supported\n"); |
| 93 | return -EINVAL; |
| 94 | } |
| 95 | |
| 96 | iprop = of_get_property(np, "mux-mask", &len); |
| 97 | if (!iprop || len != sizeof(uint32_t)) { |
| 98 | dev_err(&pdev->dev, "missing or invalid mux-mask property\n"); |
| 99 | return -ENODEV; |
| 100 | } |
| 101 | if (be32_to_cpup(iprop) > 255) { |
| 102 | dev_err(&pdev->dev, "only 8-bit registers are supported\n"); |
| 103 | return -EINVAL; |
| 104 | } |
| 105 | s->mask = be32_to_cpup(iprop); |
| 106 | |
| 107 | /* |
| 108 | * Verify that the 'reg' property of each child MDIO bus does not |
| 109 | * set any bits outside of the 'mask'. |
| 110 | */ |
| 111 | for_each_available_child_of_node(np, np2) { |
| 112 | iprop = of_get_property(np2, "reg", &len); |
| 113 | if (!iprop || len != sizeof(uint32_t)) { |
| 114 | dev_err(&pdev->dev, "mdio-mux child node %s is " |
| 115 | "missing a 'reg' property\n", np2->full_name); |
| 116 | return -ENODEV; |
| 117 | } |
| 118 | if (be32_to_cpup(iprop) & ~s->mask) { |
| 119 | dev_err(&pdev->dev, "mdio-mux child node %s has " |
| 120 | "a 'reg' value with unmasked bits\n", |
| 121 | np2->full_name); |
| 122 | return -ENODEV; |
| 123 | } |
| 124 | } |
| 125 | |
| 126 | ret = mdio_mux_init(&pdev->dev, mdio_mux_mmioreg_switch_fn, |
| 127 | &s->mux_handle, s); |
| 128 | if (ret) { |
| 129 | dev_err(&pdev->dev, "failed to register mdio-mux bus %s\n", |
| 130 | np->full_name); |
| 131 | return ret; |
| 132 | } |
| 133 | |
| 134 | pdev->dev.platform_data = s; |
| 135 | |
| 136 | return 0; |
| 137 | } |
| 138 | |
Bill Pemberton | 633d159 | 2012-12-03 09:24:14 -0500 | [diff] [blame] | 139 | static int mdio_mux_mmioreg_remove(struct platform_device *pdev) |
Timur Tabi | 6cc2ff8 | 2012-08-24 09:10:53 +0000 | [diff] [blame] | 140 | { |
| 141 | struct mdio_mux_mmioreg_state *s = dev_get_platdata(&pdev->dev); |
| 142 | |
| 143 | mdio_mux_uninit(s->mux_handle); |
| 144 | |
| 145 | return 0; |
| 146 | } |
| 147 | |
| 148 | static struct of_device_id mdio_mux_mmioreg_match[] = { |
| 149 | { |
| 150 | .compatible = "mdio-mux-mmioreg", |
| 151 | }, |
| 152 | {}, |
| 153 | }; |
| 154 | MODULE_DEVICE_TABLE(of, mdio_mux_mmioreg_match); |
| 155 | |
| 156 | static struct platform_driver mdio_mux_mmioreg_driver = { |
| 157 | .driver = { |
| 158 | .name = "mdio-mux-mmioreg", |
Timur Tabi | 6cc2ff8 | 2012-08-24 09:10:53 +0000 | [diff] [blame] | 159 | .of_match_table = mdio_mux_mmioreg_match, |
| 160 | }, |
| 161 | .probe = mdio_mux_mmioreg_probe, |
Bill Pemberton | 633d159 | 2012-12-03 09:24:14 -0500 | [diff] [blame] | 162 | .remove = mdio_mux_mmioreg_remove, |
Timur Tabi | 6cc2ff8 | 2012-08-24 09:10:53 +0000 | [diff] [blame] | 163 | }; |
| 164 | |
| 165 | module_platform_driver(mdio_mux_mmioreg_driver); |
| 166 | |
| 167 | MODULE_AUTHOR("Timur Tabi <timur@freescale.com>"); |
| 168 | MODULE_DESCRIPTION("Memory-mapped device MDIO MUX driver"); |
| 169 | MODULE_LICENSE("GPL v2"); |