1 /*
2 ** Copyright (c) 2011 The Linux Foundation. All rights reserved.
3 **
4 ** Licensed under the Apache License, Version 2.0 (the "License");
5 ** you may not use this file except in compliance with the License.
6 ** You may obtain a copy of the License at
7 **
8 ** http://www.apache.org/licenses/LICENSE-2.0
9 **
10 ** Unless required by applicable law or agreed to in writing, software
11 ** distributed under the License is distributed on an "AS IS" BASIS,
12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 ** See the License for the specific language governing permissions and
14 ** limitations under the License.
15 */
16
17 /*#error uncomment this for compiler test!*/
18
19 //#define ALOG_NDEBUG 0
20 #define ALOG_NIDEBUG 0
21 #define LOG_TAG "QualcommCamera"
22 #include <utils/Log.h>
23 #include <utils/threads.h>
24 #include <fcntl.h>
25 #include <sys/mman.h>
26
27 /* include QCamera Hardware Interface Header*/
28 #include "QualcommCamera.h"
29 #include "QualcommCameraHardware.h"
30 //#include <camera/CameraHardwareInterface.h>
31
32 extern "C" {
33 #include <sys/time.h>
34 }
35
36 /* HAL function implementation goes here*/
37
38 /**
39 * The functions need to be provided by the camera HAL.
40 *
41 * If getNumberOfCameras() returns N, the valid cameraId for getCameraInfo()
42 * and openCameraHardware() is 0 to N-1.
43 */
44
45 static hw_module_methods_t camera_module_methods = {
46 open: camera_device_open,
47 };
48
49
50 static hw_module_t camera_common = {
51 tag: HARDWARE_MODULE_TAG,
52 version_major: 0,
53 version_minor: 01,
54 id: CAMERA_HARDWARE_MODULE_ID,
55 name: "Qcamera",
56 author:"Qcom",
57 methods: &camera_module_methods,
58 dso: NULL,
59 //reserved[0]: 0,
60 };
61
62 camera_module_t HAL_MODULE_INFO_SYM = {
63 common: camera_common,
64 get_number_of_cameras: get_number_of_cameras,
65 get_camera_info: get_camera_info,
66 };
67
68 camera_device_ops_t camera_ops = {
69 set_preview_window: android::set_preview_window,
70 set_callbacks: android::set_callbacks,
71 enable_msg_type: android::enable_msg_type,
72 disable_msg_type: android::disable_msg_type,
73 msg_type_enabled: android::msg_type_enabled,
74
75 start_preview: android::start_preview,
76 stop_preview: android::stop_preview,
77 preview_enabled: android::preview_enabled,
78 store_meta_data_in_buffers: android::store_meta_data_in_buffers,
79
80 start_recording: android::start_recording,
81 stop_recording: android::stop_recording,
82 recording_enabled: android::recording_enabled,
83 release_recording_frame: android::release_recording_frame,
84
85 auto_focus: android::auto_focus,
86 cancel_auto_focus: android::cancel_auto_focus,
87
88 take_picture: android::take_picture,
89 cancel_picture: android::cancel_picture,
90
91 set_parameters: android::set_parameters,
92 get_parameters: android::get_parameters,
93 put_parameters: android::put_parameters,
94 send_command: android::send_command,
95
96 release: android::release,
97 dump: android::dump,
98 };
99
100 namespace android {
101
102 typedef struct {
103 QualcommCameraHardware *hardware;
104 int camera_released;
105 QCameraParameters parameters;
106 #if 1
107 camera_notify_callback notify_cb;
108 camera_data_callback data_cb;
109 camera_data_timestamp_callback data_cb_timestamp;
110 camera_request_memory get_memory;
111 void *user_data;
112 #endif
113 } camera_hardware_t;
114
115 typedef struct {
116 camera_memory_t mem;
117 int32_t msgType;
118 sp<IMemory> dataPtr;
119 void* user;
120 unsigned int index;
121 } q_cam_memory_t;
122
123
camera_release_memory(struct camera_memory * mem)124 static void camera_release_memory(struct camera_memory *mem)
125 {
126 }
127
cam_notify_callback(int32_t msgType,int32_t ext1,int32_t ext2,void * user)128 void cam_notify_callback(int32_t msgType,
129 int32_t ext1,
130 int32_t ext2,
131 void* user)
132 {
133 ALOGV("Q%s: E", __func__);
134 camera_device * device = (camera_device *)user;
135 if(device) {
136 camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
137 if(camHal) {
138 camera_notify_callback notify_cb = camHal->notify_cb;
139 void *user_data = camHal->user_data;
140 if(notify_cb) {
141 notify_cb(msgType, ext1, ext2, user_data);
142 }
143 }
144 }
145 }
146
get_mem(int fd,size_t buf_size,unsigned int num_bufs,void * user)147 camera_memory_t* get_mem(int fd,size_t buf_size,
148 unsigned int num_bufs,
149 void *user)
150 {
151 ALOGV("Q%s: E", __func__);
152 camera_device * device = (camera_device *)user;
153 if(device) {
154 camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
155 if(camHal) {
156 camera_request_memory getmem_cb = camHal->get_memory;
157 void *user_data = camHal->user_data;
158 if(getmem_cb) {
159 return getmem_cb(fd, buf_size, num_bufs, user_data);
160 }
161 }
162 }
163 return NULL;
164 }
165 #if 0
166 void native_send_data_callback(int32_t msgType,
167 camera_memory_t * framebuffer,
168 void* user)
169 {
170 ALOGE("Q%s: E", __func__);
171 static unsigned int counter = 0;
172 #if 0
173 camera_device * device = (camera_device *)user;
174 if(device) {
175 camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
176 if(camHal) {
177 camera_data_callback data_cb = camHal->data_cb;
178 void *user_data = camHal->user_data;
179 if(data_cb) {
180 q_cam_memory_t *qmem = (q_cam_memory_t *)malloc(sizeof(q_cam_memory_t));
181 if (qmem) {
182 qmem->dataPtr = dataPtr;
183 qmem->mem.data = (void *)((int)dataPtr->pointer() + dataPtr->offset());
184 qmem->mem.handle = NULL; //(void *)dataPtr->getHeapID();
185 qmem->mem.size = dataPtr->size( );
186 qmem->mem.release = camera_release_memory;
187 qmem->msgType = msgType;
188 qmem->index = counter;
189 #endif
190 data_cb(msgType, framebuffer, counter, NULL, user);
191 counter++;
192 #if 0
193 } else {
194 ALOGE("%s: out of memory", __func__);
195 }
196 #endif
197 // }
198 // }
199 // }
200 }
201 #endif
202
cam_data_callback(int32_t msgType,const sp<IMemory> & dataPtr,void * user)203 static void cam_data_callback(int32_t msgType,
204 const sp<IMemory>& dataPtr,
205 void* user)
206 {
207 ALOGV("Q%s: E", __func__);
208 static unsigned int counter = 0;
209 camera_device * device = (camera_device *)user;
210 if(device) {
211 camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
212 if(camHal) {
213 camera_data_callback data_cb = camHal->data_cb;
214 void *user_data = camHal->user_data;
215 if(data_cb) {
216 q_cam_memory_t *qmem = (q_cam_memory_t *)malloc(sizeof(q_cam_memory_t));
217 if (qmem) {
218 qmem->dataPtr = dataPtr;
219 qmem->mem.data = (void *)((int)dataPtr->pointer() + dataPtr->offset());
220 qmem->mem.handle = NULL; //(void *)dataPtr->getHeapID();
221 qmem->mem.size = dataPtr->size( );
222 qmem->mem.release = camera_release_memory;
223 qmem->msgType = msgType;
224 qmem->index = counter;
225 counter++;
226 data_cb(msgType, (camera_memory_t *)qmem, counter, NULL, user_data);
227 } else {
228 ALOGE("%s: out of memory", __func__);
229 }
230 }
231 }
232 }
233 }
234
cam_data_callback_timestamp(nsecs_t timestamp,int32_t msgType,const sp<IMemory> & dataPtr,void * user)235 static void cam_data_callback_timestamp(nsecs_t timestamp,
236 int32_t msgType,
237 const sp<IMemory>& dataPtr,
238 void* user)
239 {
240 ALOGV("Q%s: E", __func__);
241
242 static unsigned int counter = 0;
243 camera_device * device = (camera_device *)user;
244 if(device) {
245 camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
246 if(camHal) {
247 camera_data_timestamp_callback data_cb_timestamp = camHal->data_cb_timestamp;
248 void *user_data = camHal->user_data;
249 if(data_cb_timestamp) {
250 q_cam_memory_t *qmem = (q_cam_memory_t *)malloc(sizeof(q_cam_memory_t));
251 if (qmem) {
252 qmem->dataPtr = dataPtr;
253 qmem->mem.data = (void *)((int)dataPtr->pointer() + dataPtr->offset());
254 qmem->mem.handle = NULL; //(void *)dataPtr->getHeapID();
255 qmem->mem.size = dataPtr->size( );
256 qmem->mem.release = camera_release_memory;
257 qmem->msgType = msgType;
258 qmem->index = counter;
259 counter++;
260 data_cb_timestamp(timestamp, msgType, (camera_memory_t *)qmem, counter, user_data);
261 } else {
262 ALOGE("%s: out of memory", __func__);
263 }
264 }
265 }
266 }
267 }
268
util_get_Hal_obj(struct camera_device * device)269 QualcommCameraHardware * util_get_Hal_obj( struct camera_device * device)
270 {
271 QualcommCameraHardware* hardware = NULL;
272 if(device && device->priv){
273 camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
274 hardware = camHal->hardware;
275 }
276 return hardware;
277 }
close_Hal_obj(struct camera_device * device)278 void close_Hal_obj( struct camera_device * device)
279 {
280 ALOGV("%s: E", __func__);
281 QualcommCameraHardware* hardware = NULL;
282 if(device && device->priv){
283 camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
284 ALOGI("%s: clear hw", __func__);
285 hardware = camHal->hardware;
286 delete hardware;
287 }
288 ALOGV("%s: X", __func__);
289 }
290
291
util_get_HAL_parameter(struct camera_device * device)292 QCameraParameters* util_get_HAL_parameter( struct camera_device * device)
293 {
294 QCameraParameters *param = NULL;
295 if(device && device->priv){
296 camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
297 param = &(camHal->parameters);
298 }
299 return param;
300 }
301
302
get_number_of_cameras()303 extern "C" int get_number_of_cameras()
304 {
305 /* try to query every time we get the call!*/
306
307 ALOGV("Q%s: E", __func__);
308 return android::HAL_getNumberOfCameras( );
309 }
310
get_camera_info(int camera_id,struct camera_info * info)311 extern "C" int get_camera_info(int camera_id, struct camera_info *info)
312 {
313 int rc = -1;
314 ALOGV("Q%s: E", __func__);
315 if(info) {
316 struct CameraInfo camInfo;
317 memset(&camInfo, -1, sizeof (struct CameraInfo));
318 HAL_getCameraInfo(camera_id, &camInfo);
319 if (camInfo.facing >= 0) {
320 rc = 0;
321 info->facing = camInfo.facing;
322 info->orientation = camInfo.orientation;
323 }
324 }
325 ALOGV("Q%s: X", __func__);
326 return rc;
327 }
328
329
330 /* HAL should return NULL if it fails to open camera hardware. */
camera_device_open(const struct hw_module_t * module,const char * id,struct hw_device_t ** hw_device)331 extern "C" int camera_device_open(
332 const struct hw_module_t* module, const char* id,
333 struct hw_device_t** hw_device)
334 {
335 ALOGV("Q%s: E", __func__);
336 int rc = -1;
337 camera_device *device = NULL;
338 if(module && id && hw_device) {
339 int cameraId = atoi(id);
340
341 if (!strcmp(module->name, camera_common.name)) {
342 device =
343 (camera_device *)malloc(sizeof (struct camera_device));
344 if(device) {
345 camera_hardware_t *camHal =
346 (camera_hardware_t *) malloc(sizeof (camera_hardware_t));
347 if(camHal) {
348 memset(camHal, 0, sizeof (camera_hardware_t));
349 camHal->hardware = HAL_openCameraHardware(cameraId);
350 if (camHal->hardware != NULL) {
351 /*To Do: populate camHal*/
352 device->common.close = close_camera_device;
353 device->ops = &camera_ops;
354 device->priv = (void *)camHal;
355 rc = 0;
356 } else {
357 free(camHal);
358 free (device);
359 device = NULL;
360 }
361 } else {
362 free (device);
363 device = NULL;
364 }
365 }
366 }
367 }
368 *hw_device = (hw_device_t*)device;
369 return rc;
370 }
371
close_camera_device(hw_device_t * hw_dev)372 extern "C" int close_camera_device( hw_device_t *hw_dev)
373 {
374 ALOGV("Q%s: device =%p E", __func__, hw_dev);
375 int rc = -1;
376 camera_device_t *device = (camera_device_t *)hw_dev;
377 if(device) {
378 camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
379 if(camHal ) {
380 //if(!camHal->camera_released) {
381 QualcommCameraHardware* hardware = util_get_Hal_obj( device);
382 if(hardware != NULL) {
383 if(camHal->camera_released != true)
384 hardware->release( );
385 //hardware.clear( );
386
387 }
388 //}
389 close_Hal_obj(device);
390 free(device->priv);
391 device->priv = NULL;
392 }
393 free(device);
394 rc = 0;
395 }
396 return rc;
397 }
398
399
set_preview_window(struct camera_device * device,struct preview_stream_ops * window)400 int set_preview_window(struct camera_device * device,
401 struct preview_stream_ops *window)
402 {
403 ALOGV("Q%s: E window = %p", __func__, window);
404 int rc = -1;
405 QualcommCameraHardware *hardware = util_get_Hal_obj(device);
406 if(hardware != NULL) {
407 rc = hardware->set_PreviewWindow((void *)window);
408 }
409 return rc;
410 }
411
set_callbacks(struct camera_device * device,camera_notify_callback notify_cb,camera_data_callback data_cb,camera_data_timestamp_callback data_cb_timestamp,camera_request_memory get_memory,void * user)412 void set_callbacks(struct camera_device * device,
413 camera_notify_callback notify_cb,
414 camera_data_callback data_cb,
415 camera_data_timestamp_callback data_cb_timestamp,
416 camera_request_memory get_memory,
417 void *user)
418 {
419 ALOGV("Q%s: E", __func__);
420 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
421 if(hardware != NULL){
422 camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
423 if(camHal) {
424 camera_notify_callback cam_nt_cb;
425 camera_data_callback cam_dt_cb;
426 camera_data_timestamp_callback cam_dt_timestamp_cb;
427
428 camHal->notify_cb = notify_cb;
429 camHal->data_cb = data_cb;
430 camHal->data_cb_timestamp = data_cb_timestamp;
431 camHal->user_data = user;
432 camHal->get_memory = get_memory;
433 #if 0
434 if(notify_cb) {
435 cam_nt_cb = cam_notify_callback;
436 } else {
437 cam_nt_cb = NULL;
438 }
439
440 if(data_cb) {
441 cam_dt_cb = cam_data_callback;
442 } else {
443 cam_dt_cb = NULL;
444 }
445
446 if(data_cb_timestamp) {
447 cam_dt_timestamp_cb = cam_data_callback_timestamp;
448 } else {
449 cam_dt_timestamp_cb = NULL;
450 }
451 #endif
452 ALOGV("cam_nt_cb =%p,cam_dt_cb=%p,cam_dt_timestamp_cb=%p", cam_nt_cb, cam_dt_cb, cam_dt_timestamp_cb);
453 hardware->setCallbacks(notify_cb,data_cb,data_cb_timestamp,get_memory, user);
454 }
455 }
456 }
457
enable_msg_type(struct camera_device * device,int32_t msg_type)458 void enable_msg_type(struct camera_device * device, int32_t msg_type)
459 {
460 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
461 if(hardware != NULL){
462 hardware->enableMsgType(msg_type);
463 }
464 }
465
disable_msg_type(struct camera_device * device,int32_t msg_type)466 void disable_msg_type(struct camera_device * device, int32_t msg_type)
467 {
468 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
469 ALOGV("Q%s: E", __func__);
470 if(hardware != NULL){
471 hardware->disableMsgType(msg_type);
472 }
473 }
474
msg_type_enabled(struct camera_device * device,int32_t msg_type)475 int msg_type_enabled(struct camera_device * device, int32_t msg_type)
476 {
477 ALOGV("Q%s: E", __func__);
478 int rc = -1;
479 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
480 if(hardware != NULL){
481 rc = hardware->msgTypeEnabled(msg_type);
482 }
483 return rc;
484 }
485
start_preview(struct camera_device * device)486 int start_preview(struct camera_device * device)
487 {
488 ALOGV("Q%s: E", __func__);
489 int rc = -1;
490 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
491 if(hardware != NULL){
492 rc = hardware->startPreview( );
493 }
494 ALOGV("Q%s: X", __func__);
495 return rc;
496 }
497
stop_preview(struct camera_device * device)498 void stop_preview(struct camera_device * device)
499 {
500 ALOGV("Q%s: E", __func__);
501 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
502 if(hardware != NULL){
503 hardware->stopPreview( );
504 }
505 }
506
preview_enabled(struct camera_device * device)507 int preview_enabled(struct camera_device * device)
508 {
509 ALOGV("Q%s: E", __func__);
510 int rc = -1;
511 QualcommCameraHardware* hardware = util_get_Hal_obj(device);
512 if(hardware != NULL){
513 rc = hardware->previewEnabled( );
514 }
515 return rc;
516 }
517
store_meta_data_in_buffers(struct camera_device * device,int enable)518 int store_meta_data_in_buffers(struct camera_device * device, int enable)
519 {
520 ALOGV("Q%s: E", __func__);
521 int rc = -1;
522 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
523 if(hardware != NULL){
524 rc = hardware->storeMetaDataInBuffers( enable);
525 }
526 return rc;
527 }
528
start_recording(struct camera_device * device)529 int start_recording(struct camera_device * device)
530 {
531 ALOGV("Q%s: E", __func__);
532 int rc = -1;
533 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
534 if(hardware != NULL){
535 rc = hardware->startRecording( );
536 }
537 return rc;
538 }
539
stop_recording(struct camera_device * device)540 void stop_recording(struct camera_device * device)
541 {
542 ALOGV("Q%s: E", __func__);
543 QualcommCameraHardware* hardware = util_get_Hal_obj(device);
544 if(hardware != NULL){
545 hardware->stopRecording( );
546 }
547 }
548
recording_enabled(struct camera_device * device)549 int recording_enabled(struct camera_device * device)
550 {
551 ALOGV("Q%s: E", __func__);
552 int rc = -1;
553 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
554 if(hardware != NULL){
555 rc = hardware->recordingEnabled( );
556 }
557 return rc;
558 }
559
release_recording_frame(struct camera_device * device,const void * opaque)560 void release_recording_frame(struct camera_device * device,
561 const void *opaque)
562 {
563 ALOGV("Q%s: E", __func__);
564 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
565 if(hardware != NULL){
566 hardware->releaseRecordingFrame( opaque);
567 }
568 }
569
auto_focus(struct camera_device * device)570 int auto_focus(struct camera_device * device)
571 {
572 ALOGV("Q%s: E", __func__);
573 int rc = -1;
574 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
575 if(hardware != NULL){
576 rc = hardware->autoFocus( );
577 }
578 return rc;
579 }
580
cancel_auto_focus(struct camera_device * device)581 int cancel_auto_focus(struct camera_device * device)
582 {
583 ALOGV("Q%s: E", __func__);
584 int rc = -1;
585 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
586 if(hardware != NULL){
587 rc = hardware->cancelAutoFocus( );
588 }
589 return rc;
590 }
591
take_picture(struct camera_device * device)592 int take_picture(struct camera_device * device)
593 {
594 ALOGV("Q%s: E", __func__);
595 int rc = -1;
596 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
597 if(hardware != NULL){
598 rc = hardware->takePicture( );
599 }
600 return rc;
601 }
602
cancel_picture(struct camera_device * device)603 int cancel_picture(struct camera_device * device)
604
605 {
606 ALOGV("Q%s: E", __func__);
607 int rc = -1;
608 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
609 if(hardware != NULL){
610 rc = hardware->cancelPicture( );
611 }
612 return rc;
613 }
614
615 QCameraParameters g_param;
616 String8 g_str;
set_parameters(struct camera_device * device,const char * parms)617 int set_parameters(struct camera_device * device, const char *parms)
618
619 {
620 ALOGV("Q%s: E", __func__);
621 int rc = -1;
622 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
623 if(hardware != NULL && parms){
624 // = util_get_HAL_parameter(device);
625 g_str = String8(parms);
626
627 g_param.unflatten(g_str);
628 rc = hardware->setParameters( g_param );
629 }
630 return rc;
631 }
632
get_parameters(struct camera_device * device)633 char* get_parameters(struct camera_device * device)
634 {
635 ALOGV("Q%s: E", __func__);
636 char* rc = NULL;
637
638 QCameraParameters param;
639 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
640 if(hardware != NULL){
641 g_param = hardware->getParameters( );
642 g_str = g_param.flatten( );
643 rc = (char *)g_str.string( );
644 if (!rc) {
645 ALOGE("get_parameters: NULL string");
646 } else {
647 //ALOGE("get_parameters: %s", rc);
648 }
649 }
650 ALOGV("get_parameters X");
651 return rc;
652 }
653
put_parameters(struct camera_device * device,char * parm)654 void put_parameters(struct camera_device * device, char *parm)
655
656 {
657 ALOGV("Q%s: E", __func__);
658 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
659 if(hardware != NULL){
660 if(hardware != NULL){
661 //rc = hardware->putParameters(parm );
662 }
663 }
664 ALOGV("put_parameters X");
665 }
666
send_command(struct camera_device * device,int32_t cmd,int32_t arg1,int32_t arg2)667 int send_command(struct camera_device * device,
668 int32_t cmd, int32_t arg1, int32_t arg2)
669 {
670 ALOGV("Q%s: E", __func__);
671 int rc = -1;
672 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
673 if(hardware != NULL){
674 rc = hardware->sendCommand( cmd, arg1, arg2);
675 }
676 return rc;
677 }
678
release(struct camera_device * device)679 void release(struct camera_device * device)
680 {
681 ALOGV("Q%s: E", __func__);
682 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
683 if(hardware != NULL){
684 camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
685 hardware->release( );
686 camHal->camera_released = true;
687 }
688 }
689
dump(struct camera_device * device,int fd)690 int dump(struct camera_device * device, int fd)
691 {
692 ALOGV("Q%s: E", __func__);
693 int rc = -1;
694 QualcommCameraHardware * hardware = util_get_Hal_obj(device);
695 if(hardware != NULL){
696 //rc = hardware->dump( fd );
697 rc = 0;
698 }
699 return rc;
700 }
701
702 }; // namespace android
703