swh:1:snp:c2847dfd741eae21606027cf29250d1ebcd63fb4
Tip revision: 049e6dde7e57f0054fdc49102e7ef4830c698b46 authored by Linus Torvalds on 04 October 2015, 15:57:17 UTC
Linux 4.3-rc4
Linux 4.3-rc4
Tip revision: 049e6dd
divasi.c
/* $Id: divasi.c,v 1.25.6.2 2005/01/31 12:22:20 armin Exp $
*
* Driver for Eicon DIVA Server ISDN cards.
* User Mode IDI Interface
*
* Copyright 2000-2003 by Armin Schindler (mac@melware.de)
* Copyright 2000-2003 Cytronics & Melware (info@melware.de)
*
* This software may be used and distributed according to the terms
* of the GNU General Public License, incorporated herein by reference.
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/proc_fs.h>
#include <linux/skbuff.h>
#include <linux/seq_file.h>
#include <asm/uaccess.h>
#include "platform.h"
#include "di_defs.h"
#include "divasync.h"
#include "um_xdi.h"
#include "um_idi.h"
static char *main_revision = "$Revision: 1.25.6.2 $";
static int major;
MODULE_DESCRIPTION("User IDI Interface for Eicon ISDN cards");
MODULE_AUTHOR("Cytronics & Melware, Eicon Networks");
MODULE_SUPPORTED_DEVICE("DIVA card driver");
MODULE_LICENSE("GPL");
typedef struct _diva_um_idi_os_context {
wait_queue_head_t read_wait;
wait_queue_head_t close_wait;
struct timer_list diva_timer_id;
int aborted;
int adapter_nr;
} diva_um_idi_os_context_t;
static char *DRIVERNAME = "Eicon DIVA - User IDI (http://www.melware.net)";
static char *DRIVERLNAME = "diva_idi";
static char *DEVNAME = "DivasIDI";
char *DRIVERRELEASE_IDI = "2.0";
extern int idifunc_init(void);
extern void idifunc_finit(void);
/*
* helper functions
*/
static char *getrev(const char *revision)
{
char *rev;
char *p;
if ((p = strchr(revision, ':'))) {
rev = p + 2;
p = strchr(rev, '$');
*--p = 0;
} else
rev = "1.0";
return rev;
}
/*
* LOCALS
*/
static ssize_t um_idi_read(struct file *file, char __user *buf, size_t count,
loff_t *offset);
static ssize_t um_idi_write(struct file *file, const char __user *buf,
size_t count, loff_t *offset);
static unsigned int um_idi_poll(struct file *file, poll_table *wait);
static int um_idi_open(struct inode *inode, struct file *file);
static int um_idi_release(struct inode *inode, struct file *file);
static int remove_entity(void *entity);
static void diva_um_timer_function(unsigned long data);
/*
* proc entry
*/
extern struct proc_dir_entry *proc_net_eicon;
static struct proc_dir_entry *um_idi_proc_entry = NULL;
static int um_idi_proc_show(struct seq_file *m, void *v)
{
char tmprev[32];
seq_printf(m, "%s\n", DRIVERNAME);
seq_printf(m, "name : %s\n", DRIVERLNAME);
seq_printf(m, "release : %s\n", DRIVERRELEASE_IDI);
strcpy(tmprev, main_revision);
seq_printf(m, "revision : %s\n", getrev(tmprev));
seq_printf(m, "build : %s\n", DIVA_BUILD);
seq_printf(m, "major : %d\n", major);
return 0;
}
static int um_idi_proc_open(struct inode *inode, struct file *file)
{
return single_open(file, um_idi_proc_show, NULL);
}
static const struct file_operations um_idi_proc_fops = {
.owner = THIS_MODULE,
.open = um_idi_proc_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
static int __init create_um_idi_proc(void)
{
um_idi_proc_entry = proc_create(DRIVERLNAME, S_IRUGO, proc_net_eicon,
&um_idi_proc_fops);
if (!um_idi_proc_entry)
return (0);
return (1);
}
static void remove_um_idi_proc(void)
{
if (um_idi_proc_entry) {
remove_proc_entry(DRIVERLNAME, proc_net_eicon);
um_idi_proc_entry = NULL;
}
}
static const struct file_operations divas_idi_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.read = um_idi_read,
.write = um_idi_write,
.poll = um_idi_poll,
.open = um_idi_open,
.release = um_idi_release
};
static void divas_idi_unregister_chrdev(void)
{
unregister_chrdev(major, DEVNAME);
}
static int __init divas_idi_register_chrdev(void)
{
if ((major = register_chrdev(0, DEVNAME, &divas_idi_fops)) < 0)
{
printk(KERN_ERR "%s: failed to create /dev entry.\n",
DRIVERLNAME);
return (0);
}
return (1);
}
/*
** Driver Load
*/
static int __init divasi_init(void)
{
char tmprev[50];
int ret = 0;
printk(KERN_INFO "%s\n", DRIVERNAME);
printk(KERN_INFO "%s: Rel:%s Rev:", DRIVERLNAME, DRIVERRELEASE_IDI);
strcpy(tmprev, main_revision);
printk("%s Build: %s\n", getrev(tmprev), DIVA_BUILD);
if (!divas_idi_register_chrdev()) {
ret = -EIO;
goto out;
}
if (!create_um_idi_proc()) {
divas_idi_unregister_chrdev();
printk(KERN_ERR "%s: failed to create proc entry.\n",
DRIVERLNAME);
ret = -EIO;
goto out;
}
if (!(idifunc_init())) {
remove_um_idi_proc();
divas_idi_unregister_chrdev();
printk(KERN_ERR "%s: failed to connect to DIDD.\n",
DRIVERLNAME);
ret = -EIO;
goto out;
}
printk(KERN_INFO "%s: started with major %d\n", DRIVERLNAME, major);
out:
return (ret);
}
/*
** Driver Unload
*/
static void __exit divasi_exit(void)
{
idifunc_finit();
remove_um_idi_proc();
divas_idi_unregister_chrdev();
printk(KERN_INFO "%s: module unloaded.\n", DRIVERLNAME);
}
module_init(divasi_init);
module_exit(divasi_exit);
/*
* FILE OPERATIONS
*/
static int
divas_um_idi_copy_to_user(void *os_handle, void *dst, const void *src,
int length)
{
memcpy(dst, src, length);
return (length);
}
static ssize_t
um_idi_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
{
diva_um_idi_os_context_t *p_os;
int ret = -EINVAL;
void *data;
if (!file->private_data) {
return (-ENODEV);
}
if (!
(p_os =
(diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->
private_data)))
{
return (-ENODEV);
}
if (p_os->aborted) {
return (-ENODEV);
}
if (!(data = diva_os_malloc(0, count))) {
return (-ENOMEM);
}
ret = diva_um_idi_read(file->private_data,
file, data, count,
divas_um_idi_copy_to_user);
switch (ret) {
case 0: /* no message available */
ret = (-EAGAIN);
break;
case (-1): /* adapter was removed */
ret = (-ENODEV);
break;
case (-2): /* message_length > length of user buffer */
ret = (-EFAULT);
break;
}
if (ret > 0) {
if (copy_to_user(buf, data, ret)) {
ret = (-EFAULT);
}
}
diva_os_free(0, data);
DBG_TRC(("read: ret %d", ret));
return (ret);
}
static int
divas_um_idi_copy_from_user(void *os_handle, void *dst, const void *src,
int length)
{
memcpy(dst, src, length);
return (length);
}
static int um_idi_open_adapter(struct file *file, int adapter_nr)
{
diva_um_idi_os_context_t *p_os;
void *e =
divas_um_idi_create_entity((dword) adapter_nr, (void *) file);
if (!(file->private_data = e)) {
return (0);
}
p_os = (diva_um_idi_os_context_t *) diva_um_id_get_os_context(e);
init_waitqueue_head(&p_os->read_wait);
init_waitqueue_head(&p_os->close_wait);
init_timer(&p_os->diva_timer_id);
p_os->diva_timer_id.function = (void *) diva_um_timer_function;
p_os->diva_timer_id.data = (unsigned long) p_os;
p_os->aborted = 0;
p_os->adapter_nr = adapter_nr;
return (1);
}
static ssize_t
um_idi_write(struct file *file, const char __user *buf, size_t count,
loff_t *offset)
{
diva_um_idi_os_context_t *p_os;
int ret = -EINVAL;
void *data;
int adapter_nr = 0;
if (!file->private_data) {
/* the first write() selects the adapter_nr */
if (count == sizeof(int)) {
if (copy_from_user
((void *) &adapter_nr, buf,
count)) return (-EFAULT);
if (!(um_idi_open_adapter(file, adapter_nr)))
return (-ENODEV);
return (count);
} else
return (-ENODEV);
}
if (!(p_os =
(diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->
private_data)))
{
return (-ENODEV);
}
if (p_os->aborted) {
return (-ENODEV);
}
if (!(data = diva_os_malloc(0, count))) {
return (-ENOMEM);
}
if (copy_from_user(data, buf, count)) {
ret = -EFAULT;
} else {
ret = diva_um_idi_write(file->private_data,
file, data, count,
divas_um_idi_copy_from_user);
switch (ret) {
case 0: /* no space available */
ret = (-EAGAIN);
break;
case (-1): /* adapter was removed */
ret = (-ENODEV);
break;
case (-2): /* length of user buffer > max message_length */
ret = (-EFAULT);
break;
}
}
diva_os_free(0, data);
DBG_TRC(("write: ret %d", ret));
return (ret);
}
static unsigned int um_idi_poll(struct file *file, poll_table *wait)
{
diva_um_idi_os_context_t *p_os;
if (!file->private_data) {
return (POLLERR);
}
if ((!(p_os =
(diva_um_idi_os_context_t *)
diva_um_id_get_os_context(file->private_data)))
|| p_os->aborted) {
return (POLLERR);
}
poll_wait(file, &p_os->read_wait, wait);
if (p_os->aborted) {
return (POLLERR);
}
switch (diva_user_mode_idi_ind_ready(file->private_data, file)) {
case (-1):
return (POLLERR);
case 0:
return (0);
}
return (POLLIN | POLLRDNORM);
}
static int um_idi_open(struct inode *inode, struct file *file)
{
return (0);
}
static int um_idi_release(struct inode *inode, struct file *file)
{
diva_um_idi_os_context_t *p_os;
unsigned int adapter_nr;
int ret = 0;
if (!(file->private_data)) {
ret = -ENODEV;
goto out;
}
if (!(p_os =
(diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->private_data))) {
ret = -ENODEV;
goto out;
}
adapter_nr = p_os->adapter_nr;
if ((ret = remove_entity(file->private_data))) {
goto out;
}
if (divas_um_idi_delete_entity
((int) adapter_nr, file->private_data)) {
ret = -ENODEV;
goto out;
}
out:
return (ret);
}
int diva_os_get_context_size(void)
{
return (sizeof(diva_um_idi_os_context_t));
}
void diva_os_wakeup_read(void *os_context)
{
diva_um_idi_os_context_t *p_os =
(diva_um_idi_os_context_t *) os_context;
wake_up_interruptible(&p_os->read_wait);
}
void diva_os_wakeup_close(void *os_context)
{
diva_um_idi_os_context_t *p_os =
(diva_um_idi_os_context_t *) os_context;
wake_up_interruptible(&p_os->close_wait);
}
static
void diva_um_timer_function(unsigned long data)
{
diva_um_idi_os_context_t *p_os = (diva_um_idi_os_context_t *) data;
p_os->aborted = 1;
wake_up_interruptible(&p_os->read_wait);
wake_up_interruptible(&p_os->close_wait);
DBG_ERR(("entity removal watchdog"))
}
/*
** If application exits without entity removal this function will remove
** entity and block until removal is complete
*/
static int remove_entity(void *entity)
{
struct task_struct *curtask = current;
diva_um_idi_os_context_t *p_os;
diva_um_idi_stop_wdog(entity);
if (!entity) {
DBG_FTL(("Zero entity on remove"))
return (0);
}
if (!(p_os =
(diva_um_idi_os_context_t *)
diva_um_id_get_os_context(entity))) {
DBG_FTL(("Zero entity os context on remove"))
return (0);
}
if (!divas_um_idi_entity_assigned(entity) || p_os->aborted) {
/*
Entity is not assigned, also can be removed
*/
return (0);
}
DBG_TRC(("E(%08x) check remove", entity))
/*
If adapter not answers on remove request inside of
10 Sec, then adapter is dead
*/
diva_um_idi_start_wdog(entity);
{
DECLARE_WAITQUEUE(wait, curtask);
add_wait_queue(&p_os->close_wait, &wait);
for (;;) {
set_current_state(TASK_INTERRUPTIBLE);
if (!divas_um_idi_entity_start_remove(entity)
|| p_os->aborted) {
break;
}
schedule();
}
set_current_state(TASK_RUNNING);
remove_wait_queue(&p_os->close_wait, &wait);
}
DBG_TRC(("E(%08x) start remove", entity))
{
DECLARE_WAITQUEUE(wait, curtask);
add_wait_queue(&p_os->close_wait, &wait);
for (;;) {
set_current_state(TASK_INTERRUPTIBLE);
if (!divas_um_idi_entity_assigned(entity)
|| p_os->aborted) {
break;
}
schedule();
}
set_current_state(TASK_RUNNING);
remove_wait_queue(&p_os->close_wait, &wait);
}
DBG_TRC(("E(%08x) remove complete, aborted:%d", entity,
p_os->aborted))
diva_um_idi_stop_wdog(entity);
p_os->aborted = 0;
return (0);
}
/*
* timer watchdog
*/
void diva_um_idi_start_wdog(void *entity)
{
diva_um_idi_os_context_t *p_os;
if (entity &&
((p_os =
(diva_um_idi_os_context_t *)
diva_um_id_get_os_context(entity)))) {
mod_timer(&p_os->diva_timer_id, jiffies + 10 * HZ);
}
}
void diva_um_idi_stop_wdog(void *entity)
{
diva_um_idi_os_context_t *p_os;
if (entity &&
((p_os =
(diva_um_idi_os_context_t *)
diva_um_id_get_os_context(entity)))) {
del_timer(&p_os->diva_timer_id);
}
}