drivers/video/fbdev/via/via_i2c.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright 1998-2009 VIA Technologies, Inc. All Rights Reserved.
   4  * Copyright 2001-2008 S3 Graphics, Inc. All Rights Reserved.
   5
   6  */
   7
   8 #include <linux/platform_device.h>
   9 #include <linux/delay.h>
  10 #include <linux/spinlock.h>
  11 #include <linux/module.h>
  12 #include <linux/via-core.h>
  13 #include <linux/via_i2c.h>
  14
  15 /*
  16  * There can only be one set of these, so there's no point in having
  17  * them be dynamically allocated...
  18  */
  19 #define VIAFB_NUM_I2C           5
  20 static struct via_i2c_stuff via_i2c_par[VIAFB_NUM_I2C];
  21 static struct viafb_dev *i2c_vdev;  /* Passed in from core */
  22
  23 static void via_i2c_setscl(void *data, int state)
  24 {
  25         u8 val;
  26         struct via_port_cfg *adap_data = data;
  27         unsigned long flags;
  28
  29         spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
  30         val = via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0xF0;
  31         if (state)
  32                 val |= 0x20;
  33         else
  34                 val &= ~0x20;
  35         switch (adap_data->type) {
  36         case VIA_PORT_I2C:
  37                 val |= 0x01;
  38                 break;
  39         case VIA_PORT_GPIO:
  40                 val |= 0x82;
  41                 break;
  42         default:
  43                 printk(KERN_ERR "viafb_i2c: specify wrong i2c type.\n");
  44         }
  45         via_write_reg(adap_data->io_port, adap_data->ioport_index, val);
  46         spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
  47 }
  48
  49 static int via_i2c_getscl(void *data)
  50 {
  51         struct via_port_cfg *adap_data = data;
  52         unsigned long flags;
  53         int ret = 0;
  54
  55         spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
  56         if (adap_data->type == VIA_PORT_GPIO)
  57                 via_write_reg_mask(adap_data->io_port, adap_data->ioport_index,
  58                         0, 0x80);
  59         if (via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0x08)
  60                 ret = 1;
  61         spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
  62         return ret;
  63 }
  64
  65 static int via_i2c_getsda(void *data)
  66 {
  67         struct via_port_cfg *adap_data = data;
  68         unsigned long flags;
  69         int ret = 0;
  70
  71         spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
  72         if (adap_data->type == VIA_PORT_GPIO)
  73                 via_write_reg_mask(adap_data->io_port, adap_data->ioport_index,
  74                         0, 0x40);
  75         if (via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0x04)
  76                 ret = 1;
  77         spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
  78         return ret;
  79 }
  80
  81 static void via_i2c_setsda(void *data, int state)
  82 {
  83         u8 val;
  84         struct via_port_cfg *adap_data = data;
  85         unsigned long flags;
  86
  87         spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
  88         val = via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0xF0;
  89         if (state)
  90                 val |= 0x10;
  91         else
  92                 val &= ~0x10;
  93         switch (adap_data->type) {
  94         case VIA_PORT_I2C:
  95                 val |= 0x01;
  96                 break;
  97         case VIA_PORT_GPIO:
  98                 val |= 0x42;
  99                 break;
 100         default:
 101                 printk(KERN_ERR "viafb_i2c: specify wrong i2c type.\n");
 102         }
 103         via_write_reg(adap_data->io_port, adap_data->ioport_index, val);
 104         spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
 105 }
 106
 107 int viafb_i2c_readbyte(u8 adap, u8 target_addr, u8 index, u8 *pdata)
 108 {
 109         int ret;
 110         u8 mm1[] = {0x00};
 111         struct i2c_msg msgs[2];
 112
 113         if (!via_i2c_par[adap].is_active)
 114                 return -ENODEV;
 115         *pdata = 0;
 116         msgs[0].flags = 0;
 117         msgs[1].flags = I2C_M_RD;
 118         msgs[0].addr = msgs[1].addr = target_addr / 2;
 119         mm1[0] = index;
 120         msgs[0].len = 1; msgs[1].len = 1;
 121         msgs[0].buf = mm1; msgs[1].buf = pdata;
 122         ret = i2c_transfer(&via_i2c_par[adap].adapter, msgs, 2);
 123         if (ret == 2)
 124                 ret = 0;
 125         else if (ret >= 0)
 126                 ret = -EIO;
 127
 128         return ret;
 129 }
 130
 131 int viafb_i2c_writebyte(u8 adap, u8 target_addr, u8 index, u8 data)
 132 {
 133         int ret;
 134         u8 msg[2] = { index, data };
 135         struct i2c_msg msgs;
 136
 137         if (!via_i2c_par[adap].is_active)
 138                 return -ENODEV;
 139         msgs.flags = 0;
 140         msgs.addr = target_addr / 2;
 141         msgs.len = 2;
 142         msgs.buf = msg;
 143         ret = i2c_transfer(&via_i2c_par[adap].adapter, &msgs, 1);
 144         if (ret == 1)
 145                 ret = 0;
 146         else if (ret >= 0)
 147                 ret = -EIO;
 148
 149         return ret;
 150 }
 151
 152 int viafb_i2c_readbytes(u8 adap, u8 target_addr, u8 index, u8 *buff, int buff_len)
 153 {
 154         int ret;
 155         u8 mm1[] = {0x00};
 156         struct i2c_msg msgs[2];
 157
 158         if (!via_i2c_par[adap].is_active)
 159                 return -ENODEV;
 160         msgs[0].flags = 0;
 161         msgs[1].flags = I2C_M_RD;
 162         msgs[0].addr = msgs[1].addr = target_addr / 2;
 163         mm1[0] = index;
 164         msgs[0].len = 1; msgs[1].len = buff_len;
 165         msgs[0].buf = mm1; msgs[1].buf = buff;
 166         ret = i2c_transfer(&via_i2c_par[adap].adapter, msgs, 2);
 167         if (ret == 2)
 168                 ret = 0;
 169         else if (ret >= 0)
 170                 ret = -EIO;
 171
 172         return ret;
 173 }
 174
 175 /*
 176  * Allow other viafb subdevices to look up a specific adapter
 177  * by port name.
 178  */
 179 struct i2c_adapter *viafb_find_i2c_adapter(enum viafb_i2c_adap which)
 180 {
 181         struct via_i2c_stuff *stuff = &via_i2c_par[which];
 182
 183         return &stuff->adapter;
 184 }
 185 EXPORT_SYMBOL_GPL(viafb_find_i2c_adapter);
 186
 187
 188 static int create_i2c_bus(struct i2c_adapter *adapter,
 189                           struct i2c_algo_bit_data *algo,
 190                           struct via_port_cfg *adap_cfg,
 191                           struct pci_dev *pdev)
 192 {
 193         algo->setsda = via_i2c_setsda;
 194         algo->setscl = via_i2c_setscl;
 195         algo->getsda = via_i2c_getsda;
 196         algo->getscl = via_i2c_getscl;
 197         algo->udelay = 10;
 198         algo->timeout = 2;
 199         algo->data = adap_cfg;
 200
 201         sprintf(adapter->name, "viafb i2c io_port idx 0x%02x",
 202                 adap_cfg->ioport_index);
 203         adapter->owner = THIS_MODULE;
 204         adapter->algo_data = algo;
 205         if (pdev)
 206                 adapter->dev.parent = &pdev->dev;
 207         else
 208                 adapter->dev.parent = NULL;
 209         /* i2c_set_adapdata(adapter, adap_cfg); */
 210
 211         /* Raise SCL and SDA */
 212         via_i2c_setsda(adap_cfg, 1);
 213         via_i2c_setscl(adap_cfg, 1);
 214         udelay(20);
 215
 216         return i2c_bit_add_bus(adapter);
 217 }
 218
 219 static int viafb_i2c_probe(struct platform_device *platdev)
 220 {
 221         int i, ret;
 222         struct via_port_cfg *configs;
 223
 224         i2c_vdev = platdev->dev.platform_data;
 225         configs = i2c_vdev->port_cfg;
 226
 227         for (i = 0; i < VIAFB_NUM_PORTS; i++) {
 228                 struct via_port_cfg *adap_cfg = configs++;
 229                 struct via_i2c_stuff *i2c_stuff = &via_i2c_par[i];
 230
 231                 i2c_stuff->is_active = 0;
 232                 if (adap_cfg->type == 0 || adap_cfg->mode != VIA_MODE_I2C)
 233                         continue;
 234                 ret = create_i2c_bus(&i2c_stuff->adapter,
 235                                      &i2c_stuff->algo, adap_cfg,
 236                                 NULL); /* FIXME: PCIDEV */
 237                 if (ret < 0) {
 238                         printk(KERN_ERR "viafb: cannot create i2c bus %u:%d\n",
 239                                 i, ret);
 240                         continue;  /* Still try to make the rest */
 241                 }
 242                 i2c_stuff->is_active = 1;
 243         }
 244
 245         return 0;
 246 }
 247
 248 static void viafb_i2c_remove(struct platform_device *platdev)
 249 {
 250         int i;
 251
 252         for (i = 0; i < VIAFB_NUM_PORTS; i++) {
 253                 struct via_i2c_stuff *i2c_stuff = &via_i2c_par[i];
 254                 /*
 255                  * Only remove those entries in the array that we've
 256                  * actually used (and thus initialized algo_data)
 257                  */
 258                 if (i2c_stuff->is_active)
 259                         i2c_del_adapter(&i2c_stuff->adapter);
 260         }
 261 }
 262
 263 static struct platform_driver via_i2c_driver = {
 264         .driver = {
 265                 .name = "viafb-i2c",
 266         },
 267         .probe = viafb_i2c_probe,
 268         .remove = viafb_i2c_remove,
 269 };
 270
 271 int viafb_i2c_init(void)
 272 {
 273         return platform_driver_register(&via_i2c_driver);
 274 }
 275
 276 void viafb_i2c_exit(void)
 277 {
 278         platform_driver_unregister(&via_i2c_driver);
 279 }