target/linux/generic/files/drivers/net/phy/b53/b53_mmap.c

   1 /*
   2  * B53 register access through memory mapped registers
   3  *
   4  * Copyright (C) 2012-2013 Jonas Gorski <jogo@openwrt.org>
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include <linux/kernel.h>
  20 #include <linux/module.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/platform_data/b53.h>
  23
  24 #include "b53_priv.h"
  25
  26 static int b53_mmap_read8(struct b53_device *dev, u8 page, u8 reg, u8 *val)
  27 {
  28         u8 __iomem *regs = dev->priv;
  29
  30         *val = readb(regs + (page << 8) + reg);
  31
  32         return 0;
  33 }
  34
  35 static int b53_mmap_read16(struct b53_device *dev, u8 page, u8 reg, u16 *val)
  36 {
  37         u8 __iomem *regs = dev->priv;
  38
  39         if (WARN_ON(reg % 2))
  40                 return -EINVAL;
  41
  42         if (dev->pdata && dev->pdata->big_endian)
  43                 *val = readw_be(regs + (page << 8) + reg);
  44         else
  45                 *val = readw(regs + (page << 8) + reg);
  46
  47         return 0;
  48 }
  49
  50 static int b53_mmap_read32(struct b53_device *dev, u8 page, u8 reg, u32 *val)
  51 {
  52         u8 __iomem *regs = dev->priv;
  53
  54         if (WARN_ON(reg % 4))
  55                 return -EINVAL;
  56
  57         if (dev->pdata && dev->pdata->big_endian)
  58                 *val = readl_be(regs + (page << 8) + reg);
  59         else
  60                 *val = readl(regs + (page << 8) + reg);
  61
  62         return 0;
  63 }
  64
  65 static int b53_mmap_read48(struct b53_device *dev, u8 page, u8 reg, u64 *val)
  66 {
  67         if (WARN_ON(reg % 2))
  68                 return -EINVAL;
  69
  70         if (reg % 4) {
  71                 u16 lo;
  72                 u32 hi;
  73
  74                 b53_mmap_read16(dev, page, reg, &lo);
  75                 b53_mmap_read32(dev, page, reg + 2, &hi);
  76
  77                 *val = ((u64)hi << 16) | lo;
  78         } else {
  79                 u32 lo;
  80                 u16 hi;
  81
  82                 b53_mmap_read32(dev, page, reg, &lo);
  83                 b53_mmap_read16(dev, page, reg + 4, &hi);
  84
  85                 *val = ((u64)hi << 32) | lo;
  86         }
  87
  88         return 0;
  89 }
  90
  91 static int b53_mmap_read64(struct b53_device *dev, u8 page, u8 reg, u64 *val)
  92 {
  93         u32 hi, lo;
  94
  95         if (WARN_ON(reg % 4))
  96                 return -EINVAL;
  97
  98         b53_mmap_read32(dev, page, reg, &lo);
  99         b53_mmap_read32(dev, page, reg + 4, &hi);
 100
 101         *val = ((u64)hi << 32) | lo;
 102
 103         return 0;
 104 }
 105
 106 static int b53_mmap_write8(struct b53_device *dev, u8 page, u8 reg, u8 value)
 107 {
 108         u8 __iomem *regs = dev->priv;
 109
 110         writeb(value, regs + (page << 8) + reg);
 111
 112         return 0;
 113 }
 114
 115 static int b53_mmap_write16(struct b53_device *dev, u8 page, u8 reg,
 116                              u16 value)
 117 {
 118         u8 __iomem *regs = dev->priv;
 119
 120         if (WARN_ON(reg % 2))
 121                 return -EINVAL;
 122
 123         if (dev->pdata && dev->pdata->big_endian)
 124                 writew_be(value, regs + (page << 8) + reg);
 125         else
 126                 writew(value, regs + (page << 8) + reg);
 127
 128         return 0;
 129 }
 130
 131 static int b53_mmap_write32(struct b53_device *dev, u8 page, u8 reg,
 132                                     u32 value)
 133 {
 134         u8 __iomem *regs = dev->priv;
 135
 136         if (WARN_ON(reg % 4))
 137                 return -EINVAL;
 138
 139         if (dev->pdata && dev->pdata->big_endian)
 140                 writel_be(value, regs + (page << 8) + reg);
 141         else
 142                 writel(value, regs + (page << 8) + reg);
 143
 144         return 0;
 145 }
 146
 147 static int b53_mmap_write48(struct b53_device *dev, u8 page, u8 reg,
 148                                     u64 value)
 149 {
 150         if (WARN_ON(reg % 2))
 151                 return -EINVAL;
 152
 153         if (reg % 4) {
 154                 u32 hi = (u32)(value >> 16);
 155                 u16 lo = (u16)value;
 156
 157                 b53_mmap_write16(dev, page, reg, lo);
 158                 b53_mmap_write32(dev, page, reg + 2, hi);
 159         } else {
 160                 u16 hi = (u16)(value >> 32);
 161                 u32 lo = (u32)value;
 162
 163                 b53_mmap_write32(dev, page, reg, lo);
 164                 b53_mmap_write16(dev, page, reg + 4, hi);
 165         }
 166
 167         return 0;
 168 }
 169
 170 static int b53_mmap_write64(struct b53_device *dev, u8 page, u8 reg,
 171                              u64 value)
 172 {
 173         u32 hi, lo;
 174
 175         hi = (u32)(value >> 32);
 176         lo = (u32)value;
 177
 178         if (WARN_ON(reg % 4))
 179                 return -EINVAL;
 180
 181         b53_mmap_write32(dev, page, reg, lo);
 182         b53_mmap_write32(dev, page, reg + 4, hi);
 183
 184         return 0;
 185 }
 186
 187 static struct b53_io_ops b53_mmap_ops = {
 188         .read8 = b53_mmap_read8,
 189         .read16 = b53_mmap_read16,
 190         .read32 = b53_mmap_read32,
 191         .read48 = b53_mmap_read48,
 192         .read64 = b53_mmap_read64,
 193         .write8 = b53_mmap_write8,
 194         .write16 = b53_mmap_write16,
 195         .write32 = b53_mmap_write32,
 196         .write48 = b53_mmap_write48,
 197         .write64 = b53_mmap_write64,
 198 };
 199
 200 static int b53_mmap_probe(struct platform_device *pdev)
 201 {
 202         struct b53_platform_data *pdata = pdev->dev.platform_data;
 203         struct b53_device *dev;
 204
 205         if (!pdata)
 206                 return -EINVAL;
 207
 208         dev = b53_switch_alloc(&pdev->dev, &b53_mmap_ops, pdata->regs);
 209         if (!dev)
 210                 return -ENOMEM;
 211
 212         if (pdata)
 213                 dev->pdata = pdata;
 214
 215         platform_set_drvdata(pdev, dev);
 216
 217         return b53_switch_register(dev);
 218 }
 219
 220 static int b53_mmap_remove(struct platform_device *pdev)
 221 {
 222         struct b53_device *dev = platform_get_drvdata(pdev);
 223
 224         if (dev) {
 225                 b53_switch_remove(dev);
 226         }
 227
 228         return 0;
 229 }
 230
 231 static struct platform_driver b53_mmap_driver = {
 232         .probe = b53_mmap_probe,
 233         .remove = b53_mmap_remove,
 234         .driver = {
 235                 .name = "b53-switch",
 236         },
 237 };
 238
 239 module_platform_driver(b53_mmap_driver);
 240 MODULE_AUTHOR("Jonas Gorski <jogo@openwrt.org>");
 241 MODULE_DESCRIPTION("B53 MMAP access driver");
 242 MODULE_LICENSE("Dual BSD/GPL");