AudioDeviceID getRequestedDeviceID(char * requestedDeviceName, ASDeviceType typeRequested) {
UInt32 propertySize;
AudioDeviceID dev_array[64];
int numberOfDevices = 0;
char deviceName[256];
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &propertySize, NULL);
// printf("propertySize=%d\n",propertySize);
AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &propertySize, dev_array);
numberOfDevices = (propertySize / sizeof(AudioDeviceID));
// printf("numberOfDevices=%d\n",numberOfDevices);
for(int i = 0; i < numberOfDevices; ++i) {
switch(typeRequested) {
case kAudioTypeInput:
case kAudioTypeOutput:
if (getDeviceType(dev_array[i]) != typeRequested) continue;
break;
case kAudioTypeSystemOutput:
if (getDeviceType(dev_array[i]) != kAudioTypeOutput) continue;
break;
}
getDeviceName(dev_array[i], deviceName);
// printf("For device %d, id = %d and name is %s\n",i,dev_array[i],deviceName);
if (strcmp(requestedDeviceName, deviceName) == 0) {
return dev_array[i];
}
}
return kAudioDeviceUnknown;
}
// print out build version
void SimpleShell::version_command( string parameters, StreamOutput *stream)
{
Version vers;
uint32_t dev = getDeviceType();
const char *mcu = (dev & 0x00100000) ? "LPC1769" : "LPC1768";
stream->printf("Build version: %s, Build date: %s, MCU: %s, System Clock: %ldMHz\r\n", vers.get_build(), vers.get_build_date(), mcu, SystemCoreClock / 1000000);
}
void showAllDevices(ASDeviceType typeRequested) {
UInt32 propertySize;
AudioDeviceID dev_array[64];
int numberOfDevices = 0;
ASDeviceType device_type;
char deviceName[256];
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &propertySize, NULL);
AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &propertySize, dev_array);
numberOfDevices = (propertySize / sizeof(AudioDeviceID));
for(int i = 0; i < numberOfDevices; ++i) {
device_type = getDeviceType(dev_array[i]);
switch(typeRequested) {
case kAudioTypeInput:
case kAudioTypeOutput:
if (device_type != typeRequested) continue;
break;
case kAudioTypeSystemOutput:
if (device_type != kAudioTypeOutput) continue;
break;
}
getDeviceName(dev_array[i], deviceName);
printf("%s (%s)\n",deviceName,deviceTypeName(device_type));
}
}
bool AEDeviceEnumerationOSX::Enumerate()
{
AudioStreamIdList streamList;
bool isDigital = isDigitalDevice();
bool ret = false;
UInt32 transportType = m_caDevice.GetTransportType();
m_caStreamInfos.clear();
m_isPlanar = true;
m_deviceName = m_caDevice.GetName();
if (m_caDevice.GetStreams(&streamList))
{
for (UInt32 streamIdx = 0; streamIdx < streamList.size(); streamIdx++)
{
caStreamInfo info;
info.streamID = streamList[streamIdx];
info.numChannels = m_caDevice.GetNumChannelsOfStream(streamIdx);
// one stream with num channels other then 1 is enough to make this device non-planar
if (info.numChannels != 1)
m_isPlanar = false;
CCoreAudioStream::GetAvailablePhysicalFormats(streamList[streamIdx], &info.formatList);
hasPassthroughOrDigitalFormats(info.formatList, info.hasPassthroughFormats, info.isDigital);
info.isDigital |= isDigital;
info.deviceType = getDeviceType(info.hasPassthroughFormats, info.isDigital, info.numChannels, transportType);
m_caStreamInfos.push_back(info);
}
ret = true;
}
return ret;
}
InterfaceInfo InterfaceManagerImpl::getDeviceInfo(const std::string& deviceAddr)
{
GDBusProxy* nmDeviceProxy = nullptr;
GError* error = nullptr;
InterfaceInfo info;
try
{
nmDeviceProxy = g_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
NM_IFACE_NETWORKMANAGER,
deviceAddr.c_str(),
NM_IFACE_DEVICE,
NULL,
&error);
if (nmDeviceProxy == NULL && error != NULL){
throw std::runtime_error(error->message);
}
guint deviceType = getDeviceType(nmDeviceProxy);
info.type = nmDevTypeToLocalDevType(deviceType);
info.name = getDeviceName(nmDeviceProxy);
const std::string nmModule = getNmInterface(deviceType);
if(nmModule.length()){
info.hwAddr = getDeviceHwAddress(deviceAddr, nmModule);
}
}
catch(...)
{
if(nmDeviceProxy != nullptr){
g_object_unref(nmDeviceProxy);
}
if(error != nullptr){
g_error_free(error);
}
throw;
}
return info;
}
AudioDeviceID getNextDeviceID(AudioDeviceID currentDeviceID, ASDeviceType typeRequested) {
UInt32 propertySize;
AudioDeviceID dev_array[64];
int numberOfDevices = 0;
AudioDeviceID first_dev = kAudioDeviceUnknown;
int found = -1;
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &propertySize, NULL);
// printf("propertySize=%d\n",propertySize);
AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &propertySize, dev_array);
numberOfDevices = (propertySize / sizeof(AudioDeviceID));
// printf("numberOfDevices=%d\n",numberOfDevices);
for(int i = 0; i < numberOfDevices; ++i) {
switch(typeRequested) {
case kAudioTypeInput:
if (!isAnInputDevice(dev_array[i])) continue;
break;
case kAudioTypeOutput:
if (!isAnOutputDevice(dev_array[i])) continue;
break;
case kAudioTypeSystemOutput:
if (getDeviceType(dev_array[i]) != kAudioTypeOutput) continue;
break;
default: break;
}
if (first_dev == kAudioDeviceUnknown) {
first_dev = dev_array[i];
}
if (found >= 0) {
return dev_array[i];
}
if (dev_array[i] == currentDeviceID) {
found = i;
}
}
return first_dev;
}
QByteArray NodeIdentificationIndicator::getFrameData() {
QByteArray frameData;
frameData += getFrameType();
frameData += getSourceAddress64();
frameData += getSourceAddress16();
frameData += getReceiveOptions();
frameData += getRemoteAddress16();
frameData += getRemoteAddress64();
frameData += getNIString();
frameData += (char)0x00;
frameData += getParentAddress16();
frameData += getDeviceType();
frameData += getSourceEvent();
frameData += getProfileID();
frameData += getManufacturerID();
frameData += getDeviceTypeID();
frameData += getRSSI();
return frameData;
}
void ImuRosI::phidgetsDiagnostics(diagnostic_updater::DiagnosticStatusWrapper &stat)
{
if (is_connected_)
{
stat.summary(diagnostic_msgs::DiagnosticStatus::OK, "The Phidget is connected.");
stat.add("Device Serial Number", getDeviceSerialNumber());
stat.add("Device Name", getDeviceName());
stat.add("Device Type", getDeviceType());
}
else
{
stat.summary(diagnostic_msgs::DiagnosticStatus::ERROR, "The Phidget is not connected. Check the USB.");
}
if (error_number_ != 0)
{
stat.summary(diagnostic_msgs::DiagnosticStatus::ERROR, "The Phidget reports error.");
stat.add("Error Number", error_number_);
stat.add("Error message", getErrorDescription(error_number_));
}
}
// Getters
bool
MorpheusHMD::matchesDeviceEnumerator(const DeviceEnumerator *enumerator) const
{
// Down-cast the enumerator so we can use the correct get_path.
const HMDDeviceEnumerator *pEnum = static_cast<const HMDDeviceEnumerator *>(enumerator);
bool matches = false;
if (pEnum->get_device_type() == getDeviceType())
{
const char *enumerator_path = pEnum->get_path();
const char *dev_path = USBContext->device_identifier.c_str();
#ifdef _WIN32
matches = _stricmp(dev_path, enumerator_path) == 0;
#else
matches = strcmp(dev_path, enumerator_path) == 0;
#endif
}
return matches;
}
bool AudioAdapter::Init(){
char buf[256];
PaError err;
f_init=true;
inChan=CHANNELS;
outChan=CHANNELS;
framesPerBuffer=FRAMES_PER_BUFFER;
Logger::Println("[AudioAdapter] Initialize");
Logger::Debugln("[AudioAdapter] Initialize PortAudio");
err = Pa_Initialize();
if( err != paNoError ) goto error;
memset( &inputParameters , 0 , sizeof( inputParameters ) );
inputParameters.channelCount = inChan;
inputParameters.hostApiSpecificStreamInfo = NULL;
inputParameters.sampleFormat = paFloat32;
inputParameters.hostApiSpecificStreamInfo = NULL;
memset( &outputParameters, 0 , sizeof( outputParameters ) );
outputParameters.channelCount = outChan;
outputParameters.hostApiSpecificStreamInfo = NULL;
outputParameters.sampleFormat = paFloat32;
outputParameters.hostApiSpecificStreamInfo = NULL;
hostApiCount = Pa_GetHostApiCount();
devCount = Pa_GetDeviceCount();
int usesetup=ApplicationProperty::ReadSetupInt("Audio","UseSetup",1);
int useDefaultSetting=ApplicationProperty::ReadSetupInt("Audio","UseDefault",1);
int settingInDev=ApplicationProperty::ReadSetupInt("Audio","InputDeviceNumber",Pa_GetDefaultInputDevice());
int settingOutDev=ApplicationProperty::ReadSetupInt("Audio","OutputDeviceNumber",Pa_GetDefaultOutputDevice());
if(usesetup==0){
if(useDefaultSetting==1){
inDevNum=Pa_GetDefaultInputDevice();
outDevNum=Pa_GetDefaultOutputDevice();
}else{
inDevNum=settingInDev;
outDevNum=settingOutDev;
}
inputParameters.device = inDevNum;
outputParameters.device = outDevNum;
if(inDevNum!=devCount){
inputParameters.suggestedLatency = Pa_GetDeviceInfo(inDevNum)->defaultLowInputLatency ;
}
if(outDevNum!=devCount){
outputParameters.suggestedLatency = Pa_GetDeviceInfo(outDevNum)->defaultLowOutputLatency ;
}
err = Pa_IsFormatSupported(
inDevNum==devCount?NULL:&inputParameters
,outDevNum==devCount?NULL:&outputParameters
, SAMPLE_RATE );
if( err != paNoError ){
cout << "[AudioAdapter] Error: " << Pa_GetErrorText(err) << endl;
usesetup=1;
}
}
if(usesetup==1){
do{
hostApiNum=SelectApi();
inDevNum=SelectInput();
outDevNum=SelectOutput();
inputParameters.device = inDevNum;
outputParameters.device = outDevNum;
if(inDevNum!=devCount){
inputParameters.suggestedLatency = Pa_GetDeviceInfo(inDevNum)->defaultLowInputLatency ;
}
if(outDevNum!=devCount){
outputParameters.suggestedLatency = Pa_GetDeviceInfo(outDevNum)->defaultLowOutputLatency ;
}
err = Pa_IsFormatSupported(
inDevNum==devCount?NULL:&inputParameters
,outDevNum==devCount?NULL:&outputParameters
, SAMPLE_RATE );
if( err != paNoError ){
cout << "[AudioAdapter] Error: " << Pa_GetErrorText(err) << endl;
}
}while(err!=paNoError);
}
Logger::Println("[AudioAdapter] Audio Info");
if(0<=outDevNum && outDevNum<devCount){
Logger::Println(" HostApi : %s",Pa_GetHostApiInfo(Pa_GetDeviceInfo(outDevNum)->hostApi)->name);
}
if(devCount==inDevNum){
Logger::Println(" No Input");
}else{
getDeviceType(Pa_GetDeviceInfo(inDevNum)->maxInputChannels,Pa_GetDeviceInfo(inDevNum)->maxOutputChannels,buf);
Logger::Println(" Input Device : %s",Pa_GetDeviceInfo(inDevNum)->name);
}
if(devCount==outDevNum){
Logger::Println(" No Output");
}else{
getDeviceType(Pa_GetDeviceInfo(outDevNum)->maxInputChannels,Pa_GetDeviceInfo(outDevNum)->maxOutputChannels,buf);
Logger::Println(" Output Device : %s",Pa_GetDeviceInfo(outDevNum)->name);
}
ApplicationProperty::WriteSetupInt("Audio","InputDeviceNumber",inDevNum);
ApplicationProperty::WriteSetupInt("Audio","OutputDeviceNumber",outDevNum);
audioApi=new MyAudioApi;
audioApi->Init();
return true;
error:
Logger::Println("[AudioAdapter] Error : %s",Pa_GetErrorText(err));
return false;
}
// controller hotplugging: https://gist.github.com/urkle/6701236
bool DeviceManager::handleEvent(SDL_Event* event) {
switch(event->type) {
case SDL_CONTROLLERDEVICEADDED:
LOG_DEBUG << "CONTROLLER ADDED sdlIndex " << event->cdevice.which << endl;
if(open(event->cdevice.which)) {
#ifdef DEBUG
print();
#endif
}
return true;
case SDL_CONTROLLERDEVICEREMAPPED:
LOG << "CONTROLLER REMAPPED instance ID " << event->cdevice.which << endl;
return true;
case SDL_CONTROLLERAXISMOTION:
case SDL_CONTROLLERBUTTONDOWN: case SDL_CONTROLLERBUTTONUP:
if(getDeviceType(event->cdevice.which) == Device::GAMECONTROLLER) {
return m_devices[event->cdevice.which]->handleEvent(event);
}
return false;
case SDL_CONTROLLERDEVICEREMOVED:
LOG_DEBUG << "CONTROLLER REMOVED instance ID " << event->cdevice.which << endl;
if(close(event->cdevice.which)) {
#ifdef DEBUG
print();
#endif
}
return true;
case SDL_JOYDEVICEADDED:
LOG_DEBUG << "JOYSTICK ADDED sdlIndex " << event->jdevice.which << endl;
if(open(event->jdevice.which)) {
#ifdef DEBUG
print();
#endif
}
return true;
case SDL_JOYBUTTONDOWN: case SDL_JOYBUTTONUP:
case SDL_JOYAXISMOTION: case SDL_JOYBALLMOTION: case SDL_JOYHATMOTION:
if(getDeviceType(event->jdevice.which) == Device::JOYSTICK) {
return m_devices[event->jdevice.which]->handleEvent(event);
}
return false;
case SDL_JOYDEVICEREMOVED:
LOG_DEBUG << "JOYSTICK REMOVED instance ID " << event->jdevice.which << endl;
if(close(event->jdevice.which)) {
#ifdef DEBUG
print();
#endif
}
return true;
default:
return false;
}
}
int PSSendOps(void *arg)
{
int i;
int status = 0;
struct ps_cmd_packet *HciCmdList; /* List storing the commands */
const struct firmware* firmware;
u32 numCmds;
u8 *event;
u8 *bufferToFree;
struct hci_dev *device;
u8 *buffer;
u32 len;
u32 DevType;
u8 *PsFileName;
u8 *patchFileName;
u8 *path = NULL;
u8 *config_path = NULL;
u8 config_bdaddr[MAX_BDADDR_FORMAT_LENGTH];
struct ar3k_config_info *hdev = (struct ar3k_config_info*)arg;
struct device *firmwareDev = NULL;
status = 0;
HciCmdList = NULL;
#ifdef HCI_TRANSPORT_SDIO
device = hdev->pBtStackHCIDev;
firmwareDev = device->parent;
#else
device = hdev;
firmwareDev = &device->dev;
AthEnableSyncCommandOp(true);
#endif /* HCI_TRANSPORT_SDIO */
/* First verify if the controller is an FPGA or ASIC, so depending on the device type the PS file to be written will be different.
*/
path =(u8 *)A_MALLOC(MAX_FW_PATH_LEN);
if(path == NULL) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Malloc failed to allocate %d bytes for path\n", MAX_FW_PATH_LEN));
goto complete;
}
config_path = (u8 *) A_MALLOC(MAX_FW_PATH_LEN);
if(config_path == NULL) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Malloc failed to allocate %d bytes for config_path\n", MAX_FW_PATH_LEN));
goto complete;
}
if(A_ERROR == getDeviceType(hdev,&DevType)) {
status = 1;
goto complete;
}
if(A_ERROR == ReadVersionInfo(hdev)) {
status = 1;
goto complete;
}
patchFileName = PATCH_FILE;
snprintf(path, MAX_FW_PATH_LEN, "%s/%xcoex/",CONFIG_PATH,Rom_Version);
if(DevType){
if(DevType == 0xdeadc0de){
PsFileName = PS_ASIC_FILE;
} else{
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,(" FPGA Test Image : %x %x \n",Rom_Version,Build_Version));
if((Rom_Version == 0x99999999) && (Build_Version == 1)){
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("FPGA Test Image : Skipping Patch File load\n"));
patchFileName = NULL;
}
PsFileName = PS_FPGA_FILE;
}
}
else{
PsFileName = PS_ASIC_FILE;
}
snprintf(config_path, MAX_FW_PATH_LEN, "%s%s",path,PsFileName);
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%x: FPGA/ASIC PS File Name %s\n", DevType,config_path));
/* Read the PS file to a dynamically allocated buffer */
if(A_REQUEST_FIRMWARE(&firmware,config_path,firmwareDev) < 0) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: firmware file open error\n", __FUNCTION__ ));
status = 1;
goto complete;
}
if(NULL == firmware || firmware->size == 0) {
status = 1;
goto complete;
}
buffer = (u8 *)A_MALLOC(firmware->size);
if(buffer != NULL) {
/* Copy the read file to a local Dynamic buffer */
memcpy(buffer,firmware->data,firmware->size);
len = firmware->size;
A_RELEASE_FIRMWARE(firmware);
/* Parse the PS buffer to a global variable */
status = AthDoParsePS(buffer,len);
kfree(buffer);
} else {
A_RELEASE_FIRMWARE(firmware);
}
/* Read the patch file to a dynamically allocated buffer */
if(patchFileName != NULL)
snprintf(config_path,
MAX_FW_PATH_LEN, "%s%s",path,patchFileName);
else {
status = 0;
}
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Patch File Name %s\n", config_path));
if((patchFileName == NULL) || (A_REQUEST_FIRMWARE(&firmware,config_path,firmwareDev) < 0)) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: firmware file open error\n", __FUNCTION__ ));
/*
* It is not necessary that Patch file be available, continue with PS Operations if.
* failed.
*/
status = 0;
} else {
if(NULL == firmware || firmware->size == 0) {
status = 0;
} else {
buffer = (u8 *)A_MALLOC(firmware->size);
if(buffer != NULL) {
/* Copy the read file to a local Dynamic buffer */
memcpy(buffer,firmware->data,firmware->size);
len = firmware->size;
A_RELEASE_FIRMWARE(firmware);
/* parse and store the Patch file contents to a global variables */
status = AthDoParsePatch(buffer,len);
kfree(buffer);
} else {
A_RELEASE_FIRMWARE(firmware);
}
}
}
/* Create an HCI command list from the parsed PS and patch information */
AthCreateCommandList(&HciCmdList,&numCmds);
/* Form the parameter for PSSendOps() API */
/*
* First Send the CRC packet,
* We have to continue with the PS operations only if the CRC packet has been replied with
* a Command complete event with status Error.
*/
if(SendHCICommandWaitCommandComplete
(hdev,
HciCmdList[0].Hcipacket,
HciCmdList[0].packetLen,
&event,
&bufferToFree) == 0) {
if(ReadPSEvent(event) == 0) { /* Exit if the status is success */
if(bufferToFree != NULL) {
kfree(bufferToFree);
}
#ifndef HCI_TRANSPORT_SDIO
if(bdaddr && bdaddr[0] !='\0') {
write_bdaddr(hdev,bdaddr,BDADDR_TYPE_STRING);
}
#endif
status = 1;
goto complete;
}
if(bufferToFree != NULL) {
kfree(bufferToFree);
}
} else {
status = 0;
goto complete;
}
for(i = 1; i <numCmds; i++) {
if(SendHCICommandWaitCommandComplete
(hdev,
HciCmdList[i].Hcipacket,
HciCmdList[i].packetLen,
&event,
&bufferToFree) == 0) {
if(ReadPSEvent(event) != 0) { /* Exit if the status is success */
if(bufferToFree != NULL) {
kfree(bufferToFree);
}
status = 1;
goto complete;
}
if(bufferToFree != NULL) {
kfree(bufferToFree);
}
} else {
status = 0;
goto complete;
}
}
#ifdef HCI_TRANSPORT_SDIO
if(BDADDR == false)
if(hdev->bdaddr[0] !=0x00 ||
hdev->bdaddr[1] !=0x00 ||
hdev->bdaddr[2] !=0x00 ||
hdev->bdaddr[3] !=0x00 ||
hdev->bdaddr[4] !=0x00 ||
hdev->bdaddr[5] !=0x00)
write_bdaddr(hdev,hdev->bdaddr,BDADDR_TYPE_HEX);
#ifndef HCI_TRANSPORT_SDIO
if(bdaddr && bdaddr[0] != '\0') {
write_bdaddr(hdev,bdaddr,BDADDR_TYPE_STRING);
} else
#endif /* HCI_TRANSPORT_SDIO */
/* Write BDADDR Read from OTP here */
#endif
{
/* Read Contents of BDADDR file if user has not provided any option */
snprintf(config_path,MAX_FW_PATH_LEN, "%s%s",path,BDADDR_FILE);
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Patch File Name %s\n", config_path));
if(A_REQUEST_FIRMWARE(&firmware,config_path,firmwareDev) < 0) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: firmware file open error\n", __FUNCTION__ ));
status = 1;
goto complete;
}
if(NULL == firmware || firmware->size == 0) {
status = 1;
goto complete;
}
len = min_t(size_t, firmware->size, MAX_BDADDR_FORMAT_LENGTH - 1);
memcpy(config_bdaddr, firmware->data, len);
config_bdaddr[len] = '\0';
write_bdaddr(hdev,config_bdaddr,BDADDR_TYPE_STRING);
A_RELEASE_FIRMWARE(firmware);
}
complete:
#ifndef HCI_TRANSPORT_SDIO
AthEnableSyncCommandOp(false);
PSTagMode = false;
wake_up_interruptible(&PsCompleteEvent);
#endif /* HCI_TRANSPORT_SDIO */
if(NULL != HciCmdList) {
AthFreeCommandList(&HciCmdList,numCmds);
}
if(path) {
kfree(path);
}
if(config_path) {
kfree(config_path);
}
return status;
}
double gpu_cgm_image(uint32_t* aList, uint32_t* bList, int aLength,
int bLength, int keyLength, uint32_t** matches, char* clFile, int x,
int y) {
int gap = 0, myoffset = 0;
cl_platform_id *platforms;
cl_uint num_platforms = 0;
cl_device_id *devices;
cl_uint num_devices = 0;
cl_context context;
cl_command_queue command_queue;
cl_image_format imgFormat;
cl_mem aImg;
cl_mem bImg;
cl_mem res_buf;
cl_program program;
cl_kernel kernel;
cl_uint *results;
FILE *prgm_fptr;
struct stat prgm_sbuf;
char *prgm_data;
size_t prgm_size;
size_t offset;
size_t count;
const size_t global_work_size[] = { x, y };
const size_t origin[] = { 0, 0, 0 };
const size_t region[] = { aLength, 1, 1 };
cl_int ret;
cl_uint i;
cl_bool imageSupport;
struct timeval t1, t2;
double elapsedTime;
results = malloc(sizeof(cl_uint) * aLength);
imgFormat.image_channel_order = CL_RGBA;
imgFormat.image_channel_data_type = CL_UNSIGNED_INT32;
/* figure out how many CL platforms are available */
ret = clGetPlatformIDs(0, NULL, &num_platforms);
if (CL_SUCCESS != ret) {
print_error ("Error getting the number of platform IDs: %d", ret);
exit(EXIT_FAILURE);
}
if (0 == num_platforms) {
print_error ("No CL platforms were found.");
exit(EXIT_FAILURE);
}
/* allocate space for each available platform ID */
if (NULL == (platforms = malloc((sizeof *platforms) * num_platforms))) {
print_error ("Out of memory");
exit(EXIT_FAILURE);
}
/* get all of the platform IDs */
ret = clGetPlatformIDs(num_platforms, platforms, NULL);
if (CL_SUCCESS != ret) {
print_error ("Error getting platform IDs: %d", ret);
exit(EXIT_FAILURE);
}
/* find a platform that supports given device type */
// print_error ("Number of platforms found: %d", num_platforms);
for (i = 0; i < num_platforms; i++) {
ret = clGetDeviceIDs(platforms[i], getDeviceType(), 0, NULL,
&num_devices);
if (CL_SUCCESS != ret)
continue;
if (0 < num_devices)
break;
}
/* make sure at least one device was found */
if (num_devices == 0) {
print_error ("No CL device found that supports device type: %s.", ((getDeviceType() == CL_DEVICE_TYPE_CPU) ? "CPU" : "GPU"));
exit(EXIT_FAILURE);
}
/* only one device is necessary... */
num_devices = 1;
if (NULL == (devices = malloc((sizeof *devices) * num_devices))) {
print_error ("Out of memory");
exit(EXIT_FAILURE);
}
/* get one device id */
ret = clGetDeviceIDs(platforms[i], getDeviceType(), num_devices,
devices, NULL);
if (CL_SUCCESS != ret) {
print_error ("Error getting device IDs: %d", ret);
exit(EXIT_FAILURE);
}
ret = clGetDeviceInfo(*devices, CL_DEVICE_IMAGE_SUPPORT, sizeof(cl_bool), &imageSupport, NULL);
if (CL_SUCCESS != ret) {
print_error ("Failed to get Device Info: %d", ret);
exit(EXIT_FAILURE);
}
if(imageSupport == CL_FALSE)
{
print_error ("Failure: Images are not supported!");
exit(EXIT_FAILURE);
}
/* create a context for the CPU device that was found earlier */
context = clCreateContext(NULL, num_devices, devices, NULL, NULL, &ret);
if (NULL == context || CL_SUCCESS != ret) {
print_error ("Failed to create context: %d", ret);
exit(EXIT_FAILURE);
}
/* create a command queue for the CPU device */
command_queue = clCreateCommandQueue(context, devices[0], 0, &ret);
if (NULL == command_queue || CL_SUCCESS != ret) {
print_error ("Failed to create a command queue: %d", ret);
exit(EXIT_FAILURE);
}
/* create buffers on the CL device */
aImg = clCreateImage2D(context, CL_MEM_READ_ONLY, &imgFormat, aLength, 1, 0, NULL, &ret);
if (NULL == aImg || CL_SUCCESS != ret) {
print_error ("Failed to create a image: %d", ret);
exit(EXIT_FAILURE);
}
bImg = clCreateImage2D(context, CL_MEM_READ_ONLY, &imgFormat, aLength, 1, 0, NULL, &ret);
if (NULL == bImg || CL_SUCCESS != ret) {
print_error ("Failed to create b image: %d", ret);
exit(EXIT_FAILURE);
}
int res_bufSize = aLength;
res_buf = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(cl_uint)
* res_bufSize, NULL, &ret);
if (NULL == res_buf || CL_SUCCESS != ret) {
print_error ("Failed to create b buffer: %d", ret);
exit(EXIT_FAILURE);
}
/* read the opencl program code into a string */
prgm_fptr = fopen(clFile, "r");
if (NULL == prgm_fptr) {
print_error ("%s", strerror (errno));
exit(EXIT_FAILURE);
}
if (0 != stat(clFile, &prgm_sbuf)) {
print_error ("%s", strerror (errno));
exit(EXIT_FAILURE);
}
prgm_size = prgm_sbuf.st_size;
prgm_data = malloc(prgm_size);
if (NULL == prgm_data) {
print_error ("Out of memory");
exit(EXIT_FAILURE);
}
/* make sure all data is read from the file (just in case fread returns
* short) */
offset = 0;
while (prgm_size - offset != (count = fread(prgm_data + offset, 1,
prgm_size - offset, prgm_fptr)))
offset += count;
if (0 != fclose(prgm_fptr)) {
print_error ("%s", strerror (errno));
exit(EXIT_FAILURE);
}
/* create a 'program' from the source */
program = clCreateProgramWithSource(context, 1, (const char **) &prgm_data,
&prgm_size, &ret);
if (NULL == program || CL_SUCCESS != ret) {
print_error ("Failed to create program with source: %d", ret);
exit(EXIT_FAILURE);
}
/* compile the program.. (it uses llvm or something) */
ret = clBuildProgram(program, num_devices, devices, NULL, NULL, NULL);
if (CL_SUCCESS != ret) {
size_t size;
char *log = calloc(1, 4000);
if (NULL == log) {
print_error ("Out of memory");
exit(EXIT_FAILURE);
}
print_error ("Failed to build program: %d", ret);
ret = clGetProgramBuildInfo(program, devices[0], CL_PROGRAM_BUILD_LOG,
4096, log, &size);
if (CL_SUCCESS != ret) {
print_error ("Failed to get program build info: %d", ret);
exit(EXIT_FAILURE);
}
fprintf(stderr, "Begin log:\n%s\nEnd log.\n", log);
exit(EXIT_FAILURE);
}
/* pull out a reference to your kernel */
kernel = clCreateKernel(program, "cgm_kernel", &ret);
if (NULL == kernel || CL_SUCCESS != ret) {
print_error ("Failed to create kernel: %d", ret);
exit(EXIT_FAILURE);
}
gettimeofday(&t1, NULL);
/* write data to these buffers */
clEnqueueWriteImage(command_queue, aImg, CL_FALSE, origin, region, 0, 0,
(void*) aImg, 0, NULL, NULL);
clEnqueueWriteImage(command_queue, bImg, CL_FALSE, origin, region, 0, 0,
(void*) bImg, 0, NULL, NULL);
/* set your kernel's arguments */
ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), &aImg);
if (CL_SUCCESS != ret) {
print_error ("Failed to set kernel argument: %d", ret);
exit(EXIT_FAILURE);
}
ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), &bImg);
if (CL_SUCCESS != ret) {
print_error ("Failed to set kernel argument: %d", ret);
exit(EXIT_FAILURE);
}
ret = clSetKernelArg(kernel, 4, sizeof(int), &gap);
if (CL_SUCCESS != ret) {
print_error ("Failed to set kernel argument: %d", ret);
exit(EXIT_FAILURE);
}
ret = clSetKernelArg(kernel, 5, sizeof(int), &myoffset);
if (CL_SUCCESS != ret) {
print_error ("Failed to set kernel argument: %d", ret);
exit(EXIT_FAILURE);
}
ret = clSetKernelArg(kernel, 6, sizeof(int), &keyLength);
if (CL_SUCCESS != ret) {
print_error ("Failed to set kernel argument: %d", ret);
exit(EXIT_FAILURE);
}
ret = clSetKernelArg(kernel, 7, sizeof(cl_mem), &res_buf);
if (CL_SUCCESS != ret) {
print_error ("Failed to set kernel argument: %d", ret);
exit(EXIT_FAILURE);
}
/* make sure buffers have been written before executing */
ret = clEnqueueBarrier(command_queue);
if (CL_SUCCESS != ret) {
print_error ("Failed to enqueue barrier: %d", ret);
exit(EXIT_FAILURE);
}
/* enque this kernel for execution... */
ret = clEnqueueNDRangeKernel(command_queue, kernel, 2, NULL,
global_work_size, NULL, 0, NULL, NULL);
if (CL_SUCCESS != ret) {
print_error ("Failed to enqueue kernel: %d", ret);
exit(EXIT_FAILURE);
}
/* wait for the kernel to finish executing */
ret = clEnqueueBarrier(command_queue);
if (CL_SUCCESS != ret) {
print_error ("Failed to enqueue barrier: %d", ret);
exit(EXIT_FAILURE);
}
/* copy the contents of dev_buf from the CL device to the host (CPU) */
ret = clEnqueueReadBuffer(command_queue, res_buf, true, 0, sizeof(cl_uint)
* aLength, results, 0, NULL, NULL);
gettimeofday(&t2, NULL);
elapsedTime = (t2.tv_sec - t1.tv_sec) * 1000.0; // sec to ms
elapsedTime += (t2.tv_usec - t1.tv_usec) / 1000.0; // us to ms
if (CL_SUCCESS != ret) {
print_error ("Failed to copy data from device to host: %d", ret);
exit(EXIT_FAILURE);
}
ret = clEnqueueBarrier(command_queue);
if (CL_SUCCESS != ret) {
print_error ("Failed to enqueue barrier: %d", ret);
exit(EXIT_FAILURE);
}
/* make sure the content of the buffer are what we expect */
//for (i = 0; i < aLength; i++)
// printf("%d\n", results[i]);
/* free up resources */
ret = clReleaseKernel(kernel);
if (CL_SUCCESS != ret) {
print_error ("Failed to release kernel: %d", ret);
exit(EXIT_FAILURE);
}
ret = clReleaseProgram(program);
if (CL_SUCCESS != ret) {
print_error ("Failed to release program: %d", ret);
exit(EXIT_FAILURE);
}
ret = clReleaseMemObject(aImg);
if (CL_SUCCESS != ret) {
print_error ("Failed to release memory object: %d", ret);
exit(EXIT_FAILURE);
}
ret = clReleaseMemObject(bImg);
if (CL_SUCCESS != ret) {
print_error ("Failed to release memory object: %d", ret);
exit(EXIT_FAILURE);
}
ret = clReleaseMemObject(res_buf);
if (CL_SUCCESS != ret) {
print_error ("Failed to release memory object: %d", ret);
exit(EXIT_FAILURE);
}
if (CL_SUCCESS != (ret = clReleaseCommandQueue(command_queue))) {
print_error ("Failed to release command queue: %d", ret);
exit(EXIT_FAILURE);
}
if (CL_SUCCESS != (ret = clReleaseContext(context))) {
print_error ("Failed to release context: %d", ret);
exit(EXIT_FAILURE);
}
matches = &results;
return elapsedTime;
}
int PSSendOps(void *arg)
{
int i;
int status = 0;
PSCmdPacket *HciCmdList; /* List storing the commands */
const struct firmware* firmware;
A_UINT32 numCmds;
A_UINT8 *event;
A_UINT8 *bufferToFree;
struct hci_dev *device;
A_UCHAR *buffer;
A_UINT32 len;
A_UINT32 DevType;
A_UCHAR *PsFileName;
A_UCHAR *patchFileName;
AR3K_CONFIG_INFO *hdev = (AR3K_CONFIG_INFO*)arg;
struct device *firmwareDev = NULL;
status = 0;
HciCmdList = NULL;
#ifdef HCI_TRANSPORT_SDIO
device = hdev->pBtStackHCIDev;
firmwareDev = device->parent;
#else
device = hdev;
firmwareDev = &device->dev;
AthEnableSyncCommandOp(TRUE);
#endif /* HCI_TRANSPORT_SDIO */
/* First verify if the controller is an FPGA or ASIC, so depending on the device type the PS file to be written will be different.
*/
if(A_ERROR == getDeviceType(hdev,&DevType)) {
status = 1;
goto complete;
}
if(A_ERROR == ReadVersionInfo(hdev)) {
status = 1;
goto complete;
}
patchFileName = PATCH_FILE;
if(DevType){
if(DevType == 0xdeadc0de){
PsFileName = PS_ASIC_FILE;
} else{
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,(" FPGA Test Image : %x %x \n",Rom_Version,Build_Version));
if((Rom_Version == 0x99999999) && (Build_Version == 1)){
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("FPGA Test Image : Skipping Patch File load\n"));
patchFileName = NULL;
}
PsFileName = PS_FPGA_FILE;
}
}
else{
PsFileName = PS_ASIC_FILE;
}
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%x: FPGA/ASIC PS File Name %s\n", DevType,PsFileName));
/* Read the PS file to a dynamically allocated buffer */
if(request_firmware(&firmware,PsFileName,firmwareDev) < 0) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: firmware file open error\n", __FUNCTION__ ));
status = 1;
goto complete;
}
if(NULL == firmware || firmware->size == 0) {
status = 1;
goto complete;
}
buffer = (A_UCHAR *)A_MALLOC(firmware->size);
if(buffer != NULL) {
/* Copy the read file to a local Dynamic buffer */
memcpy(buffer,firmware->data,firmware->size);
len = firmware->size;
release_firmware(firmware);
/* Parse the PS buffer to a global variable */
status = AthDoParsePS(buffer,len);
A_FREE(buffer);
} else {
release_firmware(firmware);
}
/* Read the patch file to a dynamically allocated buffer */
if((patchFileName == NULL) || (request_firmware(&firmware,patchFileName,firmwareDev) < 0)) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: firmware file open error\n", __FUNCTION__ ));
/*
* It is not necessary that Patch file be available, continue with PS Operations if.
* failed.
*/
status = 0;
} else {
if(NULL == firmware || firmware->size == 0) {
status = 0;
} else {
buffer = (A_UCHAR *)A_MALLOC(firmware->size);
if(buffer != NULL) {
/* Copy the read file to a local Dynamic buffer */
memcpy(buffer,firmware->data,firmware->size);
len = firmware->size;
release_firmware(firmware);
/* parse and store the Patch file contents to a global variables */
status = AthDoParsePatch(buffer,len);
A_FREE(buffer);
} else {
release_firmware(firmware);
}
}
}
/* Create an HCI command list from the parsed PS and patch information */
AthCreateCommandList(&HciCmdList,&numCmds);
/* Form the parameter for PSSendOps() API */
/*
* First Send the CRC packet,
* We have to continue with the PS operations only if the CRC packet has been replied with
* a Command complete event with status Error.
*/
if(SendHCICommandWaitCommandComplete
(hdev,
HciCmdList[0].Hcipacket,
HciCmdList[0].packetLen,
&event,
&bufferToFree) == A_OK) {
if(ReadPSEvent(event) == A_OK) { /* Exit if the status is success */
if(bufferToFree != NULL) {
A_FREE(bufferToFree);
}
#ifndef HCI_TRANSPORT_SDIO
if(bdaddr[0] !='\0') {
write_bdaddr(hdev,bdaddr);
}
#endif
status = 1;
goto complete;
}
if(bufferToFree != NULL) {
A_FREE(bufferToFree);
}
} else {
status = 0;
goto complete;
}
for(i = 1; i <numCmds; i++) {
if(SendHCICommandWaitCommandComplete
(hdev,
HciCmdList[i].Hcipacket,
HciCmdList[i].packetLen,
&event,
&bufferToFree) == A_OK) {
if(ReadPSEvent(event) != A_OK) { /* Exit if the status is success */
if(bufferToFree != NULL) {
A_FREE(bufferToFree);
}
status = 1;
goto complete;
}
if(bufferToFree != NULL) {
A_FREE(bufferToFree);
}
} else {
status = 0;
goto complete;
}
}
#ifndef HCI_TRANSPORT_SDIO
if(bdaddr[0] != '\0') {
write_bdaddr(hdev,bdaddr);
} else
#endif /* HCI_TRANSPORT_SDIO */
{
/* Read Contents of BDADDR file if user has not provided any option */
if(request_firmware(&firmware,BDADDR_FILE,firmwareDev) < 0) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: firmware file open error\n", __FUNCTION__ ));
status = 1;
goto complete;
}
if(NULL == firmware || firmware->size == 0) {
status = 1;
goto complete;
}
write_bdaddr(hdev,(A_UCHAR *)firmware->data);
release_firmware(firmware);
}
complete:
#ifndef HCI_TRANSPORT_SDIO
AthEnableSyncCommandOp(FALSE);
PSTagMode = FALSE;
wake_up_interruptible(&PsCompleteEvent);
#endif /* HCI_TRANSPORT_SDIO */
if(NULL != HciCmdList) {
AthFreeCommandList(&HciCmdList,numCmds);
}
return status;
}
bool CAESinkIntelSMD::Initialize(AEAudioFormat &format, std::string &device)
{
VERBOSE2();
CLog::Log(LOGDEBUG, "%s: device: %s, data format: %s, sample rate: %d, channel count: %d, frame size: %d", __DEBUG_ID__, device.c_str(), CAEUtil::DataFormatToStr(format.m_dataFormat), format.m_sampleRate, format.m_channelLayout.Count(), format.m_frameSize);
CSingleLock lock(m_SMDAudioLock);
bool bIsHDMI = isHDMI(device);
bool bIsSPDIF = isSPDIF(device);
bool bIsAnalog = isAnalog(device);
int deviceType = getDeviceType(device);
ismd_result_t result;
AEDataFormat inputDataFormat = format.m_dataFormat;
bool bSPDIFPassthrough = false;
bool bHDMIPassthrough = false;
bool bIsRawCodec = AE_IS_RAW(inputDataFormat);
format.m_sampleRate = getOutputSampleRate(deviceType, format.m_sampleRate);
format.m_dataFormat = getAEDataFormat(deviceType, format.m_dataFormat, format.m_frameSize);
int channels = format.m_channelLayout.Count();
// can not support more than 2 channels on anything other than HDMI
if (channels > 2 && (bIsSPDIF || bIsAnalog))
channels = 2;
// support for more than 8 channels not supported
else if (channels > 8)
channels = 8;
ismd_audio_processor_t audioProcessor = -1;
ismd_audio_format_t ismdAudioInputFormat = ISMD_AUDIO_MEDIA_FMT_INVALID;
audioProcessor = g_IntelSMDGlobals.GetAudioProcessor();
if(audioProcessor == -1)
{
CLog::Log(LOGERROR, "%s audioProcessor is not valid", __DEBUG_ID__);
return false;
}
// disable all outputs
g_IntelSMDGlobals.DisableAudioOutput(g_IntelSMDGlobals.GetHDMIOutput());
g_IntelSMDGlobals.DisableAudioOutput(g_IntelSMDGlobals.GetSPDIFOutput());
g_IntelSMDGlobals.DisableAudioOutput(g_IntelSMDGlobals.GetI2SOutput());
m_audioDevice = g_IntelSMDGlobals.CreateAudioInput(false);
if(m_audioDevice == -1)
{
CLog::Log(LOGERROR, "%s failed to create audio input", __DEBUG_ID__);
return false;
}
g_IntelSMDGlobals.SetPrimaryAudioDevice(m_audioDevice);
m_audioDeviceInput = g_IntelSMDGlobals.GetAudioDevicePort(m_audioDevice);
if(m_audioDeviceInput == -1)
{
CLog::Log(LOGERROR, "%s failed to create audio input port", __DEBUG_ID__);
return false;
}
ismdAudioInputFormat = GetISMDFormat(inputDataFormat);
unsigned int uiBitsPerSample = CAEUtil::DataFormatToBits(format.m_dataFormat);
unsigned int uiUsedBitsPerSample = CAEUtil::DataFormatToUsedBits(format.m_dataFormat);
// Are we doing DD+ -> DD mode
bool bAC3Encode = false;
if (bIsHDMI)
{
unsigned int sampleRate = format.m_sampleRate;
unsigned int bitsPerSample = uiUsedBitsPerSample;
if (format.m_encodedRate != 0)
sampleRate = format.m_encodedRate;
unsigned int suggSampleRate = sampleRate;
if (!CheckEDIDSupport(ismdAudioInputFormat, channels, suggSampleRate, bitsPerSample, bAC3Encode))
{
if (suggSampleRate != sampleRate)
format.m_sampleRate = suggSampleRate;
if (bitsPerSample != uiUsedBitsPerSample)
{
if (uiUsedBitsPerSample == 24)
{
format.m_dataFormat = AE_FMT_S24NE4;
uiUsedBitsPerSample = bitsPerSample;
}
else if (uiUsedBitsPerSample == 32)
{
format.m_dataFormat = AE_FMT_S32LE;
uiUsedBitsPerSample = bitsPerSample;
}
else
{
format.m_dataFormat = AE_FMT_S16LE;
uiUsedBitsPerSample = 16;
}
uiBitsPerSample = CAEUtil::DataFormatToBits(format.m_dataFormat);
}
//format.m_frameSize = uiBitsPerSample/4;
}
}
else if (bIsSPDIF && ismdAudioInputFormat == ISMD_AUDIO_MEDIA_FMT_DD_PLUS && ISMD_SUCCESS == ismd_audio_codec_available((ismd_audio_format_t) ISMD_AUDIO_ENCODE_FMT_AC3))
{
bAC3Encode = true;
}
unsigned int outputSampleRate = format.m_sampleRate;
// for raw codecs, send as PCM passthrough
if (!bAC3Encode && bIsRawCodec && ismdAudioInputFormat != ISMD_AUDIO_MEDIA_FMT_DD && ismdAudioInputFormat != ISMD_AUDIO_MEDIA_FMT_TRUE_HD)
{
format.m_dataFormat = AE_FMT_S16NE;
ismdAudioInputFormat = ISMD_AUDIO_MEDIA_FMT_PCM;
bHDMIPassthrough = bSPDIFPassthrough = true;
}
format.m_channelLayout.Reset();
if (bIsRawCodec)
{
for (int i = 0; i < channels; ++i)
format.m_channelLayout += AE_CH_RAW;
}
// TODO: This currently handles Mono,Stereo, 5.1, 7.1 correctly
// Handle the other cases (i.e. 6.1 DTS)
else
{
for (int i = 0; i < channels; ++i)
format.m_channelLayout += s_chMap[i];
}
//TODO: Handle non normal channel configs (3 channel, etc).
int inputChannelConfig = AUDIO_CHAN_CONFIG_2_CH;
if (format.m_channelLayout.Count() == 1)
inputChannelConfig = AUDIO_CHAN_CONFIG_1_CH;
else if (format.m_channelLayout.Count() == 6)
inputChannelConfig = AUDIO_CHAN_CONFIG_6_CH;
else if (format.m_channelLayout.Count() == 8)
inputChannelConfig = AUDIO_CHAN_CONFIG_8_CH;
format.m_frameSize = channels * (CAEUtil::DataFormatToBits(format.m_dataFormat) >> 3);
// if standard audio keep buffer small so delay is short
if (!bIsRawCodec)
{
// try to keep roughly 5ms buffer using multiples of a 1024 buffer size
int numBuffers = ((0.005*((double)(format.m_sampleRate*format.m_frameSize))) / 1024.0) + 0.5;
if (numBuffers == 0)
numBuffers = 1;
else if (numBuffers > 8)
numBuffers = 8;
m_dwChunkSize = numBuffers*1024;
}
else
{
m_dwChunkSize = 8*1024;
}
m_dwBufferLen = m_dwChunkSize;
format.m_frames = m_dwChunkSize/format.m_frameSize;
format.m_frameSamples = format.m_frames*channels;
m_frameSize = format.m_frameSize;
CLog::Log(LOGINFO, "%s ismdAudioInputFormat %d\n", __DEBUG_ID__,
ismdAudioInputFormat);
int counter = 0;
while(counter < 5)
{
result = ismd_audio_input_set_data_format(audioProcessor, m_audioDevice, ismdAudioInputFormat);
if (result != ISMD_SUCCESS)
{
CLog::Log(LOGERROR, "%s ismd_audio_input_set_data_format failed. retrying %d %d", __DEBUG_ID__, counter, result);
counter++;
usleep(1000);
}
else
break;
}
switch( ismdAudioInputFormat )
{
case ISMD_AUDIO_MEDIA_FMT_DD:
CLog::Log(LOGDEBUG, "%s: Initialize DD detected", __DEBUG_ID__);
bHDMIPassthrough = bSPDIFPassthrough = true;
break;
case ISMD_AUDIO_MEDIA_FMT_DD_PLUS:
CLog::Log(LOGDEBUG, "%s: Initialize DD Plus detected", __DEBUG_ID__);
bHDMIPassthrough = true;
// check special case for DD+->DD using DDCO
if(bAC3Encode)
{
CLog::Log(LOGDEBUG, "%s: Initialize EAC3->AC3 transcoding is on", __DEBUG_ID__);
bHDMIPassthrough = false;
bAC3Encode = true;
ConfigureDolbyPlusModes(audioProcessor, m_audioDevice, bAC3Encode);
}
break;
case ISMD_AUDIO_MEDIA_FMT_DTS:
case ISMD_AUDIO_MEDIA_FMT_DTS_LBR:
CLog::Log(LOGDEBUG, "%s: Initialize DTS detected", __DEBUG_ID__);
bHDMIPassthrough = bSPDIFPassthrough = true;
break;
case ISMD_AUDIO_MEDIA_FMT_DTS_HD:
case ISMD_AUDIO_MEDIA_FMT_DTS_HD_MA:
case ISMD_AUDIO_MEDIA_FMT_DTS_HD_HRA:
CLog::Log(LOGDEBUG, "%s: Initialize DTS-HD detected", __DEBUG_ID__);
bHDMIPassthrough = true;
outputSampleRate = format.m_encodedRate;
channels = 2;
break;
case ISMD_AUDIO_MEDIA_FMT_TRUE_HD:
CLog::Log(LOGDEBUG, "%s: Initialize TrueHD detected", __DEBUG_ID__);
bHDMIPassthrough = true;
outputSampleRate = format.m_encodedRate;
channels = 2;
break;
case ISMD_AUDIO_MEDIA_FMT_PCM:
result = ismd_audio_input_set_pcm_format(audioProcessor, m_audioDevice, uiBitsPerSample, format.m_sampleRate, inputChannelConfig);
if (result != ISMD_SUCCESS)
{
CLog::Log(LOGERROR, "%s - ismd_audio_input_set_pcm_format: %d", __DEBUG_ID__, result);
// return false;
}
break;
default:
break;
}
// I2S. Nothing to touch here. we always use defaults
// SPIDF
if(bIsSPDIF)
{
ismd_audio_output_t OutputSPDIF = g_IntelSMDGlobals.GetSPDIFOutput();
ismd_audio_output_config_t spdif_output_config;
ConfigureAudioOutputParams(spdif_output_config, AE_DEVTYPE_IEC958, uiUsedBitsPerSample,
outputSampleRate, channels, ismdAudioInputFormat, bSPDIFPassthrough, bAC3Encode);
if(!g_IntelSMDGlobals.ConfigureAudioOutput(OutputSPDIF, spdif_output_config))
{
CLog::Log(LOGERROR, "%s ConfigureAudioOutput SPDIF failed %d", __DEBUG_ID__, result);
// return false;
}
//format.m_sampleRate = spdif_output_config.sample_rate;
}
// HDMI
if(bIsHDMI)
{
ismd_audio_output_t OutputHDMI = g_IntelSMDGlobals.GetHDMIOutput();
ismd_audio_output_config_t hdmi_output_config;
ConfigureAudioOutputParams(hdmi_output_config, AE_DEVTYPE_HDMI, uiUsedBitsPerSample,
outputSampleRate, channels, ismdAudioInputFormat, bHDMIPassthrough, bAC3Encode);
if(!g_IntelSMDGlobals.ConfigureAudioOutput(OutputHDMI, hdmi_output_config))
{
CLog::Log(LOGERROR, "%s ConfigureAudioOutput HDMI failed %d", __DEBUG_ID__, result);
return false;
}
//format.m_sampleRate = hdmi_output_config.sample_rate;
}
// Configure the master clock frequency
CLog::Log(LOGINFO, "%s ConfigureMasterClock %d", __DEBUG_ID__, format.m_sampleRate);
g_IntelSMDGlobals.ConfigureMasterClock(format.m_sampleRate);
bSPDIFPassthrough = bIsSPDIF && bSPDIFPassthrough;
bHDMIPassthrough = bIsHDMI && bHDMIPassthrough;
ismd_audio_input_pass_through_config_t passthrough_config;
memset(&passthrough_config, 0, sizeof(&passthrough_config));
if (bSPDIFPassthrough || bHDMIPassthrough)
{
passthrough_config.is_pass_through = TRUE;
passthrough_config.supported_format_count = 1;
passthrough_config.supported_formats[0] = ismdAudioInputFormat;
}
result = ismd_audio_input_set_as_primary(audioProcessor, m_audioDevice, passthrough_config);
if (result != ISMD_SUCCESS)
{
CLog::Log(LOGERROR, "%s ismd_audio_input_set_as_primary failed %d", __DEBUG_ID__, result);
// return false;
}
if(!g_IntelSMDGlobals.EnableAudioInput(m_audioDevice))
{
CLog::Log(LOGERROR, "%s EnableAudioInput", __DEBUG_ID__);
// return false;
}
// enable outputs
if (bIsHDMI)
{
if(!g_IntelSMDGlobals.EnableAudioOutput(g_IntelSMDGlobals.GetHDMIOutput()))
{
CLog::Log(LOGERROR, "%s EnableAudioOutput HDMI failed", __DEBUG_ID__);
// return false;
}
}
if (bIsSPDIF)
{
if(!g_IntelSMDGlobals.EnableAudioOutput(g_IntelSMDGlobals.GetSPDIFOutput()))
{
CLog::Log(LOGERROR, "%s EnableAudioOutput SPDIF failed", __DEBUG_ID__);
// return false;
}
}
if (bIsAnalog)
{
if(!g_IntelSMDGlobals.EnableAudioOutput(g_IntelSMDGlobals.GetI2SOutput()))
{
CLog::Log(LOGERROR, "%s EnableAudioOutput I2S failed", __DEBUG_ID__);
// return false;
}
}
g_IntelSMDGlobals.SetAudioDeviceState(ISMD_DEV_STATE_PLAY, m_audioDevice);
// m_fCurrentVolume = g_settings.m_fVolumeLevel;
//g_IntelSMDGlobals.SetMasterVolume(m_fCurrentVolume);
m_bPause = false;
m_dSampleRate = format.m_sampleRate;
m_bIsAllocated = true;
// set latency when using passthrough since we are not using a timed audio interface
if (bAC3Encode || ismdAudioInputFormat == ISMD_AUDIO_MEDIA_FMT_DD)
m_latency = 0.675;//0.45;
CLog::Log(LOGINFO, "%s done", __DEBUG_ID__);
return true;
}
int PSSendOps(void *arg)
{
int i;
int ps_index;
int status = 0;
PSCmdPacket *HciCmdList; /* List storing the commands */
const struct firmware* firmware;
A_UINT32 numCmds;
A_UINT8 *event;
A_UINT8 *bufferToFree;
struct hci_dev *device;
A_UCHAR *buffer;
A_UINT32 len;
A_UINT32 DevType;
A_UCHAR *PsFileName;
A_UCHAR *patchFileName;
A_UCHAR patch_loc[40];
A_UCHAR *path = NULL;
A_UCHAR *config_path = NULL;
A_UCHAR config_bdaddr[MAX_BDADDR_FORMAT_LENGTH];
AR3K_CONFIG_INFO *hdev = (AR3K_CONFIG_INFO*)arg;
struct device *firmwareDev = NULL;
A_UINT8 cFlags = 0;
A_UINT8 bit7 = 0;
status = 0;
HciCmdList = NULL;
#ifdef HCI_TRANSPORT_SDIO
device = hdev->pBtStackHCIDev;
firmwareDev = device->parent;
#else
device = hdev;
firmwareDev = &device->dev;
AthEnableSyncCommandOp(TRUE);
#endif /* HCI_TRANSPORT_SDIO */
/* First verify if the controller is an FPGA or ASIC, so depending on the device type the PS file to be written will be different.
*/
path =(A_UCHAR *)A_MALLOC(MAX_FW_PATH_LEN);
if(path == NULL) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Malloc failed to allocate %d bytes for path\n", MAX_FW_PATH_LEN));
goto complete;
}
config_path = (A_UCHAR *) A_MALLOC(MAX_FW_PATH_LEN);
if(config_path == NULL) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Malloc failed to allocate %d bytes for config_path\n", MAX_FW_PATH_LEN));
goto complete;
}
if(A_ERROR == getDeviceType(hdev,&DevType)) {
status = 1;
goto complete;
}
if(A_ERROR == ReadVersionInfo(hdev)) {
status = 1;
goto complete;
}
patchFileName = PATCH_FILE;
snprintf(path, MAX_FW_PATH_LEN, "%s/%xcoex/",CONFIG_PATH,Rom_Version);
if(DevType){
if(DevType == 0xdeadc0de){
PsFileName = PS_ASIC_FILE;
} else{
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,(" FPGA Test Image : %x %x \n",Rom_Version,Build_Version));
if((Rom_Version == 0x99999999) && (Build_Version == 1)){
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("FPGA Test Image : Skipping Patch File load\n"));
patchFileName = NULL;
}
PsFileName = PS_FPGA_FILE;
}
}
else{
PsFileName = PS_ASIC_FILE;
}
snprintf(config_path, MAX_FW_PATH_LEN, "%s%s",path,PsFileName);
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%x: FPGA/ASIC PS File Name %s\n", DevType,config_path));
/* Read the PS file to a dynamically allocated buffer */
if(A_REQUEST_FIRMWARE(&firmware,config_path,firmwareDev) < 0) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: firmware file open error\n", __FUNCTION__ ));
status = 1;
goto complete;
}
if(NULL == firmware || firmware->size == 0) {
status = 1;
goto complete;
}
buffer = (A_UCHAR *)A_MALLOC(firmware->size);
if(buffer != NULL) {
/* Copy the read file to a local Dynamic buffer */
memcpy(buffer,firmware->data,firmware->size);
len = firmware->size;
A_RELEASE_FIRMWARE(firmware);
/* Parse the PS buffer to a global variable */
status = AthDoParsePS(buffer,len);
A_FREE(buffer);
} else {
A_RELEASE_FIRMWARE(firmware);
}
/* Read the patch file to a dynamically allocated buffer */
if(patchFileName != NULL)
snprintf(config_path,
MAX_FW_PATH_LEN, "%s%s",path,patchFileName);
else {
status = 0;
}
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Patch File Name %s\n", config_path));
if((patchFileName == NULL) || (A_REQUEST_FIRMWARE(&firmware,config_path,firmwareDev) < 0)) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: firmware file open error\n", __FUNCTION__ ));
/*
* It is not necessary that Patch file be available, continue with PS Operations if.
* failed.
*/
status = 0;
} else {
if(NULL == firmware || firmware->size == 0) {
status = 0;
} else {
buffer = (A_UCHAR *)A_MALLOC(firmware->size);
if(buffer != NULL) {
/* Copy the read file to a local Dynamic buffer */
memcpy(buffer,firmware->data,firmware->size);
len = firmware->size;
A_RELEASE_FIRMWARE(firmware);
/* parse and store the Patch file contents to a global variables */
patch_loc[0] = '\0';
status = AthDoParsePatch(buffer,len, patch_loc);
A_FREE(buffer);
} else {
A_RELEASE_FIRMWARE(firmware);
}
}
}
/* Create an HCI command list from the parsed PS and patch information */
AthCreateCommandList(&HciCmdList,&numCmds);
#define CONFIG_PLATFORM 0x21
#define CONFIG_TLPM 0x23
#define PLATFORM_CONFIG_BIT 0x01
#define TLPM_CONFIG_BIT 0x02
#define IDLE_TIMEOUT_OFFSET 12
#define WAKEUP_TIMEOUT_OFFSET 8
#define IDLE_TIMEOUT_DEFAULT_VAL 1000
#define WAKEUP_TIMEOUT_DEFAULT_VAL 10
hdev->IdleTimeout = IDLE_TIMEOUT_DEFAULT_VAL;
hdev->WakeupTimeout = WAKEUP_TIMEOUT_DEFAULT_VAL;
hdev->PwrMgmtEnabled = 0;
ps_index = 2; /* CRC + PS Reset */
if (Patch_Count)
ps_index += Patch_Count + 1; /* Patches + Enable patch Cmd */
for(i = ps_index; i <numCmds; i++) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Check PS ID %x\n", HciCmdList[i].Hcipacket[4]));
/* search for Platform config and TLPM tags */
if((HciCmdList[i].Hcipacket[4] == CONFIG_PLATFORM) &&
(HciCmdList[i].Hcipacket[5] == 0)) {
cFlags |= PLATFORM_CONFIG_BIT;
bit7 = (HciCmdList[i].Hcipacket[7]) & (1<<7);
if(bit7) {
hdev->PwrMgmtEnabled = 1;
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("CONFIG PLATFORM present and Pwr Manage %x\n", hdev->PwrMgmtEnabled));
}
}
else if((HciCmdList[i].Hcipacket[4] == CONFIG_TLPM) &&
(HciCmdList[i].Hcipacket[5] == 0)) {
cFlags |= TLPM_CONFIG_BIT;
hdev->IdleTimeout = *((A_UINT32 *)&HciCmdList[i].Hcipacket[IDLE_TIMEOUT_OFFSET + 7]);
hdev->WakeupTimeout = *((A_UINT16 *)&HciCmdList[i].Hcipacket[WAKEUP_TIMEOUT_OFFSET + 7]);
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("hdev->idletimeout %d hdev->WakeupTimeout %d",hdev->IdleTimeout, hdev->WakeupTimeout));
}
}
/* Form the parameter for PSSendOps() API */
/*
* First Send the CRC packet,
* We have to continue with the PS operations only if the CRC packet has been replied with
* a Command complete event with status Error.
*/
if(SendHCICommandWaitCommandComplete
(hdev,
HciCmdList[0].Hcipacket,
HciCmdList[0].packetLen,
&event,
&bufferToFree) == A_OK) {
if(ReadPSEvent(event) == A_OK) { /* Exit if the status is success */
if(bufferToFree != NULL) {
A_FREE(bufferToFree);
}
#ifndef HCI_TRANSPORT_SDIO
if(bdaddr && bdaddr[0] !='\0') {
write_bdaddr(hdev,bdaddr,BDADDR_TYPE_STRING);
}
#endif
status = 1;
goto complete;
}
if(bufferToFree != NULL) {
A_FREE(bufferToFree);
}
} else {
status = 0;
goto complete;
}
/* Set Patch location */
if(patch_loc[0] != '\0') {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Setting Patch Location %s\n", patch_loc));
set_patch_ram(hdev,patch_loc,sizeof(patch_loc));
}
for(i = 1; i <numCmds; i++) {
Hci_log("PS/Patch Write -->",HciCmdList[i].Hcipacket,HciCmdList[i].packetLen);
if(SendHCICommandWaitCommandComplete
(hdev,
HciCmdList[i].Hcipacket,
HciCmdList[i].packetLen,
&event,
&bufferToFree) == A_OK) {
if(ReadPSEvent(event) != A_OK) { /* Exit if the status is success */
if(bufferToFree != NULL) {
A_FREE(bufferToFree);
}
status = 1;
goto complete;
}
if(bufferToFree != NULL) {
A_FREE(bufferToFree);
}
} else {
status = 0;
goto complete;
}
}
#ifdef HCI_TRANSPORT_SDIO
if(BDADDR == FALSE)
if(hdev->bdaddr[0] !=0x00 ||
hdev->bdaddr[1] !=0x00 ||
hdev->bdaddr[2] !=0x00 ||
hdev->bdaddr[3] !=0x00 ||
hdev->bdaddr[4] !=0x00 ||
hdev->bdaddr[5] !=0x00)
write_bdaddr(hdev,hdev->bdaddr,BDADDR_TYPE_HEX);
/* if Platform config is present and TLPM is not available
* write HCI command for TLPM with default timeout values */
if(bit7 && !(cFlags & TLPM_CONFIG_BIT)) {
A_UCHAR TLPMHciCmd[] = {0x0b, 0xfc, 0x1c, 0x01, 0x23, 0x00, 0x18,
0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
0x00, 0x0a, 0x00, 0x0a, 0x00, 0xe8, 0x03,
0x00, 0x00, 0xe8, 0x03, 0x00, 0x00, 0xe8,
0x03, 0x00, 0x00 };
int CmdLen = sizeof(TLPMHciCmd);
*((A_UINT32 *)&TLPMHciCmd[IDLE_TIMEOUT_OFFSET + 7]) = hdev->IdleTimeout;
*((A_UINT16 *)&TLPMHciCmd[WAKEUP_TIMEOUT_OFFSET + 7]) = hdev->WakeupTimeout;
if(SendHCICommandWaitCommandComplete
(hdev,
TLPMHciCmd,
CmdLen,
&event,
&bufferToFree) == A_OK) {
if(ReadPSEvent(event) != A_OK) { /* Exit if the status is success */
if(bufferToFree != NULL) {
A_FREE(bufferToFree);
}
status = 1;
goto complete;
}
if(bufferToFree != NULL) {
A_FREE(bufferToFree);
}
} else {
status = 0;
goto complete;
}
}
#ifndef HCI_TRANSPORT_SDIO
if(bdaddr && bdaddr[0] != '\0') {
write_bdaddr(hdev,bdaddr,BDADDR_TYPE_STRING);
} else
#endif /* HCI_TRANSPORT_SDIO */
/* Write BDADDR Read from OTP here */
#endif
{
/* Read Contents of BDADDR file if user has not provided any option */
snprintf(config_path,MAX_FW_PATH_LEN, "%s%s",path,BDADDR_FILE);
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BDADDR File Name %s\n", config_path));
if(A_REQUEST_FIRMWARE(&firmware,config_path,firmwareDev) < 0) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: firmware file open error\n", __FUNCTION__ ));
goto complete;
}
if(NULL == firmware || firmware->size == 0) {
goto complete;
}
len = (firmware->size > MAX_BDADDR_FORMAT_LENGTH)? MAX_BDADDR_FORMAT_LENGTH: firmware->size;
memcpy(config_bdaddr, firmware->data,len);
config_bdaddr[len] = '\0';
write_bdaddr(hdev,config_bdaddr,BDADDR_TYPE_STRING);
A_RELEASE_FIRMWARE(firmware);
}
complete:
#ifndef HCI_TRANSPORT_SDIO
AthEnableSyncCommandOp(FALSE);
PSTagMode = FALSE;
wake_up_interruptible(&PsCompleteEvent);
#endif /* HCI_TRANSPORT_SDIO */
if(NULL != HciCmdList) {
AthFreeCommandList(&HciCmdList,numCmds);
}
if(path) {
A_FREE(path);
}
if(config_path) {
A_FREE(config_path);
}
return status;
}
int command_can_open_ex(int bus, int type, int index)
{
assert(bus >= 1 && bus <= CH_COUNT);
assert(type >= 1 && type < 9/*eCanDevType_COUNT*/);
assert(index >= 1 && index <= 8);
int ret = 0;
PCHDSNAPSHOT pBuffer = NULL;
unsigned long u32NeededBufferSize, u32NumOfChannels, u32ProvidedBufferSize, channelIndex;
int sw_version, fw_version, hw_version, license, chip_type, i;
////////////////////////////////////////////////////////////////////////
// Set buffer size
u32ProvidedBufferSize = 0;
// call the function without a valid buffer size first to get the needed buffersize in "u32NeededBufferSize"
ret = CANL2_get_all_CAN_channels(0, &u32NeededBufferSize, &u32NumOfChannels, NULL);
if(!u32NumOfChannels)
{
printf("you have no Softing CAN interface card plugged in your Computer!\n");
printf("plug a interface card first and start this program again after this.\n");
return -1;
}
if(ret)
{
printf("The driver reported a problem: Error Code %x\n", ret);
return -1;
}
pBuffer = (PCHDSNAPSHOT)malloc(u32NeededBufferSize);
u32ProvidedBufferSize = u32NeededBufferSize;
ret = CANL2_get_all_CAN_channels(u32ProvidedBufferSize, &u32NeededBufferSize, &u32NumOfChannels, pBuffer);
if(ret)
{
printf("The driver reported a problem: Error Code %x\n", ret);
return -1;
}
printf("You have %u Softing CAN channels in your system\n\n", u32NumOfChannels);
printf("\tname\t\t serialnumber\t type\t\t chan.\t open\n");
printf("------------------------------------------------------------------------\n");
printf("\n");
for (channelIndex=0; channelIndex<u32NumOfChannels; channelIndex++)
{
PCHDSNAPSHOT pCh = &pBuffer[channelIndex];
printf("% 17s\t %09u % 18s\t %2u\t % 5s\n",
pCh->ChannelName,
pCh->u32Serial,
getDeviceType(pCh->u32DeviceType),
pCh->u32PhysCh,
(pCh->bIsOpen) ? "yes" : "no");
}
////////////////////////////////////////////////////////////////////////
// Init Channel
char ch_name[256];
sprintf_s(ch_name, 256, "%s_%d", szCanDevType[type], index);
printf("Open CAN channel[%d]: %s...\n", bus, ch_name);
//hCAN[0] = -1;
ret = INIL2_initialize_channel(&hCAN[bus-1], ch_name);
if (ret)
{
switch (ret) {
case -536215551: printf(" Internal Error.\n"); break;
case -536215550: printf(" General Error.\n"); break;
case -536215546: printf(" Illegal driver call.\n"); break;
case -536215542: printf(" Driver not loaded / not installed, or device is not plugged.\n"); break;
case -536215541: printf(" Out of memory.\n"); break;
case -536215531: printf(" An error occurred while hooking the interrupt service routine.\n"); break;
case -536215523: printf(" Device not found.\n"); break;
case -536215522: printf(" Can not get a free address region for DPRAM from system.\n"); break;
case -536215521: printf(" Error while accessing hardware.\n"); break;
case -536215519: printf(" Can not access the DPRAM memory.\n"); break;
case -536215516: printf(" Interrupt does not work/Interrupt test failed!\n"); break;
case -536215514: printf(" Device is already open.\n"); break;
case -536215512: printf(" An incompatible firmware is running on that device. (CANalyzer/CANopen/DeviceNet firmware)\n"); break;
case -536215511: printf(" Channel can not be accessed, because it is not open.\n"); break;
case -536215500: printf(" Error while calling a Windows function.\n"); break;
case -1002: printf(" Too many open channels.\n"); break;
case -1003: printf(" Wrong DLL or driver version.\n"); break;
case -1004: printf(" Error while loading the firmware. (This may be a DPRAM access error)\n"); break;
case -1: printf(" Function not successful.\n"); break;
}
printf("\tError: CAN open\n");
return ret;
}
///////////////////////////////////////////////////////////////////////
// Reset Chip
// ret = CANL2_reset_chip(hCAN[bus-1]);
// if (ret)
// {
// printf("\tError: CAN reset chip\n");
// INIL2_close_channel(hCAN[bus-1]);
// hCAN[bus-1] = 0;
// return ret;
// }
///////////////////////////////////////////////////////////////////////
// Init Chip
// ret = CANL2_initialize_chip(hCAN[bus-1], 1, 1, 4, 3, 0);
// if (ret)
// {
// printf("\tError: CAN set baud rate\n");
// INIL2_close_channel(hCAN[bus-1]);
// hCAN[bus-1] = 0;
// return ret;
// }
///////////////////////////////////////////////////////////////////////
// Set Out Control
// ret = CANL2_set_output_control(hCAN[bus-1], -1);
///////////////////////////////////////////////////////////////////////
// Enable FIFO
L2CONFIG L2Config;
L2Config.fBaudrate = 1000.0;
L2Config.bEnableAck = false;
L2Config.bEnableErrorframe = false;
L2Config.s32AccCodeStd = GET_FROM_SCIM;
L2Config.s32AccMaskStd = GET_FROM_SCIM;
L2Config.s32AccCodeXtd = GET_FROM_SCIM;
L2Config.s32AccMaskXtd = GET_FROM_SCIM;
L2Config.s32OutputCtrl = GET_FROM_SCIM;
L2Config.s32Prescaler = GET_FROM_SCIM;
L2Config.s32Sam = GET_FROM_SCIM;
L2Config.s32Sjw = GET_FROM_SCIM;
L2Config.s32Tseg1 = GET_FROM_SCIM;
L2Config.s32Tseg2 = GET_FROM_SCIM;
L2Config.hEvent = (void*)-1;
ret = CANL2_initialize_fifo_mode(hCAN[bus-1], &L2Config);
if (ret)
{
printf("\tError: CAN set fifo mode\n");
INIL2_close_channel(hCAN[bus-1]);
hCAN[bus-1] = 0;
return ret;
}
///////////////////////////////////////////////////////////////////////
// Print driver version info
ret = CANL2_get_version(hCAN[bus-1], &sw_version, &fw_version, &hw_version, &license, &chip_type);
if (ret)
{
printf("Error %u in CANL2_get_version()\n",ret);
}
else
{
printf("\n VERSION INFO: \n\n");
printf(" - Software version: %u.%02u\n", sw_version/100, sw_version%100);
printf(" - Firmware version: %u.%02u\n", fw_version/100, fw_version%100);
printf(" - Hardware version: %x.%02x\n", hw_version/0x100, hw_version%0x100);
printf(" - CAN chip : %s\n", (chip_type==1000)? "SJA1000": (chip_type==161) ? "Infineon XC161" : "Infineon XE164");
}
return 0;
}
jstring Java_opencl_executor_Executor_getDeviceType(JNIEnv * env, jclass)
{
auto type = getDeviceType();
return env->NewStringUTF(type.c_str());
}
