static int afalg_chk_platform(void)
{
    int ret;
    int i;
    int kver[3] = { -1, -1, -1 };
    char *str;
    struct utsname ut;

    ret = uname(&ut);
    if (ret != 0) {
        AFALGerr(AFALG_F_AFALG_CHK_PLATFORM,
                 AFALG_R_FAILED_TO_GET_PLATFORM_INFO);
        return 0;
    }

    str = strtok(ut.release, ".");
    for (i = 0; i < 3 && str != NULL; i++) {
        kver[i] = atoi(str);
        str = strtok(NULL, ".");
    }

    if (KERNEL_VERSION(kver[0], kver[1], kver[2])
        < KERNEL_VERSION(K_MAJ, K_MIN1, K_MIN2)) {
        ALG_ERR("ASYNC AFALG not supported this kernel(%d.%d.%d)\n",
                 kver[0], kver[1], kver[2]);
        ALG_ERR("ASYNC AFALG requires kernel version %d.%d.%d or later\n",
                 K_MAJ, K_MIN1, K_MIN2);
        AFALGerr(AFALG_F_AFALG_CHK_PLATFORM,
                 AFALG_R_KERNEL_DOES_NOT_SUPPORT_ASYNC_AFALG);
        return 0;
    }

    return 1;
}

int
get_versiondep_info_x86_64(void)
{
	/*
	 * On linux-2.6.26, MAX_PHYSMEM_BITS is changed to 44 from 40.
	 */
	if (info->kernel_version < KERNEL_VERSION(2, 6, 26))
		info->max_physmem_bits  = _MAX_PHYSMEM_BITS_ORIG;
	else if (info->kernel_version < KERNEL_VERSION(2, 6, 31))
		info->max_physmem_bits  = _MAX_PHYSMEM_BITS_2_6_26;
	else
		info->max_physmem_bits  = _MAX_PHYSMEM_BITS_2_6_31;

	if (info->kernel_version < KERNEL_VERSION(2, 6, 27))
		info->page_offset = __PAGE_OFFSET_ORIG;
	else
		info->page_offset = __PAGE_OFFSET_2_6_27;

	if (info->kernel_version < KERNEL_VERSION(2, 6, 31)) {
		info->vmalloc_start = VMALLOC_START_ORIG;
		info->vmalloc_end   = VMALLOC_END_ORIG;
		info->vmemmap_start = VMEMMAP_START_ORIG;
		info->vmemmap_end   = VMEMMAP_END_ORIG;
	} else {
		info->vmalloc_start = VMALLOC_START_2_6_31;
		info->vmalloc_end   = VMALLOC_END_2_6_31;
		info->vmemmap_start = VMEMMAP_START_2_6_31;
		info->vmemmap_end   = VMEMMAP_END_2_6_31;
	}

	return TRUE;
}

	INT32 omap_v4l2_open(struct inode *inode,struct file *file)
#endif
{
	INT32 err = 0;
	struct video_device *dev = video_devdata(file);
	cam_data *cam;
	FNRESLT ret_val;

	ret_val	= v4l2_base_struct(&cam,GET_ADDRESS);
	if(CHECK_IN_FAIL_LIMIT(ret_val))
	{
		printk(KERN_ERR "Failed to get base node of camera device\n");
		TRACE_ERR_AND_RET(FAIL);		
	}
	
	if (cam	== NULL)
	{
		printk(KERN_ERR "Internal error, cam_data not found!\n");
		TRACE_ERR_AND_RET(-EBADF);
	}
	file->private_data = dev;

	strcpy(cam->v4l2_cap.driver, "omap_v4l2");
	cam->v4l2_cap.version		= KERNEL_VERSION(0, 1, 11);
	cam->v4l2_cap.capabilities 	=	V4L2_CAP_VIDEO_CAPTURE	|	\
						V4L2_CAP_READWRITE	|	\
						V4L2_CAP_STREAMING;

	cam->v4l2_cap.card[0]		= '\0';
	cam->v4l2_cap.bus_info[0]	= '\0';

	return err;
}

int FAST_FUNC bb_init_module(const char *filename, const char *options)
{
	size_t len;
	char *image;
	int rc;

	if (!options)
		options = "";

#if ENABLE_FEATURE_2_4_MODULES
	if (get_linux_version_code() < KERNEL_VERSION(2,6,0))
		return bb_init_module_24(filename, options);
#endif

	/* Use the 2.6 way */
	len = INT_MAX - 4095;
	rc = ENOENT;
	image = xmalloc_open_zipped_read_close(filename, &len);
	if (image) {
		rc = 0;
		if (init_module(image, len, options) != 0)
			rc = errno;
		free(image);
	}

	return rc;
}

