STATIC int
max5478_ioctl(int unit, int devno,
              int request, void* data, int len)
{
    int rv = SOC_E_NONE;
    uint16 msg0;
    uint8  msg1;
    max5478_t *params;

    switch (request) {
    case I2C_POT_IOC_SET:
        params = (max5478_t *)data;
        switch (params->wiper) {
        case I2C_POT_MSG_WIPER_A:
             msg0 = MAX5478_CMD_WIPER_A_VREG;
             msg1 = MAX5478_CMD_WIPER_A_VREG_X_NVREG;
            break;

        case I2C_POT_MSG_WIPER_B:
            msg0 = MAX5478_CMD_WIPER_B_CMD;
            msg1 = MAX5478_CMD_WIPER_B_VREG_X_NVREG;
            break;

        default:
            LOG_VERBOSE(BSL_LS_SOC_COMMON,
                        (BSL_META_U(unit,
                                    "POT%d: invalid wiper %d\n"),
                         devno, params->wiper));
            return SOC_E_PARAM;
        }

        /* Command byte VREG + data byte */
        msg0 = (msg0 << 8) | params->value;
        rv = soc_i2c_write_word(unit, soc_i2c_addr(unit, devno), msg0);
        if (rv == SOC_E_NONE) {
            soc_i2c_device(unit, devno)->tbyte +=2;
        }

        /* Transfer VREG to NVREG */
        rv = soc_i2c_write_byte(unit, soc_i2c_addr(unit, devno), msg1);
        if (rv == SOC_E_NONE) {
            soc_i2c_device(unit, devno)->tbyte++;
        }

        break;

    default:
        LOG_VERBOSE(BSL_LS_SOC_COMMON,
                    (BSL_META_U(unit,
                                "POT%d: invalid request %d\n"),
                     devno, request));
        return SOC_E_PARAM;
    }
    return rv;
}

Handle openFileHandle(const char *path, u32 openFlags) {
  Handle fileHandle = 0;
  
  LOG_VERBOSE("openFileHandle: %s, %d", path, openFlags);
  FS_Path filePath = fsMakePath(PATH_ASCII, path);
  if(R_FAILED(FSUSER_OpenFile(&fileHandle, sdmcArchive, filePath, openFlags, 0))) {
    LOG_VERBOSE("FSUSER_OpenFile failed.");
    return(0);
  }
  
  LOG_VERBOSE("File opened successfully.");
  return(fileHandle);
}

Handle openDirectory(const char *path) {
  Handle dir;

  LOG_VERBOSE("openDirectory: %s", path);
  FS_Path filePath = fsMakePath(PATH_ASCII, path);
  if(R_FAILED(FSUSER_OpenDirectory(&dir, sdmcArchive, filePath))) {
    LOG_VERBOSE("FSUSER_OpenDirectory failed.");
    return(0);
  }
  
  LOG_VERBOSE("Directory opened successfully.");
  return(dir);
}

hash_map_t *hash_map_utils_new_from_string_params(const char *params) {
  assert(params != NULL);

  hash_map_t *map = hash_map_new(BUCKETS_NUM, hash_function_string, osi_free,
                                 osi_free, string_equals);
  if (!map)
    return NULL;

  char *str = osi_strdup(params);
  if (!str)
    return NULL;

  LOG_VERBOSE(LOG_TAG, "%s: source string: '%s'", __func__, str);

  // Parse |str| and add extracted key-and-value pair(s) in |map|.
  int items = 0;
  char *tmpstr;
  char *kvpair = strtok_r(str, ";", &tmpstr);
  while (kvpair && *kvpair) {
    char *eq = strchr(kvpair, '=');

    if (eq == kvpair)
      goto next_pair;

    char *key;
    char *value;
    if (eq) {
      key = osi_strndup(kvpair, eq - kvpair);

      // The increment of |eq| moves |eq| to the beginning of the value.
      ++eq;
      value = (*eq != '\0') ? osi_strdup(eq) : osi_strdup("");
    } else {
      key = osi_strdup(kvpair);
      value = osi_strdup("");
    }

    hash_map_set(map, key, value);

    items++;
next_pair:
    kvpair = strtok_r(NULL, ";", &tmpstr);
  }

  if (!items)
    LOG_VERBOSE(LOG_TAG, "%s: no items found in string\n", __func__);

  osi_free(str);
  return map;
}

