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; }
static int sh_mobile_ceu_querycap(struct soc_camera_host *ici, struct v4l2_capability *cap) { strlcpy(cap->card, "SuperH_Mobile_CEU", sizeof(cap->card)); cap->version = KERNEL_VERSION(0, 0, 5); cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; return 0; }
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; }
static int __init hello_init(void) { uint temp = KERNEL_VERSION(3,10,0); struct task_struct *t = current; printk(KERN_INFO "hello_init() j_int=%d, j_charp=%s",j_int,j_charp); printk(KERN_INFO "hello_init() LINUX_VERSION_CODE= %d",LINUX_VERSION_CODE); printk(KERN_INFO "hello_init() KERNEL_VERSION=%d",temp); printk(KERN_INFO "hello_init() t->pid=%d t->comm=%s", t->pid,t->comm); return 0; }
static unsigned int _get_sector_size (int fd) { unsigned int sector_size; if (_get_linux_version() < KERNEL_VERSION (2,3,0)) return SECTOR_SIZE; if (ioctl (fd, BLKSSZGET, §or_size)) return SECTOR_SIZE; return sector_size; }
static int hello_init(void) { struct task_struct *p = get_current(); kdbg("%s enter\n", __FUNCTION__); kdbg("paramters: count=%d, name=%s\n",count,name); kdbg("current'name=%s, current'pid=%d\n",p->comm, p->pid); kdbg("kernel version code is %d, make code is %d\n",LINUX_VERSION_CODE, KERNEL_VERSION(3,10,0)); return 0; }
static int vidioc_querycap(struct file *file, void *priv, struct v4l2_capability *cap) { strncpy(cap->driver, G2D_NAME, sizeof(cap->driver) - 1); strncpy(cap->card, G2D_NAME, sizeof(cap->card) - 1); cap->bus_info[0] = 0; cap->version = KERNEL_VERSION(1, 0, 0); cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING; return 0; }
static __u32 detect_kernel_version(void) { struct utsname name; int major, minor, release; int ret; uname(&name); ret = sscanf(name.release, "%d.%d.%d", &major, &minor, &release); if (ret == 3) { return KERNEL_VERSION(major, minor, release); } ret = sscanf(name.release, "%d.%d", &major, &minor); if (ret == 2) { return KERNEL_VERSION(major, minor, 0); } printf("Couldn't determine kernel version from version string \"%s\"\n", name.release); return 0; }
static int vidioc_querycap(struct file *file, void *priv, struct v4l2_capability *v) { struct poseidon *p = file->private_data; strlcpy(v->driver, "tele-radio", sizeof(v->driver)); strlcpy(v->card, "Telegent Poseidon", sizeof(v->card)); usb_make_path(p->udev, v->bus_info, sizeof(v->bus_info)); v->version = KERNEL_VERSION(0, 0, 1); v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO; return 0; }
static int cam_querycap(struct file *file, void *priv, struct v4l2_capability *vcap) { struct w9966 *cam = video_drvdata(file); strlcpy(vcap->driver, cam->v4l2_dev.name, sizeof(vcap->driver)); strlcpy(vcap->card, W9966_DRIVERNAME, sizeof(vcap->card)); strlcpy(vcap->bus_info, "parport", sizeof(vcap->bus_info)); vcap->version = KERNEL_VERSION(0, 33, 0); vcap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE; return 0; }
static int unicam_camera_querycap(struct soc_camera_host *ici, struct v4l2_capability *cap) { pr_debug("-enter"); /* cap->name is set by the firendly caller:-> */ strlcpy(cap->card, "Unicam Camera", sizeof(cap->card)); cap->version = KERNEL_VERSION(0, 1, 0); cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; pr_debug("-exit"); return 0; }
static int _trout_fm_querycap(struct file *file, void *priv, struct v4l2_capability *cap) { strlcpy(cap->driver, DRIVER_NAME, sizeof(cap->driver)); strlcpy(cap->card, CARD_NAME, sizeof(cap->card)); cap->version = KERNEL_VERSION(0, 1, 0); cap->capabilities = V4L2_CAP_RADIO | V4L2_CAP_TUNER | V4L2_CAP_HW_FREQ_SEEK; return 0; }