static int add_cmdline_param(char *cmdline, uint64_t addr, char *cmdstr,
				char *byte)
{
	int cmdline_size, cmdlen, len, align = 1024;
	char str[COMMAND_LINE_SIZE], *ptr;

	/* Passing in =xxxK / =xxxM format. Saves space required in cmdline.*/
	switch (byte[0]) {
		case 'K':
			if (addr%align)
				return -1;
			addr = addr/align;
			break;
		case 'M':
			addr = addr/(align *align);
			break;
	}
	ptr = str;
	strcpy(str, cmdstr);
	ptr += strlen(str);
	ultoa(addr, ptr);
	strcat(str, byte);
	len = strlen(str);
	cmdlen = strlen(cmdline) + len;
	cmdline_size = (kernel_version() < KERNEL_VERSION(3, 15, 0) ?
			512 : COMMAND_LINE_SIZE);
	if (cmdlen > (cmdline_size - 1))
		die("Command line overflow\n");
	strcat(cmdline, str);
	dbgprintf("Command line after adding elfcorehdr: %s\n", cmdline);
	return 0;
}

static OMX_BOOL v4l_new_version()
{
#if 0   // capability.version is not supported ???
	struct v4l2_capability v4l_cap;
	if (ioctl(NULL, VIDIOC_QUERYCAP, &v4l_cap) < 0)
	{
		LOG_ERROR("set output failed\n");
		return OMX_FALSE;
	}
	if(v4l_cap.version>=KERNEL_VERSION(2,6,38))
	{
		return OMX_TRUE;
	}
	else
	{
		return OMX_FALSE;
	}
#else  //FIMXE: find better way to identify the v4l version 
	OMX_S32 v4l_dev;
	v4l_dev=open("/dev/video17", O_RDWR | O_NONBLOCK, 0);
	if(v4l_dev>0)
	{
		close(v4l_dev);
		return OMX_TRUE;
	}
	else
	{
		return OMX_FALSE;
	}
#endif
}

/* querycap: check capture, out, m2m */
static int nxp_video_querycap(struct file *file, void *fh,
        struct v4l2_capability *cap)
{
    struct nxp_video *me = file->private_data;

    strlcpy(cap->driver, me->name, sizeof(cap->driver));
    strlcpy(cap->card, me->vdev.name, sizeof(cap->card));
    strlcpy(cap->bus_info, "media", sizeof(cap->bus_info));
    cap->version = KERNEL_VERSION(1, 0, 0);

    pr_debug("%s: devname(%s)\n", __func__, cap->driver);

    switch(me->type) {
    case NXP_VIDEO_TYPE_CAPTURE:
        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE_MPLANE | V4L2_CAP_STREAMING;
        break;
    case NXP_VIDEO_TYPE_OUT:
        cap->capabilities = V4L2_CAP_VIDEO_OUTPUT_MPLANE | V4L2_CAP_STREAMING;
        break;
    case NXP_VIDEO_TYPE_M2M:
        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE_MPLANE |
            V4L2_CAP_VIDEO_OUTPUT_MPLANE | V4L2_CAP_STREAMING;
        break;
    default:
        pr_err("%s: invalid type(%d)\n", __func__, me->type);
        return -EINVAL;
    }

    return 0;
}

/*
 * Media device
 */
static int camif_media_dev_init(struct camif_dev *camif)
{
	struct media_device *md = &camif->media_dev;
	struct v4l2_device *v4l2_dev = &camif->v4l2_dev;
	unsigned int ip_rev = camif->variant->ip_revision;
	int ret;

	memset(md, 0, sizeof(*md));
	snprintf(md->model, sizeof(md->model), "SAMSUNG S3C%s CAMIF",
		 ip_rev == S3C6410_CAMIF_IP_REV ? "6410" : "244X");
	strlcpy(md->bus_info, "platform", sizeof(md->bus_info));
	md->hw_revision = ip_rev;
	md->driver_version = KERNEL_VERSION(1, 0, 0);

	md->dev = camif->dev;

	strlcpy(v4l2_dev->name, "s3c-camif", sizeof(v4l2_dev->name));
	v4l2_dev->mdev = md;

	media_device_init(md);

	ret = v4l2_device_register(camif->dev, v4l2_dev);
	if (ret < 0)
		return ret;

	return ret;
}