/*
 * Function:
 *     board_probe
 * Purpose:
 *     Iterates across all registered board drivers, from the highest
 *     priority value to the lowest, and returns the name of the first
 *     board driver whose probe function returns BCM_E_NONE.
 * Parameters:
 *     none
 * Returns:
 *     !NULL - success
 *     NULL  - failed
 *
 */
char *
board_probe(void)
{
    board_reg_t *reg;
    bcm_info_t  *dev;
    int count;
    int rv = BCM_E_INTERNAL;
    char *name = NULL;

    BOARD_INIT_NULL;
    BOARD_LOCK;
    rv = _board_info(&count, &dev);

    if (BCM_SUCCESS(rv)) {
#if defined(BROADCOM_DEBUG)
        {
            int i;

            LOG_VERBOSE(BSL_LS_BOARD_COMMON,
                        (BSL_META("Board probe:\n")));
            for (i=0; i<count; i++) {
                LOG_VERBOSE(BSL_LS_BOARD_COMMON,
                            (BSL_META("  %2d: %s\n"),
                             i, board_device_name(i)));
            }
        }
#endif

        /* For each set of registered drivers */
        for (reg=driver_reg; reg != NULL; reg=reg->next) {
            if (!reg->driver->probe) {
                LOG_VERBOSE(BSL_LS_BOARD_COMMON,
                            (BSL_META("Board %s probe missing\n"),
                             reg->driver->name));
                continue;
            }
            rv = reg->driver->probe(reg->driver, count, dev);
            if (BCM_SUCCESS(rv)) {
                /* Board probe successful */
                name = reg->driver->name;
                break;
            }
        }

        FREE(dev);
    }
    BOARD_UNLOCK;

    return BCM_SUCCESS(rv) ? name : NULL;
}

int
pci_test(int u, args_t *a, void *pa)
/*
 * Function: 	pci_test
 * Purpose:	Test basic PCI stuff on StrataSwitch.
 * Parameters:	u - unit #.
 *		a - pointer to arguments.
 *		pa - ignored cookie.
 * Returns:	0
 */
{
    int		i;

    COMPILER_REFERENCE(a);
    COMPILER_REFERENCE(pa);

    setup_pca_table(u);


    for (i = 0; i < pca_cnt; i++) {
	pca_t *p = &pca_table[i];
	uint32	read_val;

	/* If write - do write first */

	if (p->pca_flags & WR) {
	    LOG_VERBOSE(BSL_LS_APPL_TESTS,
                        (BSL_META_U(u,
                                    "Writing PCI Config 0x%x <--- 0x%x\n"),
                         p->pca_addr, p->pca_write));
	    if (bde->pci_conf_write(u, p->pca_addr, p->pca_write)){
		test_error(u, "PCI config write failed to address: 0x%x\n",
			   p->pca_addr);
		continue;		/* If test error returns */
	    }
	}
	read_val = bde->pci_conf_read(u, p->pca_addr);
	read_val &= p->pca_read_mask;
	LOG_VERBOSE(BSL_LS_APPL_TESTS,
                    (BSL_META_U(u,
                                "Reading PCI Config (Masked) 0x%x --> 0x%x\n"), 
                     p->pca_addr, read_val));
	if (read_val != p->pca_read) {
	    test_error(u, "PCI Config @0x%x Read 0x%x expected 0x%x\n",
		       p->pca_addr, read_val, p->pca_read);
	}
    }

    return(0);
}

/*------------------------------------------------------------------------------
|    OMX_VideoProcessor::convertMetaData
+-----------------------------------------------------------------------------*/
inline
void OMX_MediaProcessor::convertMetaData()
{
   // TODO: It would be good to lock this somehow.
   AVDictionary* dictionary = m_omx_reader->getMetadata();

   AVDictionaryEntry* tag = NULL;
   LOG_VERBOSE(LOG_TAG, "MetaData");
   m_metadata.clear();
   while ((tag = av_dict_get(dictionary, "", tag, AV_DICT_IGNORE_SUFFIX))) {
      m_metadata.insert(tag->key, tag->value);
      LOG_VERBOSE(LOG_TAG, "Key: %s, Value: %s.", tag->key, tag->value);
   }
}

