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