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
via_i2c_setscl(void * data,int state)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
via_i2c_getscl(void * data)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
via_i2c_getsda(void * data)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
via_i2c_setsda(void * data,int state)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
viafb_i2c_readbyte(u8 adap,u8 target_addr,u8 index,u8 * pdata)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
viafb_i2c_writebyte(u8 adap,u8 target_addr,u8 index,u8 data)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
viafb_i2c_readbytes(u8 adap,u8 target_addr,u8 index,u8 * buff,int buff_len)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 */
viafb_find_i2c_adapter(enum viafb_i2c_adap which)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
create_i2c_bus(struct i2c_adapter * adapter,struct i2c_algo_bit_data * algo,struct via_port_cfg * adap_cfg,struct pci_dev * pdev)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
viafb_i2c_probe(struct platform_device * platdev)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
viafb_i2c_remove(struct platform_device * platdev)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
viafb_i2c_init(void)271 int viafb_i2c_init(void)
272 {
273 return platform_driver_register(&via_i2c_driver);
274 }
275
viafb_i2c_exit(void)276 void viafb_i2c_exit(void)
277 {
278 platform_driver_unregister(&via_i2c_driver);
279 }
280