1 /* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
2 *
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are
5 * met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above
9 * copyright notice, this list of conditions and the following
10 * disclaimer in the documentation and/or other materials provided
11 * with the distribution.
12 * * Neither the name of The Linux Foundation nor the names of its
13 * contributors may be used to endorse or promote products derived
14 * from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29 /*#error uncomment this for compiler test!*/
30
31 //#define ALOG_NDEBUG 0
32 #define ALOG_NIDEBUG 0
33 #define LOG_TAG "QualcommCamera"
34 #include <utils/Log.h>
35 #include <utils/threads.h>
36 #include <fcntl.h>
37 #include <sys/mman.h>
38
39 #include "QCameraHAL.h"
40 /* include QCamera Hardware Interface Header*/
41 #include "QualcommCamera.h"
42 #include "QualcommUsbCamera.h"
43 //#include "QualcommCameraHardware.h"
44 //#include <camera/CameraHardwareInterface.h>
45
46 extern "C" {
47 #include <sys/time.h>
48 }
49
50 /* HAL function implementation goes here*/
51
52 /**
53 * The functions need to be provided by the camera HAL.
54 *
55 * If getNumberOfCameras() returns N, the valid cameraId for getCameraInfo()
56 * and openCameraHardware() is 0 to N-1.
57 */
58
59 static hw_module_methods_t camera_module_methods = {
60 open: camera_device_open,
61 };
62
63 static hw_module_t camera_common = {
64 tag: HARDWARE_MODULE_TAG,
65 version_major: 0,
66 version_minor: 01,
67 id: CAMERA_HARDWARE_MODULE_ID,
68 name: "Qcamera",
69 author:"Qcom",
70 methods: &camera_module_methods,
71 dso: NULL,
72 reserved: {0},
73 };
74 camera_module_t HAL_MODULE_INFO_SYM = {
75 common: camera_common,
76 get_number_of_cameras: get_number_of_cameras,
77 get_camera_info: get_camera_info,
78 };
79
80 camera_device_ops_t camera_ops = {
81 set_preview_window: android::set_preview_window,
82 set_callbacks: android::set_CallBacks,
83 enable_msg_type: android::enable_msg_type,
84 disable_msg_type: android::disable_msg_type,
85 msg_type_enabled: android::msg_type_enabled,
86
87 start_preview: android::start_preview,
88 stop_preview: android::stop_preview,
89 preview_enabled: android::preview_enabled,
90 store_meta_data_in_buffers: android::store_meta_data_in_buffers,
91
92 start_recording: android::start_recording,
93 stop_recording: android::stop_recording,
94 recording_enabled: android::recording_enabled,
95 release_recording_frame: android::release_recording_frame,
96
97 auto_focus: android::auto_focus,
98 cancel_auto_focus: android::cancel_auto_focus,
99
100 take_picture: android::take_picture,
101 cancel_picture: android::cancel_picture,
102
103 set_parameters: android::set_parameters,
104 get_parameters: android::get_parameters,
105 put_parameters: android::put_parameters,
106 send_command: android::send_command,
107
108 release: android::release,
109 dump: android::dump,
110 };
111
112 namespace android {
113
114 typedef struct {
115 camera_device hw_dev;
116 //sp<CameraHardwareInterface> hardware;
117 QCameraHardwareInterface *hardware;
118 int camera_released;
119 int cameraId;
120 //QCameraParameters parameters;
121 } camera_hardware_t;
122
123 typedef struct {
124 camera_memory_t mem;
125 int32_t msgType;
126 sp<IMemory> dataPtr;
127 void* user;
128 unsigned int index;
129 } q_cam_memory_t;
130
util_get_Hal_obj(struct camera_device * device)131 QCameraHardwareInterface *util_get_Hal_obj( struct camera_device * device)
132 {
133 QCameraHardwareInterface *hardware = NULL;
134 if(device && device->priv){
135 camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
136 hardware = camHal->hardware;
137 }
138 return hardware;
139 }
140
141 #if 0 //mzhu
142 QCameraParameters* util_get_HAL_parameter( struct camera_device * device)
143 {
144 QCameraParameters *param = NULL;
145 if(device && device->priv){
146 camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
147 param = &(camHal->parameters);
148 }
149 return param;
150 }
151 #endif //mzhu
152
get_number_of_cameras()153 extern "C" int get_number_of_cameras()
154 {
155 /* try to query every time we get the call!*/
156
157 ALOGE("Q%s: E", __func__);
158 int is_mpq = 0;
159 IS_TARGET_MPQ(is_mpq);
160
161 if(is_mpq)
162 return usbcam_get_number_of_cameras();
163
164 /* if(!is_mpq) */
165 return android::HAL_getNumberOfCameras( );
166 }
167
get_camera_info(int camera_id,struct camera_info * info)168 extern "C" int get_camera_info(int camera_id, struct camera_info *info)
169 {
170 int rc = -1;
171 ALOGE("Q%s: E", __func__);
172
173 int is_mpq = 0;
174 IS_TARGET_MPQ(is_mpq);
175
176 if(is_mpq)
177 return usbcam_get_camera_info(camera_id, info);
178
179 /* if(!is_mpq) */
180 if(info) {
181 struct CameraInfo camInfo;
182 memset(&camInfo, -1, sizeof (struct CameraInfo));
183 android::HAL_getCameraInfo(camera_id, &camInfo);
184 if (camInfo.facing >= 0) {
185 rc = 0;
186 info->facing = camInfo.facing;
187 info->orientation = camInfo.orientation;
188 }
189 }
190 ALOGV("Q%s: X", __func__);
191 return rc;
192 }
193
194
195 /* 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)196 extern "C" int camera_device_open(
197 const struct hw_module_t* module, const char* id,
198 struct hw_device_t** hw_device)
199 {
200 int rc = -1;
201 int mode = 0; // TODO: need to add 3d/2d mode, etc
202 camera_device *device = NULL;
203 int is_mpq = 0;
204 IS_TARGET_MPQ(is_mpq);
205
206 if(is_mpq && module && id && hw_device)
207 return usbcam_camera_device_open(module, id, hw_device);
208
209 /* if(!is_mpq) */
210 if(module && id && hw_device) {
211 int cameraId = atoi(id);
212
213 if (!strcmp(module->name, camera_common.name)) {
214 camera_hardware_t *camHal =
215 (camera_hardware_t *) malloc(sizeof (camera_hardware_t));
216 if(!camHal) {
217 *hw_device = NULL;
218 ALOGE("%s: end in no mem", __func__);
219 return rc;
220 }
221 /* we have the camera_hardware obj malloced */
222 memset(camHal, 0, sizeof (camera_hardware_t));
223 camHal->hardware = new QCameraHardwareInterface(cameraId, mode); //HAL_openCameraHardware(cameraId);
224 if (camHal->hardware && camHal->hardware->isCameraReady()) {
225 camHal->cameraId = cameraId;
226 device = &camHal->hw_dev;
227 device->common.close = close_camera_device;
228 device->ops = &camera_ops;
229 device->priv = (void *)camHal;
230 rc = 0;
231 } else {
232 if (camHal->hardware) {
233 delete camHal->hardware;
234 camHal->hardware = NULL;
235 }
236 free(camHal);
237 device = NULL;
238 }
239 }
240 }
241 /* pass actual hw_device ptr to framework. This amkes that we actally be use memberof() macro */
242 *hw_device = (hw_device_t*)&device->common;
243 ALOGE("%s: end rc %d", __func__, rc);
244 return rc;
245 }
246
close_camera_device(hw_device_t * hw_dev)247 extern "C" int close_camera_device( hw_device_t *hw_dev)
248 {
249 ALOGE("Q%s: device =%p E", __func__, hw_dev);
250 int rc = -1;
251 camera_device_t *device = (camera_device_t *)hw_dev;
252
253 if(device) {
254 camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
255 if(camHal ) {
256 QCameraHardwareInterface *hardware = util_get_Hal_obj( device);
257 if(!camHal->camera_released) {
258 if(hardware != NULL) {
259 hardware->release( );
260 }
261 }
262 if(hardware != NULL)
263 delete hardware;
264 free(camHal);
265 }
266 rc = 0;
267 }
268 return rc;
269 }
270
271
set_preview_window(struct camera_device * device,struct preview_stream_ops * window)272 int set_preview_window(struct camera_device * device,
273 struct preview_stream_ops *window)
274 {
275 int rc = -1;
276 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
277
278 if(hardware != NULL) {
279 rc = hardware->setPreviewWindow(window);
280 }
281 return rc;
282 }
283
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)284 void set_CallBacks(struct camera_device * device,
285 camera_notify_callback notify_cb,
286 camera_data_callback data_cb,
287 camera_data_timestamp_callback data_cb_timestamp,
288 camera_request_memory get_memory,
289 void *user)
290 {
291 ALOGE("Q%s: E", __func__);
292 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
293 if(hardware != NULL){
294 hardware->setCallbacks(notify_cb,data_cb, data_cb_timestamp, get_memory, user);
295 }
296 }
297
enable_msg_type(struct camera_device * device,int32_t msg_type)298 void enable_msg_type(struct camera_device * device, int32_t msg_type)
299 {
300 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
301 if(hardware != NULL){
302 hardware->enableMsgType(msg_type);
303 }
304 }
305
disable_msg_type(struct camera_device * device,int32_t msg_type)306 void disable_msg_type(struct camera_device * device, int32_t msg_type)
307 {
308 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
309 ALOGE("Q%s: E", __func__);
310 if(hardware != NULL){
311 hardware->disableMsgType(msg_type);
312 }
313 }
314
msg_type_enabled(struct camera_device * device,int32_t msg_type)315 int msg_type_enabled(struct camera_device * device, int32_t msg_type)
316 {
317 ALOGE("Q%s: E", __func__);
318 int rc = -1;
319 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
320 if(hardware != NULL){
321 rc = hardware->msgTypeEnabled(msg_type);
322 }
323 return rc;
324 }
325
start_preview(struct camera_device * device)326 int start_preview(struct camera_device * device)
327 {
328 ALOGE("Q%s: E", __func__);
329 int rc = -1;
330 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
331 if(hardware != NULL){
332 rc = hardware->startPreview( );
333 }
334 ALOGE("Q%s: X", __func__);
335 return rc;
336 }
337
stop_preview(struct camera_device * device)338 void stop_preview(struct camera_device * device)
339 {
340 ALOGE("Q%s: E", __func__);
341 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
342 if(hardware != NULL){
343 hardware->stopPreview( );
344 }
345 }
346
preview_enabled(struct camera_device * device)347 int preview_enabled(struct camera_device * device)
348 {
349 ALOGE("Q%s: E", __func__);
350 int rc = -1;
351 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
352 if(hardware != NULL){
353 rc = hardware->previewEnabled( );
354 }
355 return rc;
356 }
357
store_meta_data_in_buffers(struct camera_device * device,int enable)358 int store_meta_data_in_buffers(struct camera_device * device, int enable)
359 {
360 ALOGE("Q%s: E", __func__);
361 int rc = -1;
362 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
363 if(hardware != NULL){
364 rc = hardware->storeMetaDataInBuffers(enable);
365 }
366 return rc;
367 }
368
start_recording(struct camera_device * device)369 int start_recording(struct camera_device * device)
370 {
371 ALOGE("Q%s: E", __func__);
372 int rc = -1;
373 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
374 if(hardware != NULL){
375 rc = hardware->startRecording( );
376 }
377 return rc;
378 }
379
stop_recording(struct camera_device * device)380 void stop_recording(struct camera_device * device)
381 {
382 ALOGE("Q%s: E", __func__);
383 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
384 if(hardware != NULL){
385 hardware->stopRecording( );
386 }
387 }
388
recording_enabled(struct camera_device * device)389 int recording_enabled(struct camera_device * device)
390 {
391 ALOGE("Q%s: E", __func__);
392 int rc = -1;
393 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
394 if(hardware != NULL){
395 rc = hardware->recordingEnabled( );
396 }
397 return rc;
398 }
399
release_recording_frame(struct camera_device * device,const void * opaque)400 void release_recording_frame(struct camera_device * device,
401 const void *opaque)
402 {
403 ALOGV("Q%s: E", __func__);
404 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
405 if(hardware != NULL){
406 hardware->releaseRecordingFrame(opaque);
407 }
408 }
409
auto_focus(struct camera_device * device)410 int auto_focus(struct camera_device * device)
411 {
412 ALOGE("Q%s: E", __func__);
413 int rc = -1;
414 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
415 if(hardware != NULL){
416 rc = hardware->autoFocus( );
417 }
418 return rc;
419 }
420
cancel_auto_focus(struct camera_device * device)421 int cancel_auto_focus(struct camera_device * device)
422 {
423 ALOGE("Q%s: E", __func__);
424 int rc = -1;
425 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
426 if(hardware != NULL){
427 rc = hardware->cancelAutoFocus( );
428 }
429 return rc;
430 }
431
take_picture(struct camera_device * device)432 int take_picture(struct camera_device * device)
433 {
434 ALOGE("Q%s: E", __func__);
435 int rc = -1;
436 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
437 if(hardware != NULL){
438 rc = hardware->takePicture( );
439 }
440 return rc;
441 }
442
cancel_picture(struct camera_device * device)443 int cancel_picture(struct camera_device * device)
444
445 {
446 ALOGE("Q%s: E", __func__);
447 int rc = -1;
448 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
449 if(hardware != NULL){
450 rc = hardware->cancelPicture( );
451 }
452 return rc;
453 }
454
set_parameters(struct camera_device * device,const char * parms)455 int set_parameters(struct camera_device * device, const char *parms)
456
457 {
458 ALOGE("Q%s: E", __func__);
459 int rc = -1;
460 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
461 if(hardware != NULL && parms){
462 //QCameraParameters param;// = util_get_HAL_parameter(device);
463 //String8 str = String8(parms);
464
465 //param.unflatten(str);
466 rc = hardware->setParameters(parms);
467 //rc = 0;
468 }
469 return rc;
470 }
471
get_parameters(struct camera_device * device)472 char* get_parameters(struct camera_device * device)
473 {
474 ALOGE("Q%s: E", __func__);
475 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
476 if(hardware != NULL){
477 char *parms = NULL;
478 hardware->getParameters(&parms);
479 return parms;
480 }
481 return NULL;
482 }
483
put_parameters(struct camera_device * device,char * parm)484 void put_parameters(struct camera_device * device, char *parm)
485
486 {
487 ALOGE("Q%s: E", __func__);
488 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
489 if(hardware != NULL){
490 hardware->putParameters(parm);
491 }
492 }
493
send_command(struct camera_device * device,int32_t cmd,int32_t arg1,int32_t arg2)494 int send_command(struct camera_device * device,
495 int32_t cmd, int32_t arg1, int32_t arg2)
496 {
497 ALOGE("Q%s: E", __func__);
498 int rc = -1;
499 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
500 if(hardware != NULL){
501 rc = hardware->sendCommand( cmd, arg1, arg2);
502 }
503 return rc;
504 }
505
release(struct camera_device * device)506 void release(struct camera_device * device)
507 {
508 ALOGE("Q%s: E", __func__);
509 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
510 if(hardware != NULL){
511 camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
512 hardware->release( );
513 camHal->camera_released = true;
514 }
515 }
516
dump(struct camera_device * device,int fd)517 int dump(struct camera_device * device, int fd)
518 {
519 ALOGE("Q%s: E", __func__);
520 int rc = -1;
521 QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
522 if(hardware != NULL){
523 rc = hardware->dump( fd );
524 //rc = 0;
525 }
526 return rc;
527 }
528
529 }; // namespace android
530