drivers/staging/dgnc/dgnc_mgmt.c

   1 /*
   2  * Copyright 2003 Digi International (www.digi.com)
   3  *      Scott H Kilau <Scott_Kilau at digi dot com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2, or (at your option)
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the
  12  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  13  * PURPOSE.  See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *
  19  *
  20  *      NOTE TO LINUX KERNEL HACKERS:  DO NOT REFORMAT THIS CODE!
  21  *
  22  *      This is shared code between Digi's CVS archive and the
  23  *      Linux Kernel sources.
  24  *      Changing the source just for reformatting needlessly breaks
  25  *      our CVS diff history.
  26  *
  27  *      Send any bug fixes/changes to:  Eng.Linux at digi dot com.
  28  *      Thank you.
  29  *
  30  */
  31
  32 /************************************************************************
  33  *
  34  * This file implements the mgmt functionality for the
  35  * Neo and ClassicBoard based product lines.
  36  *
  37  ************************************************************************
  38  */
  39 #include <linux/kernel.h>
  40 #include <linux/ctype.h>
  41 #include <linux/sched.h>        /* For jiffies, task states */
  42 #include <linux/interrupt.h>    /* For tasklet and interrupt structs/defines */
  43 #include <linux/serial_reg.h>
  44 #include <linux/termios.h>
  45 #include <linux/uaccess.h>      /* For copy_from_user/copy_to_user */
  46
  47 #include "dgnc_driver.h"
  48 #include "dgnc_pci.h"
  49 #include "dgnc_kcompat.h"       /* Kernel 2.4/2.6 compat includes */
  50 #include "dgnc_mgmt.h"
  51 #include "dpacompat.h"
  52
  53
  54 /* Our "in use" variables, to enforce 1 open only */
  55 static int dgnc_mgmt_in_use[MAXMGMTDEVICES];
  56
  57
  58 /*
  59  * dgnc_mgmt_open()
  60  *
  61  * Open the mgmt/downld/dpa device
  62  */
  63 int dgnc_mgmt_open(struct inode *inode, struct file *file)
  64 {
  65         unsigned long lock_flags;
  66         unsigned int minor = iminor(inode);
  67
  68         DPR_MGMT(("dgnc_mgmt_open start.\n"));
  69
  70         DGNC_LOCK(dgnc_global_lock, lock_flags);
  71
  72         /* mgmt device */
  73         if (minor < MAXMGMTDEVICES) {
  74                 /* Only allow 1 open at a time on mgmt device */
  75                 if (dgnc_mgmt_in_use[minor]) {
  76                         DGNC_UNLOCK(dgnc_global_lock, lock_flags);
  77                         return -EBUSY;
  78                 }
  79                 dgnc_mgmt_in_use[minor]++;
  80         } else {
  81                 DGNC_UNLOCK(dgnc_global_lock, lock_flags);
  82                 return -ENXIO;
  83         }
  84
  85         DGNC_UNLOCK(dgnc_global_lock, lock_flags);
  86
  87         DPR_MGMT(("dgnc_mgmt_open finish.\n"));
  88
  89         return 0;
  90 }
  91
  92
  93 /*
  94  * dgnc_mgmt_close()
  95  *
  96  * Open the mgmt/dpa device
  97  */
  98 int dgnc_mgmt_close(struct inode *inode, struct file *file)
  99 {
 100         unsigned long lock_flags;
 101         unsigned int minor = iminor(inode);
 102
 103         DPR_MGMT(("dgnc_mgmt_close start.\n"));
 104
 105         DGNC_LOCK(dgnc_global_lock, lock_flags);
 106
 107         /* mgmt device */
 108         if (minor < MAXMGMTDEVICES) {
 109                 if (dgnc_mgmt_in_use[minor])
 110                         dgnc_mgmt_in_use[minor] = 0;
 111         }
 112         DGNC_UNLOCK(dgnc_global_lock, lock_flags);
 113
 114         DPR_MGMT(("dgnc_mgmt_close finish.\n"));
 115
 116         return 0;
 117 }
 118
 119
 120 /*
 121  * dgnc_mgmt_ioctl()
 122  *
 123  * ioctl the mgmt/dpa device
 124  */
 125
 126 long dgnc_mgmt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 127 {
 128         unsigned long lock_flags;
 129         void __user *uarg = (void __user *) arg;
 130
 131         DPR_MGMT(("dgnc_mgmt_ioctl start.\n"));
 132
 133         switch (cmd) {
 134
 135         case DIGI_GETDD:
 136         {
 137                 /*
 138                  * This returns the total number of boards
 139                  * in the system, as well as driver version
 140                  * and has space for a reserved entry
 141                  */
 142                 struct digi_dinfo ddi;
 143
 144                 DGNC_LOCK(dgnc_global_lock, lock_flags);
 145
 146                 ddi.dinfo_nboards = dgnc_NumBoards;
 147                 sprintf(ddi.dinfo_version, "%s", DG_PART);
 148
 149                 DGNC_UNLOCK(dgnc_global_lock, lock_flags);
 150
 151                 DPR_MGMT(("DIGI_GETDD returning numboards: %d version: %s\n",
 152                         ddi.dinfo_nboards, ddi.dinfo_version));
 153
 154                 if (copy_to_user(uarg, &ddi, sizeof(ddi)))
 155                         return -EFAULT;
 156
 157                 break;
 158         }
 159
 160         case DIGI_GETBD:
 161         {
 162                 int brd;
 163
 164                 struct digi_info di;
 165
 166                 if (copy_from_user(&brd, uarg, sizeof(int)))
 167                         return -EFAULT;
 168
 169                 DPR_MGMT(("DIGI_GETBD asking about board: %d\n", brd));
 170
 171                 if ((brd < 0) || (brd > dgnc_NumBoards) ||
 172                     (dgnc_NumBoards == 0))
 173                         return -ENODEV;
 174
 175                 memset(&di, 0, sizeof(di));
 176
 177                 di.info_bdnum = brd;
 178
 179                 DGNC_LOCK(dgnc_Board[brd]->bd_lock, lock_flags);
 180
 181                 di.info_bdtype = dgnc_Board[brd]->dpatype;
 182                 di.info_bdstate = dgnc_Board[brd]->dpastatus;
 183                 di.info_ioport = 0;
 184                 di.info_physaddr = (ulong) dgnc_Board[brd]->membase;
 185                 di.info_physsize = (ulong) dgnc_Board[brd]->membase - dgnc_Board[brd]->membase_end;
 186                 if (dgnc_Board[brd]->state != BOARD_FAILED)
 187                         di.info_nports = dgnc_Board[brd]->nasync;
 188                 else
 189                         di.info_nports = 0;
 190
 191                 DGNC_UNLOCK(dgnc_Board[brd]->bd_lock, lock_flags);
 192
 193                 DPR_MGMT(("DIGI_GETBD returning type: %x state: %x ports: %x size: %x\n",
 194                         di.info_bdtype, di.info_bdstate, di.info_nports, di.info_physsize));
 195
 196                 if (copy_to_user(uarg, &di, sizeof(di)))
 197                         return -EFAULT;
 198
 199                 break;
 200         }
 201
 202         case DIGI_GET_NI_INFO:
 203         {
 204                 struct channel_t *ch;
 205                 struct ni_info ni;
 206                 uchar mstat = 0;
 207                 uint board = 0;
 208                 uint channel = 0;
 209
 210                 if (copy_from_user(&ni, uarg, sizeof(ni)))
 211                         return -EFAULT;
 212
 213                 DPR_MGMT(("DIGI_GETBD asking about board: %d channel: %d\n",
 214                         ni.board, ni.channel));
 215
 216                 board = ni.board;
 217                 channel = ni.channel;
 218
 219                 /* Verify boundaries on board */
 220                 if ((board > dgnc_NumBoards) || (dgnc_NumBoards == 0))
 221                         return -ENODEV;
 222
 223                 /* Verify boundaries on channel */
 224                 if ((channel < 0) || (channel > dgnc_Board[board]->nasync))
 225                         return -ENODEV;
 226
 227                 ch = dgnc_Board[board]->channels[channel];
 228
 229                 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
 230                         return -ENODEV;
 231
 232                 memset(&ni, 0, sizeof(ni));
 233                 ni.board = board;
 234                 ni.channel = channel;
 235
 236                 DGNC_LOCK(ch->ch_lock, lock_flags);
 237
 238                 mstat = (ch->ch_mostat | ch->ch_mistat);
 239
 240                 if (mstat & UART_MCR_DTR) {
 241                         ni.mstat |= TIOCM_DTR;
 242                         ni.dtr = TIOCM_DTR;
 243                 }
 244                 if (mstat & UART_MCR_RTS) {
 245                         ni.mstat |= TIOCM_RTS;
 246                         ni.rts = TIOCM_RTS;
 247                 }
 248                 if (mstat & UART_MSR_CTS) {
 249                         ni.mstat |= TIOCM_CTS;
 250                         ni.cts = TIOCM_CTS;
 251                 }
 252                 if (mstat & UART_MSR_RI) {
 253                         ni.mstat |= TIOCM_RI;
 254                         ni.ri = TIOCM_RI;
 255                 }
 256                 if (mstat & UART_MSR_DCD) {
 257                         ni.mstat |= TIOCM_CD;
 258                         ni.dcd = TIOCM_CD;
 259                 }
 260                 if (mstat & UART_MSR_DSR)
 261                         ni.mstat |= TIOCM_DSR;
 262
 263                 ni.iflag = ch->ch_c_iflag;
 264                 ni.oflag = ch->ch_c_oflag;
 265                 ni.cflag = ch->ch_c_cflag;
 266                 ni.lflag = ch->ch_c_lflag;
 267
 268                 if (ch->ch_digi.digi_flags & CTSPACE ||
 269                     ch->ch_c_cflag & CRTSCTS)
 270                         ni.hflow = 1;
 271                 else
 272                         ni.hflow = 0;
 273
 274                 if ((ch->ch_flags & CH_STOPI) ||
 275                     (ch->ch_flags & CH_FORCED_STOPI))
 276                         ni.recv_stopped = 1;
 277                 else
 278                         ni.recv_stopped = 0;
 279
 280                 if ((ch->ch_flags & CH_STOP) || (ch->ch_flags & CH_FORCED_STOP))
 281                         ni.xmit_stopped = 1;
 282                 else
 283                         ni.xmit_stopped = 0;
 284
 285                 ni.curtx = ch->ch_txcount;
 286                 ni.currx = ch->ch_rxcount;
 287
 288                 ni.baud = ch->ch_old_baud;
 289
 290                 DGNC_UNLOCK(ch->ch_lock, lock_flags);
 291
 292                 if (copy_to_user(uarg, &ni, sizeof(ni)))
 293                         return -EFAULT;
 294
 295                 break;
 296         }
 297
 298
 299         }
 300
 301         DPR_MGMT(("dgnc_mgmt_ioctl finish.\n"));
 302
 303         return 0;
 304 }