/* Copyright (c) 2008-2010, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and * only version 2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * */ /* #define DEBUG_TRACE_VDEC #define DEBUG */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "dal.h" #define DALDEVICEID_VDEC_DEVICE 0x02000026 #define DALDEVICEID_VDEC_PORTNAME "DAL_AQ_VID" #define VDEC_INTERFACE_VERSION 0x00020000 #define MAJOR_MASK 0xFFFF0000 #define MINOR_MASK 0x0000FFFF #define VDEC_GET_MAJOR_VERSION(version) (((version)&MAJOR_MASK)>>16) #define VDEC_GET_MINOR_VERSION(version) ((version)&MINOR_MASK) #ifdef DEBUG_TRACE_VDEC #define TRACE(fmt,x...) \ do { pr_debug("%s:%d " fmt, __func__, __LINE__, ##x); } while (0) #else #define TRACE(fmt,x...) do { } while (0) #endif #define YAMATO_COLOR_FORMAT 0x02 #define MAX_Q6_LOAD ((720*1280)/256) /* 720p */ #define MAX_Q6_LOAD_YAMATO ((736*1280)/256) #define MAX_Q6_LOAD_VP6 ((800*480)/256) #define VDEC_MAX_PORTS 4 /* *why magic number 300? *the Maximum size of the DAL payload is 512 bytes according to DAL protocol *Initialize call to QDSP6 from scorpion need to send sequence header as part of *the DAL payload. DAL payload to initialize contains the following *1) configuration data- 52 bytes 2) length field of config data - 4 bytes *3) sequence header data ( that is from the bit stream) *4) length field for sequence header - 4 bytes *5) length field for output structure - 4 bytes *that left with 512 - 68 = 448 bytes. It is unusual that we get a sequence *header with such a big length unless the bit stream has multiple sequence *headers.We estimated 300 is good enough which gives enough room for rest *of the payload and even reserves some space for future payload. */ #define VDEC_MAX_SEQ_HEADER_SIZE 300 char *Q6Portnames[] = { "DAL_AQ_VID_0", "DAL_AQ_VID_1", "DAL_AQ_VID_2", "DAL_AQ_VID_3" }; #define DALDEVICEID_VDEC_DEVICE_0 0x020000D2 #define DALDEVICEID_VDEC_DEVICE_1 0x020000D3 #define DALDEVICEID_VDEC_DEVICE_2 0x020000D4 #define DALDEVICEID_VDEC_DEVICE_3 0x020000D5 #define DALDEVICEID_VDEC_DEVICE_4 0x020000D6 #define DALDEVICEID_VDEC_DEVICE_5 0x020000D7 #define DALDEVICEID_VDEC_DEVICE_6 0x020000D8 #define DALDEVICEID_VDEC_DEVICE_7 0x020000D9 #define DALDEVICEID_VDEC_DEVICE_8 0x020000DA #define DALDEVICEID_VDEC_DEVICE_9 0x020000DB #define DALDEVICEID_VDEC_DEVICE_10 0x020000DC #define DALDEVICEID_VDEC_DEVICE_11 0x020000DD #define DALDEVICEID_VDEC_DEVICE_12 0x020000DE #define DALDEVICEID_VDEC_DEVICE_13 0x020000DF #define DALDEVICEID_VDEC_DEVICE_14 0x020000E0 #define DALDEVICEID_VDEC_DEVICE_15 0x020000E1 #define DALDEVICEID_VDEC_DEVICE_16 0x020000E2 #define DALDEVICEID_VDEC_DEVICE_17 0x020000E3 #define DALDEVICEID_VDEC_DEVICE_18 0x020000E4 #define DALDEVICEID_VDEC_DEVICE_19 0x020000E5 #define DALDEVICEID_VDEC_DEVICE_20 0x020000E6 #define DALDEVICEID_VDEC_DEVICE_21 0x020000E7 #define DALDEVICEID_VDEC_DEVICE_22 0x020000E8 #define DALDEVICEID_VDEC_DEVICE_23 0x020000E9 #define DALDEVICEID_VDEC_DEVICE_24 0x020000EA #define DALDEVICEID_VDEC_DEVICE_25 0x020000EB #define DALDEVICEID_VDEC_DEVICE_26 0x020000EC #define DALDEVICEID_VDEC_DEVICE_27 0x020000ED #define DALDEVICEID_VDEC_DEVICE_28 0x020000EE #define DALDEVICEID_VDEC_DEVICE_29 0x020000EF #define DALDEVICEID_VDEC_DEVICE_30 0x020000F0 #define DALDEVICEID_VDEC_DEVICE_31 0x020000F1 #define DALVDEC_MAX_DEVICE_IDS 32 static int numOfPorts; static char loadOnPorts[VDEC_MAX_PORTS]; static char deviceIdRegistry[DALVDEC_MAX_DEVICE_IDS]; #define VDEC_DEVID_FREE 0 #define VDEC_DEVID_OCCUPIED 1 #define MAX_SUPPORTED_INSTANCES 6 #define MAKEFOURCC(ch0, ch1, ch2, ch3) ((unsigned int)(unsigned char)(ch0) | \ ((unsigned int)(unsigned char)(ch1) << 8) | \ ((unsigned int)(unsigned char)(ch2) << 16) | \ ((unsigned int)(unsigned char)(ch3) << 24)) #define FOURCC_MPEG4 MAKEFOURCC('m', 'p', '4', 'v') #define FOURCC_H263 MAKEFOURCC('h', '2', '6', '3') #define FOURCC_H264 MAKEFOURCC('h', '2', '6', '4') #define FOURCC_VC1 MAKEFOURCC('w', 'm', 'v', '3') #define FOURCC_DIVX MAKEFOURCC('D', 'I', 'V', 'X') #define FOURCC_SPARK MAKEFOURCC('F', 'L', 'V', '1') #define FOURCC_VP6 MAKEFOURCC('V', 'P', '6', '0') /* static struct vdec_data *multiInstances[MAX_SUPPORTED_INSTANCES];*/ static int totalPlaybackQ6load; static int totalTnailQ6load; #define FLAG_THUMBNAIL_MODE 0x8 #define MAX_TNAILS 3 #define TRUE 1 #define FALSE 0 enum { VDEC_DALRPC_INITIALIZE = DAL_OP_FIRST_DEVICE_API, VDEC_DALRPC_SETBUFFERS, VDEC_DALRPC_FREEBUFFERS, VDEC_DALRPC_QUEUE, VDEC_DALRPC_SIGEOFSTREAM, VDEC_DALRPC_FLUSH, VDEC_DALRPC_REUSEFRAMEBUFFER, VDEC_DALRPC_GETDECATTRIBUTES, VDEC_DALRPC_SUSPEND, VDEC_DALRPC_RESUME, VDEC_DALRPC_INITIALIZE_00, VDEC_DALRPC_GETINTERNALBUFFERREQ, VDEC_DALRPC_SETBUFFERS_00, VDEC_DALRPC_FREEBUFFERS_00, VDEC_DALRPC_GETPROPERTY, VDEC_DALRPC_SETPROPERTY, VDEC_DALRPC_GETDECATTRIBUTES_00, VDEC_DALRPC_PERFORMANCE_CHANGE_REQUEST }; enum { VDEC_ASYNCMSG_DECODE_DONE = 0xdec0de00, VDEC_ASYNCMSG_REUSE_FRAME, }; struct vdec_init_cfg { u32 decode_done_evt; u32 reuse_frame_evt; struct vdec_config cfg; }; struct vdec_buffer_status { u32 data; u32 status; }; #define VDEC_MSG_MAX 128 struct vdec_msg_list { struct list_head list; struct vdec_msg vdec_msg; }; struct vdec_mem_info { u32 buf_type; u32 id; unsigned long phys_addr; unsigned long len; struct file *file; }; struct vdec_mem_list { struct list_head list; struct vdec_mem_info mem; }; struct videoStreamDetails{ int height; int width; unsigned int fourcc; int Q6usage; bool isThisTnail; bool isTnailGranted; }; struct vdec_data { struct dal_client *vdec_handle; unsigned int Q6deviceId; struct videoStreamDetails streamDetails; struct list_head vdec_msg_list_head; struct list_head vdec_msg_list_free; wait_queue_head_t vdec_msg_evt; spinlock_t vdec_list_lock; struct list_head vdec_mem_list_head; spinlock_t vdec_mem_list_lock; int mem_initialized; int running; int close_decode; }; static struct class *driver_class; static dev_t vdec_device_no; static struct cdev vdec_cdev; static int ref_cnt; static DEFINE_MUTEX(vdec_ref_lock); static DEFINE_MUTEX(idlecount_lock); static DEFINE_MUTEX(vdec_rm_lock); static int idlecount; static struct wake_lock wakelock; static struct pm_qos_request pm_qos_req; static void prevent_sleep(void) { mutex_lock(&idlecount_lock); if (++idlecount == 1) { pm_qos_update_request(&pm_qos_req, msm_cpuidle_get_deep_idle_latency()); wake_lock(&wakelock); } mutex_unlock(&idlecount_lock); } static void allow_sleep(void) { mutex_lock(&idlecount_lock); if (--idlecount == 0) { wake_unlock(&wakelock); pm_qos_update_request(&pm_qos_req, PM_QOS_DEFAULT_VALUE); } mutex_unlock(&idlecount_lock); } static inline int vdec_check_version(u32 client, u32 server) { int ret = -EINVAL; if ((VDEC_GET_MAJOR_VERSION(client) == VDEC_GET_MAJOR_VERSION(server)) && (VDEC_GET_MINOR_VERSION(client) <= VDEC_GET_MINOR_VERSION(server))) ret = 0; return ret; } static int vdec_get_msg(struct vdec_data *vd, void *msg) { struct vdec_msg_list *l; unsigned long flags; int ret = 0; if (!vd->running) return -EPERM; spin_lock_irqsave(&vd->vdec_list_lock, flags); list_for_each_entry_reverse(l, &vd->vdec_msg_list_head, list) { if (copy_to_user(msg, &l->vdec_msg, sizeof(struct vdec_msg))) pr_err("vdec_get_msg failed to copy_to_user!\n"); if (l->vdec_msg.id == VDEC_MSG_REUSEINPUTBUFFER) TRACE("reuse_input_buffer %d\n", l->vdec_msg.buf_id); else if (l->vdec_msg.id == VDEC_MSG_FRAMEDONE) TRACE("frame_done (stat=%d)\n", l->vdec_msg.vfr_info.status); else TRACE("unknown msg (msgid=%d)\n", l->vdec_msg.id); list_del(&l->list); list_add(&l->list, &vd->vdec_msg_list_free); ret = 1; break; } spin_unlock_irqrestore(&vd->vdec_list_lock, flags); if (vd->close_decode) ret = 1; return ret; } static void vdec_put_msg(struct vdec_data *vd, struct vdec_msg *msg) { struct vdec_msg_list *l; unsigned long flags; int found = 0; spin_lock_irqsave(&vd->vdec_list_lock, flags); list_for_each_entry(l, &vd->vdec_msg_list_free, list) { memcpy(&l->vdec_msg, msg, sizeof(struct vdec_msg)); list_del(&l->list); list_add(&l->list, &vd->vdec_msg_list_head); found = 1; break; } spin_unlock_irqrestore(&vd->vdec_list_lock, flags); if (found) wake_up(&vd->vdec_msg_evt); else pr_err("vdec_put_msg can't find free list!\n"); } static struct vdec_mem_list *vdec_get_mem_from_list(struct vdec_data *vd, u32 pmem_id, u32 buf_type) { struct vdec_mem_list *l; unsigned long flags; int found = 0; spin_lock_irqsave(&vd->vdec_mem_list_lock, flags); list_for_each_entry(l, &vd->vdec_mem_list_head, list) { if (l->mem.buf_type == buf_type && l->mem.id == pmem_id) { found = 1; break; } } spin_unlock_irqrestore(&vd->vdec_mem_list_lock, flags); if (found) return l; else return NULL; } static int vdec_setproperty(struct vdec_data *vd, void *argp) { struct vdec_property_info property; int res; if (copy_from_user(&property, argp, sizeof(struct vdec_property_info))) return -1; res = dal_call_f6(vd->vdec_handle, VDEC_DALRPC_SETPROPERTY, property.id, &(property.property), sizeof(union vdec_property)); if (res) TRACE("Set Property failed"); else TRACE("Set Property succeeded"); return res; } static int vdec_getproperty(struct vdec_data *vd, void *argp) { int res; union vdec_property property = {0}; res = dal_call_f11(vd->vdec_handle, VDEC_DALRPC_GETPROPERTY, ((struct vdec_property_info *)argp)->id, &property, sizeof(union vdec_property)); if (res) TRACE("get Property failed"); else TRACE("get Property succeeded"); res = copy_to_user( (&((struct vdec_property_info *)argp)->property), &property, sizeof(property)); return res; } static int vdec_performance_change_request(struct vdec_data *vd, void* argp) { u32 request_type; int ret; ret = copy_from_user(&request_type, argp, sizeof(request_type)); if (ret) { pr_err("%s: copy_from_user failed\n", __func__); return ret; } ret = dal_call_f0(vd->vdec_handle, VDEC_DALRPC_PERFORMANCE_CHANGE_REQUEST, request_type); if (ret) { pr_err("%s: remote function failed (%d)\n", __func__, ret); return ret; } return ret; } #ifdef TRACE_PORTS static void printportsanddeviceids(void) { int i; pr_err("\n\n%s:loadOnPorts", __func__); for (i = 0; i < numOfPorts; i++) pr_err("\t%d", loadOnPorts[i]); pr_err("\n\n"); pr_err("\n\n%s:Devids", __func__); for (i = 0; i < DALVDEC_MAX_DEVICE_IDS; i++) pr_err("Devid[%d]:%d\n", i, deviceIdRegistry[i]); pr_err("\n\n"); } #endif /*TRACE_PORTS*/ /* * * This method is used to get the number of ports supported on the Q6 * */ static int vdec_get_numberofq6ports(void) { struct dal_client *vdec_handle = NULL; int retval = 0; union vdec_property property = {0}; vdec_handle = dal_attach(DALDEVICEID_VDEC_DEVICE, DALDEVICEID_VDEC_PORTNAME, 1, NULL, NULL); if (!vdec_handle) { pr_err("%s: failed to attach\n", __func__); return 1;/* default setting */ } retval = dal_call_f6(vdec_handle, VDEC_DALRPC_GETPROPERTY, VDEC_NUM_DAL_PORTS, (void *)&property, sizeof(union vdec_property)); if (retval) { pr_err("%s: Q6get prperty failed\n", __func__); return 1;/* default setting */ } dal_detach(vdec_handle); return property.num_dal_ports ; } /** * This method is used to get the find the least loaded port and a corresponding * free device id in that port. * * Prerequisite: vdec_open should have been called. * * @param[in] deviceid * device id will be populated here. * * @param[in] portname * portname will be populated here. */ static void vdec_get_next_portanddevid(int *deviceid, char **portname) { int i = 0; int leastLoad = 0; int leastLoadedIndex = 0; if (0 == numOfPorts) { numOfPorts = vdec_get_numberofq6ports(); pr_err("%s: Q6get numOfPorts %d\n", __func__, numOfPorts); numOfPorts = 4; /*fix: me currently hard coded to 4 as *the Q6 getproperty is failing */ } if ((NULL == deviceid) || (NULL == portname)) return; else *deviceid = 0; /* init value */ if (numOfPorts > 1) { /* multi ports mode*/ /* find the least loaded port*/ for (i = 1, leastLoad = loadOnPorts[0], leastLoadedIndex = 0; i < numOfPorts; i++) { if (leastLoad > loadOnPorts[i]) { leastLoadedIndex = i; leastLoad = loadOnPorts[i]; } } /* register the load */ loadOnPorts[leastLoadedIndex]++; *portname = Q6Portnames[leastLoadedIndex]; /* find a free device id corresponding to the port*/ for (i = leastLoadedIndex; i < DALVDEC_MAX_DEVICE_IDS; i += numOfPorts) { if (VDEC_DEVID_FREE == deviceIdRegistry[i]) { deviceIdRegistry[i] = VDEC_DEVID_OCCUPIED; *deviceid = DALDEVICEID_VDEC_DEVICE_0 + i; break; } } #ifdef TRACE_PORTS printportsanddeviceids(); #endif /*TRACE_PORTS*/ } else if (1 == numOfPorts) { /* single port mode */ *deviceid = DALDEVICEID_VDEC_DEVICE; *portname = DALDEVICEID_VDEC_PORTNAME; } else if (numOfPorts <= 0) { pr_err("%s: FATAL error numOfPorts cannot be \ less than or equal to zero\n", __func__); } } /** * This method frees up the used dev id and decrements the port load. * */ static void vdec_freeup_portanddevid(int deviceid) { if (numOfPorts > 1) { /* multi ports mode*/ if (VDEC_DEVID_FREE == deviceIdRegistry[deviceid - DALDEVICEID_VDEC_DEVICE_0]) pr_err("device id cannot be already free\n"); deviceIdRegistry[deviceid - DALDEVICEID_VDEC_DEVICE_0] = VDEC_DEVID_FREE; loadOnPorts[(deviceid - DALDEVICEID_VDEC_DEVICE_0) % numOfPorts]--; if (loadOnPorts[(deviceid - DALDEVICEID_VDEC_DEVICE_0) % numOfPorts] < 0) pr_err("Warning:load cannot be negative\n"); pr_err("dettaching on deviceid %x portname %s\n", deviceid, Q6Portnames[(deviceid - DALDEVICEID_VDEC_DEVICE_0) % numOfPorts]); #ifdef TRACE_PORTS printportsanddeviceids(); #endif /*TRACE_PORTS*/ } else { /*single port mode, nothing to be done here*/ } } /** * This method validates whether a new instance can be houred or not. * */ static int vdec_rm_checkWithRm(struct vdec_data *vdecInstance, unsigned int color_format) { unsigned int maxQ6load = 0;/* in the units of macro blocks per second */ unsigned int currentq6load = 0; struct videoStreamDetails *streamDetails = &vdecInstance->streamDetails; if (streamDetails->isThisTnail) { if (totalTnailQ6load < MAX_TNAILS) { totalTnailQ6load++; streamDetails->isTnailGranted = TRUE; pr_info("%s: thumbnail granted %d\n", __func__, totalTnailQ6load); return 0; } else { pr_err("%s: thumbnails load max this instance cannot \ be supported\n", __func__); streamDetails->isTnailGranted = FALSE; return -ENOSPC; } } /* calculate the Q6 percentage instance would need */ if ((streamDetails->fourcc == FOURCC_MPEG4) || (streamDetails->fourcc == FOURCC_H264) || (streamDetails->fourcc == FOURCC_DIVX) || (streamDetails->fourcc == FOURCC_VC1) || (streamDetails->fourcc == FOURCC_SPARK) || (streamDetails->fourcc == FOURCC_H263) ){ /* is yamato color format, Rounds the H & W --> mutiple of 32 */ if (color_format == YAMATO_COLOR_FORMAT) maxQ6load = MAX_Q6_LOAD_YAMATO; else maxQ6load = MAX_Q6_LOAD; /* 720p */ } else if (streamDetails->fourcc == FOURCC_VP6) { maxQ6load = MAX_Q6_LOAD_VP6; /* FWVGA */ } else { pr_err("%s: unknown fourcc %d maxQ6load %u\n", __func__, streamDetails->fourcc, maxQ6load); return -EINVAL; } currentq6load = ((streamDetails->height)*(streamDetails->width) / 256); currentq6load = ((currentq6load * 100)/maxQ6load); if ((currentq6load+totalPlaybackQ6load) > 100) { /* reject this instance */ pr_err("%s: too much Q6load [cur+tot] = [%d + %d] = %d", __func__, currentq6load, totalPlaybackQ6load, (currentq6load+totalPlaybackQ6load)); pr_err("rejecting the instance,[WxH] = [%d x %d],color_fmt=0x%x\n", streamDetails->width, streamDetails->height, color_format); pr_err("VDEC_fmt=%s\n", (char *)(&streamDetails->fourcc)); streamDetails->Q6usage = 0; return -ENOSPC; } totalPlaybackQ6load += currentq6load; streamDetails->Q6usage = currentq6load; pr_info("%s: adding a load [%d%%] bringing total Q6load to [%d%%]\n", __func__, currentq6load, totalPlaybackQ6load); return 0; } static int vdec_initialize(struct vdec_data *vd, void *argp) { struct vdec_config_sps vdec_cfg_sps; struct vdec_init_cfg vi_cfg; struct vdec_buf_req vdec_buf_req; struct u8 *header; int ret = 0; ret = copy_from_user(&vdec_cfg_sps, &((struct vdec_init *)argp)->sps_cfg, sizeof(vdec_cfg_sps)); if (ret) { pr_err("%s: copy_from_user failed\n", __func__); return ret; } vi_cfg.decode_done_evt = VDEC_ASYNCMSG_DECODE_DONE; vi_cfg.reuse_frame_evt = VDEC_ASYNCMSG_REUSE_FRAME; memcpy(&vi_cfg.cfg, &vdec_cfg_sps.cfg, sizeof(struct vdec_config)); /* * restricting the max value of the seq header */ if (vdec_cfg_sps.seq.len > VDEC_MAX_SEQ_HEADER_SIZE) vdec_cfg_sps.seq.len = VDEC_MAX_SEQ_HEADER_SIZE; header = kmalloc(vdec_cfg_sps.seq.len, GFP_KERNEL); if (!header) { pr_err("%s: kmalloc failed\n", __func__); return -ENOMEM; } ret = copy_from_user(header, ((struct vdec_init *)argp)->sps_cfg.seq.header, vdec_cfg_sps.seq.len); if (ret) { pr_err("%s: copy_from_user failed\n", __func__); kfree(header); return ret; } TRACE("vi_cfg: handle=%p fourcc=0x%x w=%d h=%d order=%d notify_en=%d " "vc1_rb=%d h264_sd=%d h264_nls=%d pp_flag=%d fruc_en=%d\n", vd->vdec_handle, vi_cfg.cfg.fourcc, vi_cfg.cfg.width, vi_cfg.cfg.height, vi_cfg.cfg.order, vi_cfg.cfg.notify_enable, vi_cfg.cfg.vc1_rowbase, vi_cfg.cfg.h264_startcode_detect, vi_cfg.cfg.h264_nal_len_size, vi_cfg.cfg.postproc_flag, vi_cfg.cfg.fruc_enable); vd->streamDetails.height = vi_cfg.cfg.height; vd->streamDetails.width = vi_cfg.cfg.width; vd->streamDetails.fourcc = vi_cfg.cfg.fourcc; if (FLAG_THUMBNAIL_MODE == vi_cfg.cfg.postproc_flag) vd->streamDetails.isThisTnail = TRUE; else vd->streamDetails.isThisTnail = FALSE; mutex_lock(&vdec_rm_lock); ret = vdec_rm_checkWithRm(vd, vi_cfg.cfg.color_format); mutex_unlock(&vdec_rm_lock); if (ret) return ret; ret = dal_call_f13(vd->vdec_handle, VDEC_DALRPC_INITIALIZE, &vi_cfg, sizeof(vi_cfg), header, vdec_cfg_sps.seq.len, &vdec_buf_req, sizeof(vdec_buf_req)); kfree(header); if (ret) pr_err("%s: remote function failed (%d)\n", __func__, ret); else ret = copy_to_user(((struct vdec_init *)argp)->buf_req, &vdec_buf_req, sizeof(vdec_buf_req)); vd->close_decode = 0; return ret; } static void vdec_rm_freeupResources(struct vdec_data *vdecInstance) { struct videoStreamDetails *streamDetails = &vdecInstance->streamDetails; if ((streamDetails->isThisTnail) && (streamDetails->isTnailGranted)) { totalTnailQ6load--; pr_info("%s: Thumbnail released %d\n", __func__, totalTnailQ6load); } else if (streamDetails->Q6usage > 0) { totalPlaybackQ6load -= streamDetails->Q6usage; if (totalPlaybackQ6load < 0) pr_err("Warning:Q6load cannot be negative\n"); pr_info("%s:Releasing [%d%%] of Q6load from a total of [%d%%]\n" , __func__, streamDetails->Q6usage, (streamDetails->Q6usage+totalPlaybackQ6load)); } } static int vdec_setbuffers(struct vdec_data *vd, void *argp) { struct vdec_buffer vmem; struct vdec_mem_list *l; unsigned long vstart; unsigned long flags; struct { uint32_t size; struct vdec_buf_info buf; } rpc; uint32_t res; int ret = 0; vd->mem_initialized = 0; ret = copy_from_user(&vmem, argp, sizeof(vmem)); if (ret) { pr_err("%s: copy_from_user failed\n", __func__); return ret; } l = kzalloc(sizeof(struct vdec_mem_list), GFP_KERNEL); if (!l) { pr_err("%s: kzalloc failed!\n", __func__); return -ENOMEM; } l->mem.id = vmem.pmem_id; l->mem.buf_type = vmem.buf.buf_type; ret = get_pmem_file(l->mem.id, &l->mem.phys_addr, &vstart, &l->mem.len, &l->mem.file); if (ret) { pr_err("%s: get_pmem_fd failed\n", __func__); goto err_get_pmem_file; } TRACE("pmem_id=%d (phys=0x%08lx len=0x%lx) buftype=%d num_buf=%d " "islast=%d src_id=%d offset=0x%08x size=0x%x\n", vmem.pmem_id, l->mem.phys_addr, l->mem.len, vmem.buf.buf_type, vmem.buf.num_buf, vmem.buf.islast, vmem.buf.region.src_id, vmem.buf.region.offset, vmem.buf.region.size); /* input buffers */ if ((vmem.buf.region.offset + vmem.buf.region.size) > l->mem.len) { pr_err("%s: invalid input buffer offset!\n", __func__); ret = -EINVAL; goto err_bad_offset; } vmem.buf.region.offset += l->mem.phys_addr; rpc.size = sizeof(vmem.buf); memcpy(&rpc.buf, &vmem.buf, sizeof(struct vdec_buf_info)); ret = dal_call(vd->vdec_handle, VDEC_DALRPC_SETBUFFERS, 5, &rpc, sizeof(rpc), &res, sizeof(res)); if (ret < 4) { pr_err("%s: remote function failed (%d)\n", __func__, ret); ret = -EIO; goto err_dal_call; } spin_lock_irqsave(&vd->vdec_mem_list_lock, flags); list_add(&l->list, &vd->vdec_mem_list_head); spin_unlock_irqrestore(&vd->vdec_mem_list_lock, flags); vd->mem_initialized = 1; return ret; err_dal_call: err_bad_offset: put_pmem_file(l->mem.file); err_get_pmem_file: kfree(l); return ret; } static int vdec_queue(struct vdec_data *vd, void *argp) { struct { uint32_t size; struct vdec_input_buf_info buf_info; uint32_t osize; } rpc; struct vdec_mem_list *l; struct { uint32_t result; uint32_t size; struct vdec_queue_status status; } rpc_res; u32 pmem_id; int ret = 0; if (!vd->mem_initialized) { pr_err("%s: memory is not being initialized!\n", __func__); return -EPERM; } ret = copy_from_user(&rpc.buf_info, &((struct vdec_input_buf *)argp)->buffer, sizeof(rpc.buf_info)); if (ret) { pr_err("%s: copy_from_user failed\n", __func__); return ret; } ret = copy_from_user(&pmem_id, &((struct vdec_input_buf *)argp)->pmem_id, sizeof(u32)); if (ret) { pr_err("%s: copy_from_user failed\n", __func__); return ret; } l = vdec_get_mem_from_list(vd, pmem_id, VDEC_BUFFER_TYPE_INPUT); if (NULL == l) { pr_err("%s: not able to find the buffer from list\n", __func__); return -EPERM; } if ((rpc.buf_info.size + rpc.buf_info.offset) >= l->mem.len) { pr_err("%s: invalid queue buffer offset!\n", __func__); return -EINVAL; } rpc.buf_info.offset += l->mem.phys_addr; rpc.size = sizeof(struct vdec_input_buf_info); rpc.osize = sizeof(struct vdec_queue_status); /* complete the writes to the buffer */ wmb(); ret = dal_call(vd->vdec_handle, VDEC_DALRPC_QUEUE, 8, &rpc, sizeof(rpc), &rpc_res, sizeof(rpc_res)); if (ret < 4) { pr_err("%s: remote function failed (%d)\n", __func__, ret); ret = -EIO; } return ret; } static int vdec_reuse_framebuffer(struct vdec_data *vd, void *argp) { u32 buf_id; int ret = 0; ret = copy_from_user(&buf_id, argp, sizeof(buf_id)); if (ret) { pr_err("%s: copy_from_user failed\n", __func__); return ret; } ret = dal_call_f0(vd->vdec_handle, VDEC_DALRPC_REUSEFRAMEBUFFER, buf_id); if (ret) pr_err("%s: remote function failed (%d)\n", __func__, ret); return ret; } static int vdec_flush(struct vdec_data *vd, void *argp) { u32 flush_type; int ret = 0; if (!vd->mem_initialized) { pr_err("%s: memory is not being initialized!\n", __func__); return -EPERM; } ret = copy_from_user(&flush_type, argp, sizeof(flush_type)); if (ret) { pr_err("%s: copy_from_user failed\n", __func__); return ret; } TRACE("flush_type=%d\n", flush_type); ret = dal_call_f0(vd->vdec_handle, VDEC_DALRPC_FLUSH, flush_type); if (ret) { pr_err("%s: remote function failed (%d)\n", __func__, ret); return ret; } return ret; } static int vdec_close(struct vdec_data *vd, void *argp) { struct vdec_mem_list *l; int ret = 0; pr_info("q6vdec_close()\n"); vd->close_decode = 1; wake_up(&vd->vdec_msg_evt); ret = dal_call_f0(vd->vdec_handle, DAL_OP_CLOSE, 0); if (ret) pr_err("%s: failed to close daldevice (%d)\n", __func__, ret); if (vd->mem_initialized) { list_for_each_entry(l, &vd->vdec_mem_list_head, list) put_pmem_file(l->mem.file); } return ret; } static int vdec_getdecattributes(struct vdec_data *vd, void *argp) { struct { uint32_t status; uint32_t size; struct vdec_dec_attributes dec_attr; } rpc; uint32_t inp; int ret = 0; inp = sizeof(struct vdec_dec_attributes); ret = dal_call(vd->vdec_handle, VDEC_DALRPC_GETDECATTRIBUTES, 9, &inp, sizeof(inp), &rpc, sizeof(rpc)); if (ret < 4 || rpc.size != sizeof(struct vdec_dec_attributes)) { pr_err("%s: remote function failed (%d)\n", __func__, ret); ret = -EIO; } else ret = copy_to_user(((struct vdec_dec_attributes *)argp), &rpc.dec_attr, sizeof(rpc.dec_attr)); return ret; } static int vdec_freebuffers(struct vdec_data *vd, void *argp) { struct vdec_buffer vmem; struct vdec_mem_list *l; struct { uint32_t size; struct vdec_buf_info buf; } rpc; uint32_t res; int ret = 0; if (!vd->mem_initialized) { pr_err("%s: memory is not being initialized!\n", __func__); return -EPERM; } ret = copy_from_user(&vmem, argp, sizeof(vmem)); if (ret) { pr_err("%s: copy_from_user failed\n", __func__); return ret; } l = vdec_get_mem_from_list(vd, vmem.pmem_id, vmem.buf.buf_type); if (NULL == l) { pr_err("%s: not able to find the buffer from list\n", __func__); return -EPERM; } /* input buffers */ if ((vmem.buf.region.offset + vmem.buf.region.size) > l->mem.len) { pr_err("%s: invalid input buffer offset!\n", __func__); return -EINVAL; } vmem.buf.region.offset += l->mem.phys_addr; rpc.size = sizeof(vmem.buf); memcpy(&rpc.buf, &vmem.buf, sizeof(struct vdec_buf_info)); ret = dal_call(vd->vdec_handle, VDEC_DALRPC_FREEBUFFERS, 5, &rpc, sizeof(rpc), &res, sizeof(res)); if (ret < 4) { pr_err("%s: remote function failed (%d)\n", __func__, ret); } return ret; } static int vdec_getversion(struct vdec_data *vd, void *argp) { struct vdec_version ver_info; int ret = 0; ver_info.major = VDEC_GET_MAJOR_VERSION(VDEC_INTERFACE_VERSION); ver_info.minor = VDEC_GET_MINOR_VERSION(VDEC_INTERFACE_VERSION); ret = copy_to_user(((struct vdec_version *)argp), &ver_info, sizeof(ver_info)); return ret; } static long vdec_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { struct vdec_data *vd = file->private_data; void __user *argp = (void __user *)arg; int ret = 0; if (!vd->running) return -EPERM; switch (cmd) { case VDEC_IOCTL_INITIALIZE: ret = vdec_initialize(vd, argp); break; case VDEC_IOCTL_SETBUFFERS: ret = vdec_setbuffers(vd, argp); break; case VDEC_IOCTL_QUEUE: TRACE("VDEC_IOCTL_QUEUE (pid=%d tid=%d)\n", current->group_leader->pid, current->pid); ret = vdec_queue(vd, argp); break; case VDEC_IOCTL_REUSEFRAMEBUFFER: TRACE("VDEC_IOCTL_REUSEFRAMEBUFFER (pid=%d tid=%d)\n", current->group_leader->pid, current->pid); ret = vdec_reuse_framebuffer(vd, argp); break; case VDEC_IOCTL_FLUSH: TRACE("IOCTL flush\n"); ret = vdec_flush(vd, argp); break; case VDEC_IOCTL_EOS: TRACE("VDEC_IOCTL_EOS (pid=%d tid=%d)\n", current->group_leader->pid, current->pid); ret = dal_call_f0(vd->vdec_handle, VDEC_DALRPC_SIGEOFSTREAM, 0); if (ret) pr_err("%s: remote function failed (%d)\n", __func__, ret); break; case VDEC_IOCTL_GETMSG: TRACE("VDEC_IOCTL_GETMSG (pid=%d tid=%d)\n", current->group_leader->pid, current->pid); wait_event_interruptible(vd->vdec_msg_evt, vdec_get_msg(vd, argp)); if (vd->close_decode) ret = -EINTR; else /* order the reads from the buffer */ rmb(); break; case VDEC_IOCTL_CLOSE: ret = vdec_close(vd, argp); break; case VDEC_IOCTL_GETDECATTRIBUTES: TRACE("VDEC_IOCTL_GETDECATTRIBUTES (pid=%d tid=%d)\n", current->group_leader->pid, current->pid); ret = vdec_getdecattributes(vd, argp); if (ret) pr_err("%s: remote function failed (%d)\n", __func__, ret); break; case VDEC_IOCTL_FREEBUFFERS: TRACE("VDEC_IOCTL_FREEBUFFERS (pid=%d tid=%d)\n", current->group_leader->pid, current->pid); ret = vdec_freebuffers(vd, argp); if (ret) pr_err("%s: remote function failed (%d)\n", __func__, ret); break; case VDEC_IOCTL_GETVERSION: TRACE("VDEC_IOCTL_GETVERSION (pid=%d tid=%d)\n", current->group_leader->pid, current->pid); ret = vdec_getversion(vd, argp); if (ret) pr_err("%s: remote function failed (%d)\n", __func__, ret); break; case VDEC_IOCTL_GETPROPERTY: TRACE("VDEC_IOCTL_GETPROPERTY (pid=%d tid=%d)\n", current->group_leader->pid, current->pid); ret = vdec_getproperty(vd, argp); break; case VDEC_IOCTL_SETPROPERTY: TRACE("VDEC_IOCTL_SETPROPERTY (pid=%d tid=%d)\n", current->group_leader->pid, current->pid); ret = vdec_setproperty(vd, argp); break; case VDEC_IOCTL_PERFORMANCE_CHANGE_REQ: ret = vdec_performance_change_request(vd, argp); break; default: pr_err("%s: invalid ioctl!\n", __func__); ret = -EINVAL; break; } TRACE("ioctl done (pid=%d tid=%d)\n", current->group_leader->pid, current->pid); return ret; } static void vdec_dcdone_handler(struct vdec_data *vd, void *frame, uint32_t frame_size) { struct vdec_msg msg; struct vdec_mem_list *l; unsigned long flags; int found = 0; if (frame_size < sizeof(struct vdec_frame_info)) { pr_warning("%s: msg size mismatch %d != %d\n", __func__, frame_size, sizeof(struct vdec_frame_info)); return; } memcpy(&msg.vfr_info, (struct vdec_frame_info *)frame, sizeof(struct vdec_frame_info)); if (msg.vfr_info.status == VDEC_FRAME_DECODE_OK) { spin_lock_irqsave(&vd->vdec_mem_list_lock, flags); list_for_each_entry(l, &vd->vdec_mem_list_head, list) { if ((l->mem.buf_type == VDEC_BUFFER_TYPE_OUTPUT) && (msg.vfr_info.offset >= l->mem.phys_addr) && (msg.vfr_info.offset < (l->mem.phys_addr + l->mem.len))) { found = 1; msg.vfr_info.offset -= l->mem.phys_addr; msg.vfr_info.data2 = l->mem.id; break; } } spin_unlock_irqrestore(&vd->vdec_mem_list_lock, flags); } if (found || (msg.vfr_info.status != VDEC_FRAME_DECODE_OK)) { msg.id = VDEC_MSG_FRAMEDONE; vdec_put_msg(vd, &msg); } else { pr_err("%s: invalid phys addr = 0x%x\n", __func__, msg.vfr_info.offset); } } static void vdec_reuseibuf_handler(struct vdec_data *vd, void *bufstat, uint32_t bufstat_size) { struct vdec_buffer_status *vdec_bufstat; struct vdec_msg msg; /* TODO: how do we signal the client? If they are waiting on a * message in an ioctl, they may block forever */ if (bufstat_size != sizeof(struct vdec_buffer_status)) { pr_warning("%s: msg size mismatch %d != %d\n", __func__, bufstat_size, sizeof(struct vdec_buffer_status)); return; } vdec_bufstat = (struct vdec_buffer_status *)bufstat; msg.id = VDEC_MSG_REUSEINPUTBUFFER; msg.buf_id = vdec_bufstat->data; vdec_put_msg(vd, &msg); } static void callback(void *data, int len, void *cookie) { struct vdec_data *vd = (struct vdec_data *)cookie; uint32_t *tmp = (uint32_t *) data; if (!vd->mem_initialized) { pr_err("%s:memory not initialize but callback called!\n", __func__); return; } TRACE("vdec_async: tmp=0x%08x 0x%08x 0x%08x\n", tmp[0], tmp[1], tmp[2]); switch (tmp[0]) { case VDEC_ASYNCMSG_DECODE_DONE: vdec_dcdone_handler(vd, &tmp[3], tmp[2]); break; case VDEC_ASYNCMSG_REUSE_FRAME: vdec_reuseibuf_handler(vd, &tmp[3], tmp[2]); break; default: pr_err("%s: Unknown async message from DSP id=0x%08x sz=%u\n", __func__, tmp[0], tmp[2]); } } static int vdec_open(struct inode *inode, struct file *file) { int ret; int i; struct vdec_msg_list *l; struct vdec_data *vd; struct dal_info version_info; char *portname = NULL; pr_info("q6vdec_open()\n"); mutex_lock(&vdec_ref_lock); if (ref_cnt >= MAX_SUPPORTED_INSTANCES) { pr_err("%s: Max allowed instances exceeded \n", __func__); mutex_unlock(&vdec_ref_lock); return -EBUSY; } ref_cnt++; mutex_unlock(&vdec_ref_lock); vd = kmalloc(sizeof(struct vdec_data), GFP_KERNEL); if (!vd) { pr_err("%s: kmalloc failed\n", __func__); ret = -ENOMEM; goto vdec_open_err_handle_vd; } file->private_data = vd; vd->mem_initialized = 0; INIT_LIST_HEAD(&vd->vdec_msg_list_head); INIT_LIST_HEAD(&vd->vdec_msg_list_free); INIT_LIST_HEAD(&vd->vdec_mem_list_head); init_waitqueue_head(&vd->vdec_msg_evt); spin_lock_init(&vd->vdec_list_lock); spin_lock_init(&vd->vdec_mem_list_lock); for (i = 0; i < VDEC_MSG_MAX; i++) { l = kzalloc(sizeof(struct vdec_msg_list), GFP_KERNEL); if (!l) { pr_err("%s: kzalloc failed!\n", __func__); ret = -ENOMEM; goto vdec_open_err_handle_list; } list_add(&l->list, &vd->vdec_msg_list_free); } memset(&vd->streamDetails, 0, sizeof(struct videoStreamDetails)); mutex_lock(&vdec_ref_lock); vdec_get_next_portanddevid(&vd->Q6deviceId, &portname); mutex_unlock(&vdec_ref_lock); if ((0 == vd->Q6deviceId) || (NULL == portname)) { pr_err("%s: FATAL error portname %s or deviceId %d not picked properly\n", __func__, portname, vd->Q6deviceId); ret = -EIO; goto vdec_open_err_handle_list; } else { pr_err("attaching on deviceid %x portname %s\n", vd->Q6deviceId, portname); vd->vdec_handle = dal_attach(vd->Q6deviceId, portname, 1, callback, vd); } if (!vd->vdec_handle) { pr_err("%s: failed to attach\n", __func__); ret = -EIO; goto vdec_open_err_handle_list; } ret = dal_call_f9(vd->vdec_handle, DAL_OP_INFO, &version_info, sizeof(struct dal_info)); if (ret) { pr_err("%s: failed to get version \n", __func__); goto vdec_open_err_handle_version; } TRACE("q6vdec_open() interface version 0x%x\n", version_info.version); if (vdec_check_version(VDEC_INTERFACE_VERSION, version_info.version)) { pr_err("%s: driver version mismatch !\n", __func__); goto vdec_open_err_handle_version; } vd->running = 1; prevent_sleep(); return 0; vdec_open_err_handle_version: dal_detach(vd->vdec_handle); vdec_open_err_handle_list: { struct vdec_msg_list *l, *n; list_for_each_entry_safe(l, n, &vd->vdec_msg_list_free, list) { list_del(&l->list); kfree(l); } } vdec_open_err_handle_vd: mutex_lock(&vdec_ref_lock); vdec_freeup_portanddevid(vd->Q6deviceId); ref_cnt--; mutex_unlock(&vdec_ref_lock); kfree(vd); return ret; } static int vdec_release(struct inode *inode, struct file *file) { int ret; struct vdec_msg_list *l, *n; struct vdec_mem_list *m, *k; struct vdec_data *vd = file->private_data; vd->running = 0; wake_up_all(&vd->vdec_msg_evt); if (!vd->close_decode) vdec_close(vd, NULL); ret = dal_detach(vd->vdec_handle); if (ret) printk(KERN_INFO "%s: failed to detach (%d)\n", __func__, ret); list_for_each_entry_safe(l, n, &vd->vdec_msg_list_free, list) { list_del(&l->list); kfree(l); } list_for_each_entry_safe(l, n, &vd->vdec_msg_list_head, list) { list_del(&l->list); kfree(l); } list_for_each_entry_safe(m, k, &vd->vdec_mem_list_head, list) { list_del(&m->list); kfree(m); } mutex_lock(&vdec_ref_lock); BUG_ON(ref_cnt <= 0); ref_cnt--; vdec_freeup_portanddevid(vd->Q6deviceId); mutex_unlock(&vdec_ref_lock); mutex_lock(&vdec_rm_lock); vdec_rm_freeupResources(vd); mutex_unlock(&vdec_rm_lock); kfree(vd); allow_sleep(); return 0; } static const struct file_operations vdec_fops = { .owner = THIS_MODULE, .open = vdec_open, .release = vdec_release, .unlocked_ioctl = vdec_ioctl, }; static int __init vdec_init(void) { struct device *class_dev; int rc = 0; pm_qos_add_request(&pm_qos_req, PM_QOS_CPU_DMA_LATENCY, PM_QOS_DEFAULT_VALUE); wake_lock_init(&wakelock, WAKE_LOCK_SUSPEND, "vdec_suspend"); rc = alloc_chrdev_region(&vdec_device_no, 0, 1, "vdec"); if (rc < 0) { pr_err("%s: alloc_chrdev_region failed %d\n", __func__, rc); return rc; } driver_class = class_create(THIS_MODULE, "vdec"); if (IS_ERR(driver_class)) { rc = -ENOMEM; pr_err("%s: class_create failed %d\n", __func__, rc); goto vdec_init_err_unregister_chrdev_region; } class_dev = device_create(driver_class, NULL, vdec_device_no, NULL, "vdec"); if (!class_dev) { pr_err("%s: class_device_create failed %d\n", __func__, rc); rc = -ENOMEM; goto vdec_init_err_class_destroy; } cdev_init(&vdec_cdev, &vdec_fops); vdec_cdev.owner = THIS_MODULE; rc = cdev_add(&vdec_cdev, MKDEV(MAJOR(vdec_device_no), 0), 1); if (rc < 0) { pr_err("%s: cdev_add failed %d\n", __func__, rc); goto vdec_init_err_class_device_destroy; } memset(&deviceIdRegistry, 0, sizeof(deviceIdRegistry)); memset(&loadOnPorts, 0, sizeof(loadOnPorts)); numOfPorts = 0; return 0; vdec_init_err_class_device_destroy: device_destroy(driver_class, vdec_device_no); vdec_init_err_class_destroy: class_destroy(driver_class); vdec_init_err_unregister_chrdev_region: unregister_chrdev_region(vdec_device_no, 1); return rc; } static void __exit vdec_exit(void) { device_destroy(driver_class, vdec_device_no); class_destroy(driver_class); unregister_chrdev_region(vdec_device_no, 1); } MODULE_DESCRIPTION("video decoder driver for QSD platform"); MODULE_VERSION("2.00"); module_init(vdec_init); module_exit(vdec_exit);