drivers/video/via/via_i2c.c

   1 /*
   2  * Copyright 1998-2009 VIA Technologies, Inc. All Rights Reserved.
   3  * Copyright 2001-2008 S3 Graphics, Inc. All Rights Reserved.
   4
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public
   7  * License as published by the Free Software Foundation;
   8  * either version 2, or (at your option) any later version.
   9
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTIES OR REPRESENTATIONS; without even
  12  * the implied warranty of MERCHANTABILITY or FITNESS FOR
  13  * A PARTICULAR PURPOSE.See the GNU General Public License
  14  * for more details.
  15
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc.,
  19  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include <linux/platform_device.h>
  23 #include "via-core.h"
  24 #include "via_i2c.h"
  25 #include "global.h"
  26
  27 /*
  28  * There can only be one set of these, so there's no point in having
  29  * them be dynamically allocated...
  30  */
  31 #define VIAFB_NUM_I2C           5
  32 static struct via_i2c_stuff via_i2c_par[VIAFB_NUM_I2C];
  33 struct viafb_dev *i2c_vdev;  /* Passed in from core */
  34
  35 static void via_i2c_setscl(void *data, int state)
  36 {
  37         u8 val;
  38         struct via_port_cfg *adap_data = data;
  39         unsigned long flags;
  40
  41         spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
  42         val = via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0xF0;
  43         if (state)
  44                 val |= 0x20;
  45         else
  46                 val &= ~0x20;
  47         switch (adap_data->type) {
  48         case VIA_PORT_I2C:
  49                 val |= 0x01;
  50                 break;
  51         case VIA_PORT_GPIO:
  52                 val |= 0x80;
  53                 break;
  54         default:
  55                 DEBUG_MSG("viafb_i2c: specify wrong i2c type.\n");
  56         }
  57         via_write_reg(adap_data->io_port, adap_data->ioport_index, val);
  58         spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
  59 }
  60
  61 static int via_i2c_getscl(void *data)
  62 {
  63         struct via_port_cfg *adap_data = data;
  64         unsigned long flags;
  65         int ret = 0;
  66
  67         spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
  68         if (via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0x08)
  69                 ret = 1;
  70         spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
  71         return ret;
  72 }
  73
  74 static int via_i2c_getsda(void *data)
  75 {
  76         struct via_port_cfg *adap_data = data;
  77         unsigned long flags;
  78         int ret = 0;
  79
  80         spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
  81         if (via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0x04)
  82                 ret = 1;
  83         spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
  84         return ret;
  85 }
  86
  87 static void via_i2c_setsda(void *data, int state)
  88 {
  89         u8 val;
  90         struct via_port_cfg *adap_data = data;
  91         unsigned long flags;
  92
  93         spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
  94         val = via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0xF0;
  95         if (state)
  96                 val |= 0x10;
  97         else
  98                 val &= ~0x10;
  99         switch (adap_data->type) {
 100         case VIA_PORT_I2C:
 101                 val |= 0x01;
 102                 break;
 103         case VIA_PORT_GPIO:
 104                 val |= 0x40;
 105                 break;
 106         default:
 107                 DEBUG_MSG("viafb_i2c: specify wrong i2c type.\n");
 108         }
 109         via_write_reg(adap_data->io_port, adap_data->ioport_index, val);
 110         spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
 111 }
 112
 113 int viafb_i2c_readbyte(u8 adap, u8 slave_addr, u8 index, u8 *pdata)
 114 {
 115         u8 mm1[] = {0x00};
 116         struct i2c_msg msgs[2];
 117
 118         if (!via_i2c_par[adap].is_active)
 119                 return -ENODEV;
 120         *pdata = 0;
 121         msgs[0].flags = 0;
 122         msgs[1].flags = I2C_M_RD;
 123         msgs[0].addr = msgs[1].addr = slave_addr / 2;
 124         mm1[0] = index;
 125         msgs[0].len = 1; msgs[1].len = 1;
 126         msgs[0].buf = mm1; msgs[1].buf = pdata;
 127         return i2c_transfer(&via_i2c_par[adap].adapter, msgs, 2);
 128 }
 129
 130 int viafb_i2c_writebyte(u8 adap, u8 slave_addr, u8 index, u8 data)
 131 {
 132         u8 msg[2] = { index, data };
 133         struct i2c_msg msgs;
 134
 135         if (!via_i2c_par[adap].is_active)
 136                 return -ENODEV;
 137         msgs.flags = 0;
 138         msgs.addr = slave_addr / 2;
 139         msgs.len = 2;
 140         msgs.buf = msg;
 141         return i2c_transfer(&via_i2c_par[adap].adapter, &msgs, 1);
 142 }
 143
 144 int viafb_i2c_readbytes(u8 adap, u8 slave_addr, u8 index, u8 *buff, int buff_len)
 145 {
 146         u8 mm1[] = {0x00};
 147         struct i2c_msg msgs[2];
 148
 149         if (!via_i2c_par[adap].is_active)
 150                 return -ENODEV;
 151         msgs[0].flags = 0;
 152         msgs[1].flags = I2C_M_RD;
 153         msgs[0].addr = msgs[1].addr = slave_addr / 2;
 154         mm1[0] = index;
 155         msgs[0].len = 1; msgs[1].len = buff_len;
 156         msgs[0].buf = mm1; msgs[1].buf = buff;
 157         return i2c_transfer(&via_i2c_par[adap].adapter, msgs, 2);
 158 }
 159
 160 static int create_i2c_bus(struct i2c_adapter *adapter,
 161                           struct i2c_algo_bit_data *algo,
 162                           struct via_port_cfg *adap_cfg,
 163                           struct pci_dev *pdev)
 164 {
 165         DEBUG_MSG(KERN_DEBUG "viafb: creating bus adap=0x%p, algo_bit_data=0x%p, adap_cfg=0x%p\n", adapter, algo, adap_cfg);
 166
 167         algo->setsda = via_i2c_setsda;
 168         algo->setscl = via_i2c_setscl;
 169         algo->getsda = via_i2c_getsda;
 170         algo->getscl = via_i2c_getscl;
 171         algo->udelay = 40;
 172         algo->timeout = 20;
 173         algo->data = adap_cfg;
 174
 175         sprintf(adapter->name, "viafb i2c io_port idx 0x%02x",
 176                 adap_cfg->ioport_index);
 177         adapter->owner = THIS_MODULE;
 178         adapter->id = 0x01FFFF;
 179         adapter->class = I2C_CLASS_DDC;
 180         adapter->algo_data = algo;
 181         if (pdev)
 182                 adapter->dev.parent = &pdev->dev;
 183         else
 184                 adapter->dev.parent = NULL;
 185         /* i2c_set_adapdata(adapter, adap_cfg); */
 186
 187         /* Raise SCL and SDA */
 188         via_i2c_setsda(adap_cfg, 1);
 189         via_i2c_setscl(adap_cfg, 1);
 190         udelay(20);
 191
 192         return i2c_bit_add_bus(adapter);
 193 }
 194
 195 static int viafb_i2c_probe(struct platform_device *platdev)
 196 {
 197         int i, ret;
 198         struct via_port_cfg *configs;
 199
 200         i2c_vdev = platdev->dev.platform_data;
 201         configs = i2c_vdev->port_cfg;
 202
 203         for (i = 0; i < VIAFB_NUM_PORTS; i++) {
 204                 struct via_port_cfg *adap_cfg = configs++;
 205                 struct via_i2c_stuff *i2c_stuff = &via_i2c_par[i];
 206
 207                 i2c_stuff->is_active = 0;
 208                 if (adap_cfg->type == 0 || adap_cfg->mode != VIA_MODE_I2C)
 209                         continue;
 210                 ret = create_i2c_bus(&i2c_stuff->adapter,
 211                                      &i2c_stuff->algo, adap_cfg,
 212                                 NULL); /* FIXME: PCIDEV */
 213                 if (ret < 0) {
 214                         printk(KERN_ERR "viafb: cannot create i2c bus %u:%d\n",
 215                                 i, ret);
 216                         continue;  /* Still try to make the rest */
 217                 }
 218                 i2c_stuff->is_active = 1;
 219         }
 220
 221         return 0;
 222 }
 223
 224 static int viafb_i2c_remove(struct platform_device *platdev)
 225 {
 226         int i;
 227
 228         for (i = 0; i < VIAFB_NUM_PORTS; i++) {
 229                 struct via_i2c_stuff *i2c_stuff = &via_i2c_par[i];
 230                 /*
 231                  * Only remove those entries in the array that we've
 232                  * actually used (and thus initialized algo_data)
 233                  */
 234                 if (i2c_stuff->is_active)
 235                         i2c_del_adapter(&i2c_stuff->adapter);
 236         }
 237         return 0;
 238 }
 239
 240 static struct platform_driver via_i2c_driver = {
 241         .driver = {
 242                 .name = "viafb-i2c",
 243         },
 244         .probe = viafb_i2c_probe,
 245         .remove = viafb_i2c_remove,
 246 };
 247
 248 int viafb_i2c_init(void)
 249 {
 250         return platform_driver_register(&via_i2c_driver);
 251 }
 252
 253 void viafb_i2c_exit(void)
 254 {
 255         platform_driver_unregister(&via_i2c_driver);
 256 }