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