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