aeec437104ebc9ecfeb699a1a940ac3231bb62b9
[linux-2.6.git] / drivers / video / savage / savagefb-i2c.c
1 /*
2  * linux/drivers/video/savage/savagefb-i2c.c - S3 Savage DDC2
3  *
4  * Copyright 2004 Antonino A. Daplas <adaplas @pol.net>
5  *
6  * Based partly on rivafb-i2c.c
7  *
8  * This file is subject to the terms and conditions of the GNU General Public
9  * License.  See the file COPYING in the main directory of this archive
10  * for more details.
11  */
12
13 #include <linux/config.h>
14 #include <linux/module.h>
15 #include <linux/kernel.h>
16 #include <linux/sched.h>
17 #include <linux/delay.h>
18 #include <linux/pci.h>
19 #include <linux/fb.h>
20
21 #include <asm/io.h>
22 #include "savagefb.h"
23
24 #define SAVAGE_DDC      0x50
25
26 #define VGA_CR_IX       0x3d4
27 #define VGA_CR_DATA     0x3d5
28
29 #define CR_SERIAL1      0xa0    /* I2C serial communications interface */
30 #define MM_SERIAL1      0xff20
31 #define CR_SERIAL2      0xb1    /* DDC2 monitor communications interface */
32
33 /* based on vt8365 documentation */
34 #define PROSAVAGE_I2C_ENAB      0x10
35 #define PROSAVAGE_I2C_SCL_OUT   0x01
36 #define PROSAVAGE_I2C_SDA_OUT   0x02
37 #define PROSAVAGE_I2C_SCL_IN    0x04
38 #define PROSAVAGE_I2C_SDA_IN    0x08
39
40 #define SAVAGE4_I2C_ENAB        0x00000020
41 #define SAVAGE4_I2C_SCL_OUT     0x00000001
42 #define SAVAGE4_I2C_SDA_OUT     0x00000002
43 #define SAVAGE4_I2C_SCL_IN      0x00000008
44 #define SAVAGE4_I2C_SDA_IN      0x00000010
45
46 #define SET_CR_IX(base, val)    writeb((val), base + 0x8000 + VGA_CR_IX)
47 #define SET_CR_DATA(base, val)  writeb((val), base + 0x8000 + VGA_CR_DATA)
48 #define GET_CR_DATA(base)       readb(base + 0x8000 + VGA_CR_DATA)
49
50 static void savage4_gpio_setscl(void *data, int val)
51 {
52         struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
53         unsigned int r;
54
55         r = readl(chan->ioaddr + chan->reg);
56         if(val)
57                 r |= SAVAGE4_I2C_SCL_OUT;
58         else
59                 r &= ~SAVAGE4_I2C_SCL_OUT;
60         writel(r, chan->ioaddr + chan->reg);
61         readl(chan->ioaddr + chan->reg);        /* flush posted write */
62 }
63
64 static void savage4_gpio_setsda(void *data, int val)
65 {
66         struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
67
68         unsigned int r;
69         r = readl(chan->ioaddr + chan->reg);
70         if(val)
71                 r |= SAVAGE4_I2C_SDA_OUT;
72         else
73                 r &= ~SAVAGE4_I2C_SDA_OUT;
74         writel(r, chan->ioaddr + chan->reg);
75         readl(chan->ioaddr + chan->reg);        /* flush posted write */
76 }
77
78 static int savage4_gpio_getscl(void *data)
79 {
80         struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
81
82         return (0 != (readl(chan->ioaddr + chan->reg) & SAVAGE4_I2C_SCL_IN));
83 }
84
85 static int savage4_gpio_getsda(void *data)
86 {
87         struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
88
89         return (0 != (readl(chan->ioaddr + chan->reg) & SAVAGE4_I2C_SDA_IN));
90 }
91
92 static void prosavage_gpio_setscl(void* data, int val)
93 {
94         struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
95         u32                       r;
96
97         SET_CR_IX(chan->ioaddr, chan->reg);
98         r = GET_CR_DATA(chan->ioaddr);
99         r |= PROSAVAGE_I2C_ENAB;
100         if (val) {
101                 r |= PROSAVAGE_I2C_SCL_OUT;
102         } else {
103                 r &= ~PROSAVAGE_I2C_SCL_OUT;
104         }
105         SET_CR_DATA(chan->ioaddr, r);
106 }
107
108 static void prosavage_gpio_setsda(void* data, int val)
109 {
110         struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
111         unsigned int r;
112
113         SET_CR_IX(chan->ioaddr, chan->reg);
114         r = GET_CR_DATA(chan->ioaddr);
115         r |= PROSAVAGE_I2C_ENAB;
116         if (val) {
117                 r |= PROSAVAGE_I2C_SDA_OUT;
118         } else {
119                 r &= ~PROSAVAGE_I2C_SDA_OUT;
120         }
121         SET_CR_DATA(chan->ioaddr, r);
122 }
123
124 static int prosavage_gpio_getscl(void* data)
125 {
126         struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
127
128         SET_CR_IX(chan->ioaddr, chan->reg);
129         return (0 != (GET_CR_DATA(chan->ioaddr) & PROSAVAGE_I2C_SCL_IN));
130 }
131
132 static int prosavage_gpio_getsda(void* data)
133 {
134         struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
135
136         SET_CR_IX(chan->ioaddr, chan->reg);
137         return (0 != (GET_CR_DATA(chan->ioaddr) & PROSAVAGE_I2C_SDA_IN));
138 }
139
140 static int savage_setup_i2c_bus(struct savagefb_i2c_chan *chan,
141                                 const char *name)
142 {
143         int (*add_bus)(struct i2c_adapter *) = symbol_get(i2c_bit_add_bus);
144         int rc = 0;
145
146         if (add_bus && chan->par) {
147                 strcpy(chan->adapter.name, name);
148                 chan->adapter.owner             = THIS_MODULE;
149                 chan->adapter.id                = I2C_HW_B_SAVAGE;
150                 chan->adapter.algo_data         = &chan->algo;
151                 chan->adapter.dev.parent        = &chan->par->pcidev->dev;
152                 chan->algo.udelay               = 40;
153                 chan->algo.mdelay               = 5;
154                 chan->algo.timeout              = 20;
155                 chan->algo.data                 = chan;
156
157                 i2c_set_adapdata(&chan->adapter, chan);
158
159                 /* Raise SCL and SDA */
160                 chan->algo.setsda(chan, 1);
161                 chan->algo.setscl(chan, 1);
162                 udelay(20);
163
164                 rc = add_bus(&chan->adapter);
165
166                 if (rc == 0)
167                         dev_dbg(&chan->par->pcidev->dev,
168                                 "I2C bus %s registered.\n", name);
169                 else
170                         dev_warn(&chan->par->pcidev->dev,
171                                  "Failed to register I2C bus %s.\n", name);
172
173                 symbol_put(i2c_bit_add_bus);
174         } else
175                 chan->par = NULL;
176
177         return rc;
178 }
179
180 void savagefb_create_i2c_busses(struct fb_info *info)
181 {
182         struct savagefb_par *par = (struct savagefb_par *)info->par;
183         par->chan.par   = par;
184
185         switch(info->fix.accel) {
186         case FB_ACCEL_PROSAVAGE_DDRK:
187         case FB_ACCEL_PROSAVAGE_PM:
188                 par->chan.reg         = CR_SERIAL2;
189                 par->chan.ioaddr      = par->mmio.vbase;
190                 par->chan.algo.setsda = prosavage_gpio_setsda;
191                 par->chan.algo.setscl = prosavage_gpio_setscl;
192                 par->chan.algo.getsda = prosavage_gpio_getsda;
193                 par->chan.algo.getscl = prosavage_gpio_getscl;
194                 break;
195         case FB_ACCEL_SAVAGE4:
196         case FB_ACCEL_SAVAGE2000:
197                 par->chan.reg         = 0xff20;
198                 par->chan.ioaddr      = par->mmio.vbase;
199                 par->chan.algo.setsda = savage4_gpio_setsda;
200                 par->chan.algo.setscl = savage4_gpio_setscl;
201                 par->chan.algo.getsda = savage4_gpio_getsda;
202                 par->chan.algo.getscl = savage4_gpio_getscl;
203                 break;
204         default:
205                 par->chan.par = NULL;
206         }
207
208         savage_setup_i2c_bus(&par->chan, "SAVAGE DDC2");
209 }
210
211 void savagefb_delete_i2c_busses(struct fb_info *info)
212 {
213         struct savagefb_par *par = (struct savagefb_par *)info->par;
214         int (*del_bus)(struct i2c_adapter *) =
215                 symbol_get(i2c_bit_del_bus);
216
217         if (del_bus && par->chan.par) {
218                 del_bus(&par->chan.adapter);
219                 symbol_put(i2c_bit_del_bus);
220         }
221
222         par->chan.par = NULL;
223 }
224
225 static u8 *savage_do_probe_i2c_edid(struct savagefb_i2c_chan *chan)
226 {
227         u8 start = 0x0;
228         int (*transfer)(struct i2c_adapter *, struct i2c_msg *, int) =
229                 symbol_get(i2c_transfer);
230         struct i2c_msg msgs[] = {
231                 {
232                         .addr   = SAVAGE_DDC,
233                         .len    = 1,
234                         .buf    = &start,
235                 }, {
236                         .addr   = SAVAGE_DDC,
237                         .flags  = I2C_M_RD,
238                         .len    = EDID_LENGTH,
239                 },
240         };
241         u8 *buf = NULL;
242
243         if (transfer && chan->par) {
244                 buf = kmalloc(EDID_LENGTH, GFP_KERNEL);
245
246                 if (buf) {
247                         msgs[1].buf = buf;
248
249                         if (transfer(&chan->adapter, msgs, 2) != 2) {
250                                 dev_dbg(&chan->par->pcidev->dev,
251                                         "Unable to read EDID block.\n");
252                                 kfree(buf);
253                                 buf = NULL;
254                         }
255                 }
256
257                 symbol_put(i2c_transfer);
258         }
259
260         return buf;
261 }
262
263 int savagefb_probe_i2c_connector(struct fb_info *info, u8 **out_edid)
264 {
265         struct savagefb_par *par = info->par;
266         u8 *edid = NULL;
267         int i;
268
269         for (i = 0; i < 3; i++) {
270                 /* Do the real work */
271                 edid = savage_do_probe_i2c_edid(&par->chan);
272                 if (edid)
273                         break;
274         }
275
276         if (!edid) {
277                 /* try to get from firmware */
278                 const u8 *e = fb_firmware_edid(info->device);
279
280                 if (e) {
281                         edid = kmalloc(EDID_LENGTH, GFP_KERNEL);
282                         if (edid)
283                                 memcpy(edid, e, EDID_LENGTH);
284                 }
285         }
286
287         if (out_edid)
288                 *out_edid = edid;
289
290         return (edid) ? 0 : 1;
291 }
292
293 MODULE_LICENSE("GPL");