1 /* 2 * Combined Ethernet driver for Motorola MPC8xx and MPC82xx. 3 * 4 * Copyright (c) 2003 Intracom S.A. 5 * by Pantelis Antoniou <panto@intracom.gr> 6 * 7 * 2005 (c) MontaVista Software, Inc. 8 * Vitaly Bordug <vbordug@ru.mvista.com> 9 * 10 * This file is licensed under the terms of the GNU General Public License 11 * version 2. This program is licensed "as is" without any warranty of any 12 * kind, whether express or implied. 13 */ 14 15 #include <linux/module.h> 16 #include <linux/ioport.h> 17 #include <linux/slab.h> 18 #include <linux/init.h> 19 #include <linux/interrupt.h> 20 #include <linux/netdevice.h> 21 #include <linux/etherdevice.h> 22 #include <linux/mii.h> 23 #include <linux/platform_device.h> 24 #include <linux/mdio-bitbang.h> 25 #include <linux/of_mdio.h> 26 #include <linux/of_platform.h> 27 28 #include "fs_enet.h" 29 30 struct bb_info { 31 struct mdiobb_ctrl ctrl; 32 __be32 __iomem *dir; 33 __be32 __iomem *dat; 34 u32 mdio_msk; 35 u32 mdc_msk; 36 }; 37 38 /* FIXME: If any other users of GPIO crop up, then these will have to 39 * have some sort of global synchronization to avoid races with other 40 * pins on the same port. The ideal solution would probably be to 41 * bind the ports to a GPIO driver, and have this be a client of it. 42 */ 43 static inline void bb_set(u32 __iomem *p, u32 m) 44 { 45 out_be32(p, in_be32(p) | m); 46 } 47 48 static inline void bb_clr(u32 __iomem *p, u32 m) 49 { 50 out_be32(p, in_be32(p) & ~m); 51 } 52 53 static inline int bb_read(u32 __iomem *p, u32 m) 54 { 55 return (in_be32(p) & m) != 0; 56 } 57 58 static inline void mdio_dir(struct mdiobb_ctrl *ctrl, int dir) 59 { 60 struct bb_info *bitbang = container_of(ctrl, struct bb_info, ctrl); 61 62 if (dir) 63 bb_set(bitbang->dir, bitbang->mdio_msk); 64 else 65 bb_clr(bitbang->dir, bitbang->mdio_msk); 66 67 /* Read back to flush the write. */ 68 in_be32(bitbang->dir); 69 } 70 71 static inline int mdio_read(struct mdiobb_ctrl *ctrl) 72 { 73 struct bb_info *bitbang = container_of(ctrl, struct bb_info, ctrl); 74 return bb_read(bitbang->dat, bitbang->mdio_msk); 75 } 76 77 static inline void mdio(struct mdiobb_ctrl *ctrl, int what) 78 { 79 struct bb_info *bitbang = container_of(ctrl, struct bb_info, ctrl); 80 81 if (what) 82 bb_set(bitbang->dat, bitbang->mdio_msk); 83 else 84 bb_clr(bitbang->dat, bitbang->mdio_msk); 85 86 /* Read back to flush the write. */ 87 in_be32(bitbang->dat); 88 } 89 90 static inline void mdc(struct mdiobb_ctrl *ctrl, int what) 91 { 92 struct bb_info *bitbang = container_of(ctrl, struct bb_info, ctrl); 93 94 if (what) 95 bb_set(bitbang->dat, bitbang->mdc_msk); 96 else 97 bb_clr(bitbang->dat, bitbang->mdc_msk); 98 99 /* Read back to flush the write. */ 100 in_be32(bitbang->dat); 101 } 102 103 static struct mdiobb_ops bb_ops = { 104 .owner = THIS_MODULE, 105 .set_mdc = mdc, 106 .set_mdio_dir = mdio_dir, 107 .set_mdio_data = mdio, 108 .get_mdio_data = mdio_read, 109 }; 110 111 static int __devinit fs_mii_bitbang_init(struct mii_bus *bus, 112 struct device_node *np) 113 { 114 struct resource res; 115 const u32 *data; 116 int mdio_pin, mdc_pin, len; 117 struct bb_info *bitbang = bus->priv; 118 119 int ret = of_address_to_resource(np, 0, &res); 120 if (ret) 121 return ret; 122 123 if (resource_size(&res) <= 13) 124 return -ENODEV; 125 126 /* This should really encode the pin number as well, but all 127 * we get is an int, and the odds of multiple bitbang mdio buses 128 * is low enough that it's not worth going too crazy. 129 */ 130 snprintf(bus->id, MII_BUS_ID_SIZE, "%x", res.start); 131 132 data = of_get_property(np, "fsl,mdio-pin", &len); 133 if (!data || len != 4) 134 return -ENODEV; 135 mdio_pin = *data; 136 137 data = of_get_property(np, "fsl,mdc-pin", &len); 138 if (!data || len != 4) 139 return -ENODEV; 140 mdc_pin = *data; 141 142 bitbang->dir = ioremap(res.start, resource_size(&res)); 143 if (!bitbang->dir) 144 return -ENOMEM; 145 146 bitbang->dat = bitbang->dir + 4; 147 bitbang->mdio_msk = 1 << (31 - mdio_pin); 148 bitbang->mdc_msk = 1 << (31 - mdc_pin); 149 150 return 0; 151 } 152 153 static int __devinit fs_enet_mdio_probe(struct platform_device *ofdev) 154 { 155 struct mii_bus *new_bus; 156 struct bb_info *bitbang; 157 int ret = -ENOMEM; 158 159 bitbang = kzalloc(sizeof(struct bb_info), GFP_KERNEL); 160 if (!bitbang) 161 goto out; 162 163 bitbang->ctrl.ops = &bb_ops; 164 165 new_bus = alloc_mdio_bitbang(&bitbang->ctrl); 166 if (!new_bus) 167 goto out_free_priv; 168 169 new_bus->name = "CPM2 Bitbanged MII", 170 171 ret = fs_mii_bitbang_init(new_bus, ofdev->dev.of_node); 172 if (ret) 173 goto out_free_bus; 174 175 new_bus->phy_mask = ~0; 176 new_bus->irq = kmalloc(sizeof(int) * PHY_MAX_ADDR, GFP_KERNEL); 177 if (!new_bus->irq) 178 goto out_unmap_regs; 179 180 new_bus->parent = &ofdev->dev; 181 dev_set_drvdata(&ofdev->dev, new_bus); 182 183 ret = of_mdiobus_register(new_bus, ofdev->dev.of_node); 184 if (ret) 185 goto out_free_irqs; 186 187 return 0; 188 189 out_free_irqs: 190 dev_set_drvdata(&ofdev->dev, NULL); 191 kfree(new_bus->irq); 192 out_unmap_regs: 193 iounmap(bitbang->dir); 194 out_free_bus: 195 free_mdio_bitbang(new_bus); 196 out_free_priv: 197 kfree(bitbang); 198 out: 199 return ret; 200 } 201 202 static int fs_enet_mdio_remove(struct platform_device *ofdev) 203 { 204 struct mii_bus *bus = dev_get_drvdata(&ofdev->dev); 205 struct bb_info *bitbang = bus->priv; 206 207 mdiobus_unregister(bus); 208 dev_set_drvdata(&ofdev->dev, NULL); 209 kfree(bus->irq); 210 free_mdio_bitbang(bus); 211 iounmap(bitbang->dir); 212 kfree(bitbang); 213 214 return 0; 215 } 216 217 static struct of_device_id fs_enet_mdio_bb_match[] = { 218 { 219 .compatible = "fsl,cpm2-mdio-bitbang", 220 }, 221 {}, 222 }; 223 MODULE_DEVICE_TABLE(of, fs_enet_mdio_bb_match); 224 225 static struct platform_driver fs_enet_bb_mdio_driver = { 226 .driver = { 227 .name = "fsl-bb-mdio", 228 .owner = THIS_MODULE, 229 .of_match_table = fs_enet_mdio_bb_match, 230 }, 231 .probe = fs_enet_mdio_probe, 232 .remove = fs_enet_mdio_remove, 233 }; 234 235 module_platform_driver(fs_enet_bb_mdio_driver); 236