root/drivers/i2c/busses/i2c-icy.c

DEFINITIONS

1. icy_pcf_setpcf
2. icy_pcf_getpcf
3. icy_pcf_getown
4. icy_pcf_getclock
5. icy_pcf_waitforpin
6. icy_probe
7. icy_remove

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * I2C driver for stand-alone PCF8584 style adapters on Zorro cards
   4  *
   5  * Original ICY documentation can be found on Aminet:
   6  * https://aminet.net/package/docs/hard/icy
   7  *
   8  * There has been a modern community re-print of this design in 2019:
   9  * https://www.a1k.org/forum/index.php?threads/70106/
  10  *
  11  * The card is basically a Philips PCF8584 connected straight to the
  12  * beginning of the AutoConfig'd address space (register S1 on base+2),
  13  * with /INT on /INT2 on the Zorro bus.
  14  *
  15  * Copyright (c) 2019 Max Staudt <max@enpas.org>
  16  *
  17  * This started as a fork of i2c-elektor.c and has evolved since.
  18  * Thanks go to its authors for providing a base to grow on.
  19  *
  20  *
  21  * IRQ support is currently not implemented.
  22  *
  23  * As it turns out, i2c-algo-pcf is really written with i2c-elektor's
  24  * edge-triggered ISA interrupts in mind, while the Amiga's Zorro bus has
  25  * level-triggered interrupts. This means that once an interrupt occurs, we
  26  * have to tell the PCF8584 to shut up immediately, or it will keep the
  27  * interrupt line busy and cause an IRQ storm.
  28 
  29  * However, because of the PCF8584's host-side protocol, there is no good
  30  * way to just quieten it without side effects. Rather, we have to perform
  31  * the next read/write operation straight away, which will reset the /INT
  32  * pin. This entails re-designing the core of i2c-algo-pcf in the future.
  33  * For now, we never request an IRQ from the PCF8584, and poll it instead.
  34  */
  35 
  36 #include <linux/delay.h>
  37 #include <linux/init.h>
  38 #include <linux/io.h>
  39 #include <linux/ioport.h>
  40 #include <linux/kernel.h>
  41 #include <linux/module.h>
  42 
  43 #include <linux/i2c.h>
  44 #include <linux/i2c-algo-pcf.h>
  45 
  46 #include <asm/amigaints.h>
  47 #include <linux/zorro.h>
  48 
  49 #include "../algos/i2c-algo-pcf.h"
  50 
  51 struct icy_i2c {
  52         struct i2c_adapter adapter;
  53 
  54         void __iomem *reg_s0;
  55         void __iomem *reg_s1;
  56         struct fwnode_handle *ltc2990_fwnode;
  57         struct i2c_client *ltc2990_client;
  58 };
  59 
  60 /*
  61  * Functions called by i2c-algo-pcf
  62  */
  63 static void icy_pcf_setpcf(void *data, int ctl, int val)
  64 {
  65         struct icy_i2c *i2c = (struct icy_i2c *)data;
  66 
  67         u8 __iomem *address = ctl ? i2c->reg_s1 : i2c->reg_s0;
  68 
  69         z_writeb(val, address);
  70 }
  71 
  72 static int icy_pcf_getpcf(void *data, int ctl)
  73 {
  74         struct icy_i2c *i2c = (struct icy_i2c *)data;
  75 
  76         u8 __iomem *address = ctl ? i2c->reg_s1 : i2c->reg_s0;
  77 
  78         return z_readb(address);
  79 }
  80 
  81 static int icy_pcf_getown(void *data)
  82 {
  83         return 0x55;
  84 }
  85 
  86 static int icy_pcf_getclock(void *data)
  87 {
  88         return 0x1c;
  89 }
  90 
  91 static void icy_pcf_waitforpin(void *data)
  92 {
  93         usleep_range(50, 150);
  94 }
  95 
  96 /*
  97  * Main i2c-icy part
  98  */
  99 static unsigned short const icy_ltc2990_addresses[] = {
 100         0x4c, 0x4d, 0x4e, 0x4f, I2C_CLIENT_END
 101 };
 102 
 103 /*
 104  * Additional sensors exposed once this property is applied:
 105  *
 106  * in1 will be the voltage of the 5V rail, divided by 2.
 107  * in2 will be the voltage of the 12V rail, divided by 4.
 108  * temp3 will be measured using a PCB loop next the chip.
 109  */
 110 static const u32 icy_ltc2990_meas_mode[] = {0, 3};
 111 
 112 static const struct property_entry icy_ltc2990_props[] = {
 113         PROPERTY_ENTRY_U32_ARRAY("lltc,meas-mode", icy_ltc2990_meas_mode),
 114         { }
 115 };
 116 
 117 static int icy_probe(struct zorro_dev *z,
 118                      const struct zorro_device_id *ent)
 119 {
 120         struct icy_i2c *i2c;
 121         struct i2c_algo_pcf_data *algo_data;
 122         struct fwnode_handle *new_fwnode;
 123         struct i2c_board_info ltc2990_info = {
 124                 .type           = "ltc2990",
 125                 .addr           = 0x4c,
 126         };
 127 
 128         i2c = devm_kzalloc(&z->dev, sizeof(*i2c), GFP_KERNEL);
 129         if (!i2c)
 130                 return -ENOMEM;
 131 
 132         algo_data = devm_kzalloc(&z->dev, sizeof(*algo_data), GFP_KERNEL);
 133         if (!algo_data)
 134                 return -ENOMEM;
 135 
 136         dev_set_drvdata(&z->dev, i2c);
 137         i2c->adapter.dev.parent = &z->dev;
 138         i2c->adapter.owner = THIS_MODULE;
 139         /* i2c->adapter.algo assigned by i2c_pcf_add_bus() */
 140         i2c->adapter.algo_data = algo_data;
 141         strlcpy(i2c->adapter.name, "ICY I2C Zorro adapter",
 142                 sizeof(i2c->adapter.name));
 143 
 144         if (!devm_request_mem_region(&z->dev,
 145                                      z->resource.start,
 146                                      4, i2c->adapter.name))
 147                 return -ENXIO;
 148 
 149         /* Driver private data */
 150         i2c->reg_s0 = ZTWO_VADDR(z->resource.start);
 151         i2c->reg_s1 = ZTWO_VADDR(z->resource.start + 2);
 152 
 153         algo_data->data = i2c;
 154         algo_data->setpcf     = icy_pcf_setpcf;
 155         algo_data->getpcf     = icy_pcf_getpcf;
 156         algo_data->getown     = icy_pcf_getown;
 157         algo_data->getclock   = icy_pcf_getclock;
 158         algo_data->waitforpin = icy_pcf_waitforpin;
 159 
 160         if (i2c_pcf_add_bus(&i2c->adapter)) {
 161                 dev_err(&z->dev, "i2c_pcf_add_bus() failed\n");
 162                 return -ENXIO;
 163         }
 164 
 165         dev_info(&z->dev, "ICY I2C controller at %pa, IRQ not implemented\n",
 166                  &z->resource.start);
 167 
 168         /*
 169          * The 2019 a1k.org PCBs have an LTC2990 at 0x4c, so start
 170          * it automatically once ltc2990 is modprobed.
 171          *
 172          * in0 is the voltage of the internal 5V power supply.
 173          * temp1 is the temperature inside the chip.
 174          *
 175          * See property_entry above for in1, in2, temp3.
 176          */
 177         new_fwnode = fwnode_create_software_node(icy_ltc2990_props, NULL);
 178         if (IS_ERR(new_fwnode)) {
 179                 dev_info(&z->dev, "Failed to create fwnode for LTC2990, error: %ld\n",
 180                          PTR_ERR(new_fwnode));
 181         } else {
 182                 /*
 183                  * Store the fwnode so we can destroy it on .remove().
 184                  * Only store it on success, as fwnode_remove_software_node()
 185                  * is NULL safe, but not PTR_ERR safe.
 186                  */
 187                 i2c->ltc2990_fwnode = new_fwnode;
 188                 ltc2990_info.fwnode = new_fwnode;
 189 
 190                 i2c->ltc2990_client =
 191                         i2c_new_probed_device(&i2c->adapter,
 192                                               &ltc2990_info,
 193                                               icy_ltc2990_addresses,
 194                                               NULL);
 195         }
 196 
 197         return 0;
 198 }
 199 
 200 static void icy_remove(struct zorro_dev *z)
 201 {
 202         struct icy_i2c *i2c = dev_get_drvdata(&z->dev);
 203 
 204         i2c_unregister_device(i2c->ltc2990_client);
 205         fwnode_remove_software_node(i2c->ltc2990_fwnode);
 206 
 207         i2c_del_adapter(&i2c->adapter);
 208 }
 209 
 210 static const struct zorro_device_id icy_zorro_tbl[] = {
 211         { ZORRO_ID(VMC, 15, 0), },
 212         { 0 }
 213 };
 214 
 215 MODULE_DEVICE_TABLE(zorro, icy_zorro_tbl);
 216 
 217 static struct zorro_driver icy_driver = {
 218         .name           = "i2c-icy",
 219         .id_table       = icy_zorro_tbl,
 220         .probe          = icy_probe,
 221         .remove         = icy_remove,
 222 };
 223 
 224 module_driver(icy_driver,
 225               zorro_register_driver,
 226               zorro_unregister_driver);
 227 
 228 MODULE_AUTHOR("Max Staudt <max@enpas.org>");
 229 MODULE_DESCRIPTION("I2C bus via PCF8584 on ICY Zorro card");
 230 MODULE_LICENSE("GPL v2");