/*------------------------------------------------------------------------------
|    OMX_VideoProcessor::cleanup
+-----------------------------------------------------------------------------*/
void OMX_MediaProcessor::cleanup()
{
   LOG_INFORMATION(LOG_TAG, "Cleaning up...");

#if 0
   if (m_refresh)
   {
      m_BcmHost.vc_tv_hdmi_power_on_best(
               tv_state.width,
               tv_state.height,
               tv_state.frame_rate,
               HDMI_NONINTERLACED,
               (EDID_MODE_MATCH_FLAG_T)(HDMI_MODE_MATCH_FRAMERATE|
                                        HDMI_MODE_MATCH_RESOLUTION|HDMI_MODE_MATCH_SCANMODE)
               );
   }
#endif

   LOG_VERBOSE(LOG_TAG, "Closing players...");
#ifdef ENABLE_SUBTITLES
   m_player_subtitles->Close();
#endif
   m_player_video->Close();
   m_player_audio->Close();

   if (m_omx_pkt) {
      m_omx_reader->FreePacket(m_omx_pkt);
      m_omx_pkt = NULL;
   }

   LOG_VERBOSE(LOG_TAG, "Closing players...");
   m_omx_reader->Close();
   m_metadata.clear();
   emit metadataChanged(m_metadata);

   vc_tv_show_info(0);

   // lcarlon: free the texture. Invoke freeTexture so that it is the user
   // of the class to do it cause it is commonly required to do it in the
   // current OpenGL and EGL context. Do it here, after the stop command is
   // considered finished: this is needed to avoid hardlock in case the
   // used wants to free the texture in his own thread, which would still
   // be blocked waiting for the stop command to finish.
   LOG_VERBOSE(LOG_TAG, "Freeing texture...");
   m_provider->freeTexture(m_textureData);
   m_textureData = NULL;
   emit textureInvalidated();

   LOG_INFORMATION(LOG_TAG, "Cleanup done.");
}

	bool fill_input_buffer(std::string &error) {
		if (0 == strm.avail_in) {
			const unsigned char *data;
			ssize_t datasize;
			LOG_VERBOSE("fill_input_buffer: reading at offset %i\n", (int) reader.offset());
			if (!reader.read(4*1024, data, datasize)) {
				error.assign(reader.lastError());
				return false;
			}
			LOG_VERBOSE("fill_input_buffer: read %i bytes\n", (int) datasize);
			strm.next_in = data;
			strm.avail_in = datasize;
		}
		return true;
	}

float MediaPlayerPrivate::maxTimeLoaded() const
{
    // TODO
    LOG_VERBOSE(Media, "maxTimeLoaded");
    notImplemented();
    return duration();
}

float MediaPlayerPrivate::maxTimeBuffered() const
{
    notImplemented();
    LOG_VERBOSE(Media, "maxTimeBuffered");
    // rtsp streams are not buffered
    return m_isStreaming ? 0 : maxTimeLoaded();
}

/**
 * Disconnect and clean up
 *
 * @param icb The connection control block
 */
static void
cleanup_disconnect(connection_t *cxn)
{
    uint8_t *data;
    biglist_t *ble;

    cxn->status.disconnect_count++;

    /* Close this socket. */
    if (cxn->sd >= 0) {
        ind_soc_socket_unregister(cxn->sd);
        close(cxn->sd);
    }
    cxn->sd = -1;

    cxn->generation_id++;

    /* @fixme Is it possible there's a message that should be processed? */
    LOG_VERBOSE(cxn, "Closing connection, current read buf has %d bytes",
                cxn->read_bytes);
    cxn->read_bytes = 0;
    /* Clear write queue */
    BIGLIST_FOREACH_DATA(ble, cxn->output_list, uint8_t *, data) {
        LOG_TRACE(cxn, "Freeing outgoing msg %p", data);
        INDIGO_MEM_FREE(data);
    }
    biglist_free(cxn->output_list);
    cxn->output_list = NULL;

    cxn->bytes_enqueued = 0;
    cxn->pkts_enqueued = 0;
    cxn->output_head_offset = 0;
}

