]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/video/via/via_i2c.c
021112e279dea051ed07a5537f79d89142c5a4dd
[~shefty/rdma-dev.git] / 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 <linux/delay.h>
24 #include <linux/spinlock.h>
25 #include <linux/module.h>
26 #include <linux/via-core.h>
27 #include <linux/via_i2c.h>
28
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];
35 struct viafb_dev *i2c_vdev;  /* Passed in from core */
36
37 static void via_i2c_setscl(void *data, int state)
38 {
39         u8 val;
40         struct via_port_cfg *adap_data = data;
41         unsigned long flags;
42
43         spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
44         val = via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0xF0;
45         if (state)
46                 val |= 0x20;
47         else
48                 val &= ~0x20;
49         switch (adap_data->type) {
50         case VIA_PORT_I2C:
51                 val |= 0x01;
52                 break;
53         case VIA_PORT_GPIO:
54                 val |= 0x80;
55                 break;
56         default:
57                 printk(KERN_ERR "viafb_i2c: specify wrong i2c type.\n");
58         }
59         via_write_reg(adap_data->io_port, adap_data->ioport_index, val);
60         spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
61 }
62
63 static int via_i2c_getscl(void *data)
64 {
65         struct via_port_cfg *adap_data = data;
66         unsigned long flags;
67         int ret = 0;
68
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;
74 }
75
76 static int via_i2c_getsda(void *data)
77 {
78         struct via_port_cfg *adap_data = data;
79         unsigned long flags;
80         int ret = 0;
81
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;
87 }
88
89 static void via_i2c_setsda(void *data, int state)
90 {
91         u8 val;
92         struct via_port_cfg *adap_data = data;
93         unsigned long flags;
94
95         spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
96         val = via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0xF0;
97         if (state)
98                 val |= 0x10;
99         else
100                 val &= ~0x10;
101         switch (adap_data->type) {
102         case VIA_PORT_I2C:
103                 val |= 0x01;
104                 break;
105         case VIA_PORT_GPIO:
106                 val |= 0x40;
107                 break;
108         default:
109                 printk(KERN_ERR "viafb_i2c: specify wrong i2c type.\n");
110         }
111         via_write_reg(adap_data->io_port, adap_data->ioport_index, val);
112         spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
113 }
114
115 int viafb_i2c_readbyte(u8 adap, u8 slave_addr, u8 index, u8 *pdata)
116 {
117         int ret;
118         u8 mm1[] = {0x00};
119         struct i2c_msg msgs[2];
120
121         if (!via_i2c_par[adap].is_active)
122                 return -ENODEV;
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;
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;
137 }
138
139 int viafb_i2c_writebyte(u8 adap, u8 slave_addr, u8 index, u8 data)
140 {
141         int ret;
142         u8 msg[2] = { index, data };
143         struct i2c_msg msgs;
144
145         if (!via_i2c_par[adap].is_active)
146                 return -ENODEV;
147         msgs.flags = 0;
148         msgs.addr = slave_addr / 2;
149         msgs.len = 2;
150         msgs.buf = msg;
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;
158 }
159
160 int viafb_i2c_readbytes(u8 adap, u8 slave_addr, u8 index, u8 *buff, int buff_len)
161 {
162         int ret;
163         u8 mm1[] = {0x00};
164         struct i2c_msg msgs[2];
165
166         if (!via_i2c_par[adap].is_active)
167                 return -ENODEV;
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;
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;
181 }
182
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
196 static int create_i2c_bus(struct i2c_adapter *adapter,
197                           struct i2c_algo_bit_data *algo,
198                           struct via_port_cfg *adap_cfg,
199                           struct pci_dev *pdev)
200 {
201         algo->setsda = via_i2c_setsda;
202         algo->setscl = via_i2c_setscl;
203         algo->getsda = via_i2c_getsda;
204         algo->getscl = via_i2c_getscl;
205         algo->udelay = 40;
206         algo->timeout = 20;
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
229 static int viafb_i2c_probe(struct platform_device *platdev)
230 {
231         int i, ret;
232         struct via_port_cfg *configs;
233
234         i2c_vdev = platdev->dev.platform_data;
235         configs = i2c_vdev->port_cfg;
236
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];
240
241                 i2c_stuff->is_active = 0;
242                 if (adap_cfg->type == 0 || adap_cfg->mode != VIA_MODE_I2C)
243                         continue;
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);
250                         continue;  /* Still try to make the rest */
251                 }
252                 i2c_stuff->is_active = 1;
253         }
254
255         return 0;
256 }
257
258 static int viafb_i2c_remove(struct platform_device *platdev)
259 {
260         int i;
261
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                  */
268                 if (i2c_stuff->is_active)
269                         i2c_del_adapter(&i2c_stuff->adapter);
270         }
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);
290 }