void ipset_init(void)
{
  struct utsname utsname;
  int version;
  char *split;
  
  if (uname(&utsname) < 0)
    die(_("failed to find kernel version: %s"), NULL, EC_MISC);
  
  split = strtok(utsname.release, ".");
  version = (split ? atoi(split) : 0);
  split = strtok(NULL, ".");
  version = version * 256 + (split ? atoi(split) : 0);
  split = strtok(NULL, ".");
  version = version * 256 + (split ? atoi(split) : 0);
  old_kernel = (version < KERNEL_VERSION(2,6,32));
  
  if (old_kernel && (ipset_sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) != -1)
    return;
  
  if (!old_kernel && 
      (buffer = safe_malloc(BUFF_SZ)) &&
      (ipset_sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_NETFILTER)) != -1 &&
      (bind(ipset_sock, (struct sockaddr *)&snl, sizeof(snl)) != -1))
    return;
  
  die (_("failed to create IPset control socket: %s"), NULL, EC_MISC);
}

static int emit_e820_device(int loglevel, struct ndctl_test *test)
{
	int err, fd;
	char path[256];
	const char *bdev;
	struct ndctl_ctx *ctx;
	struct ndctl_bus *bus;
	struct ndctl_region *region;
	struct ndctl_namespace *ndns;
	enum ndctl_namespace_mode mode;

	if (!ndctl_test_attempt(test, KERNEL_VERSION(4, 3, 0)))
		return 77;

	err = ndctl_new(&ctx);
	if (err < 0)
		return err;

	ndctl_set_log_priority(ctx, loglevel);
	err = -ENXIO;
	bus = ndctl_bus_get_by_provider(ctx, "e820");
	if (!bus)
		goto out;

	region = ndctl_region_get_first(bus);
	if (!region)
		goto out;

	ndns = ndctl_namespace_get_first(region);
	if (!ndns)
		goto out;

	mode = ndctl_namespace_get_mode(ndns);
	if (mode >= 0 && mode != NDCTL_NS_MODE_MEMORY)
		goto out;

	bdev = ndctl_namespace_get_block_device(ndns);
	if (!bdev)
		goto out;

	if (snprintf(path, sizeof(path), "/dev/%s", bdev) >= (int) sizeof(path))
		goto out;

	/*
	 * Note, if the bdev goes active after this check we'll still
	 * clobber it in the following tests, see test/dax.sh.
	 */
	fd = open(path, O_RDWR | O_EXCL);
	if (fd < 0)
		goto out;
	err = 0;
	fprintf(stdout, "%s\n", path);

 out:
	if (err)
		fprintf(stderr, "%s: failed to find usable victim device\n",
				__func__);
	ndctl_unref(ctx);
	return err;
}

int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
{
	int bytes_read;

	if (milliseconds != 0) {
		/* milliseconds is -1 or > 0. In both cases, we want to
		   call poll() and wait for data to arrive. -1 means
		   INFINITE. */
		int ret;
		struct pollfd fds;

		fds.fd = dev->device_handle;
		fds.events = POLLIN;
		fds.revents = 0;
		ret = poll(&fds, 1, milliseconds);
		if (ret == -1 || ret == 0)
			/* Error or timeout */
			return ret;
	}

	bytes_read = read(dev->device_handle, data, length);
	if (bytes_read < 0 && errno == EAGAIN)
		bytes_read = 0;
	
	if (bytes_read >= 0 &&
	    kernel_version < KERNEL_VERSION(2,6,34) &&
	    dev->uses_numbered_reports) {
		/* Work around a kernel bug. Chop off the first byte. */
		memmove(data, data+1, bytes_read);
		bytes_read--;
	}

	return bytes_read;
}

void check_kernel_version(kernel_version_t *version) {
	static struct utsname buf;
	static long major, minor, patch, ver = -1;
	if (ver == -1) {
		must_success(uname(&buf), "uname failed");
		if (buf.release[0] < '2')
			goto fail;
		sscanf(buf.release, "%d.%d.%d", &major, &minor, &patch);
		debugf("Kernel version: %d.%d.%d", major, minor, patch);
		ver = KERNEL_VERSION(major, minor, patch);
		if (ver < KERNEL_VERSION(2, 6, 32))
			goto fail;
	}
	*version = ver;
	return;
fail:
	fatalf("Kernel version < 2.6.32 is not supported!");
}

static int vidioc_querycap(struct file *file, void *priv,
			   struct v4l2_capability *cap)
{
	strcpy(cap->driver, "dummy");
	strcpy(cap->card, "dummy");
	cap->version = KERNEL_VERSION(0, 0, 1);
	cap->capabilities = 0;
	return 0;
}

