static ssize_t pp_write (struct file * file, const char __user * buf, size_t count, loff_t * ppos) { unsigned int minor = iminor(file->f_path.dentry->d_inode); struct pp_struct *pp = file->private_data; char * kbuffer; ssize_t bytes_written = 0; ssize_t wrote; int mode; struct parport *pport; if (!(pp->flags & PP_CLAIMED)) { /* Don't have the port claimed */ printk (KERN_DEBUG CHRDEV "%x: claim the port first\n", minor); return -EINVAL; } kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL); if (!kbuffer) { return -ENOMEM; } pport = pp->pdev->port; mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR); parport_set_timeout (pp->pdev, (file->f_flags & O_NONBLOCK) ? PARPORT_INACTIVITY_O_NONBLOCK : pp->default_inactivity); while (bytes_written < count) { ssize_t n = min_t(unsigned long, count - bytes_written, PP_BUFFER_SIZE); if (copy_from_user (kbuffer, buf + bytes_written, n)) { bytes_written = -EFAULT; break; } if ((pp->flags & PP_FASTWRITE) && (mode == IEEE1284_MODE_EPP)) { /* do a fast EPP write */ if (pport->ieee1284.mode & IEEE1284_ADDR) { wrote = pport->ops->epp_write_addr (pport, kbuffer, n, PARPORT_EPP_FAST); } else { wrote = pport->ops->epp_write_data (pport, kbuffer, n, PARPORT_EPP_FAST); } } else { wrote = parport_write (pp->pdev->port, kbuffer, n); } if (wrote <= 0) { if (!bytes_written) { bytes_written = wrote; } break; } bytes_written += wrote; if (file->f_flags & O_NONBLOCK) { if (!bytes_written) bytes_written = -EAGAIN; break; } if (signal_pending (current)) { if (!bytes_written) { bytes_written = -EINTR; } break; } cond_resched(); } parport_set_timeout (pp->pdev, pp->default_inactivity); kfree (kbuffer); pp_enable_irq (pp); return bytes_written; }
static ssize_t fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) { unsigned long p = *ppos; struct inode *inode = file->f_path.dentry->d_inode; int fbidx = iminor(inode); struct fb_info *info = registered_fb[fbidx]; u32 *buffer, *dst; u32 __iomem *src; int c, i, cnt = 0, err = 0; unsigned long total_size; if (!info || ! info->screen_base) return -ENODEV; if (info->state != FBINFO_STATE_RUNNING) return -EPERM; if (info->fbops->fb_read) return info->fbops->fb_read(info, buf, count, ppos); total_size = info->screen_size; if (total_size == 0) total_size = info->fix.smem_len; if (p >= total_size) return 0; if (count >= total_size) count = total_size; if (count + p > total_size) count = total_size - p; buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count, GFP_KERNEL); if (!buffer) return -ENOMEM; src = (u32 __iomem *) (info->screen_base + p); if (info->fbops->fb_sync) info->fbops->fb_sync(info); while (count) { c = (count > PAGE_SIZE) ? PAGE_SIZE : count; dst = buffer; for (i = c >> 2; i--; ) *dst++ = fb_readl(src++); if (c & 3) { u8 *dst8 = (u8 *) dst; u8 __iomem *src8 = (u8 __iomem *) src; for (i = c & 3; i--;) *dst8++ = fb_readb(src8++); src = (u32 __iomem *) src8; } if (copy_to_user(buf, buffer, c)) { err = -EFAULT; break; } *ppos += c; buf += c; cnt += c; count -= c; }
static ssize_t pp_read (struct file * file, char __user * buf, size_t count, loff_t * ppos) { unsigned int minor = iminor(file->f_path.dentry->d_inode); struct pp_struct *pp = file->private_data; char * kbuffer; ssize_t bytes_read = 0; struct parport *pport; int mode; if (!(pp->flags & PP_CLAIMED)) { /* Don't have the port claimed */ printk (KERN_DEBUG CHRDEV "%x: claim the port first\n", minor); return -EINVAL; } /* Trivial case. */ if (count == 0) return 0; kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL); if (!kbuffer) { return -ENOMEM; } pport = pp->pdev->port; mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR); parport_set_timeout (pp->pdev, (file->f_flags & O_NONBLOCK) ? PARPORT_INACTIVITY_O_NONBLOCK : pp->default_inactivity); while (bytes_read == 0) { ssize_t need = min_t(unsigned long, count, PP_BUFFER_SIZE); if (mode == IEEE1284_MODE_EPP) { /* various specials for EPP mode */ int flags = 0; size_t (*fn)(struct parport *, void *, size_t, int); if (pp->flags & PP_W91284PIC) { flags |= PARPORT_W91284PIC; } if (pp->flags & PP_FASTREAD) { flags |= PARPORT_EPP_FAST; } if (pport->ieee1284.mode & IEEE1284_ADDR) { fn = pport->ops->epp_read_addr; } else { fn = pport->ops->epp_read_data; } bytes_read = (*fn)(pport, kbuffer, need, flags); } else { bytes_read = parport_read (pport, kbuffer, need); } if (bytes_read != 0) break; if (file->f_flags & O_NONBLOCK) { bytes_read = -EAGAIN; break; } if (signal_pending (current)) { bytes_read = -ERESTARTSYS; break; } cond_resched(); } parport_set_timeout (pp->pdev, pp->default_inactivity); if (bytes_read > 0 && copy_to_user (buf, kbuffer, bytes_read)) bytes_read = -EFAULT; kfree (kbuffer); pp_enable_irq (pp); return bytes_read; }
static int dsp56k_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { int dev = iminor(inode) & 0x0f; switch(dev) { case DSP56K_DEV_56001: switch(cmd) { case DSP56K_UPLOAD: { char *bin; int r, len; struct dsp56k_upload *binary = (struct dsp56k_upload *) arg; if(get_user(len, &binary->len) < 0) return -EFAULT; if(get_user(bin, &binary->bin) < 0) return -EFAULT; if (len == 0) { return -EINVAL; /* nothing to upload?!? */ } if (len > DSP56K_MAX_BINARY_LENGTH) { return -EINVAL; } r = dsp56k_upload(bin, len); if (r < 0) { return r; } break; } case DSP56K_SET_TX_WSIZE: if (arg > 4 || arg < 1) return -EINVAL; dsp56k.tx_wsize = (int) arg; break; case DSP56K_SET_RX_WSIZE: if (arg > 4 || arg < 1) return -EINVAL; dsp56k.rx_wsize = (int) arg; break; case DSP56K_HOST_FLAGS: { int dir, out, status; struct dsp56k_host_flags *hf = (struct dsp56k_host_flags*) arg; if(get_user(dir, &hf->dir) < 0) return -EFAULT; if(get_user(out, &hf->out) < 0) return -EFAULT; if ((dir & 0x1) && (out & 0x1)) dsp56k_host_interface.icr |= DSP56K_ICR_HF0; else if (dir & 0x1) dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0; if ((dir & 0x2) && (out & 0x2)) dsp56k_host_interface.icr |= DSP56K_ICR_HF1; else if (dir & 0x2) dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1; status = 0; if (dsp56k_host_interface.icr & DSP56K_ICR_HF0) status |= 0x1; if (dsp56k_host_interface.icr & DSP56K_ICR_HF1) status |= 0x2; if (dsp56k_host_interface.isr & DSP56K_ISR_HF2) status |= 0x4; if (dsp56k_host_interface.isr & DSP56K_ISR_HF3) status |= 0x8; return put_user(status, &hf->status); } case DSP56K_HOST_CMD: if (arg > 31 || arg < 0) return -EINVAL; dsp56k_host_interface.cvr = (u_char)((arg & DSP56K_CVR_HV_MASK) | DSP56K_CVR_HC); break; default: return -EINVAL; } return 0; default: printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev); return -ENXIO; } }
/* * a note on stream states used: * we use follwing states in the compressed core * SNDRV_PCM_STATE_OPEN: When stream has been opened. * SNDRV_PCM_STATE_SETUP: When stream has been initialized. This is done by * calling SNDRV_COMPRESS_SET_PARAMS. running streams will come to this * state at stop by calling SNDRV_COMPRESS_STOP, or at end of drain. * SNDRV_PCM_STATE_RUNNING: When stream has been started and is * decoding/encoding and rendering/capturing data. * SNDRV_PCM_STATE_DRAINING: When stream is draining current data. This is done * by calling SNDRV_COMPRESS_DRAIN. * SNDRV_PCM_STATE_PAUSED: When stream is paused. This is done by calling * SNDRV_COMPRESS_PAUSE. It can be stopped or resumed by calling * SNDRV_COMPRESS_STOP or SNDRV_COMPRESS_RESUME respectively. */ static int snd_compr_open(struct inode *inode, struct file *f) { struct snd_compr *compr; struct snd_compr_file *data; struct snd_compr_runtime *runtime; enum snd_compr_direction dirn; int maj = imajor(inode); int ret; if ((f->f_flags & O_ACCMODE) == O_WRONLY) dirn = SND_COMPRESS_PLAYBACK; else if ((f->f_flags & O_ACCMODE) == O_RDONLY) dirn = SND_COMPRESS_CAPTURE; else return -EINVAL; if (maj == snd_major) compr = snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_COMPRESS); else return -EBADFD; if (compr == NULL) { pr_err("no device data!!!\n"); return -ENODEV; } if (dirn != compr->direction) { pr_err("this device doesn't support this direction\n"); snd_card_unref(compr->card); return -EINVAL; } data = kzalloc(sizeof(*data), GFP_KERNEL); if (!data) { snd_card_unref(compr->card); return -ENOMEM; } data->stream.ops = compr->ops; data->stream.direction = dirn; data->stream.private_data = compr->private_data; data->stream.device = compr; runtime = kzalloc(sizeof(*runtime), GFP_KERNEL); if (!runtime) { kfree(data); snd_card_unref(compr->card); return -ENOMEM; } runtime->state = SNDRV_PCM_STATE_OPEN; init_waitqueue_head(&runtime->sleep); data->stream.runtime = runtime; f->private_data = (void *)data; mutex_lock(&compr->lock); ret = compr->ops->open(&data->stream); mutex_unlock(&compr->lock); if (ret) { kfree(runtime); kfree(data); } snd_card_unref(compr->card); return ret; }
static ssize_t driver_open(struct inode *inode, struct file* file) { if (is_open) return -EBUSY; is_open++; try_module_get(THIS_MODULE); pr_debug("Module fops:device %s was opened from device with minor no %d \n", DEVNAME , iminor(inode)); return 0; }
static ssize_t dsp56k_write(struct file *file, const char *buf, size_t count, loff_t *ppos) { struct inode *inode = file->f_dentry->d_inode; int dev = iminor(inode) & 0x0f; switch(dev) { case DSP56K_DEV_56001: { long n; /* Don't do anything if nothing is to be done */ if (!count) return 0; n = 0; switch (dsp56k.tx_wsize) { case 1: /* 8 bit */ { handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT, get_user(dsp56k_host_interface.data.b[3], buf+n++)); return n; } case 2: /* 16 bit */ { short *data; count /= 2; data = (short*) buf; handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT, get_user(dsp56k_host_interface.data.w[1], data+n++)); return 2*n; } case 3: /* 24 bit */ { count /= 3; handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT, get_user(dsp56k_host_interface.data.b[1], buf+n++); get_user(dsp56k_host_interface.data.b[2], buf+n++); get_user(dsp56k_host_interface.data.b[3], buf+n++)); return 3*n; } case 4: /* 32 bit */ { long *data; count /= 4; data = (long*) buf; handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT, get_user(dsp56k_host_interface.data.l, data+n++)); return 4*n; } } return -EFAULT; } default: printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev); return -ENXIO; } }
static int file_release(struct inode *inode, struct file *filp) { return rtlx_release(iminor(inode)); }
/* We use the SunOS mmap() semantics. */ asmlinkage unsigned long sunos_mmap(unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, unsigned long off) { struct file * file = NULL; unsigned long retval, ret_type; if (flags & MAP_NORESERVE) { static int cnt; if (cnt++ < 10) printk("%s: unimplemented SunOS MAP_NORESERVE mmap() flag\n", current->comm); flags &= ~MAP_NORESERVE; } retval = -EBADF; if (!(flags & MAP_ANONYMOUS)) { if (fd >= SUNOS_NR_OPEN) goto out; file = fget(fd); if (!file) goto out; } retval = -EINVAL; /* If this is ld.so or a shared library doing an mmap * of /dev/zero, transform it into an anonymous mapping. * SunOS is so stupid some times... hmph! */ if (file) { if (imajor(file->f_path.dentry->d_inode) == MEM_MAJOR && iminor(file->f_path.dentry->d_inode) == 5) { flags |= MAP_ANONYMOUS; fput(file); file = NULL; } } ret_type = flags & _MAP_NEW; flags &= ~_MAP_NEW; if (!(flags & MAP_FIXED)) addr = 0; else { if (ARCH_SUN4C_SUN4 && (len > 0x20000000 || ((flags & MAP_FIXED) && addr < 0xe0000000 && addr + len > 0x20000000))) goto out_putf; /* See asm-sparc/uaccess.h */ if (len > TASK_SIZE - PAGE_SIZE || addr + len > TASK_SIZE - PAGE_SIZE) goto out_putf; } flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE); down_write(¤t->mm->mmap_sem); retval = do_mmap(file, addr, len, prot, flags, off); up_write(¤t->mm->mmap_sem); if (!ret_type) retval = ((retval < PAGE_OFFSET) ? 0 : retval); out_putf: if (file) fput(file); out: return retval; }
ssize_t nsc_gpio_write(struct file *file, const char __user *data, size_t len, loff_t *ppos) { unsigned m = iminor(file->f_path.dentry->d_inode); struct nsc_gpio_ops *amp = file->private_data; struct device *dev = amp->dev; size_t i; int err = 0; for (i = 0; i < len; ++i) { char c; if (get_user(c, data + i)) return -EFAULT; switch (c) { case '0': amp->gpio_set(m, 0); break; case '1': amp->gpio_set(m, 1); break; case 'O': dev_dbg(dev, "GPIO%d output enabled\n", m); amp->gpio_config(m, ~1, 1); break; case 'o': dev_dbg(dev, "GPIO%d output disabled\n", m); amp->gpio_config(m, ~1, 0); break; case 'T': dev_dbg(dev, "GPIO%d output is push pull\n", m); amp->gpio_config(m, ~2, 2); break; case 't': dev_dbg(dev, "GPIO%d output is open drain\n", m); amp->gpio_config(m, ~2, 0); break; case 'P': dev_dbg(dev, "GPIO%d pull up enabled\n", m); amp->gpio_config(m, ~4, 4); break; case 'p': dev_dbg(dev, "GPIO%d pull up disabled\n", m); amp->gpio_config(m, ~4, 0); break; case 'v': /* View Current pin settings */ amp->gpio_dump(amp, m); break; case '\n': /* end of settings string, do nothing */ break; default: dev_err(dev, "io%2d bad setting: chr<0x%2x>\n", m, (int)c); err++; } } if (err) return -EINVAL; /* full string handled, report error */ return len; }
static int file_open(struct inode *inode, struct file *filp) { return rtlx_open(iminor(inode), (filp->f_flags & O_NONBLOCK) ? 0 : 1); }
/** * usb_tranzport_open */ static int usb_tranzport_open(struct inode *inode, struct file *file) { struct usb_tranzport *dev; int subminor; int retval = 0; struct usb_interface *interface; nonseekable_open(inode, file); subminor = iminor(inode); mutex_lock(&disconnect_mutex); interface = usb_find_interface(&usb_tranzport_driver, subminor); if (!interface) { err("%s - error, can't find device for minor %d\n", __FUNCTION__, subminor); retval = -ENODEV; goto unlock_disconnect_exit; } dev = usb_get_intfdata(interface); if (!dev) { retval = -ENODEV; goto unlock_disconnect_exit; } /* lock this device */ if (down_interruptible(&dev->sem)) { retval = -ERESTARTSYS; goto unlock_disconnect_exit; } /* allow opening only once */ if (dev->open_count) { retval = -EBUSY; goto unlock_exit; } dev->open_count = 1; /* initialize in direction */ dev->ring_head = 0; dev->ring_tail = 0; usb_fill_int_urb(dev->interrupt_in_urb, interface_to_usbdev(interface), usb_rcvintpipe(interface_to_usbdev(interface), dev->interrupt_in_endpoint->bEndpointAddress), dev->interrupt_in_buffer, dev->interrupt_in_endpoint_size, usb_tranzport_interrupt_in_callback, dev, dev->interrupt_in_interval); dev->interrupt_in_running = 1; dev->interrupt_in_done = 0; dev->enable = 1; dev->offline = 0; dev->compress_wheel = 1; retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL); if (retval) { dev_err(&interface->dev, "Couldn't submit interrupt_in_urb %d\n", retval); dev->interrupt_in_running = 0; dev->open_count = 0; goto unlock_exit; } /* save device in the file's private structure */ file->private_data = dev; unlock_exit: up(&dev->sem); unlock_disconnect_exit: mutex_unlock(&disconnect_mutex); return retval; }
static int z2_open( struct inode *inode, struct file *filp ) { int device; int max_z2_map = ( Z2RAM_SIZE / Z2RAM_CHUNKSIZE ) * sizeof( z2ram_map[0] ); int max_chip_map = ( amiga_chip_size / Z2RAM_CHUNKSIZE ) * sizeof( z2ram_map[0] ); int rc = -ENOMEM; device = iminor(inode); if ( current_device != -1 && current_device != device ) { rc = -EBUSY; goto err_out; } if ( current_device == -1 ) { z2_count = 0; chip_count = 0; list_count = 0; z2ram_size = 0; /* Use a specific list entry. */ if (device >= Z2MINOR_MEMLIST1 && device <= Z2MINOR_MEMLIST4) { int index = device - Z2MINOR_MEMLIST1 + 1; unsigned long size, paddr, vaddr; if (index >= m68k_realnum_memory) { printk( KERN_ERR DEVICE_NAME ": no such entry in z2ram_map\n" ); goto err_out; } paddr = m68k_memory[index].addr; size = m68k_memory[index].size & ~(Z2RAM_CHUNKSIZE-1); #ifdef __powerpc__ /* FIXME: ioremap doesn't build correct memory tables. */ { vfree(vmalloc (size)); } vaddr = (unsigned long) __ioremap (paddr, size, _PAGE_WRITETHRU); #else vaddr = (unsigned long)z_remap_nocache_nonser(paddr, size); #endif z2ram_map = kmalloc((size/Z2RAM_CHUNKSIZE)*sizeof(z2ram_map[0]), GFP_KERNEL); if ( z2ram_map == NULL ) { printk( KERN_ERR DEVICE_NAME ": cannot get mem for z2ram_map\n" ); goto err_out; } while (size) { z2ram_map[ z2ram_size++ ] = vaddr; size -= Z2RAM_CHUNKSIZE; vaddr += Z2RAM_CHUNKSIZE; list_count++; } if ( z2ram_size != 0 ) printk( KERN_INFO DEVICE_NAME ": using %iK List Entry %d Memory\n", list_count * Z2RAM_CHUNK1024, index ); } else switch ( device ) { case Z2MINOR_COMBINED: z2ram_map = kmalloc( max_z2_map + max_chip_map, GFP_KERNEL ); if ( z2ram_map == NULL ) { printk( KERN_ERR DEVICE_NAME ": cannot get mem for z2ram_map\n" ); goto err_out; } get_z2ram(); get_chipram(); if ( z2ram_size != 0 ) printk( KERN_INFO DEVICE_NAME ": using %iK Zorro II RAM and %iK Chip RAM (Total %dK)\n", z2_count * Z2RAM_CHUNK1024, chip_count * Z2RAM_CHUNK1024, ( z2_count + chip_count ) * Z2RAM_CHUNK1024 ); break; case Z2MINOR_Z2ONLY: z2ram_map = kmalloc( max_z2_map, GFP_KERNEL ); if ( z2ram_map == NULL ) { printk( KERN_ERR DEVICE_NAME ": cannot get mem for z2ram_map\n" ); goto err_out; } get_z2ram(); if ( z2ram_size != 0 ) printk( KERN_INFO DEVICE_NAME ": using %iK of Zorro II RAM\n", z2_count * Z2RAM_CHUNK1024 ); break; case Z2MINOR_CHIPONLY: z2ram_map = kmalloc( max_chip_map, GFP_KERNEL ); if ( z2ram_map == NULL ) { printk( KERN_ERR DEVICE_NAME ": cannot get mem for z2ram_map\n" ); goto err_out; } get_chipram(); if ( z2ram_size != 0 ) printk( KERN_INFO DEVICE_NAME ": using %iK Chip RAM\n", chip_count * Z2RAM_CHUNK1024 ); break; default: rc = -ENODEV; goto err_out; break; } if ( z2ram_size == 0 ) { printk( KERN_NOTICE DEVICE_NAME ": no unused ZII/Chip RAM found\n" ); goto err_out_kfree; } current_device = device; z2ram_size <<= Z2RAM_CHUNKSHIFT; set_capacity(z2ram_gendisk, z2ram_size >> 9); }
int pwm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { int mode; unsigned int minor = iminor(inode); struct pwm_davinci_device *pwm_dev; pwm_dev = pwm_dev_get_by_minor(minor); switch (cmd) { case PWMIOC_SET_MODE: if (pwm_dev->regs->cfg & 0x20000) return -EBUSY; get_user(mode, (int *)arg); if (mode == PWM_ONESHOT_MODE) { pwm_dev->regs->cfg &= 0xFFFFFFFC; pwm_dev->regs->cfg |= 0x1; } else if (mode == PWM_CONTINUOUS_MODE) { pwm_dev->regs->cfg &= 0xFFFFFFFC; pwm_dev->regs->cfg |= 0x2; } else return -EINVAL; break; case PWMIOC_SET_PERIOD: get_user(mode, (int *)arg); if (mode < 0 || mode > 0xffffffff) return -EINVAL; if (pwm_dev->regs->cfg & 0x2 && pwm_dev->regs->cfg & 0x20000) { if (mode < 7) return -EINVAL; /* Enable PWM interrupts */ pwm_dev->regs->cfg |= 0x40; /* wait for the transaction to complete */ wait_event_timeout(pwm_dev->intr_wait, pwm_dev->intr_complete, DAVINCI_PWM_TIMEOUT); if (pwm_dev->intr_complete) pwm_dev->regs->per = mode; else return -1; } else pwm_dev->regs->per = mode; break; case PWMIOC_SET_DURATION: get_user(mode, (int *)arg); if (mode < 0 || mode > 0xffffffff) return -EINVAL; if (pwm_dev->regs->cfg & 0x2 && pwm_dev->regs->cfg & 0x20000) { /* Enable PWM interrupts */ pwm_dev->regs->cfg |= 0x40; /* wait for the transaction to complete */ wait_event_timeout(pwm_dev->intr_wait, pwm_dev->intr_complete, DAVINCI_PWM_TIMEOUT); if (pwm_dev->intr_complete) pwm_dev->regs->ph1d = mode; else return -1; } else pwm_dev->regs->ph1d = mode; break; case PWMIOC_SET_RPT_VAL: get_user(mode, (int *)arg); if (mode < 0 || mode > 0xff) return -EINVAL; pwm_dev->regs->rpt = mode; break; case PWMIOC_SET_FIRST_PHASE_STATE: get_user(mode, (int *)arg); if (pwm_dev->regs->cfg & 0x20000) return -EBUSY; if (mode == 1) pwm_dev->regs->cfg |= 0x10; else if (mode == 0) pwm_dev->regs->cfg &= ~0x10; else return -EINVAL; break; case PWMIOC_SET_INACT_OUT_STATE: get_user(mode, (int *)arg); if (pwm_dev->regs->cfg & 0x20000) return -EBUSY; if (mode == 1) pwm_dev->regs->cfg |= 0x20; else if (mode == 0) pwm_dev->regs->cfg &= ~0x20; else return -EINVAL; break; case PWMIOC_START: pwm_dev->regs->start = 0x1; break; case PWMIOC_STOP: if (pwm_dev->regs->cfg & 0x1 && pwm_dev->regs->cfg & 0x20000) pwm_dev->regs->cfg &= 0xFFFFFFFC; if (pwm_dev->regs->cfg & 0x2 && pwm_dev->regs->cfg & 0x20000) { unsigned long temp; temp = pwm_dev->regs->cfg; temp &= 0xFFFFFFFC; temp |= 0x1; /* Enable PWM interrupts */ pwm_dev->regs->cfg |= 0x40; /* wait for the transaction to complete */ wait_event_timeout(pwm_dev->intr_wait, pwm_dev->intr_complete, DAVINCI_PWM_TIMEOUT); if (pwm_dev->intr_complete) pwm_dev->regs->cfg = temp; else return -1; } break; } return 0; }
static int tf_device_open(struct inode *inode, struct file *file) { int error; struct tf_device *dev = &g_tf_dev; struct tf_connection *connection = NULL; dprintk(KERN_INFO "tf_device_open(%u:%u, %p)\n", imajor(inode), iminor(inode), file); /* Dummy lseek for non-seekable driver */ error = nonseekable_open(inode, file); if (error != 0) { dprintk(KERN_ERR "tf_device_open(%p): " "nonseekable_open failed (error %d)!\n", file, error); goto error; } /* * Open a new connection. */ error = tf_open(dev, file, &connection); if (error != 0) { dprintk(KERN_ERR "tf_device_open(%p): " "tf_open failed (error %d)!\n", file, error); goto error; } file->private_data = connection; /* * Send the CreateDeviceContext command to the secure */ error = tf_create_device_context(connection); if (error != 0) { dprintk(KERN_ERR "tf_device_open(%p): " "tf_create_device_context failed (error %d)!\n", file, error); goto error1; } /* * Successful completion. */ dprintk(KERN_INFO "tf_device_open(%p): Success (connection=%p)\n", file, connection); return 0; /* * Error handling. */ error1: tf_close(connection); error: dprintk(KERN_INFO "tf_device_open(%p): Failure (error %d)\n", file, error); return error; }
struct video_device *video_devdata(struct file *file) { return video_device[iminor(file->f_path.dentry->d_inode)]; }
/** * ld_usb_open */ static int ld_usb_open(struct inode *inode, struct file *file) { struct ld_usb *dev; int subminor; int retval; struct usb_interface *interface; nonseekable_open(inode, file); subminor = iminor(inode); interface = usb_find_interface(&ld_usb_driver, subminor); if (!interface) { printk(KERN_ERR "%s - error, can't find device for minor %d\n", __func__, subminor); return -ENODEV; } dev = usb_get_intfdata(interface); if (!dev) return -ENODEV; /* lock this device */ if (mutex_lock_interruptible(&dev->mutex)) return -ERESTARTSYS; /* allow opening only once */ if (dev->open_count) { retval = -EBUSY; goto unlock_exit; } dev->open_count = 1; /* initialize in direction */ dev->ring_head = 0; dev->ring_tail = 0; dev->buffer_overflow = 0; usb_fill_int_urb(dev->interrupt_in_urb, interface_to_usbdev(interface), usb_rcvintpipe(interface_to_usbdev(interface), dev->interrupt_in_endpoint->bEndpointAddress), dev->interrupt_in_buffer, dev->interrupt_in_endpoint_size, ld_usb_interrupt_in_callback, dev, dev->interrupt_in_interval); dev->interrupt_in_running = 1; dev->interrupt_in_done = 0; retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL); if (retval) { dev_err(&interface->dev, "Couldn't submit interrupt_in_urb %d\n", retval); dev->interrupt_in_running = 0; dev->open_count = 0; goto unlock_exit; } /* save device in the file's private structure */ file->private_data = dev; unlock_exit: mutex_unlock(&dev->mutex); return retval; }
struct video_device *video_devdata(struct file *file) { return video_device[iminor(file_inode(file))]; }