/****************************************************************************
NAME
    handleClSdpServiceSearchCfm

DESCRIPTION
    Handles the CL library SDP service search confirmation message.

*/
static void handleClSdpServiceSearchCfm(CL_SDP_SERVICE_SEARCH_CFM_T *cfm)
{        
    mvdAppState app_state = the_app->app_state;
    
    switch (app_state)
    {
        case AppStateSearching:
        {
            devInstanceTaskData *inst = devInstanceFindFromBddr(&cfm->bd_addr, FALSE);
            
            if ((inst != NULL))
            {
                if (cfm->status==sdp_response_success)
                {
                }
            }
                
            (void)scanHandleSdpSearchResult(cfm);
            (void)scanKickNextSdpSearch();
            break;
        }    
        case AppStateIdle:
        {
            /* Silently ignore primitive - may occur if inquiry scan timeout is reached */
            DEBUG_CL((" - ignored\n"));
            break;
        }    
        default:
        {
            unexpectedClMessage(app_state, CL_SDP_SERVICE_SEARCH_CFM);
            break;
        }
    }
}
/****************************************************************************
NAME
    handleClDmInquireResult

DESCRIPTION
    Handles the CL library inquiry result message.

*/
static void handleClDmInquireResult(const CL_DM_INQUIRE_RESULT_T *result)
{
    mvdAppState app_state = the_app->app_state;
    
    switch ( app_state )
    {
        case AppStateInquiring:
        {
            switch (result->status)
            {
            case inquiry_status_result:
                scanStoreInquireResult(result);
                break;
                
            case inquiry_status_ready:
                scanProcessNextInquireResult();
                break;
            }
            break;
        }    
        case AppStateIdle:
        {
            /* Silently ignore primitive - Inquiry scan will have timed out */
            DEBUG_CL((" - ignored\n"));
            break;
        }    
        default:
        {
            unexpectedClMessage(app_state, CL_DM_INQUIRE_RESULT);
            break;
        }
    }
}
/****************************************************************************
NAME
    handleClSmPinCodeInd

DESCRIPTION
    Handles the CL library PIN code indication message.

*/
static void handleClSmPinCodeInd(const CL_SM_PIN_CODE_IND_T *ind)
{
    devInstanceTaskData *inst = devInstanceFindFromBddr(&ind->bd_addr, TRUE);    

    if (inst != NULL)
    {                          
        {
            ConnectionSmPinCodeResponse(&ind->bd_addr, strlen(the_app->pin), (unsigned char *)the_app->pin);
            return;
        }        
        
        /* Device intance can be deleted as all pin codes have been tried */
        MessageSend(&inst->task, APP_INTERNAL_DESTROY_REQ, 0);
        ConnectionSmPinCodeResponse(&ind->bd_addr, 0, NULL);
        DEBUG_CL(("    No pin code returned\n"));
    }
    else
    {
        ConnectionSmPinCodeResponse(&ind->bd_addr, 0, NULL);
        DEBUG_CL(("    No pin code returned\n"));
    }
}
Пример #4
0
iv::Sampler::Sampler(cl_context* context, cl_bool normalizedCoords, cl_addressing_mode addrMode, cl_filter_mode filterMode)
{
//    clCreateSampler(cl_context          /* context */,
//                    cl_bool             /* normalized_coords */,
//                    cl_addressing_mode  /* addressing_mode */,
//                    cl_filter_mode      /* filter_mode */,
//                    cl_int *            /* errcode_ret */)
    // Create the image sampler
    cl_int status;
    _sampler = clCreateSampler(*context, normalizedCoords,
                                         addrMode, filterMode, &status);
    DEBUG_CL(status);
}
static void release_callback_kernel(void * e) {
  cl_kernel kernel = (cl_kernel)e;

  //Free args
  unsigned int i;
  for (i=0; i<kernel->num_args; i++) {
    switch (kernel->arg_type[i]) {
      case Null:
      case Buffer:
        break;
      case Immediate:
        free(kernel->arg_value[i]);
        break;
    }
  }
  if (kernel->arg_size != NULL)
    free(kernel->arg_size);
  if (kernel->arg_value != NULL)
    free(kernel->arg_value);
  if (kernel->arg_type != NULL)
    free(kernel->arg_type);

  //Release real kernels...
  for (i=0; i<socl_device_count; i++) {
     if (kernel->cl_kernels[i] != NULL) {
        cl_int err = clReleaseKernel(kernel->cl_kernels[i]);
        if (err != CL_SUCCESS)
           DEBUG_CL("clReleaseKernel", err);
     }
  }

  //Release perfmodel
  //FIXME: we cannot release performance models before StarPU shutdown as it
  //will use them to store kernel execution times

  //free(kernel->perfmodel);
  //free(kernel->kernel_name);

  gc_entity_unstore(&kernel->program);

  free(kernel->cl_kernels);
  free(kernel->errcodes);
}
static void soclCreateKernel_task(void *data) {
   struct _cl_kernel *k = (struct _cl_kernel *)data;

   int range = starpu_worker_get_range();
   cl_int err;

   if (k->program->cl_programs[range] == NULL) {
      k->errcodes[range] = CL_SUCCESS;
      DEBUG_MSG("[Device %d] Kernel creation skipped: program has not been built for this device.\n", starpu_worker_get_id());
      return;
   }

   DEBUG_MSG("[Device %d] Creating kernel...\n", starpu_worker_get_id());
   k->cl_kernels[range] = clCreateKernel(k->program->cl_programs[range], k->kernel_name, &err);
   if (err != CL_SUCCESS) {
      k->errcodes[range] = err;
      ERROR_STOP("[Device %d] Unable to create kernel. Error %d. Aborting.\n", starpu_worker_get_id(), err);
      return;
   }

   /* One worker creates argument structures */
   if (__sync_bool_compare_and_swap(&k->num_args, 0, 666)) {
      unsigned int i;
      cl_uint num_args;

      err = clGetKernelInfo(k->cl_kernels[range], CL_KERNEL_NUM_ARGS, sizeof(num_args), &num_args, NULL);
      if (err != CL_SUCCESS) {
         DEBUG_CL("clGetKernelInfo", err);
         ERROR_STOP("Unable to get kernel argument count. Aborting.\n");
      }
      k->num_args = num_args;
      DEBUG_MSG("Kernel has %d arguments\n", num_args);

      k->arg_size = (size_t*)malloc(sizeof(size_t) * num_args);
      k->arg_value = (void**)malloc(sizeof(void*) * num_args);
      k->arg_type = (enum kernel_arg_type*)malloc(sizeof(enum kernel_arg_type) * num_args);
      /* Settings default type to NULL */
      for (i=0; i<num_args; i++) {
         k->arg_value[i] = NULL;
         k->arg_type[i] = Null;
      }
   }
}
/****************************************************************************
NAME
    handleClInitCfm

DESCRIPTION
    Handles the CL library initialisation result.

*/
static void handleClInitCfm(const CL_INIT_CFM_T *cfm)
{
    mvdAppState app_state = the_app->app_state;
    
    switch (app_state)
    {
        case AppStateInitialising:
        {
            if (cfm->status == success)
            {
                /* Configure Mode4 Security Settings */
                ConnectionSmSecModeConfig(&the_app->task, cl_sm_wae_acl_owner_none, FALSE, TRUE);
                
                /* Turn off all SDP security */
                ConnectionSmSetSecurityLevel(protocol_l2cap, 1, ssp_secl4_l0, TRUE, FALSE, FALSE);
                
                if (cfm->version == bluetooth2_1)
                {
                    /* EIR inquiry mode */
                    ConnectionWriteInquiryMode(&the_app->task, inquiry_mode_eir);
                }
                
                /* Set default role switch policy */
                ConnectionSetRoleSwitchParams(NULL);
                
                initProfile();
            }
            else
            {
                DEBUG_CL((" App failed to init CL\n"));
                Panic();
            }
            break;
        }    
        default:
        {
            unexpectedClMessage(app_state, CL_INIT_CFM);
            break;
        }
    }
}
/****************************************************************************
NAME
    handleClRole

DESCRIPTION
    Checks the current role.

*/
static void handleClRole(devInstanceTaskData *inst, hci_role role, hci_status status, bool role_switch)
{
    Sink sink = 0;
    
    if (inst->a2dp)
        sink = inst->a2dp_sig_sink;
    else if (inst->aghfp_sink)
        sink = inst->aghfp_sink;
        
    /* store the current role */
    if ((status == hci_success) && (inst->role != role))
    {
        inst->role = role;
        DEBUG_CL(("    Current role: inst[0x%x] role:[%d]\n", (uint16)inst, inst->role));
        if (sink)
        {
            if (inst->role == hci_role_master)
            {
                /* Set link supervision timeout 5 seconds */
                ConnectionSetLinkSupervisionTimeout(sink, 0x1F80);
            }
        }
    }        
}
void soclEnqueueNDRangeKernel_task(void *descr[], void *args) {
	command_ndrange_kernel cmd = (command_ndrange_kernel)args;

   cl_command_queue cq;
   int wid;
   cl_int err;

  cl_event ev = command_event_get(cmd);
  ev->prof_start = _socl_nanotime();
  gc_entity_release(ev);

   wid = starpu_worker_get_id();
   starpu_opencl_get_queue(wid, &cq);

   DEBUG_MSG("[worker %d] [kernel %d] Executing kernel...\n", wid, cmd->kernel->id);

   int range = starpu_worker_get_range();

   /* Set arguments */
   {
	   unsigned int i;
	   int buf = 0;
	   for (i=0; i<cmd->num_args; i++) {
		   switch (cmd->arg_types[i]) {
			   case Null:
				   err = clSetKernelArg(cmd->kernel->cl_kernels[range], i, cmd->arg_sizes[i], NULL);
				   break;
			   case Buffer: {
						cl_mem mem;  
						mem = (cl_mem)STARPU_VARIABLE_GET_PTR(descr[buf]);
						err = clSetKernelArg(cmd->kernel->cl_kernels[range], i, cmd->arg_sizes[i], &mem);
						buf++;
					}
					break;
			   case Immediate:
					err = clSetKernelArg(cmd->kernel->cl_kernels[range], i, cmd->arg_sizes[i], cmd->args[i]);
					break;
		   }
		   if (err != CL_SUCCESS) {
			   DEBUG_CL("clSetKernelArg", err);
			   DEBUG_ERROR("Aborting\n");
		   }
	   }
   }

   /* Calling Kernel */
   cl_event event;
   err = clEnqueueNDRangeKernel(cq, cmd->kernel->cl_kernels[range], cmd->work_dim, cmd->global_work_offset, cmd->global_work_size, cmd->local_work_size, 0, NULL, &event);

   if (err != CL_SUCCESS) {
	   ERROR_MSG("Worker[%d] Unable to Enqueue kernel (error %d)\n", wid, err);
	   DEBUG_CL("clEnqueueNDRangeKernel", err);
	   DEBUG_MSG("Workdim %d, global_work_offset %p, global_work_size %p, local_work_size %p\n",
			   cmd->work_dim, cmd->global_work_offset, cmd->global_work_size, cmd->local_work_size);
	   DEBUG_MSG("Global work size: %ld %ld %ld\n", cmd->global_work_size[0],
			   (cmd->work_dim > 1 ? cmd->global_work_size[1] : 1), (cmd->work_dim > 2 ? cmd->global_work_size[2] : 1)); 
	   if (cmd->local_work_size != NULL)
		   DEBUG_MSG("Local work size: %ld %ld %ld\n", cmd->local_work_size[0],
				   (cmd->work_dim > 1 ? cmd->local_work_size[1] : 1), (cmd->work_dim > 2 ? cmd->local_work_size[2] : 1)); 
   }
   else {
      /* Waiting for kernel to terminate */
      clWaitForEvents(1, &event);
      clReleaseEvent(event);
   }
}
/****************************************************************************
NAME
    clMsgHandleLibMessage

DESCRIPTION
    Handles the CL library messages and calls the relevant function.

*/
void clMsgHandleLibMessage(MessageId id, Message message)
{
    switch(id)
    {
        case CL_INIT_CFM:
        {
            DEBUG_CL(("CL_INIT_CFM status = %u\n", ((CL_INIT_CFM_T *)message)->status));
            handleClInitCfm((CL_INIT_CFM_T *)message);    
            break;
        }    
        case CL_DM_WRITE_INQUIRY_MODE_CFM:
        {
            DEBUG_CL(("CL_DM_WRITE_INQUIRY_MODE_CFM\n"));
            /* Read the local name to put in our EIR data */
            ConnectionReadInquiryTx(&the_app->task);
            break;
        }    
        case CL_DM_READ_INQUIRY_TX_CFM:
        {
            the_app->inquiry_tx = ((CL_DM_READ_INQUIRY_TX_CFM_T*)message)->tx_power;
            ConnectionReadLocalName(&the_app->task);
            break;
        }    
        case CL_DM_LOCAL_NAME_COMPLETE:
        {
            DEBUG_CL(("CL_DM_LOCAL_NAME_COMPLETE\n"));
            /* Write EIR data and initialise the codec task */
            scanWriteEirData((CL_DM_LOCAL_NAME_COMPLETE_T*)message);
            break;
        }    
        case CL_DM_ACL_OPENED_IND:
        {
            DEBUG_CL(("CL_DM_ACL_OPENED_IND from: 0x%X 0x%X 0x%lX\n", ((CL_DM_ACL_OPENED_IND_T *)message)->bd_addr.nap, ((CL_DM_ACL_OPENED_IND_T *)message)->bd_addr.uap, ((CL_DM_ACL_OPENED_IND_T *)message)->bd_addr.lap));
            /* Ignore this message for now */
            DEBUG_CL((" - ignored\n"));
            break;
        }    
        case CL_DM_ACL_CLOSED_IND:
        {
            DEBUG_CL(("CL_DM_ACL_CLOSED_IND from: 0x%X 0x%X 0x%lX\n", ((CL_DM_ACL_CLOSED_IND_T *)message)->bd_addr.nap, ((CL_DM_ACL_CLOSED_IND_T *)message)->bd_addr.uap, ((CL_DM_ACL_CLOSED_IND_T *)message)->bd_addr.lap));
            /* Ignore this message for now */
            DEBUG_CL((" - ignored\n"));
            break;
        }
        case CL_SM_PIN_CODE_IND:
        {
            DEBUG_CL(("CL_SM_PIN_CODE_IND from: 0x%X 0x%X 0x%lX\n", (uint16)((CL_SM_PIN_CODE_IND_T *)message)->bd_addr.nap, (uint16)((CL_SM_PIN_CODE_IND_T *)message)->bd_addr.uap, (uint32)((CL_SM_PIN_CODE_IND_T *)message)->bd_addr.lap));
            handleClSmPinCodeInd((CL_SM_PIN_CODE_IND_T *)message);
            break;
        }
        case CL_SM_IO_CAPABILITY_REQ_IND:
        {
            DEBUG_CL(("CL_SM_IO_CAPABILITY_REQUEST_IND\n"));
            {
                CL_SM_IO_CAPABILITY_REQ_IND_T *prim = (CL_SM_IO_CAPABILITY_REQ_IND_T *)message;
                ConnectionSmIoCapabilityResponse(&prim->bd_addr, cl_sm_io_cap_no_input_no_output, FALSE, TRUE, FALSE, NULL, NULL);
            }
            break;
        }
        case CL_SM_USER_CONFIRMATION_REQ_IND:
        {
            DEBUG_CL(("CL_SM_USER_CONFIRMATION_REQ_IND\n"));
            /* Shouldn't get this so if we do reject it! */
            ConnectionSmUserConfirmationResponse(&((CL_SM_USER_CONFIRMATION_REQ_IND_T*)message)->bd_addr, FALSE);
            break;
        }
        case CL_SM_AUTHORISE_IND:
        {
            DEBUG_CL(("CL_SM_AUTHORISE_IND\n"));
            {    /* For now, blindly accept this request */
                CL_SM_AUTHORISE_IND_T *prim = (CL_SM_AUTHORISE_IND_T *)message;
                ConnectionSmAuthoriseResponse(&prim->bd_addr, prim->protocol_id, prim->channel, prim->incoming, TRUE);
            }    
            break;
        }
        case CL_SM_AUTHENTICATE_CFM:
        {
            DEBUG_CL(("CL_SM_AUTHENTICATE_CFM status = %u\n", ((CL_SM_AUTHENTICATE_CFM_T *)message)->status));
            if ( ((CL_SM_AUTHENTICATE_CFM_T *)message)->status == auth_status_success )
            {    /* Pin code will be stored on a successful SLC/A2DP connection */
            }
            break;
        }
        case CL_SM_SECURITY_LEVEL_CFM:
        {
            DEBUG_CL(("CL_SM_SECURITY_LEVEL_CFM success = %u\n", ((CL_SM_SECURITY_LEVEL_CFM_T *)message)->success));
            break;
        }
        case CL_DM_INQUIRE_RESULT:
        {
            DEBUG_CL(("CL_DM_INQUIRE_RESULT status = %u\n", ((CL_DM_INQUIRE_RESULT_T *)message)->status));
            handleClDmInquireResult((CL_DM_INQUIRE_RESULT_T *)message);        
            break;
        }
        case CL_SDP_OPEN_SEARCH_CFM:
        {   
            DEBUG_CL(("CL_SDP_OPEN_SEARCH_CFM status = %u\n", ((CL_SDP_OPEN_SEARCH_CFM_T *)message)->status)); 
            handleClSdpOpenSearchCfm((CL_SDP_OPEN_SEARCH_CFM_T *)message);       
            break;
        }    
        case CL_SDP_CLOSE_SEARCH_CFM:
        {
            DEBUG_CL(("CL_SDP_CLOSE_SEARCH_CFM status = %u\n", ((CL_SDP_CLOSE_SEARCH_CFM_T *)message)->status));
            handleClSdpCloseSearchCfm();      
            break;
        }    
        case CL_SDP_SERVICE_SEARCH_CFM:
        {
            DEBUG_CL(("CL_SDP_SERVICE_SEARCH_CFM status = %u\n", ((CL_SDP_SERVICE_SEARCH_CFM_T *)message)->status));
            handleClSdpServiceSearchCfm((CL_SDP_SERVICE_SEARCH_CFM_T *)message);          
            break;
        }    
        case CL_SM_SEC_MODE_CONFIG_CFM:
        {
            DEBUG_CL(("CL_SM_SEC_MODE_CONFIG_CFM\n"));
            DEBUG_CL((" - ignored\n"));
            break;
        }    
        case CL_SM_REMOTE_IO_CAPABILITY_IND:
        {
            DEBUG_CL(("CL_SM_REMOTE_IO_CAPABILITY_IND\n"));
            DEBUG_CL((" - ignored\n"));
            break;
        }
        case CL_DM_LINK_SUPERVISION_TIMEOUT_IND:
        {
            DEBUG_CL(("CL_DM_LINK_SUPERVISION_TIMEOUT_IND:\n"));
            DEBUG_CL(("    timeout:[0x%x] bdaddr:[0x%x%x%lx]\n", 
                        ((CL_DM_LINK_SUPERVISION_TIMEOUT_IND_T *)message)->timeout,
                        ((CL_DM_LINK_SUPERVISION_TIMEOUT_IND_T *)message)->bd_addr.nap,
                        ((CL_DM_LINK_SUPERVISION_TIMEOUT_IND_T *)message)->bd_addr.uap,
                        ((CL_DM_LINK_SUPERVISION_TIMEOUT_IND_T *)message)->bd_addr.lap));
            break;
        }
        case CL_DM_ROLE_IND:
        {
            DEBUG_CL(("CL_DM_ROLE_IND\n"));
            handleClRoleInd((CL_DM_ROLE_IND_T *)message);
            break;
        }
        case CL_DM_ROLE_CFM:
        {
            DEBUG_CL(("CL_DM_ROLE_CFM\n"));
            handleClRoleCfm((CL_DM_ROLE_CFM_T *)message);
            break;
        }
        case CL_DM_SNIFF_SUB_RATING_IND:
        {
            DEBUG_CL(("CL_DM_SNIFF_SUB_RATING_IND\n"));
            break;
        }
        case CL_DM_REMOTE_FEATURES_CFM:
        {
            DEBUG_CL(("CL_DM_REMOTE_FEATURES_CFM\n"));
            handleClDmRemoteFeaturesConfirm((CL_DM_REMOTE_FEATURES_CFM_T *)message);
            return;
        }

		case CL_DM_REMOTE_NAME_COMPLETE:
		{
			CL_DM_REMOTE_NAME_COMPLETE_T *name = (CL_DM_REMOTE_NAME_COMPLETE_T*)message;
			DEBUG_CL(("CL_DM_REMOTE_NAME_COMPLETE\n"));

			if(name->status == hci_success)
			{
				char *name_str = PanicUnlessMalloc(name->size_remote_name+1);
				memcpy(name_str,name->remote_name,name->size_remote_name);
				name_str[name->size_remote_name] = 0;
				UartPrintf("\r\n+RNM=%s\r\n",name_str);
				free(name_str);
			}
			else
				UartPrintf("\r\nERROR\r\n");
			
			break;
		}
		case CL_DM_RSSI_CFM:
		{
            DEBUG_CL(("CL_DM_RSSI_CFM_T %d (%d)\n",((CL_DM_RSSI_CFM_T*)message)->status,((CL_DM_RSSI_CFM_T*)message)->rssi));
			UartPrintf("\r\n+RSSI=%d\r\n",((CL_DM_RSSI_CFM_T*)message)->rssi);
            break;
		}
        default:
        {
            DEBUG_CL(("Unhandled CL message 0x%X\n", (uint16)id));    
            break;
        }
    }
}
/****************************************************************************
NAME
    unexpectedClMessage

DESCRIPTION
    For debug purposes, so any unhandled CL messages are discovered.     

*/
static void unexpectedClMessage(mvdAppState state, MessageId id)
{
    DEBUG_CL(("Unexpected CL message 0x%X in state %u\n", (uint16)id, (uint16)state));
}
/****************************************************************************
NAME
    handleClDmRemoteFeaturesConfirm

DESCRIPTION
    Handles the retrieved supported features of the remote device.

*/
static void handleClDmRemoteFeaturesConfirm(const CL_DM_REMOTE_FEATURES_CFM_T *cfm)
{
    uint16 i;    
    devInstanceTaskData *inst = NULL;
    devInstanceTaskData *temp_inst = NULL;
    bool found = FALSE;
    uint16 features[4];
    a2dpAudioQuality quality = A2DP_AUDIO_QUALITY_UNKNOWN;
    a2dpAudioQuality lowest_quality = A2DP_AUDIO_QUALITY_UNKNOWN;
    uint16 signalling_conns = 0;
    uint16 media_conns = 0;
    
    if (cfm->status == hci_success)
    {
        /* Look at all possible connections to find the device instance associated with the Sink returned */
        /* Look at all possible connections to get number of signalling connections, and media connections */
        for (i = 0; i < MAX_NUM_DEV_CONNECTIONS; i++)
        {
            inst = the_app->dev_inst[i];
            if (inst != NULL)
            {         
                if ((cfm->sink == inst->aghfp_sink) || (cfm->sink == inst->a2dp_sig_sink))
                {
                    /* store the instance that was found */
                    found = TRUE;
                    temp_inst = inst;
                }   
                if (inst->a2dp_sig_sink)
                {
                    signalling_conns++;
                    if (inst->a2dp_media_sink)
                        media_conns++;
                }    
                if (inst->a2dp_audio_quality < lowest_quality)
                    lowest_quality = inst->a2dp_audio_quality;
            }
        }
    
        if (!found)
            return;
        
        /* retrieve the instance which was found */
        inst = temp_inst;

        /* Get supported features that both devices support */
        for (i = 0; i < 4; i++)
        {
            features[i] = the_app->local_supported_features[i];
            features[i] &= cfm->features[i];
        }

        /* Determine the sort of audio quality a link could support. */
        if ((features[1] & 0x0600) && (features[2] & 0x0180))
        {
            /* Both sides capable of supporting EDR ACL 2Mbps and/or 3Mbps with three or five slot packets */
            quality = A2DP_AUDIO_QUALITY_HIGH;
        }
        else if (features[0] & 0x0002)
        {
            /* Capable of supporting BR ACL 1Mbps with five slot packets */
            quality = A2DP_AUDIO_QUALITY_MEDIUM;
        }
        else
        {
            /* All other data rate and slot size combinations only capable of supporting a low data rate */
            quality = A2DP_AUDIO_QUALITY_LOW;
        }

        /* Update supported packet types and data rates */
        inst->a2dp_audio_quality = quality;
        
        DEBUG_CL(("    audio quality = %d\n", quality));    
    }
}