]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/staging/dream/camera/msm_vfe7x.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
semaphore: Remove mutex emulation
[net-next-2.6.git] / drivers / staging / dream / camera / msm_vfe7x.c
CommitLineData
eb7b797b
BS		 1/*
2 * Copyright (C) 2008-2009 QUALCOMM Incorporated.
3 */
4
5#include <linux/msm_adsp.h>
6#include <linux/uaccess.h>
7#include <linux/fs.h>
ace9e791 8#include <linux/sched.h>
eb7b797b 9#include <linux/android_pmem.h>
5a0e3ad6 10#include <linux/slab.h>
eb7b797b
BS		 11#include <mach/msm_adsp.h>
12#include <linux/delay.h>
13#include <linux/wait.h>
14#include "msm_vfe7x.h"
15
16#define QDSP_CMDQUEUE QDSP_vfeCommandQueue
17
18#define VFE_RESET_CMD 0
19#define VFE_START_CMD 1
20#define VFE_STOP_CMD 2
21#define VFE_FRAME_ACK 20
22#define STATS_AF_ACK 21
23#define STATS_WE_ACK 22
24
25#define MSG_STOP_ACK 1
26#define MSG_SNAPSHOT 2
27#define MSG_OUTPUT1 6
28#define MSG_OUTPUT2 7
29#define MSG_STATS_AF 8
30#define MSG_STATS_WE 9
31
32static struct msm_adsp_module *qcam_mod;
33static struct msm_adsp_module *vfe_mod;
34static struct msm_vfe_callback *resp;
35static void *extdata;
36static uint32_t extlen;
37
38struct mutex vfe_lock;
39static void *vfe_syncdata;
40static uint8_t vfestopped;
41
42static struct stop_event stopevent;
43
44static void vfe_7x_convert(struct msm_vfe_phy_info *pinfo,
45 enum vfe_resp_msg type,
46 void *data, void **ext, int32_t *elen)
47{
48 switch (type) {
49 case VFE_MSG_OUTPUT1:
50 case VFE_MSG_OUTPUT2: {
51 pinfo->y_phy = ((struct vfe_endframe *)data)->y_address;
52 pinfo->cbcr_phy =
53 ((struct vfe_endframe *)data)->cbcr_address;
54
55 CDBG("vfe_7x_convert, y_phy = 0x%x, cbcr_phy = 0x%x\n",
56 pinfo->y_phy, pinfo->cbcr_phy);
57
58 ((struct vfe_frame_extra *)extdata)->bl_evencol =
59 ((struct vfe_endframe *)data)->blacklevelevencolumn;
60
61 ((struct vfe_frame_extra *)extdata)->bl_oddcol =
62 ((struct vfe_endframe *)data)->blackleveloddcolumn;
63
64 ((struct vfe_frame_extra *)extdata)->g_def_p_cnt =
65 ((struct vfe_endframe *)data)->greendefectpixelcount;
66
67 ((struct vfe_frame_extra *)extdata)->r_b_def_p_cnt =
68 ((struct vfe_endframe *)data)->redbluedefectpixelcount;
69
70 *ext = extdata;
71 *elen = extlen;
72 }
73 break;
74
75 case VFE_MSG_STATS_AF:
76 case VFE_MSG_STATS_WE:
77 pinfo->sbuf_phy = *(uint32_t *)data;
78 break;
79
80 default:
81 break;
82 } /* switch */
83}
84
85static void vfe_7x_ops(void *driver_data, unsigned id, size_t len,
86 void (*getevent)(void *ptr, size_t len))
87{
88 uint32_t evt_buf[3];
89 struct msm_vfe_resp *rp;
90 void *data;
91
92 len = (id == (uint16_t)-1) ? 0 : len;
93 data = resp->vfe_alloc(sizeof(struct msm_vfe_resp) + len, vfe_syncdata);
94
95 if (!data) {
96 pr_err("rp: cannot allocate buffer\n");
97 return;
98 }
99 rp = (struct msm_vfe_resp *)data;
100 rp->evt_msg.len = len;
101
102 if (id == ((uint16_t)-1)) {
103 /* event */
104 rp->type = VFE_EVENT;
105 rp->evt_msg.type = MSM_CAMERA_EVT;
106 getevent(evt_buf, sizeof(evt_buf));
107 rp->evt_msg.msg_id = evt_buf[0];
108 resp->vfe_resp(rp, MSM_CAM_Q_VFE_EVT, vfe_syncdata);
109 } else {
110 /* messages */
111 rp->evt_msg.type = MSM_CAMERA_MSG;
112 rp->evt_msg.msg_id = id;
113 rp->evt_msg.data = rp + 1;
114 getevent(rp->evt_msg.data, len);
115
116 switch (rp->evt_msg.msg_id) {
117 case MSG_SNAPSHOT:
118 rp->type = VFE_MSG_SNAPSHOT;
119 break;
120
121 case MSG_OUTPUT1:
122 rp->type = VFE_MSG_OUTPUT1;
123 vfe_7x_convert(&(rp->phy), VFE_MSG_OUTPUT1,
124 rp->evt_msg.data, &(rp->extdata),
125 &(rp->extlen));
126 break;
127
128 case MSG_OUTPUT2:
129 rp->type = VFE_MSG_OUTPUT2;
130 vfe_7x_convert(&(rp->phy), VFE_MSG_OUTPUT2,
131 rp->evt_msg.data, &(rp->extdata),
132 &(rp->extlen));
133 break;
134
135 case MSG_STATS_AF:
136 rp->type = VFE_MSG_STATS_AF;
137 vfe_7x_convert(&(rp->phy), VFE_MSG_STATS_AF,
138 rp->evt_msg.data, NULL, NULL);
139 break;
140
141 case MSG_STATS_WE:
142 rp->type = VFE_MSG_STATS_WE;
143 vfe_7x_convert(&(rp->phy), VFE_MSG_STATS_WE,
144 rp->evt_msg.data, NULL, NULL);
145
146 CDBG("MSG_STATS_WE: phy = 0x%x\n", rp->phy.sbuf_phy);
147 break;
148
149 case MSG_STOP_ACK:
150 rp->type = VFE_MSG_GENERAL;
151 stopevent.state = 1;
152 wake_up(&stopevent.wait);
153 break;
154
155
156 default:
157 rp->type = VFE_MSG_GENERAL;
158 break;
159 }
160 resp->vfe_resp(rp, MSM_CAM_Q_VFE_MSG, vfe_syncdata);
161 }
162}
163
164static struct msm_adsp_ops vfe_7x_sync = {
165 .event = vfe_7x_ops,
166};
167
168static int vfe_7x_enable(struct camera_enable_cmd *enable)
169{
170 int rc = -EFAULT;
171
172 if (!strcmp(enable->name, "QCAMTASK"))
173 rc = msm_adsp_enable(qcam_mod);
174 else if (!strcmp(enable->name, "VFETASK"))
175 rc = msm_adsp_enable(vfe_mod);
176
177 return rc;
178}
179
180static int vfe_7x_disable(struct camera_enable_cmd *enable,
181 struct platform_device *dev __attribute__((unused)))
182{
183 int rc = -EFAULT;
184
185 if (!strcmp(enable->name, "QCAMTASK"))
186 rc = msm_adsp_disable(qcam_mod);
187 else if (!strcmp(enable->name, "VFETASK"))
188 rc = msm_adsp_disable(vfe_mod);
189
190 return rc;
191}
192
193static int vfe_7x_stop(void)
194{
195 int rc = 0;
196 uint32_t stopcmd = VFE_STOP_CMD;
197 rc = msm_adsp_write(vfe_mod, QDSP_CMDQUEUE,
198 &stopcmd, sizeof(uint32_t));
199 if (rc < 0) {
200 CDBG("%s:%d: failed rc = %d \n", __func__, __LINE__, rc);
201 return rc;
202 }
203
204 stopevent.state = 0;
205 rc = wait_event_timeout(stopevent.wait,
206 stopevent.state != 0,
207 msecs_to_jiffies(stopevent.timeout));
208
209 return rc;
210}
211
212static void vfe_7x_release(struct platform_device *pdev)
213{
214 mutex_lock(&vfe_lock);
215 vfe_syncdata = NULL;
216 mutex_unlock(&vfe_lock);
217
218 if (!vfestopped) {
219 CDBG("%s:%d:Calling vfe_7x_stop()\n", __func__, __LINE__);
220 vfe_7x_stop();
221 } else
222 vfestopped = 0;
223
224 msm_adsp_disable(qcam_mod);
225 msm_adsp_disable(vfe_mod);
226
227 msm_adsp_put(qcam_mod);
228 msm_adsp_put(vfe_mod);
229
230 msm_camio_disable(pdev);
231
232 kfree(extdata);
233 extlen = 0;
234}
235
236static int vfe_7x_init(struct msm_vfe_callback *presp,
237 struct platform_device *dev)
238{
239 int rc = 0;
240
241 init_waitqueue_head(&stopevent.wait);
242 stopevent.timeout = 200;
243 stopevent.state = 0;
244
245 if (presp && presp->vfe_resp)
246 resp = presp;
247 else
248 return -EFAULT;
249
250 /* Bring up all the required GPIOs and Clocks */
251 rc = msm_camio_enable(dev);
252 if (rc < 0)
253 return rc;
254
255 msm_camio_camif_pad_reg_reset();
256
257 extlen = sizeof(struct vfe_frame_extra);
258
32dbb671 259 extdata = kmalloc(extlen, GFP_ATOMIC);
eb7b797b
BS		 260 if (!extdata) {
261 rc = -ENOMEM;
262 goto init_fail;
263 }
264
265 rc = msm_adsp_get("QCAMTASK", &qcam_mod, &vfe_7x_sync, NULL);
266 if (rc) {
267 rc = -EBUSY;
268 goto get_qcam_fail;
269 }
270
271 rc = msm_adsp_get("VFETASK", &vfe_mod, &vfe_7x_sync, NULL);
272 if (rc) {
273 rc = -EBUSY;
274 goto get_vfe_fail;
275 }
276
277 return 0;
278
279get_vfe_fail:
280 msm_adsp_put(qcam_mod);
281get_qcam_fail:
282 kfree(extdata);
283init_fail:
284 extlen = 0;
285 return rc;
286}
287
288static int vfe_7x_config_axi(int mode,
289 struct axidata *ad, struct axiout *ao)
290{
291 struct msm_pmem_region *regptr;
292 unsigned long *bptr;
293 int cnt;
294
295 int rc = 0;
296
297 if (mode == OUTPUT_1 || mode == OUTPUT_1_AND_2) {
298 regptr = ad->region;
299
300 CDBG("bufnum1 = %d\n", ad->bufnum1);
301 CDBG("config_axi1: O1, phy = 0x%lx, y_off = %d, cbcr_off =%d\n",
302 regptr->paddr, regptr->y_off, regptr->cbcr_off);
303
304 bptr = &ao->output1buffer1_y_phy;
305 for (cnt = 0; cnt < ad->bufnum1; cnt++) {
306 *bptr = regptr->paddr + regptr->y_off;
307 bptr++;
308 *bptr = regptr->paddr + regptr->cbcr_off;
309
310 bptr++;
311 regptr++;
312 }
313
314 regptr--;
315 for (cnt = 0; cnt < (8 - ad->bufnum1); cnt++) {
316 *bptr = regptr->paddr + regptr->y_off;
317 bptr++;
318 *bptr = regptr->paddr + regptr->cbcr_off;
319 bptr++;
320 }
321 } /* if OUTPUT1 or Both */
322
323 if (mode == OUTPUT_2 || mode == OUTPUT_1_AND_2) {
324 regptr = &(ad->region[ad->bufnum1]);
325
326 CDBG("bufnum2 = %d\n", ad->bufnum2);
327 CDBG("config_axi2: O2, phy = 0x%lx, y_off = %d, cbcr_off =%d\n",
328 regptr->paddr, regptr->y_off, regptr->cbcr_off);
329
330 bptr = &ao->output2buffer1_y_phy;
331 for (cnt = 0; cnt < ad->bufnum2; cnt++) {
332 *bptr = regptr->paddr + regptr->y_off;
333 bptr++;
334 *bptr = regptr->paddr + regptr->cbcr_off;
335
336 bptr++;
337 regptr++;
338 }
339
340 regptr--;
341 for (cnt = 0; cnt < (8 - ad->bufnum2); cnt++) {
342 *bptr = regptr->paddr + regptr->y_off;
343 bptr++;
344 *bptr = regptr->paddr + regptr->cbcr_off;
345 bptr++;
346 }
347 }
348
349 return rc;
350}
351
352static int vfe_7x_config(struct msm_vfe_cfg_cmd *cmd, void *data)
353{
354 struct msm_pmem_region *regptr;
355 unsigned char buf[256];
356
357 struct vfe_stats_ack sack;
358 struct axidata *axid;
359 uint32_t i;
360
361 struct vfe_stats_we_cfg *scfg = NULL;
362 struct vfe_stats_af_cfg *sfcfg = NULL;
363
364 struct axiout *axio = NULL;
365 void *cmd_data = NULL;
366 void *cmd_data_alloc = NULL;
367 long rc = 0;
368 struct msm_vfe_command_7k *vfecmd;
369
370 vfecmd =
371 kmalloc(sizeof(struct msm_vfe_command_7k),
372 GFP_ATOMIC);
373 if (!vfecmd) {
374 pr_err("vfecmd alloc failed!\n");
375 return -ENOMEM;
376 }
377
378 if (cmd->cmd_type != CMD_FRAME_BUF_RELEASE &&
379 cmd->cmd_type != CMD_STATS_BUF_RELEASE &&
380 cmd->cmd_type != CMD_STATS_AF_BUF_RELEASE) {
381 if (copy_from_user(vfecmd,
382 (void __user *)(cmd->value),
383 sizeof(struct msm_vfe_command_7k))) {
384 rc = -EFAULT;
385 goto config_failure;
386 }
387 }
388
389 switch (cmd->cmd_type) {
390 case CMD_STATS_ENABLE:
391 case CMD_STATS_AXI_CFG: {
392 axid = data;
393 if (!axid) {
394 rc = -EFAULT;
395 goto config_failure;
396 }
397
398 scfg =
399 kmalloc(sizeof(struct vfe_stats_we_cfg),
400 GFP_ATOMIC);
401 if (!scfg) {
402 rc = -ENOMEM;
403 goto config_failure;
404 }
405
406 if (copy_from_user(scfg,
407 (void __user *)(vfecmd->value),
408 vfecmd->length)) {
409
410 rc = -EFAULT;
411 goto config_done;
412 }
413
414 CDBG("STATS_ENABLE: bufnum = %d, enabling = %d\n",
415 axid->bufnum1, scfg->wb_expstatsenable);
416
417 if (axid->bufnum1 > 0) {
418 regptr = axid->region;
419
420 for (i = 0; i < axid->bufnum1; i++) {
421
422 CDBG("STATS_ENABLE, phy = 0x%lx\n",
423 regptr->paddr);
424
425 scfg->wb_expstatoutputbuffer[i] =
426 (void *)regptr->paddr;
427 regptr++;
428 }
429
430 cmd_data = scfg;
431
432 } else {
433 rc = -EINVAL;
434 goto config_done;
435 }
436 }
437 break;
438
439 case CMD_STATS_AF_ENABLE:
440 case CMD_STATS_AF_AXI_CFG: {
441 axid = data;
442 if (!axid) {
443 rc = -EFAULT;
444 goto config_failure;
445 }
446
447 sfcfg =
448 kmalloc(sizeof(struct vfe_stats_af_cfg),
449 GFP_ATOMIC);
450
451 if (!sfcfg) {
452 rc = -ENOMEM;
453 goto config_failure;
454 }
455
456 if (copy_from_user(sfcfg,
457 (void __user *)(vfecmd->value),
458 vfecmd->length)) {
459
460 rc = -EFAULT;
461 goto config_done;
462 }
463
464 CDBG("AF_ENABLE: bufnum = %d, enabling = %d\n",
465 axid->bufnum1, sfcfg->af_enable);
466
467 if (axid->bufnum1 > 0) {
468 regptr = axid->region;
469
470 for (i = 0; i < axid->bufnum1; i++) {
471
472 CDBG("STATS_ENABLE, phy = 0x%lx\n",
473 regptr->paddr);
474
475 sfcfg->af_outbuf[i] =
476 (void *)regptr->paddr;
477
478 regptr++;
479 }
480
481 cmd_data = sfcfg;
482
483 } else {
484 rc = -EINVAL;
485 goto config_done;
486 }
487 }
488 break;
489
490 case CMD_FRAME_BUF_RELEASE: {
491 struct msm_frame *b;
492 unsigned long p;
493 struct vfe_outputack fack;
494 if (!data) {
495 rc = -EFAULT;
496 goto config_failure;
497 }
498
499 b = (struct msm_frame *)(cmd->value);
500 p = *(unsigned long *)data;
501
502 fack.header = VFE_FRAME_ACK;
503
504 fack.output2newybufferaddress =
505 (void *)(p + b->y_off);
506
507 fack.output2newcbcrbufferaddress =
508 (void *)(p + b->cbcr_off);
509
510 vfecmd->queue = QDSP_CMDQUEUE;
511 vfecmd->length = sizeof(struct vfe_outputack);
512 cmd_data = &fack;
513 }
514 break;
515
516 case CMD_SNAP_BUF_RELEASE:
517 break;
518
519 case CMD_STATS_BUF_RELEASE: {
520 CDBG("vfe_7x_config: CMD_STATS_BUF_RELEASE\n");
521 if (!data) {
522 rc = -EFAULT;
523 goto config_failure;
524 }
525
526 sack.header = STATS_WE_ACK;
527 sack.bufaddr = (void *)*(uint32_t *)data;
528
529 vfecmd->queue = QDSP_CMDQUEUE;
530 vfecmd->length = sizeof(struct vfe_stats_ack);
531 cmd_data = &sack;
532 }
533 break;
534
535 case CMD_STATS_AF_BUF_RELEASE: {
536 CDBG("vfe_7x_config: CMD_STATS_AF_BUF_RELEASE\n");
537 if (!data) {
538 rc = -EFAULT;
539 goto config_failure;
540 }
541
542 sack.header = STATS_AF_ACK;
543 sack.bufaddr = (void *)*(uint32_t *)data;
544
545 vfecmd->queue = QDSP_CMDQUEUE;
546 vfecmd->length = sizeof(struct vfe_stats_ack);
547 cmd_data = &sack;
548 }
549 break;
550
551 case CMD_GENERAL:
552 case CMD_STATS_DISABLE: {
553 if (vfecmd->length > 256) {
554 cmd_data_alloc =
555 cmd_data = kmalloc(vfecmd->length, GFP_ATOMIC);
556 if (!cmd_data) {
557 rc = -ENOMEM;
558 goto config_failure;
559 }
560 } else
561 cmd_data = buf;
562
563 if (copy_from_user(cmd_data,
564 (void __user *)(vfecmd->value),
565 vfecmd->length)) {
566
567 rc = -EFAULT;
568 goto config_done;
569 }
570
571 if (vfecmd->queue == QDSP_CMDQUEUE) {
572 switch (*(uint32_t *)cmd_data) {
573 case VFE_RESET_CMD:
574 msm_camio_vfe_blk_reset();
575 msm_camio_camif_pad_reg_reset_2();
576 vfestopped = 0;
577 break;
578
579 case VFE_START_CMD:
580 msm_camio_camif_pad_reg_reset_2();
581 vfestopped = 0;
582 break;
583
584 case VFE_STOP_CMD:
585 vfestopped = 1;
586 goto config_send;
587
588 default:
589 break;
590 }
591 } /* QDSP_CMDQUEUE */
592 }
593 break;
594
595 case CMD_AXI_CFG_OUT1: {
596 axid = data;
597 if (!axid) {
598 rc = -EFAULT;
599 goto config_failure;
600 }
601
602 axio = kmalloc(sizeof(struct axiout), GFP_ATOMIC);
603 if (!axio) {
604 rc = -ENOMEM;
605 goto config_failure;
606 }
607
608 if (copy_from_user(axio, (void *)(vfecmd->value),
609 sizeof(struct axiout))) {
610 rc = -EFAULT;
611 goto config_done;
612 }
613
614 vfe_7x_config_axi(OUTPUT_1, axid, axio);
615
616 cmd_data = axio;
617 }
618 break;
619
620 case CMD_AXI_CFG_OUT2:
621 case CMD_RAW_PICT_AXI_CFG: {
622 axid = data;
623 if (!axid) {
624 rc = -EFAULT;
625 goto config_failure;
626 }
627
628 axio = kmalloc(sizeof(struct axiout), GFP_ATOMIC);
629 if (!axio) {
630 rc = -ENOMEM;
631 goto config_failure;
632 }
633
634 if (copy_from_user(axio, (void __user *)(vfecmd->value),
635 sizeof(struct axiout))) {
636 rc = -EFAULT;
637 goto config_done;
638 }
639
640 vfe_7x_config_axi(OUTPUT_2, axid, axio);
641 cmd_data = axio;
642 }
643 break;
644
645 case CMD_AXI_CFG_SNAP_O1_AND_O2: {
646 axid = data;
647 if (!axid) {
648 rc = -EFAULT;
649 goto config_failure;
650 }
651
652 axio = kmalloc(sizeof(struct axiout), GFP_ATOMIC);
653 if (!axio) {
654 rc = -ENOMEM;
655 goto config_failure;
656 }
657
658 if (copy_from_user(axio, (void __user *)(vfecmd->value),
659 sizeof(struct axiout))) {
660 rc = -EFAULT;
661 goto config_done;
662 }
663
664 vfe_7x_config_axi(OUTPUT_1_AND_2, axid, axio);
665
666 cmd_data = axio;
667 }
668 break;
669
670 default:
671 break;
672 } /* switch */
673
674 if (vfestopped)
675 goto config_done;
676
677config_send:
678 CDBG("send adsp command = %d\n", *(uint32_t *)cmd_data);
679 rc = msm_adsp_write(vfe_mod, vfecmd->queue,
680 cmd_data, vfecmd->length);
681
682config_done:
683 if (cmd_data_alloc != NULL)
684 kfree(cmd_data_alloc);
685
686config_failure:
687 kfree(scfg);
688 kfree(axio);
689 kfree(vfecmd);
690 return rc;
691}
692
693void msm_camvfe_fn_init(struct msm_camvfe_fn *fptr, void *data)
694{
695 mutex_init(&vfe_lock);
696 fptr->vfe_init = vfe_7x_init;
697 fptr->vfe_enable = vfe_7x_enable;
698 fptr->vfe_config = vfe_7x_config;
699 fptr->vfe_disable = vfe_7x_disable;
700 fptr->vfe_release = vfe_7x_release;
701 vfe_syncdata = data;
702}
Clone of davem's net-next-2.6 tree