void getAllOpenGLEntryPoints()
{
    static bool haveProcs = false;
    if(haveProcs) return;

#define GET_PROC(name) *((void**)&name) = wglGetProcAddress(#name); DENG2_ASSERT(name != 0)

    LOG_AS("getAllOpenGLEntryPoints");

    LOG_VERBOSE("GL_VERSION: ") << (char const *) glGetString(GL_VERSION);

    GET_PROC(glActiveTexture);
    GET_PROC(glAttachShader);
    GET_PROC(glBindAttribLocation);
    GET_PROC(glBindBuffer);
    GET_PROC(glBindFramebuffer);
    GET_PROC(glBindRenderbuffer);
    GET_PROC(glBlendEquation);
    GET_PROC(glBufferData);
    GET_PROC(glCheckFramebufferStatus);
    GET_PROC(glCompileShader);
    GET_PROC(glCreateProgram);
    GET_PROC(glCreateShader);
    GET_PROC(glDeleteBuffers);
    GET_PROC(glDeleteFramebuffers);
    GET_PROC(glDeleteProgram);
    GET_PROC(glDeleteRenderbuffers);
    GET_PROC(glDeleteShader);
    GET_PROC(glDetachShader);
    GET_PROC(glDisableVertexAttribArray);
    GET_PROC(glEnableVertexAttribArray);
    GET_PROC(glFramebufferRenderbuffer);
    GET_PROC(glFramebufferTexture2D);
    GET_PROC(glGenBuffers);
    GET_PROC(glGenFramebuffers);
    GET_PROC(glGenerateMipmap);
    GET_PROC(glGenRenderbuffers);
    GET_PROC(glGetAttribLocation);
    GET_PROC(glGetProgramInfoLog);
    GET_PROC(glGetProgramiv);
    GET_PROC(glGetShaderInfoLog);
    GET_PROC(glGetShaderiv);
    GET_PROC(glGetShaderSource);
    GET_PROC(glGetUniformLocation);
    GET_PROC(glIsBuffer);
    GET_PROC(glLinkProgram);
    GET_PROC(glRenderbufferStorage);
    GET_PROC(glShaderSource);
    GET_PROC(glUniform1f);
    GET_PROC(glUniform1i);
    GET_PROC(glUniform2f);
    GET_PROC(glUniform3f);
    GET_PROC(glUniform4f);
    GET_PROC(glUniformMatrix3fv);
    GET_PROC(glUniformMatrix4fv);
    GET_PROC(glUseProgram);
    GET_PROC(glVertexAttribPointer);

    haveProcs = true;
}

indigo_error_t
ind_core_enable_set(int enable)
{
    LOG_TRACE("OF state mgr enable called");

    INIT_CHECK;

    if (enable && !ind_core_module_enabled) {
        LOG_INFO("Enabling OF state mgr");
        if (CORE_EXPIRES_FLOWS(&ind_core_config)) {
            ind_soc_timer_event_register_with_priority(
                flow_expiration_timer, NULL,
                ind_core_config.stats_check_ms, -10);
        }
        ind_core_module_enabled = 1;
    } else if (!enable && ind_core_module_enabled) {
        LOG_INFO("Disabling OF state mgr");
        if (CORE_EXPIRES_FLOWS(&ind_core_config)) {
            ind_soc_timer_event_unregister(flow_expiration_timer, NULL);
        }
        ind_core_module_enabled = 0;
    } else {
        LOG_VERBOSE("Redundant enable call.  Currently %s",
                    ind_core_module_enabled ? "enabled" : "disabled");
    }

    return INDIGO_ERROR_NONE;
}

STATIC int
topo_sp_info_update(cpudb_entry_t *entry)
{
    int           i;
    int           unit;
    bcm_port_t    port;
    bcm_trunk_t   tid;
    bcm_module_t  modid = -1;
    int           topo_sp_max = COUNTOF(topo_sp);
    
    /* Load information from current system configuration */
    TOPO_DATA_LOCK;
    for (i = 0; i < topo_sp_max; i++) {
        unit = topo_sp[i].unit;
        port = topo_sp[i].port;
        
        if ((unit < 0) || (port < 0)) {
            continue;
        }
        
        if (BCM_SUCCESS(bcm_trunk_find(unit, modid,
                                       BCM_GPORT_DEVPORT(unit, port), &tid))) {
            topo_sp[i].tid = tid;
        } else {
            topo_sp[i].tid = -1;
        }
        LOG_VERBOSE(BSL_LS_TKS_TOPOLOGY,
                    (BSL_META_U(unit,
                    "Stack port %d: unit %d, port %d, tid %d\n"),
                     i, unit, port, topo_sp[i].tid));
    }
    TOPO_DATA_UNLOCK;

    return BCM_E_NONE;
}

