b53_mmap.c 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288
  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. #include <linux/kernel.h>
  19. #include <linux/module.h>
  20. #include <linux/io.h>
  21. #include <linux/platform_device.h>
  22. #include <linux/platform_data/b53.h>
  23. #include "b53_priv.h"
  24. struct b53_mmap_priv {
  25. void __iomem *regs;
  26. };
  27. static int b53_mmap_read8(struct b53_device *dev, u8 page, u8 reg, u8 *val)
  28. {
  29. struct b53_mmap_priv *priv = dev->priv;
  30. void __iomem *regs = priv->regs;
  31. *val = readb(regs + (page << 8) + reg);
  32. return 0;
  33. }
  34. static int b53_mmap_read16(struct b53_device *dev, u8 page, u8 reg, u16 *val)
  35. {
  36. struct b53_mmap_priv *priv = dev->priv;
  37. void __iomem *regs = priv->regs;
  38. if (WARN_ON(reg % 2))
  39. return -EINVAL;
  40. if (dev->pdata && dev->pdata->big_endian)
  41. *val = ioread16be(regs + (page << 8) + reg);
  42. else
  43. *val = readw(regs + (page << 8) + reg);
  44. return 0;
  45. }
  46. static int b53_mmap_read32(struct b53_device *dev, u8 page, u8 reg, u32 *val)
  47. {
  48. struct b53_mmap_priv *priv = dev->priv;
  49. void __iomem *regs = priv->regs;
  50. if (WARN_ON(reg % 4))
  51. return -EINVAL;
  52. if (dev->pdata && dev->pdata->big_endian)
  53. *val = ioread32be(regs + (page << 8) + reg);
  54. else
  55. *val = readl(regs + (page << 8) + reg);
  56. return 0;
  57. }
  58. static int b53_mmap_read48(struct b53_device *dev, u8 page, u8 reg, u64 *val)
  59. {
  60. struct b53_mmap_priv *priv = dev->priv;
  61. void __iomem *regs = priv->regs;
  62. if (WARN_ON(reg % 2))
  63. return -EINVAL;
  64. if (reg % 4) {
  65. u16 lo;
  66. u32 hi;
  67. if (dev->pdata && dev->pdata->big_endian) {
  68. lo = ioread16be(regs + (page << 8) + reg);
  69. hi = ioread32be(regs + (page << 8) + reg + 2);
  70. } else {
  71. lo = readw(regs + (page << 8) + reg);
  72. hi = readl(regs + (page << 8) + reg + 2);
  73. }
  74. *val = ((u64)hi << 16) | lo;
  75. } else {
  76. u32 lo;
  77. u16 hi;
  78. if (dev->pdata && dev->pdata->big_endian) {
  79. lo = ioread32be(regs + (page << 8) + reg);
  80. hi = ioread16be(regs + (page << 8) + reg + 4);
  81. } else {
  82. lo = readl(regs + (page << 8) + reg);
  83. hi = readw(regs + (page << 8) + reg + 4);
  84. }
  85. *val = ((u64)hi << 32) | lo;
  86. }
  87. return 0;
  88. }
  89. static int b53_mmap_read64(struct b53_device *dev, u8 page, u8 reg, u64 *val)
  90. {
  91. struct b53_mmap_priv *priv = dev->priv;
  92. void __iomem *regs = priv->regs;
  93. u32 hi, lo;
  94. if (WARN_ON(reg % 4))
  95. return -EINVAL;
  96. if (dev->pdata && dev->pdata->big_endian) {
  97. lo = ioread32be(regs + (page << 8) + reg);
  98. hi = ioread32be(regs + (page << 8) + reg + 4);
  99. } else {
  100. lo = readl(regs + (page << 8) + reg);
  101. hi = readl(regs + (page << 8) + reg + 4);
  102. }
  103. *val = ((u64)hi << 32) | lo;
  104. return 0;
  105. }
  106. static int b53_mmap_write8(struct b53_device *dev, u8 page, u8 reg, u8 value)
  107. {
  108. struct b53_mmap_priv *priv = dev->priv;
  109. void __iomem *regs = priv->regs;
  110. writeb(value, regs + (page << 8) + reg);
  111. return 0;
  112. }
  113. static int b53_mmap_write16(struct b53_device *dev, u8 page, u8 reg,
  114. u16 value)
  115. {
  116. struct b53_mmap_priv *priv = dev->priv;
  117. void __iomem *regs = priv->regs;
  118. if (WARN_ON(reg % 2))
  119. return -EINVAL;
  120. if (dev->pdata && dev->pdata->big_endian)
  121. iowrite16be(value, regs + (page << 8) + reg);
  122. else
  123. writew(value, regs + (page << 8) + reg);
  124. return 0;
  125. }
  126. static int b53_mmap_write32(struct b53_device *dev, u8 page, u8 reg,
  127. u32 value)
  128. {
  129. struct b53_mmap_priv *priv = dev->priv;
  130. void __iomem *regs = priv->regs;
  131. if (WARN_ON(reg % 4))
  132. return -EINVAL;
  133. if (dev->pdata && dev->pdata->big_endian)
  134. iowrite32be(value, regs + (page << 8) + reg);
  135. else
  136. writel(value, regs + (page << 8) + reg);
  137. return 0;
  138. }
  139. static int b53_mmap_write48(struct b53_device *dev, u8 page, u8 reg,
  140. u64 value)
  141. {
  142. if (WARN_ON(reg % 2))
  143. return -EINVAL;
  144. if (reg % 4) {
  145. u32 hi = (u32)(value >> 16);
  146. u16 lo = (u16)value;
  147. b53_mmap_write16(dev, page, reg, lo);
  148. b53_mmap_write32(dev, page, reg + 2, hi);
  149. } else {
  150. u16 hi = (u16)(value >> 32);
  151. u32 lo = (u32)value;
  152. b53_mmap_write32(dev, page, reg, lo);
  153. b53_mmap_write16(dev, page, reg + 4, hi);
  154. }
  155. return 0;
  156. }
  157. static int b53_mmap_write64(struct b53_device *dev, u8 page, u8 reg,
  158. u64 value)
  159. {
  160. u32 hi, lo;
  161. hi = upper_32_bits(value);
  162. lo = lower_32_bits(value);
  163. if (WARN_ON(reg % 4))
  164. return -EINVAL;
  165. b53_mmap_write32(dev, page, reg, lo);
  166. b53_mmap_write32(dev, page, reg + 4, hi);
  167. return 0;
  168. }
  169. static const struct b53_io_ops b53_mmap_ops = {
  170. .read8 = b53_mmap_read8,
  171. .read16 = b53_mmap_read16,
  172. .read32 = b53_mmap_read32,
  173. .read48 = b53_mmap_read48,
  174. .read64 = b53_mmap_read64,
  175. .write8 = b53_mmap_write8,
  176. .write16 = b53_mmap_write16,
  177. .write32 = b53_mmap_write32,
  178. .write48 = b53_mmap_write48,
  179. .write64 = b53_mmap_write64,
  180. };
  181. static int b53_mmap_probe(struct platform_device *pdev)
  182. {
  183. struct b53_platform_data *pdata = pdev->dev.platform_data;
  184. struct b53_mmap_priv *priv;
  185. struct b53_device *dev;
  186. if (!pdata)
  187. return -EINVAL;
  188. priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
  189. if (!priv)
  190. return -ENOMEM;
  191. priv->regs = pdata->regs;
  192. dev = b53_switch_alloc(&pdev->dev, &b53_mmap_ops, priv);
  193. if (!dev)
  194. return -ENOMEM;
  195. dev->pdata = pdata;
  196. platform_set_drvdata(pdev, dev);
  197. return b53_switch_register(dev);
  198. }
  199. static int b53_mmap_remove(struct platform_device *pdev)
  200. {
  201. struct b53_device *dev = platform_get_drvdata(pdev);
  202. if (dev)
  203. b53_switch_remove(dev);
  204. return 0;
  205. }
  206. static const struct of_device_id b53_mmap_of_table[] = {
  207. { .compatible = "brcm,bcm3384-switch" },
  208. { .compatible = "brcm,bcm6328-switch" },
  209. { .compatible = "brcm,bcm6368-switch" },
  210. { .compatible = "brcm,bcm63xx-switch" },
  211. { /* sentinel */ },
  212. };
  213. MODULE_DEVICE_TABLE(of, b53_mmap_of_table);
  214. static struct platform_driver b53_mmap_driver = {
  215. .probe = b53_mmap_probe,
  216. .remove = b53_mmap_remove,
  217. .driver = {
  218. .name = "b53-switch",
  219. .of_match_table = b53_mmap_of_table,
  220. },
  221. };
  222. module_platform_driver(b53_mmap_driver);
  223. MODULE_AUTHOR("Jonas Gorski <jogo@openwrt.org>");
  224. MODULE_DESCRIPTION("B53 MMAP access driver");
  225. MODULE_LICENSE("Dual BSD/GPL");