Commit | Line | Data |
---|---|---|
d480ace0 PM |
1 | /* |
2 | * MSM MDDI Transport | |
3 | * | |
4 | * Copyright (C) 2007 Google Incorporated | |
5 | * Copyright (C) 2007 QUALCOMM Incorporated | |
6 | * | |
7 | * This software is licensed under the terms of the GNU General Public | |
8 | * License version 2, as published by the Free Software Foundation, and | |
9 | * may be copied, distributed, and modified under those terms. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public License for more details. | |
15 | * | |
16 | */ | |
17 | ||
18 | #include <linux/module.h> | |
19 | #include <linux/kernel.h> | |
20 | #include <linux/dma-mapping.h> | |
21 | #include <linux/interrupt.h> | |
22 | #include <linux/platform_device.h> | |
23 | #include <linux/delay.h> | |
24 | #include <linux/spinlock.h> | |
25 | #include <linux/clk.h> | |
26 | #include <linux/io.h> | |
69fd8d24 | 27 | #include <linux/sched.h> |
d480ace0 PM |
28 | #include <mach/msm_iomap.h> |
29 | #include <mach/irqs.h> | |
30 | #include <mach/board.h> | |
d480ace0 PM |
31 | #include <mach/msm_fb.h> |
32 | #include "mddi_hw.h" | |
33 | ||
34 | #define FLAG_DISABLE_HIBERNATION 0x0001 | |
35 | #define FLAG_HAVE_CAPS 0x0002 | |
36 | #define FLAG_HAS_VSYNC_IRQ 0x0004 | |
37 | #define FLAG_HAVE_STATUS 0x0008 | |
38 | ||
39 | #define CMD_GET_CLIENT_CAP 0x0601 | |
40 | #define CMD_GET_CLIENT_STATUS 0x0602 | |
41 | ||
42 | union mddi_rev { | |
43 | unsigned char raw[MDDI_REV_BUFFER_SIZE]; | |
44 | struct mddi_rev_packet hdr; | |
45 | struct mddi_client_status status; | |
46 | struct mddi_client_caps caps; | |
47 | struct mddi_register_access reg; | |
48 | }; | |
49 | ||
50 | struct reg_read_info { | |
51 | struct completion done; | |
52 | uint32_t reg; | |
53 | uint32_t status; | |
54 | uint32_t result; | |
55 | }; | |
56 | ||
57 | struct mddi_info { | |
58 | uint16_t flags; | |
59 | uint16_t version; | |
60 | char __iomem *base; | |
61 | int irq; | |
62 | struct clk *clk; | |
63 | struct msm_mddi_client_data client_data; | |
64 | ||
65 | /* buffer for rev encap packets */ | |
66 | void *rev_data; | |
67 | dma_addr_t rev_addr; | |
68 | struct mddi_llentry *reg_write_data; | |
69 | dma_addr_t reg_write_addr; | |
70 | struct mddi_llentry *reg_read_data; | |
71 | dma_addr_t reg_read_addr; | |
72 | size_t rev_data_curr; | |
73 | ||
74 | spinlock_t int_lock; | |
75 | uint32_t int_enable; | |
76 | uint32_t got_int; | |
77 | wait_queue_head_t int_wait; | |
78 | ||
79 | struct mutex reg_write_lock; | |
80 | struct mutex reg_read_lock; | |
81 | struct reg_read_info *reg_read; | |
82 | ||
83 | struct mddi_client_caps caps; | |
84 | struct mddi_client_status status; | |
85 | ||
86 | void (*power_client)(struct msm_mddi_client_data *, int); | |
87 | ||
88 | /* client device published to bind us to the | |
89 | * appropriate mddi_client driver | |
90 | */ | |
91 | char client_name[20]; | |
92 | ||
93 | struct platform_device client_pdev; | |
94 | }; | |
95 | ||
96 | static void mddi_init_rev_encap(struct mddi_info *mddi); | |
97 | ||
98 | #define mddi_readl(r) readl(mddi->base + (MDDI_##r)) | |
99 | #define mddi_writel(v, r) writel((v), mddi->base + (MDDI_##r)) | |
100 | ||
101 | void mddi_activate_link(struct msm_mddi_client_data *cdata) | |
102 | { | |
103 | struct mddi_info *mddi = container_of(cdata, struct mddi_info, | |
104 | client_data); | |
105 | ||
106 | mddi_writel(MDDI_CMD_LINK_ACTIVE, CMD); | |
107 | } | |
108 | ||
109 | static void mddi_handle_link_list_done(struct mddi_info *mddi) | |
110 | { | |
111 | } | |
112 | ||
113 | static void mddi_reset_rev_encap_ptr(struct mddi_info *mddi) | |
114 | { | |
115 | printk(KERN_INFO "mddi: resetting rev ptr\n"); | |
116 | mddi->rev_data_curr = 0; | |
117 | mddi_writel(mddi->rev_addr, REV_PTR); | |
118 | mddi_writel(mddi->rev_addr, REV_PTR); | |
119 | mddi_writel(MDDI_CMD_FORCE_NEW_REV_PTR, CMD); | |
120 | } | |
121 | ||
122 | static void mddi_handle_rev_data(struct mddi_info *mddi, union mddi_rev *rev) | |
123 | { | |
124 | int i; | |
125 | struct reg_read_info *ri; | |
126 | ||
127 | if ((rev->hdr.length <= MDDI_REV_BUFFER_SIZE - 2) && | |
128 | (rev->hdr.length >= sizeof(struct mddi_rev_packet) - 2)) { | |
129 | ||
130 | switch (rev->hdr.type) { | |
131 | case TYPE_CLIENT_CAPS: | |
132 | memcpy(&mddi->caps, &rev->caps, | |
133 | sizeof(struct mddi_client_caps)); | |
134 | mddi->flags |= FLAG_HAVE_CAPS; | |
135 | wake_up(&mddi->int_wait); | |
136 | break; | |
137 | case TYPE_CLIENT_STATUS: | |
138 | memcpy(&mddi->status, &rev->status, | |
139 | sizeof(struct mddi_client_status)); | |
140 | mddi->flags |= FLAG_HAVE_STATUS; | |
141 | wake_up(&mddi->int_wait); | |
142 | break; | |
143 | case TYPE_REGISTER_ACCESS: | |
144 | ri = mddi->reg_read; | |
145 | if (ri == 0) { | |
146 | printk(KERN_INFO "rev: got reg %x = %x without " | |
147 | " pending read\n", | |
148 | rev->reg.register_address, | |
149 | rev->reg.register_data_list); | |
150 | break; | |
151 | } | |
152 | if (ri->reg != rev->reg.register_address) { | |
153 | printk(KERN_INFO "rev: got reg %x = %x for " | |
154 | "wrong register, expected " | |
155 | "%x\n", | |
156 | rev->reg.register_address, | |
157 | rev->reg.register_data_list, ri->reg); | |
158 | break; | |
159 | } | |
160 | mddi->reg_read = NULL; | |
161 | ri->status = 0; | |
162 | ri->result = rev->reg.register_data_list; | |
163 | complete(&ri->done); | |
164 | break; | |
165 | default: | |
166 | printk(KERN_INFO "rev: unknown reverse packet: " | |
167 | "len=%04x type=%04x CURR_REV_PTR=%x\n", | |
168 | rev->hdr.length, rev->hdr.type, | |
169 | mddi_readl(CURR_REV_PTR)); | |
170 | for (i = 0; i < rev->hdr.length + 2; i++) { | |
171 | if ((i % 16) == 0) | |
172 | printk(KERN_INFO "\n"); | |
173 | printk(KERN_INFO " %02x", rev->raw[i]); | |
174 | } | |
175 | printk(KERN_INFO "\n"); | |
176 | mddi_reset_rev_encap_ptr(mddi); | |
177 | } | |
178 | } else { | |
179 | printk(KERN_INFO "bad rev length, %d, CURR_REV_PTR %x\n", | |
180 | rev->hdr.length, mddi_readl(CURR_REV_PTR)); | |
181 | mddi_reset_rev_encap_ptr(mddi); | |
182 | } | |
183 | } | |
184 | ||
185 | static void mddi_wait_interrupt(struct mddi_info *mddi, uint32_t intmask); | |
186 | ||
187 | static void mddi_handle_rev_data_avail(struct mddi_info *mddi) | |
188 | { | |
189 | union mddi_rev *rev = mddi->rev_data; | |
190 | uint32_t rev_data_count; | |
191 | uint32_t rev_crc_err_count; | |
192 | int i; | |
193 | struct reg_read_info *ri; | |
194 | size_t prev_offset; | |
195 | uint16_t length; | |
196 | ||
197 | union mddi_rev *crev = mddi->rev_data + mddi->rev_data_curr; | |
198 | ||
199 | /* clear the interrupt */ | |
200 | mddi_writel(MDDI_INT_REV_DATA_AVAIL, INT); | |
201 | rev_data_count = mddi_readl(REV_PKT_CNT); | |
202 | rev_crc_err_count = mddi_readl(REV_CRC_ERR); | |
203 | if (rev_data_count > 1) | |
204 | printk(KERN_INFO "rev_data_count %d\n", rev_data_count); | |
205 | ||
206 | if (rev_crc_err_count) { | |
207 | printk(KERN_INFO "rev_crc_err_count %d, INT %x\n", | |
208 | rev_crc_err_count, mddi_readl(INT)); | |
209 | ri = mddi->reg_read; | |
210 | if (ri == 0) { | |
211 | printk(KERN_INFO "rev: got crc error without pending " | |
212 | "read\n"); | |
213 | } else { | |
214 | mddi->reg_read = NULL; | |
215 | ri->status = -EIO; | |
216 | ri->result = -1; | |
217 | complete(&ri->done); | |
218 | } | |
219 | } | |
220 | ||
221 | if (rev_data_count == 0) | |
222 | return; | |
223 | ||
224 | prev_offset = mddi->rev_data_curr; | |
225 | ||
226 | length = *((uint8_t *)mddi->rev_data + mddi->rev_data_curr); | |
227 | mddi->rev_data_curr++; | |
228 | if (mddi->rev_data_curr == MDDI_REV_BUFFER_SIZE) | |
229 | mddi->rev_data_curr = 0; | |
230 | length += *((uint8_t *)mddi->rev_data + mddi->rev_data_curr) << 8; | |
231 | mddi->rev_data_curr += 1 + length; | |
232 | if (mddi->rev_data_curr >= MDDI_REV_BUFFER_SIZE) | |
233 | mddi->rev_data_curr = | |
234 | mddi->rev_data_curr % MDDI_REV_BUFFER_SIZE; | |
235 | ||
236 | if (length > MDDI_REV_BUFFER_SIZE - 2) { | |
237 | printk(KERN_INFO "mddi: rev data length greater than buffer" | |
238 | "size\n"); | |
239 | mddi_reset_rev_encap_ptr(mddi); | |
240 | return; | |
241 | } | |
242 | ||
243 | if (prev_offset + 2 + length >= MDDI_REV_BUFFER_SIZE) { | |
244 | union mddi_rev tmprev; | |
245 | size_t rem = MDDI_REV_BUFFER_SIZE - prev_offset; | |
246 | memcpy(&tmprev.raw[0], mddi->rev_data + prev_offset, rem); | |
247 | memcpy(&tmprev.raw[rem], mddi->rev_data, 2 + length - rem); | |
248 | mddi_handle_rev_data(mddi, &tmprev); | |
249 | } else { | |
250 | mddi_handle_rev_data(mddi, crev); | |
251 | } | |
252 | ||
253 | if (prev_offset < MDDI_REV_BUFFER_SIZE / 2 && | |
254 | mddi->rev_data_curr >= MDDI_REV_BUFFER_SIZE / 2) { | |
255 | mddi_writel(mddi->rev_addr, REV_PTR); | |
256 | } | |
257 | } | |
258 | ||
259 | static irqreturn_t mddi_isr(int irq, void *data) | |
260 | { | |
261 | struct msm_mddi_client_data *cdata = data; | |
262 | struct mddi_info *mddi = container_of(cdata, struct mddi_info, | |
263 | client_data); | |
264 | uint32_t active, status; | |
265 | ||
266 | spin_lock(&mddi->int_lock); | |
267 | ||
268 | active = mddi_readl(INT); | |
269 | status = mddi_readl(STAT); | |
270 | ||
271 | mddi_writel(active, INT); | |
272 | ||
273 | /* ignore any interrupts we have disabled */ | |
274 | active &= mddi->int_enable; | |
275 | ||
276 | mddi->got_int |= active; | |
277 | wake_up(&mddi->int_wait); | |
278 | ||
279 | if (active & MDDI_INT_PRI_LINK_LIST_DONE) { | |
280 | mddi->int_enable &= (~MDDI_INT_PRI_LINK_LIST_DONE); | |
281 | mddi_handle_link_list_done(mddi); | |
282 | } | |
283 | if (active & MDDI_INT_REV_DATA_AVAIL) | |
284 | mddi_handle_rev_data_avail(mddi); | |
285 | ||
286 | if (active & ~MDDI_INT_NEED_CLEAR) | |
287 | mddi->int_enable &= ~(active & ~MDDI_INT_NEED_CLEAR); | |
288 | ||
289 | if (active & MDDI_INT_LINK_ACTIVE) { | |
290 | mddi->int_enable &= (~MDDI_INT_LINK_ACTIVE); | |
291 | mddi->int_enable |= MDDI_INT_IN_HIBERNATION; | |
292 | } | |
293 | ||
294 | if (active & MDDI_INT_IN_HIBERNATION) { | |
295 | mddi->int_enable &= (~MDDI_INT_IN_HIBERNATION); | |
296 | mddi->int_enable |= MDDI_INT_LINK_ACTIVE; | |
297 | } | |
298 | ||
299 | mddi_writel(mddi->int_enable, INTEN); | |
300 | spin_unlock(&mddi->int_lock); | |
301 | ||
302 | return IRQ_HANDLED; | |
303 | } | |
304 | ||
305 | static long mddi_wait_interrupt_timeout(struct mddi_info *mddi, | |
306 | uint32_t intmask, int timeout) | |
307 | { | |
308 | unsigned long irq_flags; | |
309 | ||
310 | spin_lock_irqsave(&mddi->int_lock, irq_flags); | |
311 | mddi->got_int &= ~intmask; | |
312 | mddi->int_enable |= intmask; | |
313 | mddi_writel(mddi->int_enable, INTEN); | |
314 | spin_unlock_irqrestore(&mddi->int_lock, irq_flags); | |
315 | return wait_event_timeout(mddi->int_wait, mddi->got_int & intmask, | |
316 | timeout); | |
317 | } | |
318 | ||
319 | static void mddi_wait_interrupt(struct mddi_info *mddi, uint32_t intmask) | |
320 | { | |
321 | if (mddi_wait_interrupt_timeout(mddi, intmask, HZ/10) == 0) | |
322 | printk(KERN_INFO KERN_ERR "mddi_wait_interrupt %d, timeout " | |
323 | "waiting for %x, INT = %x, STAT = %x gotint = %x\n", | |
324 | current->pid, intmask, mddi_readl(INT), mddi_readl(STAT), | |
325 | mddi->got_int); | |
326 | } | |
327 | ||
328 | static void mddi_init_rev_encap(struct mddi_info *mddi) | |
329 | { | |
330 | memset(mddi->rev_data, 0xee, MDDI_REV_BUFFER_SIZE); | |
331 | mddi_writel(mddi->rev_addr, REV_PTR); | |
332 | mddi_writel(MDDI_CMD_FORCE_NEW_REV_PTR, CMD); | |
333 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
334 | } | |
335 | ||
336 | void mddi_set_auto_hibernate(struct msm_mddi_client_data *cdata, int on) | |
337 | { | |
338 | struct mddi_info *mddi = container_of(cdata, struct mddi_info, | |
339 | client_data); | |
340 | mddi_writel(MDDI_CMD_POWERDOWN, CMD); | |
341 | mddi_wait_interrupt(mddi, MDDI_INT_IN_HIBERNATION); | |
342 | mddi_writel(MDDI_CMD_HIBERNATE | !!on, CMD); | |
343 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
344 | } | |
345 | ||
346 | ||
347 | static uint16_t mddi_init_registers(struct mddi_info *mddi) | |
348 | { | |
349 | mddi_writel(0x0001, VERSION); | |
350 | mddi_writel(MDDI_HOST_BYTES_PER_SUBFRAME, BPS); | |
351 | mddi_writel(0x0003, SPM); /* subframes per media */ | |
352 | mddi_writel(0x0005, TA1_LEN); | |
353 | mddi_writel(MDDI_HOST_TA2_LEN, TA2_LEN); | |
354 | mddi_writel(0x0096, DRIVE_HI); | |
355 | /* 0x32 normal, 0x50 for Toshiba display */ | |
356 | mddi_writel(0x0050, DRIVE_LO); | |
357 | mddi_writel(0x003C, DISP_WAKE); /* wakeup counter */ | |
358 | mddi_writel(MDDI_HOST_REV_RATE_DIV, REV_RATE_DIV); | |
359 | ||
360 | mddi_writel(MDDI_REV_BUFFER_SIZE, REV_SIZE); | |
361 | mddi_writel(MDDI_MAX_REV_PKT_SIZE, REV_ENCAP_SZ); | |
362 | ||
363 | /* disable periodic rev encap */ | |
364 | mddi_writel(MDDI_CMD_PERIODIC_REV_ENCAP, CMD); | |
365 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
366 | ||
367 | if (mddi_readl(PAD_CTL) == 0) { | |
368 | /* If we are turning on band gap, need to wait 5us before | |
369 | * turning on the rest of the PAD */ | |
370 | mddi_writel(0x08000, PAD_CTL); | |
371 | udelay(5); | |
372 | } | |
373 | ||
374 | /* Recommendation from PAD hw team */ | |
375 | mddi_writel(0xa850f, PAD_CTL); | |
376 | ||
377 | ||
378 | /* Need an even number for counts */ | |
379 | mddi_writel(0x60006, DRIVER_START_CNT); | |
380 | ||
381 | mddi_set_auto_hibernate(&mddi->client_data, 0); | |
382 | ||
383 | mddi_writel(MDDI_CMD_DISP_IGNORE, CMD); | |
384 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
385 | ||
386 | mddi_init_rev_encap(mddi); | |
387 | return mddi_readl(CORE_VER) & 0xffff; | |
388 | } | |
389 | ||
390 | static void mddi_suspend(struct msm_mddi_client_data *cdata) | |
391 | { | |
392 | struct mddi_info *mddi = container_of(cdata, struct mddi_info, | |
393 | client_data); | |
394 | /* turn off the client */ | |
395 | if (mddi->power_client) | |
396 | mddi->power_client(&mddi->client_data, 0); | |
397 | /* turn off the link */ | |
398 | mddi_writel(MDDI_CMD_RESET, CMD); | |
399 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
400 | /* turn off the clock */ | |
401 | clk_disable(mddi->clk); | |
402 | } | |
403 | ||
404 | static void mddi_resume(struct msm_mddi_client_data *cdata) | |
405 | { | |
406 | struct mddi_info *mddi = container_of(cdata, struct mddi_info, | |
407 | client_data); | |
408 | mddi_set_auto_hibernate(&mddi->client_data, 0); | |
409 | /* turn on the client */ | |
410 | if (mddi->power_client) | |
411 | mddi->power_client(&mddi->client_data, 1); | |
412 | /* turn on the clock */ | |
413 | clk_enable(mddi->clk); | |
414 | /* set up the local registers */ | |
415 | mddi->rev_data_curr = 0; | |
416 | mddi_init_registers(mddi); | |
417 | mddi_writel(mddi->int_enable, INTEN); | |
418 | mddi_writel(MDDI_CMD_LINK_ACTIVE, CMD); | |
419 | mddi_writel(MDDI_CMD_SEND_RTD, CMD); | |
420 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
421 | mddi_set_auto_hibernate(&mddi->client_data, 1); | |
422 | } | |
423 | ||
424 | static int __init mddi_get_client_caps(struct mddi_info *mddi) | |
425 | { | |
426 | int i, j; | |
427 | ||
428 | /* clear any stale interrupts */ | |
429 | mddi_writel(0xffffffff, INT); | |
430 | ||
431 | mddi->int_enable = MDDI_INT_LINK_ACTIVE | | |
432 | MDDI_INT_IN_HIBERNATION | | |
433 | MDDI_INT_PRI_LINK_LIST_DONE | | |
434 | MDDI_INT_REV_DATA_AVAIL | | |
435 | MDDI_INT_REV_OVERFLOW | | |
436 | MDDI_INT_REV_OVERWRITE | | |
437 | MDDI_INT_RTD_FAILURE; | |
438 | mddi_writel(mddi->int_enable, INTEN); | |
439 | ||
440 | mddi_writel(MDDI_CMD_LINK_ACTIVE, CMD); | |
441 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
442 | ||
443 | for (j = 0; j < 3; j++) { | |
444 | /* the toshiba vga panel does not respond to get | |
445 | * caps unless you SEND_RTD, but the first SEND_RTD | |
446 | * will fail... | |
447 | */ | |
448 | for (i = 0; i < 4; i++) { | |
449 | uint32_t stat; | |
450 | ||
451 | mddi_writel(MDDI_CMD_SEND_RTD, CMD); | |
452 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
453 | stat = mddi_readl(STAT); | |
454 | printk(KERN_INFO "mddi cmd send rtd: int %x, stat %x, " | |
455 | "rtd val %x\n", mddi_readl(INT), stat, | |
456 | mddi_readl(RTD_VAL)); | |
457 | if ((stat & MDDI_STAT_RTD_MEAS_FAIL) == 0) | |
458 | break; | |
459 | msleep(1); | |
460 | } | |
461 | ||
462 | mddi_writel(CMD_GET_CLIENT_CAP, CMD); | |
463 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
464 | wait_event_timeout(mddi->int_wait, mddi->flags & FLAG_HAVE_CAPS, | |
465 | HZ / 100); | |
466 | ||
467 | if (mddi->flags & FLAG_HAVE_CAPS) | |
468 | break; | |
469 | printk(KERN_INFO KERN_ERR "mddi_init, timeout waiting for " | |
470 | "caps\n"); | |
471 | } | |
472 | return mddi->flags & FLAG_HAVE_CAPS; | |
473 | } | |
474 | ||
475 | /* link must be active when this is called */ | |
476 | int mddi_check_status(struct mddi_info *mddi) | |
477 | { | |
478 | int ret = -1, retry = 3; | |
479 | mutex_lock(&mddi->reg_read_lock); | |
480 | mddi_writel(MDDI_CMD_PERIODIC_REV_ENCAP | 1, CMD); | |
481 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
482 | ||
483 | do { | |
484 | mddi->flags &= ~FLAG_HAVE_STATUS; | |
485 | mddi_writel(CMD_GET_CLIENT_STATUS, CMD); | |
486 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
487 | wait_event_timeout(mddi->int_wait, | |
488 | mddi->flags & FLAG_HAVE_STATUS, | |
489 | HZ / 100); | |
490 | ||
491 | if (mddi->flags & FLAG_HAVE_STATUS) { | |
492 | if (mddi->status.crc_error_count) | |
493 | printk(KERN_INFO "mddi status: crc_error " | |
494 | "count: %d\n", | |
495 | mddi->status.crc_error_count); | |
496 | else | |
497 | ret = 0; | |
498 | break; | |
499 | } else | |
500 | printk(KERN_INFO "mddi status: failed to get client " | |
501 | "status\n"); | |
502 | mddi_writel(MDDI_CMD_SEND_RTD, CMD); | |
503 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
504 | } while (--retry); | |
505 | ||
506 | mddi_writel(MDDI_CMD_PERIODIC_REV_ENCAP | 0, CMD); | |
507 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
508 | mutex_unlock(&mddi->reg_read_lock); | |
509 | return ret; | |
510 | } | |
511 | ||
512 | ||
513 | void mddi_remote_write(struct msm_mddi_client_data *cdata, uint32_t val, | |
514 | uint32_t reg) | |
515 | { | |
516 | struct mddi_info *mddi = container_of(cdata, struct mddi_info, | |
517 | client_data); | |
518 | struct mddi_llentry *ll; | |
519 | struct mddi_register_access *ra; | |
520 | ||
521 | mutex_lock(&mddi->reg_write_lock); | |
522 | ||
523 | ll = mddi->reg_write_data; | |
524 | ||
525 | ra = &(ll->u.r); | |
526 | ra->length = 14 + 4; | |
527 | ra->type = TYPE_REGISTER_ACCESS; | |
528 | ra->client_id = 0; | |
529 | ra->read_write_info = MDDI_WRITE | 1; | |
530 | ra->crc16 = 0; | |
531 | ||
532 | ra->register_address = reg; | |
533 | ra->register_data_list = val; | |
534 | ||
535 | ll->flags = 1; | |
536 | ll->header_count = 14; | |
537 | ll->data_count = 4; | |
538 | ll->data = mddi->reg_write_addr + offsetof(struct mddi_llentry, | |
539 | u.r.register_data_list); | |
540 | ll->next = 0; | |
541 | ll->reserved = 0; | |
542 | ||
543 | mddi_writel(mddi->reg_write_addr, PRI_PTR); | |
544 | ||
545 | mddi_wait_interrupt(mddi, MDDI_INT_PRI_LINK_LIST_DONE); | |
546 | mutex_unlock(&mddi->reg_write_lock); | |
547 | } | |
548 | ||
549 | uint32_t mddi_remote_read(struct msm_mddi_client_data *cdata, uint32_t reg) | |
550 | { | |
551 | struct mddi_info *mddi = container_of(cdata, struct mddi_info, | |
552 | client_data); | |
553 | struct mddi_llentry *ll; | |
554 | struct mddi_register_access *ra; | |
555 | struct reg_read_info ri; | |
556 | unsigned s; | |
557 | int retry_count = 2; | |
558 | unsigned long irq_flags; | |
559 | ||
560 | mutex_lock(&mddi->reg_read_lock); | |
561 | ||
562 | ll = mddi->reg_read_data; | |
563 | ||
564 | ra = &(ll->u.r); | |
565 | ra->length = 14; | |
566 | ra->type = TYPE_REGISTER_ACCESS; | |
567 | ra->client_id = 0; | |
568 | ra->read_write_info = MDDI_READ | 1; | |
569 | ra->crc16 = 0; | |
570 | ||
571 | ra->register_address = reg; | |
572 | ||
573 | ll->flags = 0x11; | |
574 | ll->header_count = 14; | |
575 | ll->data_count = 0; | |
576 | ll->data = 0; | |
577 | ll->next = 0; | |
578 | ll->reserved = 0; | |
579 | ||
580 | s = mddi_readl(STAT); | |
581 | ||
582 | ri.reg = reg; | |
583 | ri.status = -1; | |
584 | ||
585 | do { | |
586 | init_completion(&ri.done); | |
587 | mddi->reg_read = &ri; | |
588 | mddi_writel(mddi->reg_read_addr, PRI_PTR); | |
589 | ||
590 | mddi_wait_interrupt(mddi, MDDI_INT_PRI_LINK_LIST_DONE); | |
591 | ||
592 | /* Enable Periodic Reverse Encapsulation. */ | |
593 | mddi_writel(MDDI_CMD_PERIODIC_REV_ENCAP | 1, CMD); | |
594 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
595 | if (wait_for_completion_timeout(&ri.done, HZ/10) == 0 && | |
596 | !ri.done.done) { | |
597 | printk(KERN_INFO "mddi_remote_read(%x) timeout " | |
598 | "(%d %d %d)\n", | |
599 | reg, ri.status, ri.result, ri.done.done); | |
600 | spin_lock_irqsave(&mddi->int_lock, irq_flags); | |
601 | mddi->reg_read = NULL; | |
602 | spin_unlock_irqrestore(&mddi->int_lock, irq_flags); | |
603 | ri.status = -1; | |
604 | ri.result = -1; | |
605 | } | |
606 | if (ri.status == 0) | |
607 | break; | |
608 | ||
609 | mddi_writel(MDDI_CMD_SEND_RTD, CMD); | |
610 | mddi_writel(MDDI_CMD_LINK_ACTIVE, CMD); | |
611 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
612 | printk(KERN_INFO "mddi_remote_read: failed, sent " | |
613 | "MDDI_CMD_SEND_RTD: int %x, stat %x, rtd val %x " | |
614 | "curr_rev_ptr %x\n", mddi_readl(INT), mddi_readl(STAT), | |
615 | mddi_readl(RTD_VAL), mddi_readl(CURR_REV_PTR)); | |
616 | } while (retry_count-- > 0); | |
617 | /* Disable Periodic Reverse Encapsulation. */ | |
618 | mddi_writel(MDDI_CMD_PERIODIC_REV_ENCAP | 0, CMD); | |
619 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
620 | mddi->reg_read = NULL; | |
621 | mutex_unlock(&mddi->reg_read_lock); | |
622 | return ri.result; | |
623 | } | |
624 | ||
625 | static struct mddi_info mddi_info[2]; | |
626 | ||
627 | static int __init mddi_clk_setup(struct platform_device *pdev, | |
628 | struct mddi_info *mddi, | |
629 | unsigned long clk_rate) | |
630 | { | |
631 | int ret; | |
632 | ||
633 | /* set up the clocks */ | |
634 | mddi->clk = clk_get(&pdev->dev, "mddi_clk"); | |
635 | if (IS_ERR(mddi->clk)) { | |
636 | printk(KERN_INFO "mddi: failed to get clock\n"); | |
637 | return PTR_ERR(mddi->clk); | |
638 | } | |
639 | ret = clk_enable(mddi->clk); | |
640 | if (ret) | |
641 | goto fail; | |
642 | ret = clk_set_rate(mddi->clk, clk_rate); | |
643 | if (ret) | |
644 | goto fail; | |
645 | return 0; | |
646 | ||
647 | fail: | |
648 | clk_put(mddi->clk); | |
649 | return ret; | |
650 | } | |
651 | ||
652 | static int __init mddi_rev_data_setup(struct mddi_info *mddi) | |
653 | { | |
654 | void *dma; | |
655 | dma_addr_t dma_addr; | |
656 | ||
657 | /* set up dma buffer */ | |
658 | dma = dma_alloc_coherent(NULL, 0x1000, &dma_addr, GFP_KERNEL); | |
659 | if (dma == 0) | |
660 | return -ENOMEM; | |
661 | mddi->rev_data = dma; | |
662 | mddi->rev_data_curr = 0; | |
663 | mddi->rev_addr = dma_addr; | |
664 | mddi->reg_write_data = dma + MDDI_REV_BUFFER_SIZE; | |
665 | mddi->reg_write_addr = dma_addr + MDDI_REV_BUFFER_SIZE; | |
666 | mddi->reg_read_data = mddi->reg_write_data + 1; | |
667 | mddi->reg_read_addr = mddi->reg_write_addr + | |
668 | sizeof(*mddi->reg_write_data); | |
669 | return 0; | |
670 | } | |
671 | ||
672 | static int __init mddi_probe(struct platform_device *pdev) | |
673 | { | |
674 | struct msm_mddi_platform_data *pdata = pdev->dev.platform_data; | |
675 | struct mddi_info *mddi = &mddi_info[pdev->id]; | |
676 | struct resource *resource; | |
677 | int ret, i; | |
678 | ||
679 | resource = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
680 | if (!resource) { | |
681 | printk(KERN_ERR "mddi: no associated mem resource!\n"); | |
682 | return -ENOMEM; | |
683 | } | |
684 | mddi->base = ioremap(resource->start, resource->end - resource->start); | |
685 | if (!mddi->base) { | |
686 | printk(KERN_ERR "mddi: failed to remap base!\n"); | |
687 | ret = -EINVAL; | |
688 | goto error_ioremap; | |
689 | } | |
690 | resource = platform_get_resource(pdev, IORESOURCE_IRQ, 0); | |
691 | if (!resource) { | |
692 | printk(KERN_ERR "mddi: no associated irq resource!\n"); | |
693 | ret = -EINVAL; | |
694 | goto error_get_irq_resource; | |
695 | } | |
696 | mddi->irq = resource->start; | |
697 | printk(KERN_INFO "mddi: init() base=0x%p irq=%d\n", mddi->base, | |
698 | mddi->irq); | |
699 | mddi->power_client = pdata->power_client; | |
700 | ||
701 | mutex_init(&mddi->reg_write_lock); | |
702 | mutex_init(&mddi->reg_read_lock); | |
703 | spin_lock_init(&mddi->int_lock); | |
704 | init_waitqueue_head(&mddi->int_wait); | |
705 | ||
706 | ret = mddi_clk_setup(pdev, mddi, pdata->clk_rate); | |
707 | if (ret) { | |
708 | printk(KERN_ERR "mddi: failed to setup clock!\n"); | |
709 | goto error_clk_setup; | |
710 | } | |
711 | ||
712 | ret = mddi_rev_data_setup(mddi); | |
713 | if (ret) { | |
714 | printk(KERN_ERR "mddi: failed to setup rev data!\n"); | |
715 | goto error_rev_data; | |
716 | } | |
717 | ||
718 | mddi->int_enable = 0; | |
719 | mddi_writel(mddi->int_enable, INTEN); | |
720 | ret = request_irq(mddi->irq, mddi_isr, IRQF_DISABLED, "mddi", | |
721 | &mddi->client_data); | |
722 | if (ret) { | |
723 | printk(KERN_ERR "mddi: failed to request enable irq!\n"); | |
724 | goto error_request_irq; | |
725 | } | |
726 | ||
727 | /* turn on the mddi client bridge chip */ | |
728 | if (mddi->power_client) | |
729 | mddi->power_client(&mddi->client_data, 1); | |
730 | ||
731 | /* initialize the mddi registers */ | |
732 | mddi_set_auto_hibernate(&mddi->client_data, 0); | |
733 | mddi_writel(MDDI_CMD_RESET, CMD); | |
734 | mddi_wait_interrupt(mddi, MDDI_INT_NO_CMD_PKTS_PEND); | |
735 | mddi->version = mddi_init_registers(mddi); | |
736 | if (mddi->version < 0x20) { | |
737 | printk(KERN_ERR "mddi: unsupported version 0x%x\n", | |
738 | mddi->version); | |
739 | ret = -ENODEV; | |
740 | goto error_mddi_version; | |
741 | } | |
742 | ||
743 | /* read the capabilities off the client */ | |
744 | if (!mddi_get_client_caps(mddi)) { | |
745 | printk(KERN_INFO "mddi: no client found\n"); | |
746 | /* power down the panel */ | |
747 | mddi_writel(MDDI_CMD_POWERDOWN, CMD); | |
748 | printk(KERN_INFO "mddi powerdown: stat %x\n", mddi_readl(STAT)); | |
749 | msleep(100); | |
750 | printk(KERN_INFO "mddi powerdown: stat %x\n", mddi_readl(STAT)); | |
751 | return 0; | |
752 | } | |
753 | mddi_set_auto_hibernate(&mddi->client_data, 1); | |
754 | ||
755 | if (mddi->caps.Mfr_Name == 0 && mddi->caps.Product_Code == 0) | |
756 | pdata->fixup(&mddi->caps.Mfr_Name, &mddi->caps.Product_Code); | |
757 | ||
758 | mddi->client_pdev.id = 0; | |
759 | for (i = 0; i < pdata->num_clients; i++) { | |
760 | if (pdata->client_platform_data[i].product_id == | |
761 | (mddi->caps.Mfr_Name << 16 | mddi->caps.Product_Code)) { | |
762 | mddi->client_data.private_client_data = | |
763 | pdata->client_platform_data[i].client_data; | |
764 | mddi->client_pdev.name = | |
765 | pdata->client_platform_data[i].name; | |
766 | mddi->client_pdev.id = | |
767 | pdata->client_platform_data[i].id; | |
768 | /* XXX: possibly set clock */ | |
769 | break; | |
770 | } | |
771 | } | |
772 | ||
773 | if (i >= pdata->num_clients) | |
774 | mddi->client_pdev.name = "mddi_c_dummy"; | |
775 | printk(KERN_INFO "mddi: registering panel %s\n", | |
776 | mddi->client_pdev.name); | |
777 | ||
778 | mddi->client_data.suspend = mddi_suspend; | |
779 | mddi->client_data.resume = mddi_resume; | |
780 | mddi->client_data.activate_link = mddi_activate_link; | |
781 | mddi->client_data.remote_write = mddi_remote_write; | |
782 | mddi->client_data.remote_read = mddi_remote_read; | |
783 | mddi->client_data.auto_hibernate = mddi_set_auto_hibernate; | |
784 | mddi->client_data.fb_resource = pdata->fb_resource; | |
785 | if (pdev->id == 0) | |
786 | mddi->client_data.interface_type = MSM_MDDI_PMDH_INTERFACE; | |
787 | else if (pdev->id == 1) | |
788 | mddi->client_data.interface_type = MSM_MDDI_EMDH_INTERFACE; | |
789 | else { | |
790 | printk(KERN_ERR "mddi: can not determine interface %d!\n", | |
791 | pdev->id); | |
792 | ret = -EINVAL; | |
793 | goto error_mddi_interface; | |
794 | } | |
795 | ||
796 | mddi->client_pdev.dev.platform_data = &mddi->client_data; | |
797 | printk(KERN_INFO "mddi: publish: %s\n", mddi->client_name); | |
798 | platform_device_register(&mddi->client_pdev); | |
799 | return 0; | |
800 | ||
801 | error_mddi_interface: | |
802 | error_mddi_version: | |
803 | free_irq(mddi->irq, 0); | |
804 | error_request_irq: | |
805 | dma_free_coherent(NULL, 0x1000, mddi->rev_data, mddi->rev_addr); | |
806 | error_rev_data: | |
807 | error_clk_setup: | |
808 | error_get_irq_resource: | |
809 | iounmap(mddi->base); | |
810 | error_ioremap: | |
811 | ||
812 | printk(KERN_INFO "mddi: mddi_init() failed (%d)\n", ret); | |
813 | return ret; | |
814 | } | |
815 | ||
816 | ||
817 | static struct platform_driver mddi_driver = { | |
818 | .probe = mddi_probe, | |
819 | .driver = { .name = "msm_mddi" }, | |
820 | }; | |
821 | ||
822 | static int __init _mddi_init(void) | |
823 | { | |
824 | return platform_driver_register(&mddi_driver); | |
825 | } | |
826 | ||
827 | module_init(_mddi_init); |