bool CCabManager::Init(std::vector<TCabinetPtr> aCabinets, const TIndexData& aIndexValues)
{
   LOG_METHOD();
   iCabinets.swap(aCabinets);
   iResourceIndex.clear();
   iFileIndex.clear();
   const TSize size = iCabinets.size();
   if (size == 0) {
      return false;
   }
   if (size > 1) {
      std::stable_sort(iCabinets.begin(), iCabinets.end(), CmpCabinetsByPatch);
   }

   // Create the file prefix index
   LOG_DEBUG("Creating file prefix index");
   for (uint8_t i = static_cast<uint8_t>(size); i > 0; i--) {
      MergeIntoFileList(i-1, iCabinets[i-1]->GetFilePrefixList());
   }

   // Create the quick access index
   LOG_DEBUG("Creating quick access index");
   iResourceIndex.resize(aIndexValues.size() + 1, TIndexEntry(KINVALID, 0));
   for (const auto& resourceEntry : aIndexValues) {
      std::vector<TFileEntry>::iterator it = std::lower_bound(iFileIndex.begin(), iFileIndex.end(),
         resourceEntry.second, CmpFileNameIndex);
      if ((it != iFileIndex.end()) && (std::get<0>(*it) == resourceEntry.second)) {
         LOG_VERBOSE("Adding resource index to %d: %d, %s", resourceEntry.first, (int)std::get<2>(*it), resourceEntry.second.c_str());
         iResourceIndex[resourceEntry.first] = TIndexEntry(std::get<1>(*it), std::get<2>(*it));
      } else LOG_ERROR("File not found in cabinet index: %s", resourceEntry.second.c_str());
   }
   return true;
}

QVariant SongListStandardItemModel::data(
        const QModelIndex & index,
        int role) const
{
    LOG_VERBOSE(__FUNCTION_NAME__);

    /* for the time being, I put static data into the model.
       if this causes performance issue, then I will consider dynamic data fetching.
    */

#if 0
    if(role == Qt::CheckStateRole && index.column() != 4)
    {
        return QVariant();
    }

    switch(index.column())
    {
        case 0:
            return QVariant(songs->at(index.column())->name.c_str());
        case 1:
            return QVariant(songs->at(index.column())->url.c_str());
        case 2:
            return QVariant(songs->at(index.column())->artistName.c_str());
        default:
            break;
    }
#endif

    return QStandardItemModel::data(index,role);
}

bool ProgSymbolWriter::writeSymbolsToFile(const Prog *prog, const QString &dstFileName)
{
    LOG_VERBOSE("Writing symbols to '%1'", dstFileName);
    const QString fname = prog->getProject()->getSettings()->getOutputDirectory().absoluteFilePath(
        dstFileName);
    QSaveFile tgt(fname);

    if (!tgt.open(QFile::WriteOnly)) {
        LOG_ERROR("Cannot open '%1' for writing", fname);
        return false;
    }

    OStream f(&tgt);

    /* Print procs */
    f << "/* Functions: */\n";
    std::set<Function *> seen;

    for (UserProc *up : prog->getEntryProcs()) {
        printProcsRecursive(up, 0, f, seen);
    }

    f << "/* Leftovers: */\n";

    for (const auto &m : prog->getModuleList()) {
        for (Function *pp : *m) {
            if (!pp->isLib() && (seen.find(pp) == seen.end())) {
                printProcsRecursive(pp, 0, f, seen);
            }
        }
    }

    f.flush();
    return tgt.commit();
}

	bool decodeFillBuffer(std::string &error) {
		for (;0 != strm.avail_out;) {
			LOG_VERBOSE("decodeFillBuffer: %i bytes to go\n", (int) strm.avail_out);

			if (!fill_input_buffer(error)) return false;

			if (0 == strm.avail_in) {
				error.assign("Unexpected end of file");
				return false;
			}

			lzma_ret ret = lzma_code(&strm, LZMA_RUN);
			if (LZMA_OK != ret && LZMA_STREAM_END != ret) {
				errnoLzmaToStr("failed decoding data", ret, error);
				return false;
			}

			if (0 == strm.avail_out) return true; // done filling buffer

			if (LZMA_STREAM_END == ret) {
				if (lzma_index_iter_next(&iter, LZMA_INDEX_ITER_ANY)) {
					error.assign("Unexepected end of file");
					return false;
				}
				/* restart decoder */
				if (!loadBlock(error)) return false;
			}
		}
		return true;
	}

	void selectDefaultBuffer() {
		LOG_VERBOSE("selectDefaultBuffer\n");
		/* selectBuffer flushes the current buffer, so only call it when necesary */
		if (defaultOutputBuffer != currentBuffer || sizeof(defaultOutputBuffer) != currentBufferSize) {
			selectBuffer(defaultOutputBuffer, sizeof(defaultOutputBuffer));
		}
	}