SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/isdn/hardware/eicon/divasi.c

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