b53_spi.c 7.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376
  1. /*
  2. * B53 register access through SPI
  3. *
  4. * Copyright (C) 2011-2013 Jonas Gorski <[email protected]>
  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 <asm/unaligned.h>
  19. #include <linux/delay.h>
  20. #include <linux/kernel.h>
  21. #include <linux/module.h>
  22. #include <linux/spi/spi.h>
  23. #include <linux/platform_data/b53.h>
  24. #include "b53_priv.h"
  25. #define B53_SPI_DATA 0xf0
  26. #define B53_SPI_STATUS 0xfe
  27. #define B53_SPI_CMD_SPIF BIT(7)
  28. #define B53_SPI_CMD_RACK BIT(5)
  29. #define B53_SPI_CMD_READ 0x00
  30. #define B53_SPI_CMD_WRITE 0x01
  31. #define B53_SPI_CMD_NORMAL 0x60
  32. #define B53_SPI_CMD_FAST 0x10
  33. #define B53_SPI_PAGE_SELECT 0xff
  34. static inline int b53_spi_read_reg(struct spi_device *spi, u8 reg, u8 *val,
  35. unsigned int len)
  36. {
  37. u8 txbuf[2];
  38. txbuf[0] = B53_SPI_CMD_NORMAL | B53_SPI_CMD_READ;
  39. txbuf[1] = reg;
  40. return spi_write_then_read(spi, txbuf, 2, val, len);
  41. }
  42. static inline int b53_spi_clear_status(struct spi_device *spi)
  43. {
  44. unsigned int i;
  45. u8 rxbuf;
  46. int ret;
  47. for (i = 0; i < 10; i++) {
  48. ret = b53_spi_read_reg(spi, B53_SPI_STATUS, &rxbuf, 1);
  49. if (ret)
  50. return ret;
  51. if (!(rxbuf & B53_SPI_CMD_SPIF))
  52. break;
  53. mdelay(1);
  54. }
  55. if (i == 10)
  56. return -EIO;
  57. return 0;
  58. }
  59. static inline int b53_spi_set_page(struct spi_device *spi, u8 page)
  60. {
  61. u8 txbuf[3];
  62. txbuf[0] = B53_SPI_CMD_NORMAL | B53_SPI_CMD_WRITE;
  63. txbuf[1] = B53_SPI_PAGE_SELECT;
  64. txbuf[2] = page;
  65. return spi_write(spi, txbuf, sizeof(txbuf));
  66. }
  67. static inline int b53_prepare_reg_access(struct spi_device *spi, u8 page)
  68. {
  69. int ret = b53_spi_clear_status(spi);
  70. if (ret)
  71. return ret;
  72. return b53_spi_set_page(spi, page);
  73. }
  74. static int b53_spi_prepare_reg_read(struct spi_device *spi, u8 reg)
  75. {
  76. u8 rxbuf;
  77. int retry_count;
  78. int ret;
  79. ret = b53_spi_read_reg(spi, reg, &rxbuf, 1);
  80. if (ret)
  81. return ret;
  82. for (retry_count = 0; retry_count < 10; retry_count++) {
  83. ret = b53_spi_read_reg(spi, B53_SPI_STATUS, &rxbuf, 1);
  84. if (ret)
  85. return ret;
  86. if (rxbuf & B53_SPI_CMD_RACK)
  87. break;
  88. mdelay(1);
  89. }
  90. if (retry_count == 10)
  91. return -EIO;
  92. return 0;
  93. }
  94. static int b53_spi_read(struct b53_device *dev, u8 page, u8 reg, u8 *data,
  95. unsigned int len)
  96. {
  97. struct spi_device *spi = dev->priv;
  98. int ret;
  99. ret = b53_prepare_reg_access(spi, page);
  100. if (ret)
  101. return ret;
  102. ret = b53_spi_prepare_reg_read(spi, reg);
  103. if (ret)
  104. return ret;
  105. return b53_spi_read_reg(spi, B53_SPI_DATA, data, len);
  106. }
  107. static int b53_spi_read8(struct b53_device *dev, u8 page, u8 reg, u8 *val)
  108. {
  109. return b53_spi_read(dev, page, reg, val, 1);
  110. }
  111. static int b53_spi_read16(struct b53_device *dev, u8 page, u8 reg, u16 *val)
  112. {
  113. __le16 value;
  114. int ret;
  115. ret = b53_spi_read(dev, page, reg, (u8 *)&value, 2);
  116. if (!ret)
  117. *val = le16_to_cpu(value);
  118. return ret;
  119. }
  120. static int b53_spi_read32(struct b53_device *dev, u8 page, u8 reg, u32 *val)
  121. {
  122. __le32 value;
  123. int ret;
  124. ret = b53_spi_read(dev, page, reg, (u8 *)&value, 4);
  125. if (!ret)
  126. *val = le32_to_cpu(value);
  127. return ret;
  128. }
  129. static int b53_spi_read48(struct b53_device *dev, u8 page, u8 reg, u64 *val)
  130. {
  131. __le64 value;
  132. int ret;
  133. *val = 0;
  134. ret = b53_spi_read(dev, page, reg, (u8 *)&value, 6);
  135. if (!ret)
  136. *val = le64_to_cpu(value);
  137. return ret;
  138. }
  139. static int b53_spi_read64(struct b53_device *dev, u8 page, u8 reg, u64 *val)
  140. {
  141. __le64 value;
  142. int ret;
  143. ret = b53_spi_read(dev, page, reg, (u8 *)&value, 8);
  144. if (!ret)
  145. *val = le64_to_cpu(value);
  146. return ret;
  147. }
  148. static int b53_spi_write8(struct b53_device *dev, u8 page, u8 reg, u8 value)
  149. {
  150. struct spi_device *spi = dev->priv;
  151. int ret;
  152. u8 txbuf[3];
  153. ret = b53_prepare_reg_access(spi, page);
  154. if (ret)
  155. return ret;
  156. txbuf[0] = B53_SPI_CMD_NORMAL | B53_SPI_CMD_WRITE;
  157. txbuf[1] = reg;
  158. txbuf[2] = value;
  159. return spi_write(spi, txbuf, sizeof(txbuf));
  160. }
  161. static int b53_spi_write16(struct b53_device *dev, u8 page, u8 reg, u16 value)
  162. {
  163. struct spi_device *spi = dev->priv;
  164. int ret;
  165. u8 txbuf[4];
  166. ret = b53_prepare_reg_access(spi, page);
  167. if (ret)
  168. return ret;
  169. txbuf[0] = B53_SPI_CMD_NORMAL | B53_SPI_CMD_WRITE;
  170. txbuf[1] = reg;
  171. put_unaligned_le16(value, &txbuf[2]);
  172. return spi_write(spi, txbuf, sizeof(txbuf));
  173. }
  174. static int b53_spi_write32(struct b53_device *dev, u8 page, u8 reg, u32 value)
  175. {
  176. struct spi_device *spi = dev->priv;
  177. int ret;
  178. u8 txbuf[6];
  179. ret = b53_prepare_reg_access(spi, page);
  180. if (ret)
  181. return ret;
  182. txbuf[0] = B53_SPI_CMD_NORMAL | B53_SPI_CMD_WRITE;
  183. txbuf[1] = reg;
  184. put_unaligned_le32(value, &txbuf[2]);
  185. return spi_write(spi, txbuf, sizeof(txbuf));
  186. }
  187. static int b53_spi_write48(struct b53_device *dev, u8 page, u8 reg, u64 value)
  188. {
  189. struct spi_device *spi = dev->priv;
  190. int ret;
  191. u8 txbuf[10];
  192. ret = b53_prepare_reg_access(spi, page);
  193. if (ret)
  194. return ret;
  195. txbuf[0] = B53_SPI_CMD_NORMAL | B53_SPI_CMD_WRITE;
  196. txbuf[1] = reg;
  197. put_unaligned_le64(value, &txbuf[2]);
  198. return spi_write(spi, txbuf, sizeof(txbuf) - 2);
  199. }
  200. static int b53_spi_write64(struct b53_device *dev, u8 page, u8 reg, u64 value)
  201. {
  202. struct spi_device *spi = dev->priv;
  203. int ret;
  204. u8 txbuf[10];
  205. ret = b53_prepare_reg_access(spi, page);
  206. if (ret)
  207. return ret;
  208. txbuf[0] = B53_SPI_CMD_NORMAL | B53_SPI_CMD_WRITE;
  209. txbuf[1] = reg;
  210. put_unaligned_le64(value, &txbuf[2]);
  211. return spi_write(spi, txbuf, sizeof(txbuf));
  212. }
  213. static const struct b53_io_ops b53_spi_ops = {
  214. .read8 = b53_spi_read8,
  215. .read16 = b53_spi_read16,
  216. .read32 = b53_spi_read32,
  217. .read48 = b53_spi_read48,
  218. .read64 = b53_spi_read64,
  219. .write8 = b53_spi_write8,
  220. .write16 = b53_spi_write16,
  221. .write32 = b53_spi_write32,
  222. .write48 = b53_spi_write48,
  223. .write64 = b53_spi_write64,
  224. };
  225. static int b53_spi_probe(struct spi_device *spi)
  226. {
  227. struct b53_device *dev;
  228. int ret;
  229. dev = b53_switch_alloc(&spi->dev, &b53_spi_ops, spi);
  230. if (!dev)
  231. return -ENOMEM;
  232. if (spi->dev.platform_data)
  233. dev->pdata = spi->dev.platform_data;
  234. ret = b53_switch_register(dev);
  235. if (ret)
  236. return ret;
  237. spi_set_drvdata(spi, dev);
  238. return 0;
  239. }
  240. static void b53_spi_remove(struct spi_device *spi)
  241. {
  242. struct b53_device *dev = spi_get_drvdata(spi);
  243. if (dev)
  244. b53_switch_remove(dev);
  245. }
  246. static void b53_spi_shutdown(struct spi_device *spi)
  247. {
  248. struct b53_device *dev = spi_get_drvdata(spi);
  249. if (dev)
  250. b53_switch_shutdown(dev);
  251. spi_set_drvdata(spi, NULL);
  252. }
  253. static const struct of_device_id b53_spi_of_match[] = {
  254. { .compatible = "brcm,bcm5325" },
  255. { .compatible = "brcm,bcm5365" },
  256. { .compatible = "brcm,bcm5395" },
  257. { .compatible = "brcm,bcm5397" },
  258. { .compatible = "brcm,bcm5398" },
  259. { .compatible = "brcm,bcm53115" },
  260. { .compatible = "brcm,bcm53125" },
  261. { .compatible = "brcm,bcm53128" },
  262. { /* sentinel */ }
  263. };
  264. MODULE_DEVICE_TABLE(of, b53_spi_of_match);
  265. static const struct spi_device_id b53_spi_ids[] = {
  266. { .name = "bcm5325" },
  267. { .name = "bcm5365" },
  268. { .name = "bcm5395" },
  269. { .name = "bcm5397" },
  270. { .name = "bcm5398" },
  271. { .name = "bcm53115" },
  272. { .name = "bcm53125" },
  273. { .name = "bcm53128" },
  274. { /* sentinel */ }
  275. };
  276. MODULE_DEVICE_TABLE(spi, b53_spi_ids);
  277. static struct spi_driver b53_spi_driver = {
  278. .driver = {
  279. .name = "b53-switch",
  280. .of_match_table = b53_spi_of_match,
  281. },
  282. .probe = b53_spi_probe,
  283. .remove = b53_spi_remove,
  284. .shutdown = b53_spi_shutdown,
  285. .id_table = b53_spi_ids,
  286. };
  287. module_spi_driver(b53_spi_driver);
  288. MODULE_AUTHOR("Jonas Gorski <[email protected]>");
  289. MODULE_DESCRIPTION("B53 SPI access driver");
  290. MODULE_LICENSE("Dual BSD/GPL");