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