static uint64_t
_get_num_sectors(int fd)
{
	int version = _get_linux_version();
	unsigned long	size;
	uint64_t bytes=0;

	if (version >= KERNEL_VERSION(2,5,4) ||
		(version <  KERNEL_VERSION(2,5,0) &&
		 version >= KERNEL_VERSION (2,4,18)))
	{
                if (ioctl(fd, BLKGETSIZE64, &bytes) == 0)
                        return bytes / _get_sector_size(fd);
	}
	if (ioctl (fd, BLKGETSIZE, &size))
		return 0;
	return size;
}

static int
tapdisk_lio_check_resfd(void)
{
#if defined(__linux__)
	return tapdisk_linux_version() >= KERNEL_VERSION(2, 6, 22);
#else
	return 1;
#endif
}

int get_linux_version(void)
{
	struct utsname ubuf;
	int a, b, c;
	int n;

	if (uname(&ubuf) || strcmp(ubuf.sysname, "Linux"))
		return 0;

	n = sscanf(ubuf.release, "%d.%d.%d", &a, &b, &c);
	switch (n) {
	case 3:
		return KERNEL_VERSION(a, b, c);
	case 2:
		return KERNEL_VERSION(a, b, 0);
	default:
		return 0;
	}
}

/*
 * Unfortunately, the kernel prints annoying console messages
 * in case of an unexpected nfs mount version (instead of
 * just returning some error).  Therefore we'll have to try
 * and figure out what version the kernel expects.
 *
 * Variables:
 *	KERNEL_NFS_MOUNT_VERSION: kernel sources at compile time
 *	NFS_MOUNT_VERSION: these nfsmount sources at compile time
 *	nfs_mount_version: version this source and running kernel can handle
 */
static void
find_kernel_nfs_mount_version(void)
{
	if (kernel_version)
		return;

	nfs_mount_version = 4; /* default */

	kernel_version = get_linux_version_code();
	if (kernel_version) {
		if (kernel_version < KERNEL_VERSION(2,1,32))
			nfs_mount_version = 1;
		else if (kernel_version < KERNEL_VERSION(2,2,18) ||
				(kernel_version >= KERNEL_VERSION(2,3,0) &&
				 kernel_version < KERNEL_VERSION(2,3,99)))
			nfs_mount_version = 3;
		/* else v4 since 2.3.99pre4 */
	}
}

static int afalg_chk_platform(void)
{
    int ret;
    int i;
    int kver[3] = { -1, -1, -1 };
    int sock;
    char *str;
    struct utsname ut;

    ret = uname(&ut);
    if (ret != 0) {
        AFALGerr(AFALG_F_AFALG_CHK_PLATFORM,
                 AFALG_R_FAILED_TO_GET_PLATFORM_INFO);
        return 0;
    }

    str = strtok(ut.release, ".");
    for (i = 0; i < 3 && str != NULL; i++) {
        kver[i] = atoi(str);
        str = strtok(NULL, ".");
    }

    if (KERNEL_VERSION(kver[0], kver[1], kver[2])
        < KERNEL_VERSION(K_MAJ, K_MIN1, K_MIN2)) {
        ALG_ERR("ASYNC AFALG not supported this kernel(%d.%d.%d)\n",
                 kver[0], kver[1], kver[2]);
        ALG_ERR("ASYNC AFALG requires kernel version %d.%d.%d or later\n",
                 K_MAJ, K_MIN1, K_MIN2);
        AFALGerr(AFALG_F_AFALG_CHK_PLATFORM,
                 AFALG_R_KERNEL_DOES_NOT_SUPPORT_ASYNC_AFALG);
        return 0;
    }

    /* Test if we can actually create an AF_ALG socket */
    sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
    if (sock == -1) {
        AFALGerr(AFALG_F_AFALG_CHK_PLATFORM, AFALG_R_SOCKET_CREATE_FAILED);
        return 0;
    }
    close(sock);

    return 1;
}

static int mx3_camera_querycap(struct soc_camera_host *ici,
			       struct v4l2_capability *cap)
{
	/* cap->name is set by the firendly caller:-> */
	strlcpy(cap->card, "i.MX3x Camera", sizeof(cap->card));
	cap->version = KERNEL_VERSION(0, 2, 2);
	cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;

	return 0;
}

int
create_autofs_service(void)
{
  hash_init();

  /* not the best place, but... */
  if (linux_version_code() < KERNEL_VERSION(2,4,0))
    bind_works = 0;

  return 0;
}