projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drm/i915: Change I2C api to pass around i2c_adapters
[deliverable/linux.git] / drivers / gpu / drm / i915 / dvo_sil164.c
CommitLineData
79e53945
JB		 1/**************************************************************************
2
3Copyright © 2006 Dave Airlie
4
5All Rights Reserved.
6
7Permission is hereby granted, free of charge, to any person obtaining a
8copy of this software and associated documentation files (the
9"Software"), to deal in the Software without restriction, including
10without limitation the rights to use, copy, modify, merge, publish,
11distribute, sub license, and/or sell copies of the Software, and to
12permit persons to whom the Software is furnished to do so, subject to
13the following conditions:
14
15The above copyright notice and this permission notice (including the
16next paragraph) shall be included in all copies or substantial portions
17of the Software.
18
19THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
22IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
23ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
24TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
25SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26
27**************************************************************************/
28
29#include "dvo.h"
30
31#define SIL164_VID 0x0001
32#define SIL164_DID 0x0006
33
34#define SIL164_VID_LO 0x00
35#define SIL164_VID_HI 0x01
36#define SIL164_DID_LO 0x02
37#define SIL164_DID_HI 0x03
38#define SIL164_REV 0x04
39#define SIL164_RSVD 0x05
40#define SIL164_FREQ_LO 0x06
41#define SIL164_FREQ_HI 0x07
42
43#define SIL164_REG8 0x08
44#define SIL164_8_VEN (1<<5)
45#define SIL164_8_HEN (1<<4)
46#define SIL164_8_DSEL (1<<3)
47#define SIL164_8_BSEL (1<<2)
48#define SIL164_8_EDGE (1<<1)
49#define SIL164_8_PD (1<<0)
50
51#define SIL164_REG9 0x09
52#define SIL164_9_VLOW (1<<7)
53#define SIL164_9_MSEL_MASK (0x7<<4)
54#define SIL164_9_TSEL (1<<3)
55#define SIL164_9_RSEN (1<<2)
56#define SIL164_9_HTPLG (1<<1)
57#define SIL164_9_MDI (1<<0)
58
59#define SIL164_REGC 0x0c
60
61struct sil164_save_rec {
62 uint8_t reg8;
63 uint8_t reg9;
64 uint8_t regc;
65};
66
67struct sil164_priv {
68 //I2CDevRec d;
69 bool quiet;
70 struct sil164_save_rec save_regs;
71 struct sil164_save_rec mode_regs;
72};
73
74#define SILPTR(d) ((SIL164Ptr)(d->DriverPrivate.ptr))
75
76static bool sil164_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
77{
78 struct sil164_priv *sil = dvo->dev_priv;
f9c10a9b
KP		 79 struct i2c_adapter *adapter = dvo->i2c_bus;
80 struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
79e53945
JB		 81 u8 out_buf[2];
82 u8 in_buf[2];
83
84 struct i2c_msg msgs[] = {
85 {
f9c10a9b 86 .addr = dvo->slave_addr,
79e53945
JB		 87 .flags = 0,
88 .len = 1,
89 .buf = out_buf,
90 },
91 {
f9c10a9b 92 .addr = dvo->slave_addr,
79e53945
JB		 93 .flags = I2C_M_RD,
94 .len = 1,
95 .buf = in_buf,
96 }
97 };
98
99 out_buf[0] = addr;
100 out_buf[1] = 0;
101
102 if (i2c_transfer(&i2cbus->adapter, msgs, 2) == 2) {
103 *ch = in_buf[0];
104 return true;
105 };
106
107 if (!sil->quiet) {
108 DRM_DEBUG("Unable to read register 0x%02x from %s:%02x.\n",
f9c10a9b 109 addr, i2cbus->adapter.name, dvo->slave_addr);
79e53945
JB		 110 }
111 return false;
112}
113
114static bool sil164_writeb(struct intel_dvo_device *dvo, int addr, uint8_t ch)
115{
116 struct sil164_priv *sil= dvo->dev_priv;
f9c10a9b
KP		 117 struct i2c_adapter *adapter = dvo->i2c_bus;
118 struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
79e53945
JB		 119 uint8_t out_buf[2];
120 struct i2c_msg msg = {
f9c10a9b 121 .addr = dvo->slave_addr,
79e53945
JB		 122 .flags = 0,
123 .len = 2,
124 .buf = out_buf,
125 };
126
127 out_buf[0] = addr;
128 out_buf[1] = ch;
129
130 if (i2c_transfer(&i2cbus->adapter, &msg, 1) == 1)
131 return true;
132
133 if (!sil->quiet) {
134 DRM_DEBUG("Unable to write register 0x%02x to %s:%d.\n",
f9c10a9b 135 addr, i2cbus->adapter.name, dvo->slave_addr);
79e53945
JB		 136 }
137
138 return false;
139}
140
141/* Silicon Image 164 driver for chip on i2c bus */
142static bool sil164_init(struct intel_dvo_device *dvo,
f9c10a9b 143 struct i2c_adapter *adapter)
79e53945
JB		 144{
145 /* this will detect the SIL164 chip on the specified i2c bus */
146 struct sil164_priv *sil;
147 unsigned char ch;
148
149 sil = kzalloc(sizeof(struct sil164_priv), GFP_KERNEL);
150 if (sil == NULL)
151 return false;
152
f9c10a9b 153 dvo->i2c_bus = adapter;
79e53945
JB		 154 dvo->dev_priv = sil;
155 sil->quiet = true;
156
157 if (!sil164_readb(dvo, SIL164_VID_LO, &ch))
158 goto out;
159
160 if (ch != (SIL164_VID & 0xff)) {
161 DRM_DEBUG("sil164 not detected got %d: from %s Slave %d.\n",
f9c10a9b 162 ch, adapter->name, dvo->slave_addr);
79e53945
JB		 163 goto out;
164 }
165
166 if (!sil164_readb(dvo, SIL164_DID_LO, &ch))
167 goto out;
168
169 if (ch != (SIL164_DID & 0xff)) {
170 DRM_DEBUG("sil164 not detected got %d: from %s Slave %d.\n",
f9c10a9b 171 ch, adapter->name, dvo->slave_addr);
79e53945
JB		 172 goto out;
173 }
174 sil->quiet = false;
175
176 DRM_DEBUG("init sil164 dvo controller successfully!\n");
177 return true;
178
179out:
180 kfree(sil);
181 return false;
182}
183
184static enum drm_connector_status sil164_detect(struct intel_dvo_device *dvo)
185{
186 uint8_t reg9;
187
188 sil164_readb(dvo, SIL164_REG9, &reg9);
189
190 if (reg9 & SIL164_9_HTPLG)
191 return connector_status_connected;
192 else
193 return connector_status_disconnected;
194}
195
196static enum drm_mode_status sil164_mode_valid(struct intel_dvo_device *dvo,
197 struct drm_display_mode *mode)
198{
199 return MODE_OK;
200}
201
202static void sil164_mode_set(struct intel_dvo_device *dvo,
203 struct drm_display_mode *mode,
204 struct drm_display_mode *adjusted_mode)
205{
206 /* As long as the basics are set up, since we don't have clock
207 * dependencies in the mode setup, we can just leave the
208 * registers alone and everything will work fine.
209 */
210 /* recommended programming sequence from doc */
211 /*sil164_writeb(sil, 0x08, 0x30);
212 sil164_writeb(sil, 0x09, 0x00);
213 sil164_writeb(sil, 0x0a, 0x90);
214 sil164_writeb(sil, 0x0c, 0x89);
215 sil164_writeb(sil, 0x08, 0x31);*/
216 /* don't do much */
217 return;
218}
219
220/* set the SIL164 power state */
221static void sil164_dpms(struct intel_dvo_device *dvo, int mode)
222{
223 int ret;
224 unsigned char ch;
225
226 ret = sil164_readb(dvo, SIL164_REG8, &ch);
227 if (ret == false)
228 return;
229
230 if (mode == DRM_MODE_DPMS_ON)
231 ch |= SIL164_8_PD;
232 else
233 ch &= ~SIL164_8_PD;
234
235 sil164_writeb(dvo, SIL164_REG8, ch);
236 return;
237}
238
239static void sil164_dump_regs(struct intel_dvo_device *dvo)
240{
241 uint8_t val;
242
243 sil164_readb(dvo, SIL164_FREQ_LO, &val);
244 DRM_DEBUG("SIL164_FREQ_LO: 0x%02x\n", val);
245 sil164_readb(dvo, SIL164_FREQ_HI, &val);
246 DRM_DEBUG("SIL164_FREQ_HI: 0x%02x\n", val);
247 sil164_readb(dvo, SIL164_REG8, &val);
248 DRM_DEBUG("SIL164_REG8: 0x%02x\n", val);
249 sil164_readb(dvo, SIL164_REG9, &val);
250 DRM_DEBUG("SIL164_REG9: 0x%02x\n", val);
251 sil164_readb(dvo, SIL164_REGC, &val);
252 DRM_DEBUG("SIL164_REGC: 0x%02x\n", val);
253}
254
255static void sil164_save(struct intel_dvo_device *dvo)
256{
257 struct sil164_priv *sil= dvo->dev_priv;
258
259 if (!sil164_readb(dvo, SIL164_REG8, &sil->save_regs.reg8))
260 return;
261
262 if (!sil164_readb(dvo, SIL164_REG9, &sil->save_regs.reg9))
263 return;
264
265 if (!sil164_readb(dvo, SIL164_REGC, &sil->save_regs.regc))
266 return;
267
268 return;
269}
270
271static void sil164_restore(struct intel_dvo_device *dvo)
272{
273 struct sil164_priv *sil = dvo->dev_priv;
274
275 /* Restore it powered down initially */
276 sil164_writeb(dvo, SIL164_REG8, sil->save_regs.reg8 & ~0x1);
277
278 sil164_writeb(dvo, SIL164_REG9, sil->save_regs.reg9);
279 sil164_writeb(dvo, SIL164_REGC, sil->save_regs.regc);
280 sil164_writeb(dvo, SIL164_REG8, sil->save_regs.reg8);
281}
282
283static void sil164_destroy(struct intel_dvo_device *dvo)
284{
285 struct sil164_priv *sil = dvo->dev_priv;
286
287 if (sil) {
288 kfree(sil);
289 dvo->dev_priv = NULL;
290 }
291}
292
293struct intel_dvo_dev_ops sil164_ops = {
294 .init = sil164_init,
295 .detect = sil164_detect,
296 .mode_valid = sil164_mode_valid,
297 .mode_set = sil164_mode_set,
298 .dpms = sil164_dpms,
299 .dump_regs = sil164_dump_regs,
300 .save = sil164_save,
301 .restore = sil164_restore,
302 .destroy = sil164_destroy,
303};
Linux kernel - Deliverables
This page took 0.179222 seconds and 5 git commands to generate.