mdio_mux_i2creg.c 2.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * (C) Copyright 2019
  4. * Alex Marginean, NXP
  5. */
  6. #include <dm.h>
  7. #include <errno.h>
  8. #include <log.h>
  9. #include <miiphy.h>
  10. #include <i2c.h>
  11. /*
  12. * This driver is used for MDIO muxes driven by writing to a register of an I2C
  13. * chip. The board it was developed for uses a mux controlled by on-board FPGA
  14. * which in turn is accessed as a chip over I2C.
  15. */
  16. struct mdio_mux_i2creg_priv {
  17. struct udevice *chip;
  18. int reg;
  19. int mask;
  20. };
  21. static int mdio_mux_i2creg_select(struct udevice *mux, int cur, int sel)
  22. {
  23. struct mdio_mux_i2creg_priv *priv = dev_get_priv(mux);
  24. u8 val, val_old;
  25. /* if last selection didn't change we're good to go */
  26. if (cur == sel)
  27. return 0;
  28. val_old = dm_i2c_reg_read(priv->chip, priv->reg);
  29. val = (val_old & ~priv->mask) | (sel & priv->mask);
  30. debug("%s: chip %s, reg %x, val %x => %x\n", __func__, priv->chip->name,
  31. priv->reg, val_old, val);
  32. dm_i2c_reg_write(priv->chip, priv->reg, val);
  33. return 0;
  34. }
  35. static const struct mdio_mux_ops mdio_mux_i2creg_ops = {
  36. .select = mdio_mux_i2creg_select,
  37. };
  38. static int mdio_mux_i2creg_probe(struct udevice *dev)
  39. {
  40. struct mdio_mux_i2creg_priv *priv = dev_get_priv(dev);
  41. ofnode chip_node, bus_node;
  42. struct udevice *i2c_bus;
  43. u32 reg_mask[2];
  44. u32 chip_addr;
  45. int err;
  46. /* read the register addr/mask pair */
  47. err = dev_read_u32_array(dev, "mux-reg-masks", reg_mask, 2);
  48. if (err) {
  49. debug("%s: error reading mux-reg-masks property\n", __func__);
  50. return err;
  51. }
  52. /* parent should be an I2C chip, grandparent should be an I2C bus */
  53. chip_node = ofnode_get_parent(dev->node);
  54. bus_node = ofnode_get_parent(chip_node);
  55. err = uclass_get_device_by_ofnode(UCLASS_I2C, bus_node, &i2c_bus);
  56. if (err) {
  57. debug("%s: can't find I2C bus for node %s\n", __func__,
  58. ofnode_get_name(bus_node));
  59. return err;
  60. }
  61. err = ofnode_read_u32(chip_node, "reg", &chip_addr);
  62. if (err) {
  63. debug("%s: can't read chip address in %s\n", __func__,
  64. ofnode_get_name(chip_node));
  65. return err;
  66. }
  67. err = i2c_get_chip(i2c_bus, (uint)chip_addr, 1, &priv->chip);
  68. if (err) {
  69. debug("%s: can't find i2c chip device for addr %x\n", __func__,
  70. chip_addr);
  71. return err;
  72. }
  73. priv->reg = (int)reg_mask[0];
  74. priv->mask = (int)reg_mask[1];
  75. debug("%s: chip %s, reg %x, mask %x\n", __func__, priv->chip->name,
  76. priv->reg, priv->mask);
  77. return 0;
  78. }
  79. static const struct udevice_id mdio_mux_i2creg_ids[] = {
  80. { .compatible = "mdio-mux-i2creg" },
  81. { }
  82. };
  83. U_BOOT_DRIVER(mdio_mux_i2creg) = {
  84. .name = "mdio_mux_i2creg",
  85. .id = UCLASS_MDIO_MUX,
  86. .of_match = mdio_mux_i2creg_ids,
  87. .probe = mdio_mux_i2creg_probe,
  88. .ops = &mdio_mux_i2creg_ops,
  89. .priv_auto_alloc_size = sizeof(struct mdio_mux_i2creg_priv),
  90. };