本文整理汇总了C++中copy_to_user函数的典型用法代码示例。如果您正苦于以下问题:C++ copy_to_user函数的具体用法?C++ copy_to_user怎么用?C++ copy_to_user使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了copy_to_user函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: put_v4l2_sliced_vbi_format
static inline int put_v4l2_sliced_vbi_format(struct v4l2_sliced_vbi_format *kp, struct v4l2_sliced_vbi_format __user *up)
{
if (copy_to_user(up, kp, sizeof(struct v4l2_sliced_vbi_format)))
return -EFAULT;
return 0;
}
示例2: mtd_read
static int mtd_read(struct inode *inode,struct file *file, char *buf, int count)
#endif
{
struct mtd_info *mtd = (struct mtd_info *)file->private_data;
size_t retlen=0;
size_t total_retlen=0;
int ret=0;
#ifndef NO_MM
int len;
char *kbuf;
#endif
DEBUG(MTD_DEBUG_LEVEL0,"MTD_read\n");
if (FILE_POS + count > mtd->size)
count = mtd->size - FILE_POS;
if (!count)
return 0;
/* FIXME: Use kiovec in 2.3 or 2.2+rawio, or at
* least split the IO into smaller chunks.
*/
#ifdef NO_MM
ret = MTD_READ(mtd, FILE_POS, count, &retlen, buf);
if (!ret) {
FILE_POS += retlen;
ret = retlen;
}
total_retlen = ret;
#else
while (count) {
if (count > MAX_KMALLOC_SIZE)
len = MAX_KMALLOC_SIZE;
else
len = count;
kbuf=kmalloc(len,GFP_KERNEL);
if (!kbuf)
return -ENOMEM;
ret = MTD_READ(mtd, FILE_POS, len, &retlen, kbuf);
if (!ret) {
FILE_POS += retlen;
if (copy_to_user(buf, kbuf, retlen)) {
kfree(kbuf);
return -EFAULT;
}
else
total_retlen += retlen;
count -= retlen;
buf += retlen;
}
else {
kfree(kbuf);
return ret;
}
kfree(kbuf);
}
#endif
return total_retlen;
} /* mtd_read */
示例3: ipv6_flowlabel_opt
//.........这里部分代码省略.........
net_info_ratelimited("Can not set IPV6_FL_F_REFLECT if flowlabel_consistency sysctl is enable\n");
return -EPERM;
}
if (sk->sk_protocol != IPPROTO_TCP)
return -ENOPROTOOPT;
np->repflow = 1;
return 0;
}
if (freq.flr_label & ~IPV6_FLOWLABEL_MASK)
return -EINVAL;
if (net->ipv6.sysctl.flowlabel_state_ranges &&
(freq.flr_label & IPV6_FLOWLABEL_STATELESS_FLAG))
return -ERANGE;
fl = fl_create(net, sk, &freq, optval, optlen, &err);
if (!fl)
return err;
sfl1 = kmalloc(sizeof(*sfl1), GFP_KERNEL);
if (freq.flr_label) {
err = -EEXIST;
rcu_read_lock_bh();
for_each_sk_fl_rcu(np, sfl) {
if (sfl->fl->label == freq.flr_label) {
if (freq.flr_flags&IPV6_FL_F_EXCL) {
rcu_read_unlock_bh();
goto done;
}
fl1 = sfl->fl;
atomic_inc(&fl1->users);
break;
}
}
rcu_read_unlock_bh();
if (!fl1)
fl1 = fl_lookup(net, freq.flr_label);
if (fl1) {
recheck:
err = -EEXIST;
if (freq.flr_flags&IPV6_FL_F_EXCL)
goto release;
err = -EPERM;
if (fl1->share == IPV6_FL_S_EXCL ||
fl1->share != fl->share ||
((fl1->share == IPV6_FL_S_PROCESS) &&
(fl1->owner.pid == fl->owner.pid)) ||
((fl1->share == IPV6_FL_S_USER) &&
uid_eq(fl1->owner.uid, fl->owner.uid)))
goto release;
err = -ENOMEM;
if (!sfl1)
goto release;
if (fl->linger > fl1->linger)
fl1->linger = fl->linger;
if ((long)(fl->expires - fl1->expires) > 0)
fl1->expires = fl->expires;
fl_link(np, sfl1, fl1);
fl_free(fl);
return 0;
release:
fl_release(fl1);
goto done;
}
}
err = -ENOENT;
if (!(freq.flr_flags&IPV6_FL_F_CREATE))
goto done;
err = -ENOMEM;
if (!sfl1)
goto done;
err = mem_check(sk);
if (err != 0)
goto done;
fl1 = fl_intern(net, fl, freq.flr_label);
if (fl1)
goto recheck;
if (!freq.flr_label) {
if (copy_to_user(&((struct in6_flowlabel_req __user *) optval)->flr_label,
&fl->label, sizeof(fl->label))) {
/* Intentionally ignore fault. */
}
}
fl_link(np, sfl1, fl);
return 0;
default:
return -EINVAL;
}
示例4: jpeg_ioctl
static long jpeg_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
int ret;
struct jpeg_control *ctrl;
ctrl = (struct jpeg_control *)file->private_data;
if (!ctrl) {
jpeg_err("jpeg invalid input argument\n");
return -1;
}
switch (cmd) {
case IOCTL_JPEG_DEC_EXE:
ret = copy_from_user(&ctrl->dec_param,
(struct jpeg_dec_param *)arg,
sizeof(struct jpeg_dec_param));
jpeg_exe_dec(ctrl);
ret = copy_to_user((void *)arg,
(void *) &ctrl->dec_param,
sizeof(struct jpeg_dec_param));
break;
case IOCTL_JPEG_ENC_EXE:
ret = copy_from_user(&ctrl->enc_param,
(struct jpeg_enc_param *)arg,
sizeof(struct jpeg_enc_param));
jpeg_exe_enc(ctrl);
ret = copy_to_user((void *)arg,
(void *) &ctrl->enc_param,
sizeof(struct jpeg_enc_param));
break;
case IOCTL_GET_DEC_IN_BUF:
case IOCTL_GET_ENC_OUT_BUF:
return jpeg_get_stream_buf(arg);
case IOCTL_GET_DEC_OUT_BUF:
case IOCTL_GET_ENC_IN_BUF:
return jpeg_get_frame_buf(arg);
case IOCTL_GET_PHYADDR:
return jpeg_ctrl->mem.frame_data_addr;
case IOCTL_GET_PHYMEM_BASE:
#ifdef CONFIG_VIDEO_SAMSUNG_MEMSIZE_JPEG
if (copy_to_user((void *)arg, &jpeg_ctrl->mem.base, sizeof(unsigned int))) {
jpeg_err("IOCTL_GET_PHYMEM_BASE:::copy_to_user error\n");
return -1;
}
return 0;
#else
return -1;
#endif
case IOCTL_GET_PHYMEM_SIZE:
#ifdef CONFIG_VIDEO_SAMSUNG_MEMSIZE_JPEG
ret = CONFIG_VIDEO_SAMSUNG_MEMSIZE_JPEG * 1024;
if (copy_to_user((void *)arg, &ret, sizeof(unsigned int))) {
jpeg_err("IOCTL_GET_PHYMEM_SIZE:::copy_to_user error\n");
return -1;
}
return 0;
#else
return -1;
#endif
case IOCTL_SET_DEC_PARAM:
ret = copy_from_user(&ctrl->dec_param,
(struct jpeg_dec_param *)arg,
sizeof(struct jpeg_dec_param));
ret = jpeg_set_dec_param(ctrl);
break;
case IOCTL_SET_ENC_PARAM:
ret = copy_from_user(&ctrl->enc_param,
(struct jpeg_enc_param *)arg,
sizeof(struct jpeg_enc_param));
ret = jpeg_set_enc_param(ctrl);
break;
default:
break;
}
return 0;
}
示例5: ecs_ctrl_ioctl
static int ecs_ctrl_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
void __user *pa = (void __user *)arg;
short flag;
short delay;
int parms[4];
int ypr[12];
switch (cmd) {
case ECOMPASS_IOC_SET_MODE:
break;
case ECOMPASS_IOC_SET_DELAY:
if (copy_from_user(&delay, pa, sizeof(delay)))
return -EFAULT;
ecompass_delay = delay;
break;
case ECOMPASS_IOC_GET_DELAY:
delay = ecompass_delay;
if (copy_to_user(pa, &delay, sizeof(delay)))
return -EFAULT;
break;
case ECOMPASS_IOC_SET_AFLAG:
if (copy_from_user(&flag, pa, sizeof(flag)))
return -EFAULT;
if (flag < 0 || flag > 1)
return -EINVAL;
atomic_set(&a_flag, flag);
break;
case ECOMPASS_IOC_GET_AFLAG:
flag = atomic_read(&a_flag);
if (copy_to_user(pa, &flag, sizeof(flag)))
return -EFAULT;
break;
case ECOMPASS_IOC_SET_MFLAG:
if (copy_from_user(&flag, pa, sizeof(flag)))
return -EFAULT;
if (flag < 0 || flag > 1)
return -EINVAL;
atomic_set(&m_flag, flag);
break;
case ECOMPASS_IOC_GET_MFLAG:
flag = atomic_read(&m_flag);
if (copy_to_user(pa, &flag, sizeof(flag)))
return -EFAULT;
break;
case ECOMPASS_IOC_SET_OFLAG:
if (copy_from_user(&flag, pa, sizeof(flag)))
return -EFAULT;
if (flag < 0 || flag > 1)
return -EINVAL;
atomic_set(&o_flag, flag);
break;
case ECOMPASS_IOC_GET_OFLAG:
flag = atomic_read(&o_flag);
if (copy_to_user(pa, &flag, sizeof(flag)))
return -EFAULT;
break;
case ECOMPASS_IOC_SET_APARMS:
if (copy_from_user(parms, pa, sizeof(parms)))
return -EFAULT;
/* acceleration x-axis */
input_set_abs_params(ecs_data_device, ABS_X,
parms[0], parms[1], parms[2], parms[3]);
/* acceleration y-axis */
input_set_abs_params(ecs_data_device, ABS_Y,
parms[0], parms[1], parms[2], parms[3]);
/* acceleration z-axis */
input_set_abs_params(ecs_data_device, ABS_Z,
parms[0], parms[1], parms[2], parms[3]);
break;
case ECOMPASS_IOC_GET_APARMS:
break;
case ECOMPASS_IOC_SET_MPARMS:
if (copy_from_user(parms, pa, sizeof(parms)))
return -EFAULT;
/* magnetic raw x-axis */
input_set_abs_params(ecs_data_device, ABS_HAT0X,
parms[0], parms[1], parms[2], parms[3]);
/* magnetic raw y-axis */
input_set_abs_params(ecs_data_device, ABS_HAT0Y,
parms[0], parms[1], parms[2], parms[3]);
/* magnetic raw z-axis */
input_set_abs_params(ecs_data_device, ABS_BRAKE,
parms[0], parms[1], parms[2], parms[3]);
break;
case ECOMPASS_IOC_GET_MPARMS:
break;
case ECOMPASS_IOC_SET_OPARMS_YAW:
if (copy_from_user(parms, pa, sizeof(parms)))
return -EFAULT;
/* orientation yaw */
input_set_abs_params(ecs_data_device, ABS_RX,
parms[0], parms[1], parms[2], parms[3]);
break;
case ECOMPASS_IOC_GET_OPARMS_YAW:
break;
case ECOMPASS_IOC_SET_OPARMS_PITCH:
//.........这里部分代码省略.........
示例6: iowarrior_ioctl
/**
* iowarrior_ioctl
*/
static long iowarrior_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
struct iowarrior *dev = NULL;
__u8 *buffer;
__u8 __user *user_buffer;
int retval;
int io_res; /* checks for bytes read/written and copy_to/from_user results */
dev = file->private_data;
if (dev == NULL) {
return -ENODEV;
}
buffer = kzalloc(dev->report_size, GFP_KERNEL);
if (!buffer)
return -ENOMEM;
/* lock this object */
mutex_lock(&iowarrior_mutex);
mutex_lock(&dev->mutex);
/* verify that the device wasn't unplugged */
if (!dev->present) {
retval = -ENODEV;
goto error_out;
}
dbg("%s - minor %d, cmd 0x%.4x, arg %ld", __func__, dev->minor, cmd,
arg);
retval = 0;
io_res = 0;
switch (cmd) {
case IOW_WRITE:
if (dev->product_id == USB_DEVICE_ID_CODEMERCS_IOW24 ||
dev->product_id == USB_DEVICE_ID_CODEMERCS_IOWPV1 ||
dev->product_id == USB_DEVICE_ID_CODEMERCS_IOWPV2 ||
dev->product_id == USB_DEVICE_ID_CODEMERCS_IOW40) {
user_buffer = (__u8 __user *)arg;
io_res = copy_from_user(buffer, user_buffer,
dev->report_size);
if (io_res) {
retval = -EFAULT;
} else {
io_res = usb_set_report(dev->interface, 2, 0,
buffer,
dev->report_size);
if (io_res < 0)
retval = io_res;
}
} else {
retval = -EINVAL;
dev_err(&dev->interface->dev,
"ioctl 'IOW_WRITE' is not supported for product=0x%x.\n",
dev->product_id);
}
break;
case IOW_READ:
user_buffer = (__u8 __user *)arg;
io_res = usb_get_report(dev->udev,
dev->interface->cur_altsetting, 1, 0,
buffer, dev->report_size);
if (io_res < 0)
retval = io_res;
else {
io_res = copy_to_user(user_buffer, buffer, dev->report_size);
if (io_res < 0)
retval = -EFAULT;
}
break;
case IOW_GETINFO:
{
/* Report available information for the device */
struct iowarrior_info info;
/* needed for power consumption */
struct usb_config_descriptor *cfg_descriptor = &dev->udev->actconfig->desc;
memset(&info, 0, sizeof(info));
/* directly from the descriptor */
info.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
info.product = dev->product_id;
info.revision = le16_to_cpu(dev->udev->descriptor.bcdDevice);
/* 0==UNKNOWN, 1==LOW(usb1.1) ,2=FULL(usb1.1), 3=HIGH(usb2.0) */
info.speed = le16_to_cpu(dev->udev->speed);
info.if_num = dev->interface->cur_altsetting->desc.bInterfaceNumber;
info.report_size = dev->report_size;
/* serial number string has been read earlier 8 chars or empty string */
memcpy(info.serial, dev->chip_serial,
sizeof(dev->chip_serial));
if (cfg_descriptor == NULL) {
info.power = -1; /* no information available */
} else {
/* the MaxPower is stored in units of 2mA to make it fit into a byte-value */
info.power = cfg_descriptor->bMaxPower * 2;
//.........这里部分代码省略.........
示例7: wpa_get_scan
//.........这里部分代码省略.........
return ret;
}
for (ii = 0; ii < MAX_BSS_NUM; ii++) {
for(jj=0;jj<MAX_BSS_NUM-ii-1;jj++) {
if((pMgmt->sBSSList[jj].bActive!=true) ||
((pMgmt->sBSSList[jj].uRSSI>pMgmt->sBSSList[jj+1].uRSSI) &&(pMgmt->sBSSList[jj+1].bActive!=false))) {
memcpy(ptempBSS,&pMgmt->sBSSList[jj],sizeof(KnownBSS));
memcpy(&pMgmt->sBSSList[jj],&pMgmt->sBSSList[jj+1],sizeof(KnownBSS));
memcpy(&pMgmt->sBSSList[jj+1],ptempBSS,sizeof(KnownBSS));
}
}
}
kfree(ptempBSS);
// printk("bubble sort result:\n");
//for (ii = 0; ii < MAX_BSS_NUM; ii++)
// printk("%d [%s]:RSSI=%d\n",ii,((PWLAN_IE_SSID)(pMgmt->sBSSList[ii].abySSID))->abySSID,
// pMgmt->sBSSList[ii].uRSSI);
#endif
//******mike:bubble sort by stronger RSSI*****//
count = 0;
pBSS = &(pMgmt->sBSSList[0]);
for (ii = 0; ii < MAX_BSS_NUM; ii++) {
pBSS = &(pMgmt->sBSSList[ii]);
if (!pBSS->bActive)
continue;
count++;
}
pBuf = kcalloc(count, sizeof(struct viawget_scan_result), (int)GFP_ATOMIC);
if (pBuf == NULL) {
ret = -ENOMEM;
return ret;
}
scan_buf = (struct viawget_scan_result *)pBuf;
pBSS = &(pMgmt->sBSSList[0]);
for (ii = 0, jj = 0; ii < MAX_BSS_NUM ; ii++) {
pBSS = &(pMgmt->sBSSList[ii]);
if (pBSS->bActive) {
if (jj >= count)
break;
memcpy(scan_buf->bssid, pBSS->abyBSSID, WLAN_BSSID_LEN);
pItemSSID = (PWLAN_IE_SSID)pBSS->abySSID;
memcpy(scan_buf->ssid, pItemSSID->abySSID, pItemSSID->len);
scan_buf->ssid_len = pItemSSID->len;
scan_buf->freq = frequency_list[pBSS->uChannel-1];
scan_buf->caps = pBSS->wCapInfo;
//scan_buf->caps = pBSS->wCapInfo;
//scan_buf->qual =
//scan_buf->noise =
//scan_buf->level =
//scan_buf->maxrate =
if (pBSS->wWPALen != 0) {
scan_buf->wpa_ie_len = pBSS->wWPALen;
memcpy(scan_buf->wpa_ie, pBSS->byWPAIE, pBSS->wWPALen);
}
if (pBSS->wRSNLen != 0) {
scan_buf->rsn_ie_len = pBSS->wRSNLen;
memcpy(scan_buf->rsn_ie, pBSS->byRSNIE, pBSS->wRSNLen);
}
scan_buf = (struct viawget_scan_result *)((unsigned char *)scan_buf + sizeof(struct viawget_scan_result));
jj ++;
}
}
if (jj < count)
count = jj;
if (copy_to_user(param->u.scan_results.buf, pBuf, sizeof(struct viawget_scan_result) * count)) {
ret = -EFAULT;
}
param->u.scan_results.scan_count = count;
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " param->u.scan_results.scan_count = %d\n", count)
kfree(pBuf);
return ret;
}
示例8: printer_read
static ssize_t
printer_read(struct file *fd, char __user *buf, size_t len, loff_t *ptr)
{
struct printer_dev *dev = fd->private_data;
unsigned long flags;
size_t size;
size_t bytes_copied;
struct usb_request *req;
/* This is a pointer to the current USB rx request. */
struct usb_request *current_rx_req;
/* This is the number of bytes in the current rx buffer. */
size_t current_rx_bytes;
/* This is a pointer to the current rx buffer. */
u8 *current_rx_buf;
if (len == 0)
return -EINVAL;
DBG(dev, "printer_read trying to read %d bytes\n", (int)len);
spin_lock(&dev->lock_printer_io);
spin_lock_irqsave(&dev->lock, flags);
/* We will use this flag later to check if a printer reset happened
* after we turn interrupts back on.
*/
dev->reset_printer = 0;
setup_rx_reqs(dev);
bytes_copied = 0;
current_rx_req = dev->current_rx_req;
current_rx_bytes = dev->current_rx_bytes;
current_rx_buf = dev->current_rx_buf;
dev->current_rx_req = NULL;
dev->current_rx_bytes = 0;
dev->current_rx_buf = NULL;
/* Check if there is any data in the read buffers. Please note that
* current_rx_bytes is the number of bytes in the current rx buffer.
* If it is zero then check if there are any other rx_buffers that
* are on the completed list. We are only out of data if all rx
* buffers are empty.
*/
if ((current_rx_bytes == 0) &&
(likely(list_empty(&dev->rx_buffers)))) {
/* Turn interrupts back on before sleeping. */
spin_unlock_irqrestore(&dev->lock, flags);
/*
* If no data is available check if this is a NON-Blocking
* call or not.
*/
if (fd->f_flags & (O_NONBLOCK|O_NDELAY)) {
spin_unlock(&dev->lock_printer_io);
return -EAGAIN;
}
/* Sleep until data is available */
wait_event_interruptible(dev->rx_wait,
(likely(!list_empty(&dev->rx_buffers))));
spin_lock_irqsave(&dev->lock, flags);
}
/* We have data to return then copy it to the caller's buffer.*/
while ((current_rx_bytes || likely(!list_empty(&dev->rx_buffers)))
&& len) {
if (current_rx_bytes == 0) {
req = container_of(dev->rx_buffers.next,
struct usb_request, list);
list_del_init(&req->list);
if (req->actual && req->buf) {
current_rx_req = req;
current_rx_bytes = req->actual;
current_rx_buf = req->buf;
} else {
list_add(&req->list, &dev->rx_reqs);
continue;
}
}
/* Don't leave irqs off while doing memory copies */
spin_unlock_irqrestore(&dev->lock, flags);
if (len > current_rx_bytes)
size = current_rx_bytes;
else
size = len;
size -= copy_to_user(buf, current_rx_buf, size);
bytes_copied += size;
len -= size;
buf += size;
spin_lock_irqsave(&dev->lock, flags);
/* We've disconnected or reset so return. */
if (dev->reset_printer) {
list_add(¤t_rx_req->list, &dev->rx_reqs);
//.........这里部分代码省略.........
示例9: libcfs_ioctl_popdata
int libcfs_ioctl_popdata(void *arg, void *data, int size)
{
if (copy_to_user((char *)arg, data, size))
return -EFAULT;
return 0;
}
示例10: ppc_rtas
asmlinkage int ppc_rtas(struct rtas_args __user *uargs)
{
struct rtas_args args;
unsigned long flags;
char *buff_copy, *errbuf = NULL;
int nargs;
int rc;
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
if (copy_from_user(&args, uargs, 3 * sizeof(u32)) != 0)
return -EFAULT;
nargs = args.nargs;
if (nargs > ARRAY_SIZE(args.args)
|| args.nret > ARRAY_SIZE(args.args)
|| nargs + args.nret > ARRAY_SIZE(args.args))
return -EINVAL;
/* Copy in args. */
if (copy_from_user(args.args, uargs->args,
nargs * sizeof(rtas_arg_t)) != 0)
return -EFAULT;
if (args.token == RTAS_UNKNOWN_SERVICE)
return -EINVAL;
args.rets = &args.args[nargs];
memset(args.rets, 0, args.nret * sizeof(rtas_arg_t));
/* Need to handle ibm,suspend_me call specially */
if (args.token == ibm_suspend_me_token) {
rc = rtas_ibm_suspend_me(&args);
if (rc)
return rc;
goto copy_return;
}
buff_copy = get_errorlog_buffer();
flags = lock_rtas();
rtas.args = args;
enter_rtas(__pa(&rtas.args));
args = rtas.args;
/* A -1 return code indicates that the last command couldn't
be completed due to a hardware error. */
if (args.rets[0] == -1)
errbuf = __fetch_rtas_last_error(buff_copy);
unlock_rtas(flags);
if (buff_copy) {
if (errbuf)
log_error(errbuf, ERR_TYPE_RTAS_LOG, 0);
kfree(buff_copy);
}
copy_return:
/* Copy out args. */
if (copy_to_user(uargs->args + nargs,
args.args + nargs,
args.nret * sizeof(rtas_arg_t)) != 0)
return -EFAULT;
return 0;
}
示例11: mpc83xx_wdt_ioctl
static int mpc83xx_wdt_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
void __user *argp = (void __user *)arg;
int __user *p = argp;
static struct watchdog_info ident = {
.options = WDIOF_KEEPALIVEPING,
.firmware_version = 1,
.identity = "MPC83xx",
};
switch (cmd) {
case WDIOC_GETSUPPORT:
return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
case WDIOC_GETSTATUS:
case WDIOC_GETBOOTSTATUS:
return put_user(0, p);
case WDIOC_KEEPALIVE:
mpc83xx_wdt_keepalive();
return 0;
case WDIOC_GETTIMEOUT:
return put_user(timeout_sec, p);
default:
return -ENOTTY;
}
}
static const struct file_operations mpc83xx_wdt_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.write = mpc83xx_wdt_write,
.ioctl = mpc83xx_wdt_ioctl,
.open = mpc83xx_wdt_open,
.release = mpc83xx_wdt_release,
};
static struct miscdevice mpc83xx_wdt_miscdev = {
.minor = WATCHDOG_MINOR,
.name = "watchdog",
.fops = &mpc83xx_wdt_fops,
};
static int __devinit mpc83xx_wdt_probe(struct platform_device *dev)
{
struct resource *r;
int ret;
unsigned int *freq = dev->dev.platform_data;
/* get a pointer to the register memory */
r = platform_get_resource(dev, IORESOURCE_MEM, 0);
if (!r) {
ret = -ENODEV;
goto err_out;
}
wd_base = ioremap(r->start, sizeof (struct mpc83xx_wdt));
if (wd_base == NULL) {
ret = -ENOMEM;
goto err_out;
}
ret = misc_register(&mpc83xx_wdt_miscdev);
if (ret) {
printk(KERN_ERR "cannot register miscdev on minor=%d "
"(err=%d)\n",
WATCHDOG_MINOR, ret);
goto err_unmap;
}
/* Calculate the timeout in seconds */
if (prescale)
timeout_sec = (timeout * 0x10000) / (*freq);
else
timeout_sec = timeout / (*freq);
printk(KERN_INFO "WDT driver for MPC83xx initialized. "
"mode:%s timeout=%d (%d seconds)\n",
reset ? "reset":"interrupt", timeout, timeout_sec);
spin_lock_init(&wdt_spinlock);
return 0;
err_unmap:
iounmap(wd_base);
err_out:
return ret;
}
static int __devexit mpc83xx_wdt_remove(struct platform_device *dev)
{
misc_deregister(&mpc83xx_wdt_miscdev);
iounmap(wd_base);
return 0;
}
static struct platform_driver mpc83xx_wdt_driver = {
//.........这里部分代码省略.........
示例12: sep0611_overlay_ioctl
/******************************** the module driver ************************************************************/
static int sep0611_overlay_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
unsigned int intArg,data;
overlay_config_t config;
lcdc_timming timming_tmp;
switch(cmd)
{
#if 0
case OVERLAY_FORBID:
if(copy_from_user(&intArg, (int *)arg, sizeof(int)))
return -EFAULT;
overlay_forbid = intArg;
return 0;
#endif
#if USE_PICTURE
case 111://GET_IMG
//if(copy_from_user(&config, (overlay_config_t *)arg, sizeof(overlay_config_t)))
// return -EFAULT;
return sep0611_overlay_get_img();
#endif
case OVERLAY_PRINT_REGS:
dprintk("print regs:\n");
for(intArg=0; intArg<=0xCC;intArg+=4)
{
printk("reg[0x%x] = (0x%x)\n", (unsigned int)io + intArg, readl(io + intArg));
}
break;
case OVERLAY_GET_STARTBUF:
dprintk("overlay_kernel ioctl get startbuffer!\n");
if(copy_to_user((unsigned int *)arg, &over1_addr_phy, sizeof(unsigned int)))
{
dprintk("error while copy!\n");
return -EFAULT;
}else{
// dprintk("success get startbuf: 0x%x",over1_addr_phy);
}
break;
case OVERLAY_AUTORP_CTL:
if(copy_from_user(&intArg, (int *)arg, sizeof(int)))
return -EFAULT;
if(intArg == 1){
writel(0, io + SEP0611_ACSR);
data = readl(io + SEP0611_LCDCBCR);
data &=~(0x3<<13);
data |=(0x2<<13);
writel(data, io + SEP0611_LCDCBCR);
mdelay(10);
writel(1, io + SEP0611_ACSR);
dprintk("ctl enable auto repair\n");
}else{
data = readl(io + SEP0611_LCDCBCR);
data &=~(0x3<<13);
writel(data, io + SEP0611_LCDCBCR);
dprintk("ctl disable auto repair\n");
}
break;
case OVERLAY_SHOW_CURSOR:
return sep0611_overlay_drawcursor();
case OVERLAY_SETPOS_CURSOR:
if(copy_from_user(&intArg, (int *)arg, sizeof(int)))
return -EFAULT;
return sep0611_overlay_setpos_cursor(intArg);
case OVERLAY_LAYERS_CTL://enable or disable layers
if(copy_from_user(&intArg, (int *)arg, sizeof(int)))
return -EFAULT;
sep0611_overlay_layers_ctl(intArg);
break;
case 114://set lcdc timming
if(copy_from_user(&timming_tmp, (lcdc_timming *)arg, sizeof(lcdc_timming)))
return -EFAULT;
sep0611_overlay_settimming(timming_tmp);
break;
case 115://set lcdc base layer size and format
if(copy_from_user(&config, (overlay_config_t *)arg, sizeof(overlay_config_t)))
return -EFAULT;
intArg = 0;
dprintk("set base size:(%d,%d)\n", config.width, config.height);
intArg = XMAX(config.width)|YMAX(config.height);
writel(intArg, io + SEP0611_BBPCR);
writel(config.width, io + SEP0611_BASE_RAW_IMAGE_WIDTH);
switch(config.format)
{
case V4L2_PIX_FMT_RGB565:
dprintk("use rgb565\n");
data = readl(io + SEP0611_LCDCBCR);
data &=~(0x3<<27);
writel(data, io + SEP0611_LCDCBCR);
break;
case V4L2_PIX_FMT_RGB24:
dprintk("use rgb888\n");
data = readl(io + SEP0611_LCDCBCR);
data &= ~(0x3<<27);
data |= (0x2<<27);
writel(data, io + SEP0611_LCDCBCR);
break;
default:
dprintk("not support!\n");
break;
//.........这里部分代码省略.........
示例13: put_v4l2_input32
static inline int put_v4l2_input32(struct v4l2_input *kp, struct v4l2_input32 __user *up)
{
if (copy_to_user(up, kp, sizeof(struct v4l2_input32)))
return -EFAULT;
return 0;
}
示例14: put_v4l2_buffer32
static int put_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user *up)
{
struct v4l2_plane32 __user *uplane32;
struct v4l2_plane __user *uplane;
compat_caddr_t p;
int num_planes;
int ret;
if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_buffer32)) ||
put_user(kp->index, &up->index) ||
put_user(kp->type, &up->type) ||
put_user(kp->flags, &up->flags) ||
put_user(kp->memory, &up->memory) ||
put_user(kp->input, &up->input))
return -EFAULT;
if (put_user(kp->bytesused, &up->bytesused) ||
put_user(kp->field, &up->field) ||
put_user(kp->timestamp.tv_sec, &up->timestamp.tv_sec) ||
put_user(kp->timestamp.tv_usec, &up->timestamp.tv_usec) ||
copy_to_user(&up->timecode, &kp->timecode, sizeof(struct v4l2_timecode)) ||
put_user(kp->sequence, &up->sequence) ||
put_user(kp->reserved, &up->reserved))
return -EFAULT;
if (V4L2_TYPE_IS_MULTIPLANAR(kp->type)) {
num_planes = kp->length;
if (num_planes == 0)
return 0;
uplane = kp->m.planes;
if (get_user(p, &up->m.planes))
return -EFAULT;
uplane32 = compat_ptr(p);
while (--num_planes >= 0) {
ret = put_v4l2_plane32(uplane, uplane32, kp->memory);
if (ret)
return ret;
++uplane;
++uplane32;
}
} else {
switch (kp->memory) {
case V4L2_MEMORY_MMAP:
if (put_user(kp->length, &up->length) ||
put_user(kp->m.offset, &up->m.offset))
return -EFAULT;
break;
case V4L2_MEMORY_USERPTR:
if (put_user(kp->length, &up->length) ||
put_user(kp->m.userptr, &up->m.userptr))
return -EFAULT;
break;
case V4L2_MEMORY_OVERLAY:
if (put_user(kp->m.offset, &up->m.offset))
return -EFAULT;
break;
}
}
return 0;
}
示例15: epx_c3_ioctl
static long epx_c3_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
int options, retval = -EINVAL;
int __user *argp = (void __user *)arg;
static const struct watchdog_info ident = {
.options = WDIOF_KEEPALIVEPING,
.firmware_version = 0,
.identity = "Winsystems EPX-C3 H/W Watchdog",
};
switch (cmd) {
case WDIOC_GETSUPPORT:
if (copy_to_user(argp, &ident, sizeof(ident)))
return -EFAULT;
return 0;
case WDIOC_GETSTATUS:
case WDIOC_GETBOOTSTATUS:
return put_user(0, argp);
case WDIOC_SETOPTIONS:
if (get_user(options, argp))
return -EFAULT;
if (options & WDIOS_DISABLECARD) {
epx_c3_stop();
retval = 0;
}
if (options & WDIOS_ENABLECARD) {
epx_c3_start();
retval = 0;
}
return retval;
case WDIOC_KEEPALIVE:
epx_c3_pet();
return 0;
case WDIOC_GETTIMEOUT:
return put_user(WATCHDOG_TIMEOUT, argp);
default:
return -ENOTTY;
}
}
static int epx_c3_notify_sys(struct notifier_block *this, unsigned long code,
void *unused)
{
if (code == SYS_DOWN || code == SYS_HALT)
epx_c3_stop(); /* Turn the WDT off */
return NOTIFY_DONE;
}
static const struct file_operations epx_c3_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.write = epx_c3_write,
.unlocked_ioctl = epx_c3_ioctl,
.open = epx_c3_open,
.release = epx_c3_release,
};
static struct miscdevice epx_c3_miscdev = {
.minor = WATCHDOG_MINOR,
.name = "watchdog",
.fops = &epx_c3_fops,
};
static struct notifier_block epx_c3_notifier = {
.notifier_call = epx_c3_notify_sys,
};
static const char banner[] __initdata = KERN_INFO PFX
"Hardware Watchdog Timer for Winsystems EPX-C3 SBC: 0.1\n";
static int __init watchdog_init(void)
{
int ret;
if (!request_region(EPXC3_WATCHDOG_CTL_REG, 2, "epxc3_watchdog"))
return -EBUSY;
ret = register_reboot_notifier(&epx_c3_notifier);
if (ret) {
// printk(KERN_ERR PFX "cannot register reboot notifier "
;
goto out;
}
ret = misc_register(&epx_c3_miscdev);
if (ret) {
// printk(KERN_ERR PFX "cannot register miscdev on minor=%d "
;
unregister_reboot_notifier(&epx_c3_notifier);
goto out;
}
;
return 0;
//.........这里部分代码省略.........