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