linux/drivers/isdn/hardware/eicon/divasi.c
<<
>>
Prefs
   1/* $Id: divasi.c,v 1.25.6.2 2005/01/31 12:22:20 armin Exp $
   2 *
   3 * Driver for Eicon DIVA Server ISDN cards.
   4 * User Mode IDI Interface
   5 *
   6 * Copyright 2000-2003 by Armin Schindler (mac@melware.de)
   7 * Copyright 2000-2003 Cytronics & Melware (info@melware.de)
   8 *
   9 * This software may be used and distributed according to the terms
  10 * of the GNU General Public License, incorporated herein by reference.
  11 */
  12
  13#include <linux/module.h>
  14#include <linux/init.h>
  15#include <linux/kernel.h>
  16#include <linux/sched.h>
  17#include <linux/poll.h>
  18#include <linux/proc_fs.h>
  19#include <linux/skbuff.h>
  20#include <linux/seq_file.h>
  21#include <asm/uaccess.h>
  22
  23#include "platform.h"
  24#include "di_defs.h"
  25#include "divasync.h"
  26#include "um_xdi.h"
  27#include "um_idi.h"
  28
  29static char *main_revision = "$Revision: 1.25.6.2 $";
  30
  31static int major;
  32
  33MODULE_DESCRIPTION("User IDI Interface for Eicon ISDN cards");
  34MODULE_AUTHOR("Cytronics & Melware, Eicon Networks");
  35MODULE_SUPPORTED_DEVICE("DIVA card driver");
  36MODULE_LICENSE("GPL");
  37
  38typedef struct _diva_um_idi_os_context {
  39        wait_queue_head_t read_wait;
  40        wait_queue_head_t close_wait;
  41        struct timer_list diva_timer_id;
  42        int aborted;
  43        int adapter_nr;
  44} diva_um_idi_os_context_t;
  45
  46static char *DRIVERNAME = "Eicon DIVA - User IDI (http://www.melware.net)";
  47static char *DRIVERLNAME = "diva_idi";
  48static char *DEVNAME = "DivasIDI";
  49char *DRIVERRELEASE_IDI = "2.0";
  50
  51extern int idifunc_init(void);
  52extern void idifunc_finit(void);
  53
  54/*
  55 *  helper functions
  56 */
  57static char *getrev(const char *revision)
  58{
  59        char *rev;
  60        char *p;
  61        if ((p = strchr(revision, ':'))) {
  62                rev = p + 2;
  63                p = strchr(rev, '$');
  64                *--p = 0;
  65        } else
  66                rev = "1.0";
  67        return rev;
  68}
  69
  70/*
  71 *  LOCALS
  72 */
  73static ssize_t um_idi_read(struct file *file, char __user *buf, size_t count,
  74                           loff_t *offset);
  75static ssize_t um_idi_write(struct file *file, const char __user *buf,
  76                            size_t count, loff_t *offset);
  77static unsigned int um_idi_poll(struct file *file, poll_table *wait);
  78static int um_idi_open(struct inode *inode, struct file *file);
  79static int um_idi_release(struct inode *inode, struct file *file);
  80static int remove_entity(void *entity);
  81static void diva_um_timer_function(unsigned long data);
  82
  83/*
  84 * proc entry
  85 */
  86extern struct proc_dir_entry *proc_net_eicon;
  87static struct proc_dir_entry *um_idi_proc_entry = NULL;
  88
  89static int um_idi_proc_show(struct seq_file *m, void *v)
  90{
  91        char tmprev[32];
  92
  93        seq_printf(m, "%s\n", DRIVERNAME);
  94        seq_printf(m, "name     : %s\n", DRIVERLNAME);
  95        seq_printf(m, "release  : %s\n", DRIVERRELEASE_IDI);
  96        strcpy(tmprev, main_revision);
  97        seq_printf(m, "revision : %s\n", getrev(tmprev));
  98        seq_printf(m, "build    : %s\n", DIVA_BUILD);
  99        seq_printf(m, "major    : %d\n", major);
 100
 101        return 0;
 102}
 103
 104static int um_idi_proc_open(struct inode *inode, struct file *file)
 105{
 106        return single_open(file, um_idi_proc_show, NULL);
 107}
 108
 109static const struct file_operations um_idi_proc_fops = {
 110        .owner          = THIS_MODULE,
 111        .open           = um_idi_proc_open,
 112        .read           = seq_read,
 113        .llseek         = seq_lseek,
 114        .release        = single_release,
 115};
 116
 117static int __init create_um_idi_proc(void)
 118{
 119        um_idi_proc_entry = proc_create(DRIVERLNAME, S_IRUGO, proc_net_eicon,
 120                                        &um_idi_proc_fops);
 121        if (!um_idi_proc_entry)
 122                return (0);
 123        return (1);
 124}
 125
 126static void remove_um_idi_proc(void)
 127{
 128        if (um_idi_proc_entry) {
 129                remove_proc_entry(DRIVERLNAME, proc_net_eicon);
 130                um_idi_proc_entry = NULL;
 131        }
 132}
 133
 134static const struct file_operations divas_idi_fops = {
 135        .owner   = THIS_MODULE,
 136        .llseek  = no_llseek,
 137        .read    = um_idi_read,
 138        .write   = um_idi_write,
 139        .poll    = um_idi_poll,
 140        .open    = um_idi_open,
 141        .release = um_idi_release
 142};
 143
 144static void divas_idi_unregister_chrdev(void)
 145{
 146        unregister_chrdev(major, DEVNAME);
 147}
 148
 149static int __init divas_idi_register_chrdev(void)
 150{
 151        if ((major = register_chrdev(0, DEVNAME, &divas_idi_fops)) < 0)
 152        {
 153                printk(KERN_ERR "%s: failed to create /dev entry.\n",
 154                       DRIVERLNAME);
 155                return (0);
 156        }
 157
 158        return (1);
 159}
 160
 161/*
 162** Driver Load
 163*/
 164static int __init divasi_init(void)
 165{
 166        char tmprev[50];
 167        int ret = 0;
 168
 169        printk(KERN_INFO "%s\n", DRIVERNAME);
 170        printk(KERN_INFO "%s: Rel:%s  Rev:", DRIVERLNAME, DRIVERRELEASE_IDI);
 171        strcpy(tmprev, main_revision);
 172        printk("%s  Build: %s\n", getrev(tmprev), DIVA_BUILD);
 173
 174        if (!divas_idi_register_chrdev()) {
 175                ret = -EIO;
 176                goto out;
 177        }
 178
 179        if (!create_um_idi_proc()) {
 180                divas_idi_unregister_chrdev();
 181                printk(KERN_ERR "%s: failed to create proc entry.\n",
 182                       DRIVERLNAME);
 183                ret = -EIO;
 184                goto out;
 185        }
 186
 187        if (!(idifunc_init())) {
 188                remove_um_idi_proc();
 189                divas_idi_unregister_chrdev();
 190                printk(KERN_ERR "%s: failed to connect to DIDD.\n",
 191                       DRIVERLNAME);
 192                ret = -EIO;
 193                goto out;
 194        }
 195        printk(KERN_INFO "%s: started with major %d\n", DRIVERLNAME, major);
 196
 197out:
 198        return (ret);
 199}
 200
 201
 202/*
 203** Driver Unload
 204*/
 205static void __exit divasi_exit(void)
 206{
 207        idifunc_finit();
 208        remove_um_idi_proc();
 209        divas_idi_unregister_chrdev();
 210
 211        printk(KERN_INFO "%s: module unloaded.\n", DRIVERLNAME);
 212}
 213
 214module_init(divasi_init);
 215module_exit(divasi_exit);
 216
 217
 218/*
 219 *  FILE OPERATIONS
 220 */
 221
 222static int
 223divas_um_idi_copy_to_user(void *os_handle, void *dst, const void *src,
 224                          int length)
 225{
 226        memcpy(dst, src, length);
 227        return (length);
 228}
 229
 230static ssize_t
 231um_idi_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
 232{
 233        diva_um_idi_os_context_t *p_os;
 234        int ret = -EINVAL;
 235        void *data;
 236
 237        if (!file->private_data) {
 238                return (-ENODEV);
 239        }
 240
 241        if (!
 242            (p_os =
 243             (diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->
 244                                                                    private_data)))
 245        {
 246                return (-ENODEV);
 247        }
 248        if (p_os->aborted) {
 249                return (-ENODEV);
 250        }
 251
 252        if (!(data = diva_os_malloc(0, count))) {
 253                return (-ENOMEM);
 254        }
 255
 256        ret = diva_um_idi_read(file->private_data,
 257                               file, data, count,
 258                               divas_um_idi_copy_to_user);
 259        switch (ret) {
 260        case 0:         /* no message available */
 261                ret = (-EAGAIN);
 262                break;
 263        case (-1):              /* adapter was removed */
 264                ret = (-ENODEV);
 265                break;
 266        case (-2):              /* message_length > length of user buffer */
 267                ret = (-EFAULT);
 268                break;
 269        }
 270
 271        if (ret > 0) {
 272                if (copy_to_user(buf, data, ret)) {
 273                        ret = (-EFAULT);
 274                }
 275        }
 276
 277        diva_os_free(0, data);
 278        DBG_TRC(("read: ret %d", ret));
 279        return (ret);
 280}
 281
 282
 283static int
 284divas_um_idi_copy_from_user(void *os_handle, void *dst, const void *src,
 285                            int length)
 286{
 287        memcpy(dst, src, length);
 288        return (length);
 289}
 290
 291static int um_idi_open_adapter(struct file *file, int adapter_nr)
 292{
 293        diva_um_idi_os_context_t *p_os;
 294        void *e =
 295                divas_um_idi_create_entity((dword) adapter_nr, (void *) file);
 296
 297        if (!(file->private_data = e)) {
 298                return (0);
 299        }
 300        p_os = (diva_um_idi_os_context_t *) diva_um_id_get_os_context(e);
 301        init_waitqueue_head(&p_os->read_wait);
 302        init_waitqueue_head(&p_os->close_wait);
 303        init_timer(&p_os->diva_timer_id);
 304        p_os->diva_timer_id.function = (void *) diva_um_timer_function;
 305        p_os->diva_timer_id.data = (unsigned long) p_os;
 306        p_os->aborted = 0;
 307        p_os->adapter_nr = adapter_nr;
 308        return (1);
 309}
 310
 311static ssize_t
 312um_idi_write(struct file *file, const char __user *buf, size_t count,
 313             loff_t *offset)
 314{
 315        diva_um_idi_os_context_t *p_os;
 316        int ret = -EINVAL;
 317        void *data;
 318        int adapter_nr = 0;
 319
 320        if (!file->private_data) {
 321                /* the first write() selects the adapter_nr */
 322                if (count == sizeof(int)) {
 323                        if (copy_from_user
 324                            ((void *) &adapter_nr, buf,
 325                             count)) return (-EFAULT);
 326                        if (!(um_idi_open_adapter(file, adapter_nr)))
 327                                return (-ENODEV);
 328                        return (count);
 329                } else
 330                        return (-ENODEV);
 331        }
 332
 333        if (!(p_os =
 334              (diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->
 335                                                                     private_data)))
 336        {
 337                return (-ENODEV);
 338        }
 339        if (p_os->aborted) {
 340                return (-ENODEV);
 341        }
 342
 343        if (!(data = diva_os_malloc(0, count))) {
 344                return (-ENOMEM);
 345        }
 346
 347        if (copy_from_user(data, buf, count)) {
 348                ret = -EFAULT;
 349        } else {
 350                ret = diva_um_idi_write(file->private_data,
 351                                        file, data, count,
 352                                        divas_um_idi_copy_from_user);
 353                switch (ret) {
 354                case 0: /* no space available */
 355                        ret = (-EAGAIN);
 356                        break;
 357                case (-1):      /* adapter was removed */
 358                        ret = (-ENODEV);
 359                        break;
 360                case (-2):      /* length of user buffer > max message_length */
 361                        ret = (-EFAULT);
 362                        break;
 363                }
 364        }
 365        diva_os_free(0, data);
 366        DBG_TRC(("write: ret %d", ret));
 367        return (ret);
 368}
 369
 370static unsigned int um_idi_poll(struct file *file, poll_table *wait)
 371{
 372        diva_um_idi_os_context_t *p_os;
 373
 374        if (!file->private_data) {
 375                return (POLLERR);
 376        }
 377
 378        if ((!(p_os =
 379               (diva_um_idi_os_context_t *)
 380               diva_um_id_get_os_context(file->private_data)))
 381            || p_os->aborted) {
 382                return (POLLERR);
 383        }
 384
 385        poll_wait(file, &p_os->read_wait, wait);
 386
 387        if (p_os->aborted) {
 388                return (POLLERR);
 389        }
 390
 391        switch (diva_user_mode_idi_ind_ready(file->private_data, file)) {
 392        case (-1):
 393                return (POLLERR);
 394
 395        case 0:
 396                return (0);
 397        }
 398
 399        return (POLLIN | POLLRDNORM);
 400}
 401
 402static int um_idi_open(struct inode *inode, struct file *file)
 403{
 404        return (0);
 405}
 406
 407
 408static int um_idi_release(struct inode *inode, struct file *file)
 409{
 410        diva_um_idi_os_context_t *p_os;
 411        unsigned int adapter_nr;
 412        int ret = 0;
 413
 414        if (!(file->private_data)) {
 415                ret = -ENODEV;
 416                goto out;
 417        }
 418
 419        if (!(p_os =
 420              (diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->private_data))) {
 421                ret = -ENODEV;
 422                goto out;
 423        }
 424
 425        adapter_nr = p_os->adapter_nr;
 426
 427        if ((ret = remove_entity(file->private_data))) {
 428                goto out;
 429        }
 430
 431        if (divas_um_idi_delete_entity
 432            ((int) adapter_nr, file->private_data)) {
 433                ret = -ENODEV;
 434                goto out;
 435        }
 436
 437out:
 438        return (ret);
 439}
 440
 441int diva_os_get_context_size(void)
 442{
 443        return (sizeof(diva_um_idi_os_context_t));
 444}
 445
 446void diva_os_wakeup_read(void *os_context)
 447{
 448        diva_um_idi_os_context_t *p_os =
 449                (diva_um_idi_os_context_t *) os_context;
 450        wake_up_interruptible(&p_os->read_wait);
 451}
 452
 453void diva_os_wakeup_close(void *os_context)
 454{
 455        diva_um_idi_os_context_t *p_os =
 456                (diva_um_idi_os_context_t *) os_context;
 457        wake_up_interruptible(&p_os->close_wait);
 458}
 459
 460static
 461void diva_um_timer_function(unsigned long data)
 462{
 463        diva_um_idi_os_context_t *p_os = (diva_um_idi_os_context_t *) data;
 464
 465        p_os->aborted = 1;
 466        wake_up_interruptible(&p_os->read_wait);
 467        wake_up_interruptible(&p_os->close_wait);
 468        DBG_ERR(("entity removal watchdog"))
 469                }
 470
 471/*
 472**  If application exits without entity removal this function will remove
 473**  entity and block until removal is complete
 474*/
 475static int remove_entity(void *entity)
 476{
 477        struct task_struct *curtask = current;
 478        diva_um_idi_os_context_t *p_os;
 479
 480        diva_um_idi_stop_wdog(entity);
 481
 482        if (!entity) {
 483                DBG_FTL(("Zero entity on remove"))
 484                        return (0);
 485        }
 486
 487        if (!(p_os =
 488              (diva_um_idi_os_context_t *)
 489              diva_um_id_get_os_context(entity))) {
 490                DBG_FTL(("Zero entity os context on remove"))
 491                        return (0);
 492        }
 493
 494        if (!divas_um_idi_entity_assigned(entity) || p_os->aborted) {
 495                /*
 496                  Entity is not assigned, also can be removed
 497                */
 498                return (0);
 499        }
 500
 501        DBG_TRC(("E(%08x) check remove", entity))
 502
 503                /*
 504                  If adapter not answers on remove request inside of
 505                  10 Sec, then adapter is dead
 506                */
 507                diva_um_idi_start_wdog(entity);
 508
 509        {
 510                DECLARE_WAITQUEUE(wait, curtask);
 511
 512                add_wait_queue(&p_os->close_wait, &wait);
 513                for (;;) {
 514                        set_current_state(TASK_INTERRUPTIBLE);
 515                        if (!divas_um_idi_entity_start_remove(entity)
 516                            || p_os->aborted) {
 517                                break;
 518                        }
 519                        schedule();
 520                }
 521                set_current_state(TASK_RUNNING);
 522                remove_wait_queue(&p_os->close_wait, &wait);
 523        }
 524
 525        DBG_TRC(("E(%08x) start remove", entity))
 526        {
 527                DECLARE_WAITQUEUE(wait, curtask);
 528
 529                add_wait_queue(&p_os->close_wait, &wait);
 530                for (;;) {
 531                        set_current_state(TASK_INTERRUPTIBLE);
 532                        if (!divas_um_idi_entity_assigned(entity)
 533                            || p_os->aborted) {
 534                                break;
 535                        }
 536                        schedule();
 537                }
 538                set_current_state(TASK_RUNNING);
 539                remove_wait_queue(&p_os->close_wait, &wait);
 540        }
 541
 542        DBG_TRC(("E(%08x) remove complete, aborted:%d", entity,
 543                 p_os->aborted))
 544
 545                diva_um_idi_stop_wdog(entity);
 546
 547        p_os->aborted = 0;
 548
 549        return (0);
 550}
 551
 552/*
 553 * timer watchdog
 554 */
 555void diva_um_idi_start_wdog(void *entity)
 556{
 557        diva_um_idi_os_context_t *p_os;
 558
 559        if (entity &&
 560            ((p_os =
 561              (diva_um_idi_os_context_t *)
 562              diva_um_id_get_os_context(entity)))) {
 563                mod_timer(&p_os->diva_timer_id, jiffies + 10 * HZ);
 564        }
 565}
 566
 567void diva_um_idi_stop_wdog(void *entity)
 568{
 569        diva_um_idi_os_context_t *p_os;
 570
 571        if (entity &&
 572            ((p_os =
 573              (diva_um_idi_os_context_t *)
 574              diva_um_id_get_os_context(entity)))) {
 575                del_timer(&p_os->diva_timer_id);
 576        }
 577}
 578