SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/hamradio/baycom_ser_fdx.c

   1 /*****************************************************************************/
   2
   3 /*
   4  *      baycom_ser_fdx.c  -- baycom ser12 fullduplex radio modem driver.
   5  *
   6  *      Copyright (C) 1996-2000  Thomas Sailer (sailer@ife.ee.ethz.ch)
   7  *
   8  *      This program is free software; you can redistribute it and/or modify
   9  *      it under the terms of the GNU General Public License as published by
  10  *      the Free Software Foundation; either version 2 of the License, or
  11  *      (at your option) any later version.
  12  *
  13  *      This program is distributed in the hope that it will be useful,
  14  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *      GNU General Public License for more details.
  17  *
  18  *      You should have received a copy of the GNU General Public License
  19  *      along with this program; if not, write to the Free Software
  20  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  *
  22  *  Please note that the GPL allows you to use the driver, NOT the radio.
  23  *  In order to use the radio, you need a license from the communications
  24  *  authority of your country.
  25  *
  26  *
  27  *  Supported modems
  28  *
  29  *  ser12:  This is a very simple 1200 baud AFSK modem. The modem consists only
  30  *          of a modulator/demodulator chip, usually a TI TCM3105. The computer
  31  *          is responsible for regenerating the receiver bit clock, as well as
  32  *          for handling the HDLC protocol. The modem connects to a serial port,
  33  *          hence the name. Since the serial port is not used as an async serial
  34  *          port, the kernel driver for serial ports cannot be used, and this
  35  *          driver only supports standard serial hardware (8250, 16450, 16550A)
  36  *
  37  *          This modem usually draws its supply current out of the otherwise unused
  38  *          TXD pin of the serial port. Thus a contignuous stream of 0x00-bytes
  39  *          is transmitted to achieve a positive supply voltage.
  40  *
  41  *  hsk:    This is a 4800 baud FSK modem, designed for TNC use. It works fine
  42  *          in 'baycom-mode' :-)  In contrast to the TCM3105 modem, power is
  43  *          externally supplied. So there's no need to provide the 0x00-byte-stream
  44  *          when receiving or idle, which drastically reduces interrupt load.
  45  *
  46  *  Command line options (insmod command line)
  47  *
  48  *  mode     ser#    hardware DCD
  49  *           ser#*   software DCD
  50  *           ser#+   hardware DCD, inverted signal at DCD pin
  51  *           '#' denotes the baud rate / 100, eg. ser12* is '1200 baud, soft DCD'
  52  *  iobase   base address of the port; common values are 0x3f8, 0x2f8, 0x3e8, 0x2e8
  53  *  baud     baud rate (between 300 and 4800)
  54  *  irq      interrupt line of the port; common values are 4,3
  55  *
  56  *
  57  *  History:
  58  *   0.1  26.06.1996  Adapted from baycom.c and made network driver interface
  59  *        18.10.1996  Changed to new user space access routines (copy_{to,from}_user)
  60  *   0.3  26.04.1997  init code/data tagged
  61  *   0.4  08.07.1997  alternative ser12 decoding algorithm (uses delta CTS ints)
  62  *   0.5  11.11.1997  ser12/par96 split into separate files
  63  *   0.6  24.01.1998  Thorsten Kranzkowski, dl8bcu and Thomas Sailer:
  64  *                    reduced interrupt load in transmit case
  65  *                    reworked receiver
  66  *   0.7  03.08.1999  adapt to Linus' new __setup/__initcall
  67  *   0.8  10.08.1999  use module_init/module_exit
  68  *   0.9  12.02.2000  adapted to softnet driver interface
  69  *   0.10 03.07.2000  fix interface name handling
  70  */
  71
  72 /*****************************************************************************/
  73
  74 #include <linux/module.h>
  75 #include <linux/ioport.h>
  76 #include <linux/string.h>
  77 #include <linux/init.h>
  78 #include <asm/uaccess.h>
  79 #include <asm/io.h>
  80 #include <linux/hdlcdrv.h>
  81 #include <linux/baycom.h>
  82 #include <linux/jiffies.h>
  83
  84 /* --------------------------------------------------------------------- */
  85
  86 #define BAYCOM_DEBUG
  87
  88 /* --------------------------------------------------------------------- */
  89
  90 static const char bc_drvname[] = "baycom_ser_fdx";
  91 static const char bc_drvinfo[] = KERN_INFO "baycom_ser_fdx: (C) 1996-2000 Thomas Sailer, HB9JNX/AE4WA\n"
  92 KERN_INFO "baycom_ser_fdx: version 0.10 compiled " __TIME__ " " __DATE__ "\n";
  93
  94 /* --------------------------------------------------------------------- */
  95
  96 #define NR_PORTS 4
  97
  98 static struct net_device *baycom_device[NR_PORTS];
  99
 100 /* --------------------------------------------------------------------- */
 101
 102 #define RBR(iobase) (iobase+0)
 103 #define THR(iobase) (iobase+0)
 104 #define IER(iobase) (iobase+1)
 105 #define IIR(iobase) (iobase+2)
 106 #define FCR(iobase) (iobase+2)
 107 #define LCR(iobase) (iobase+3)
 108 #define MCR(iobase) (iobase+4)
 109 #define LSR(iobase) (iobase+5)
 110 #define MSR(iobase) (iobase+6)
 111 #define SCR(iobase) (iobase+7)
 112 #define DLL(iobase) (iobase+0)
 113 #define DLM(iobase) (iobase+1)
 114
 115 #define SER12_EXTENT 8
 116
 117 /* ---------------------------------------------------------------------- */
 118 /*
 119  * Information that need to be kept for each board.
 120  */
 121
 122 struct baycom_state {
 123         struct hdlcdrv_state hdrv;
 124
 125         unsigned int baud, baud_us, baud_arbdiv, baud_uartdiv, baud_dcdtimeout;
 126         int opt_dcd;
 127
 128         struct modem_state {
 129                 unsigned char flags;
 130                 unsigned char ptt;
 131                 unsigned int shreg;
 132                 struct modem_state_ser12 {
 133                         unsigned char tx_bit;
 134                         unsigned char last_rxbit;
 135                         int dcd_sum0, dcd_sum1, dcd_sum2;
 136                         int dcd_time;
 137                         unsigned int pll_time;
 138                         unsigned int txshreg;
 139                 } ser12;
 140         } modem;
 141
 142 #ifdef BAYCOM_DEBUG
 143         struct debug_vals {
 144                 unsigned long last_jiffies;
 145                 unsigned cur_intcnt;
 146                 unsigned last_intcnt;
 147                 int cur_pllcorr;
 148                 int last_pllcorr;
 149         } debug_vals;
 150 #endif /* BAYCOM_DEBUG */
 151 };
 152
 153 /* --------------------------------------------------------------------- */
 154
 155 static inline void baycom_int_freq(struct baycom_state *bc)
 156 {
 157 #ifdef BAYCOM_DEBUG
 158         unsigned long cur_jiffies = jiffies;
 159         /*
 160          * measure the interrupt frequency
 161          */
 162         bc->debug_vals.cur_intcnt++;
 163         if (time_after_eq(cur_jiffies, bc->debug_vals.last_jiffies + HZ)) {
 164                 bc->debug_vals.last_jiffies = cur_jiffies;
 165                 bc->debug_vals.last_intcnt = bc->debug_vals.cur_intcnt;
 166                 bc->debug_vals.cur_intcnt = 0;
 167                 bc->debug_vals.last_pllcorr = bc->debug_vals.cur_pllcorr;
 168                 bc->debug_vals.cur_pllcorr = 0;
 169         }
 170 #endif /* BAYCOM_DEBUG */
 171 }
 172
 173 /* --------------------------------------------------------------------- */
 174 /*
 175  * ===================== SER12 specific routines =========================
 176  */
 177
 178 /* --------------------------------------------------------------------- */
 179
 180 static inline void ser12_set_divisor(struct net_device *dev,
 181                                      unsigned int divisor)
 182 {
 183         outb(0x81, LCR(dev->base_addr));        /* DLAB = 1 */
 184         outb(divisor, DLL(dev->base_addr));
 185         outb(divisor >> 8, DLM(dev->base_addr));
 186         outb(0x01, LCR(dev->base_addr));        /* word length = 6 */
 187         /*
 188          * make sure the next interrupt is generated;
 189          * 0 must be used to power the modem; the modem draws its
 190          * power from the TxD line
 191          */
 192         outb(0x00, THR(dev->base_addr));
 193         /*
 194          * it is important not to set the divider while transmitting;
 195          * this reportedly makes some UARTs generating interrupts
 196          * in the hundredthousands per second region
 197          * Reported by: Ignacio.Arenaza@studi.epfl.ch (Ignacio Arenaza Nuno)
 198          */
 199 }
 200
 201 /* --------------------------------------------------------------------- */
 202
 203 #if 0
 204 static inline unsigned int hweight16(unsigned int w)
 205         __attribute__ ((unused));
 206 static inline unsigned int hweight8(unsigned int w)
 207         __attribute__ ((unused));
 208
 209 static inline unsigned int hweight16(unsigned int w)
 210 {
 211         unsigned short res = (w & 0x5555) + ((w >> 1) & 0x5555);
 212         res = (res & 0x3333) + ((res >> 2) & 0x3333);
 213         res = (res & 0x0F0F) + ((res >> 4) & 0x0F0F);
 214         return (res & 0x00FF) + ((res >> 8) & 0x00FF);
 215 }
 216
 217 static inline unsigned int hweight8(unsigned int w)
 218 {
 219         unsigned short res = (w & 0x55) + ((w >> 1) & 0x55);
 220         res = (res & 0x33) + ((res >> 2) & 0x33);
 221         return (res & 0x0F) + ((res >> 4) & 0x0F);
 222 }
 223 #endif
 224
 225 /* --------------------------------------------------------------------- */
 226
 227 static __inline__ void ser12_rx(struct net_device *dev, struct baycom_state *bc, struct timeval *tv, unsigned char curs)
 228 {
 229         int timediff;
 230         int bdus8 = bc->baud_us >> 3;
 231         int bdus4 = bc->baud_us >> 2;
 232         int bdus2 = bc->baud_us >> 1;
 233
 234         timediff = 1000000 + tv->tv_usec - bc->modem.ser12.pll_time;
 235         while (timediff >= 500000)
 236                 timediff -= 1000000;
 237         while (timediff >= bdus2) {
 238                 timediff -= bc->baud_us;
 239                 bc->modem.ser12.pll_time += bc->baud_us;
 240                 bc->modem.ser12.dcd_time--;
 241                 /* first check if there is room to add a bit */
 242                 if (bc->modem.shreg & 1) {
 243                         hdlcdrv_putbits(&bc->hdrv, (bc->modem.shreg >> 1) ^ 0xffff);
 244                         bc->modem.shreg = 0x10000;
 245                 }
 246                 /* add a one bit */
 247                 bc->modem.shreg >>= 1;
 248         }
 249         if (bc->modem.ser12.dcd_time <= 0) {
 250                 if (!bc->opt_dcd)
 251                         hdlcdrv_setdcd(&bc->hdrv, (bc->modem.ser12.dcd_sum0 +
 252                                                    bc->modem.ser12.dcd_sum1 +
 253                                                    bc->modem.ser12.dcd_sum2) < 0);
 254                 bc->modem.ser12.dcd_sum2 = bc->modem.ser12.dcd_sum1;
 255                 bc->modem.ser12.dcd_sum1 = bc->modem.ser12.dcd_sum0;
 256                 bc->modem.ser12.dcd_sum0 = 2; /* slight bias */
 257                 bc->modem.ser12.dcd_time += 120;
 258         }
 259         if (bc->modem.ser12.last_rxbit != curs) {
 260                 bc->modem.ser12.last_rxbit = curs;
 261                 bc->modem.shreg |= 0x10000;
 262                 /* adjust the PLL */
 263                 if (timediff > 0)
 264                         bc->modem.ser12.pll_time += bdus8;
 265                 else
 266                         bc->modem.ser12.pll_time += 1000000 - bdus8;
 267                 /* update DCD */
 268                 if (abs(timediff) > bdus4)
 269                         bc->modem.ser12.dcd_sum0 += 4;
 270                 else
 271                         bc->modem.ser12.dcd_sum0--;
 272 #ifdef BAYCOM_DEBUG
 273                 bc->debug_vals.cur_pllcorr = timediff;
 274 #endif /* BAYCOM_DEBUG */
 275         }
 276         while (bc->modem.ser12.pll_time >= 1000000)
 277                 bc->modem.ser12.pll_time -= 1000000;
 278 }
 279
 280 /* --------------------------------------------------------------------- */
 281
 282 static irqreturn_t ser12_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 283 {
 284         struct net_device *dev = (struct net_device *)dev_id;
 285         struct baycom_state *bc = netdev_priv(dev);
 286         struct timeval tv;
 287         unsigned char iir, msr;
 288         unsigned int txcount = 0;
 289
 290         if (!bc || bc->hdrv.magic != HDLCDRV_MAGIC)
 291                 return IRQ_NONE;
 292         /* fast way out for shared irq */
 293         if ((iir = inb(IIR(dev->base_addr))) & 1)
 294                 return IRQ_NONE;
 295         /* get current time */
 296         do_gettimeofday(&tv);
 297         msr = inb(MSR(dev->base_addr));
 298         /* delta DCD */
 299         if ((msr & 8) && bc->opt_dcd)
 300                 hdlcdrv_setdcd(&bc->hdrv, !((msr ^ bc->opt_dcd) & 0x80));
 301         do {
 302                 switch (iir & 6) {
 303                 case 6:
 304                         inb(LSR(dev->base_addr));
 305                         break;
 306
 307                 case 4:
 308                         inb(RBR(dev->base_addr));
 309                         break;
 310
 311                 case 2:
 312                         /*
 313                          * make sure the next interrupt is generated;
 314                          * 0 must be used to power the modem; the modem draws its
 315                          * power from the TxD line
 316                          */
 317                         outb(0x00, THR(dev->base_addr));
 318                         baycom_int_freq(bc);
 319                         txcount++;
 320                         /*
 321                          * first output the last bit (!) then call HDLC transmitter,
 322                          * since this may take quite long
 323                          */
 324                         if (bc->modem.ptt)
 325                                 outb(0x0e | (!!bc->modem.ser12.tx_bit), MCR(dev->base_addr));
 326                         else
 327                                 outb(0x0d, MCR(dev->base_addr));       /* transmitter off */
 328                         break;
 329
 330                 default:
 331                         msr = inb(MSR(dev->base_addr));
 332                         /* delta DCD */
 333                         if ((msr & 8) && bc->opt_dcd)
 334                                 hdlcdrv_setdcd(&bc->hdrv, !((msr ^ bc->opt_dcd) & 0x80));
 335                         break;
 336                 }
 337                 iir = inb(IIR(dev->base_addr));
 338         } while (!(iir & 1));
 339         ser12_rx(dev, bc, &tv, msr & 0x10); /* CTS */
 340         if (bc->modem.ptt && txcount) {
 341                 if (bc->modem.ser12.txshreg <= 1) {
 342                         bc->modem.ser12.txshreg = 0x10000 | hdlcdrv_getbits(&bc->hdrv);
 343                         if (!hdlcdrv_ptt(&bc->hdrv)) {
 344                                 ser12_set_divisor(dev, 115200/100/8);
 345                                 bc->modem.ptt = 0;
 346                                 goto end_transmit;
 347                         }
 348                 }
 349                 bc->modem.ser12.tx_bit = !(bc->modem.ser12.tx_bit ^ (bc->modem.ser12.txshreg & 1));
 350                 bc->modem.ser12.txshreg >>= 1;
 351         }
 352  end_transmit:
 353         local_irq_enable();
 354         if (!bc->modem.ptt && txcount) {
 355                 hdlcdrv_arbitrate(dev, &bc->hdrv);
 356                 if (hdlcdrv_ptt(&bc->hdrv)) {
 357                         ser12_set_divisor(dev, bc->baud_uartdiv);
 358                         bc->modem.ser12.txshreg = 1;
 359                         bc->modem.ptt = 1;
 360                 }
 361         }
 362         hdlcdrv_transmitter(dev, &bc->hdrv);
 363         hdlcdrv_receiver(dev, &bc->hdrv);
 364         local_irq_disable();
 365         return IRQ_HANDLED;
 366 }
 367
 368 /* --------------------------------------------------------------------- */
 369
 370 enum uart { c_uart_unknown, c_uart_8250,
 371             c_uart_16450, c_uart_16550, c_uart_16550A};
 372 static const char *uart_str[] = {
 373         "unknown", "8250", "16450", "16550", "16550A"
 374 };
 375
 376 static enum uart ser12_check_uart(unsigned int iobase)
 377 {
 378         unsigned char b1,b2,b3;
 379         enum uart u;
 380         enum uart uart_tab[] =
 381                 { c_uart_16450, c_uart_unknown, c_uart_16550, c_uart_16550A };
 382
 383         b1 = inb(MCR(iobase));
 384         outb(b1 | 0x10, MCR(iobase));   /* loopback mode */
 385         b2 = inb(MSR(iobase));
 386         outb(0x1a, MCR(iobase));
 387         b3 = inb(MSR(iobase)) & 0xf0;
 388         outb(b1, MCR(iobase));                  /* restore old values */
 389         outb(b2, MSR(iobase));
 390         if (b3 != 0x90)
 391                 return c_uart_unknown;
 392         inb(RBR(iobase));
 393         inb(RBR(iobase));
 394         outb(0x01, FCR(iobase));                /* enable FIFOs */
 395         u = uart_tab[(inb(IIR(iobase)) >> 6) & 3];
 396         if (u == c_uart_16450) {
 397                 outb(0x5a, SCR(iobase));
 398                 b1 = inb(SCR(iobase));
 399                 outb(0xa5, SCR(iobase));
 400                 b2 = inb(SCR(iobase));
 401                 if ((b1 != 0x5a) || (b2 != 0xa5))
 402                         u = c_uart_8250;
 403         }
 404         return u;
 405 }
 406
 407 /* --------------------------------------------------------------------- */
 408
 409 static int ser12_open(struct net_device *dev)
 410 {
 411         struct baycom_state *bc = netdev_priv(dev);
 412         enum uart u;
 413
 414         if (!dev || !bc)
 415                 return -ENXIO;
 416         if (!dev->base_addr || dev->base_addr > 0x1000-SER12_EXTENT ||
 417             dev->irq < 2 || dev->irq > 15)
 418                 return -ENXIO;
 419         if (bc->baud < 300 || bc->baud > 4800)
 420                 return -EINVAL;
 421         if (!request_region(dev->base_addr, SER12_EXTENT, "baycom_ser_fdx")) {
 422                 printk(KERN_WARNING "BAYCOM_SER_FSX: I/O port 0x%04lx busy \n",
 423                        dev->base_addr);
 424                 return -EACCES;
 425         }
 426         memset(&bc->modem, 0, sizeof(bc->modem));
 427         bc->hdrv.par.bitrate = bc->baud;
 428         bc->baud_us = 1000000/bc->baud;
 429         bc->baud_uartdiv = (115200/8)/bc->baud;
 430         if ((u = ser12_check_uart(dev->base_addr)) == c_uart_unknown){
 431                 release_region(dev->base_addr, SER12_EXTENT);
 432                 return -EIO;
 433         }
 434         outb(0, FCR(dev->base_addr));  /* disable FIFOs */
 435         outb(0x0d, MCR(dev->base_addr));
 436         outb(0, IER(dev->base_addr));
 437         if (request_irq(dev->irq, ser12_interrupt, IRQF_DISABLED | IRQF_SHARED,
 438                         "baycom_ser_fdx", dev)) {
 439                 release_region(dev->base_addr, SER12_EXTENT);
 440                 return -EBUSY;
 441         }
 442         /*
 443          * set the SIO to 6 Bits/character; during receive,
 444          * the baud rate is set to produce 100 ints/sec
 445          * to feed the channel arbitration process,
 446          * during transmit to baud ints/sec to run
 447          * the transmitter
 448          */
 449         ser12_set_divisor(dev, 115200/100/8);
 450         /*
 451          * enable transmitter empty interrupt and modem status interrupt
 452          */
 453         outb(0x0a, IER(dev->base_addr));
 454         /*
 455          * make sure the next interrupt is generated;
 456          * 0 must be used to power the modem; the modem draws its
 457          * power from the TxD line
 458          */
 459         outb(0x00, THR(dev->base_addr));
 460         hdlcdrv_setdcd(&bc->hdrv, 0);
 461         printk(KERN_INFO "%s: ser_fdx at iobase 0x%lx irq %u baud %u uart %s\n",
 462                bc_drvname, dev->base_addr, dev->irq, bc->baud, uart_str[u]);
 463         return 0;
 464 }
 465
 466 /* --------------------------------------------------------------------- */
 467
 468 static int ser12_close(struct net_device *dev)
 469 {
 470         struct baycom_state *bc = netdev_priv(dev);
 471
 472         if (!dev || !bc)
 473                 return -EINVAL;
 474         /*
 475          * disable interrupts
 476          */
 477         outb(0, IER(dev->base_addr));
 478         outb(1, MCR(dev->base_addr));
 479         free_irq(dev->irq, dev);
 480         release_region(dev->base_addr, SER12_EXTENT);
 481         printk(KERN_INFO "%s: close ser_fdx at iobase 0x%lx irq %u\n",
 482                bc_drvname, dev->base_addr, dev->irq);
 483         return 0;
 484 }
 485
 486 /* --------------------------------------------------------------------- */
 487 /*
 488  * ===================== hdlcdrv driver interface =========================
 489  */
 490
 491 /* --------------------------------------------------------------------- */
 492
 493 static int baycom_ioctl(struct net_device *dev, struct ifreq *ifr,
 494                         struct hdlcdrv_ioctl *hi, int cmd);
 495
 496 /* --------------------------------------------------------------------- */
 497
 498 static struct hdlcdrv_ops ser12_ops = {
 499         .drvname = bc_drvname,
 500         .drvinfo = bc_drvinfo,
 501         .open    = ser12_open,
 502         .close   = ser12_close,
 503         .ioctl   = baycom_ioctl,
 504 };
 505
 506 /* --------------------------------------------------------------------- */
 507
 508 static int baycom_setmode(struct baycom_state *bc, const char *modestr)
 509 {
 510         unsigned int baud;
 511
 512         if (!strncmp(modestr, "ser", 3)) {
 513                 baud = simple_strtoul(modestr+3, NULL, 10);
 514                 if (baud >= 3 && baud <= 48)
 515                         bc->baud = baud*100;
 516         }
 517         if (strchr(modestr, '*'))
 518                 bc->opt_dcd = 0;
 519         else if (strchr(modestr, '+'))
 520                 bc->opt_dcd = -1;
 521         else
 522                 bc->opt_dcd = 1;
 523         return 0;
 524 }
 525
 526 /* --------------------------------------------------------------------- */
 527
 528 static int baycom_ioctl(struct net_device *dev, struct ifreq *ifr,
 529                         struct hdlcdrv_ioctl *hi, int cmd)
 530 {
 531         struct baycom_state *bc;
 532         struct baycom_ioctl bi;
 533
 534         if (!dev)
 535                 return -EINVAL;
 536
 537         bc = netdev_priv(dev);
 538         BUG_ON(bc->hdrv.magic != HDLCDRV_MAGIC);
 539
 540         if (cmd != SIOCDEVPRIVATE)
 541                 return -ENOIOCTLCMD;
 542         switch (hi->cmd) {
 543         default:
 544                 break;
 545
 546         case HDLCDRVCTL_GETMODE:
 547                 sprintf(hi->data.modename, "ser%u", bc->baud / 100);
 548                 if (bc->opt_dcd <= 0)
 549                         strcat(hi->data.modename, (!bc->opt_dcd) ? "*" : "+");
 550                 if (copy_to_user(ifr->ifr_data, hi, sizeof(struct hdlcdrv_ioctl)))
 551                         return -EFAULT;
 552                 return 0;
 553
 554         case HDLCDRVCTL_SETMODE:
 555                 if (netif_running(dev) || !capable(CAP_NET_ADMIN))
 556                         return -EACCES;
 557                 hi->data.modename[sizeof(hi->data.modename)-1] = '\0';
 558                 return baycom_setmode(bc, hi->data.modename);
 559
 560         case HDLCDRVCTL_MODELIST:
 561                 strcpy(hi->data.modename, "ser12,ser3,ser24");
 562                 if (copy_to_user(ifr->ifr_data, hi, sizeof(struct hdlcdrv_ioctl)))
 563                         return -EFAULT;
 564                 return 0;
 565
 566         case HDLCDRVCTL_MODEMPARMASK:
 567                 return HDLCDRV_PARMASK_IOBASE | HDLCDRV_PARMASK_IRQ;
 568
 569         }
 570
 571         if (copy_from_user(&bi, ifr->ifr_data, sizeof(bi)))
 572                 return -EFAULT;
 573         switch (bi.cmd) {
 574         default:
 575                 return -ENOIOCTLCMD;
 576
 577 #ifdef BAYCOM_DEBUG
 578         case BAYCOMCTL_GETDEBUG:
 579                 bi.data.dbg.debug1 = bc->hdrv.ptt_keyed;
 580                 bi.data.dbg.debug2 = bc->debug_vals.last_intcnt;
 581                 bi.data.dbg.debug3 = bc->debug_vals.last_pllcorr;
 582                 break;
 583 #endif /* BAYCOM_DEBUG */
 584
 585         }
 586         if (copy_to_user(ifr->ifr_data, &bi, sizeof(bi)))
 587                 return -EFAULT;
 588         return 0;
 589
 590 }
 591
 592 /* --------------------------------------------------------------------- */
 593
 594 /*
 595  * command line settable parameters
 596  */
 597 static char *mode[NR_PORTS] = { "ser12*", };
 598 static int iobase[NR_PORTS] = { 0x3f8, };
 599 static int irq[NR_PORTS] = { 4, };
 600 static int baud[NR_PORTS] = { [0 ... NR_PORTS-1] = 1200 };
 601
 602 module_param_array(mode, charp, NULL, 0);
 603 MODULE_PARM_DESC(mode, "baycom operating mode; * for software DCD");
 604 module_param_array(iobase, int, NULL, 0);
 605 MODULE_PARM_DESC(iobase, "baycom io base address");
 606 module_param_array(irq, int, NULL, 0);
 607 MODULE_PARM_DESC(irq, "baycom irq number");
 608 module_param_array(baud, int, NULL, 0);
 609 MODULE_PARM_DESC(baud, "baycom baud rate (300 to 4800)");
 610
 611 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
 612 MODULE_DESCRIPTION("Baycom ser12 full duplex amateur radio modem driver");
 613 MODULE_LICENSE("GPL");
 614
 615 /* --------------------------------------------------------------------- */
 616
 617 static int __init init_baycomserfdx(void)
 618 {
 619         int i, found = 0;
 620         char set_hw = 1;
 621
 622         printk(bc_drvinfo);
 623         /*
 624          * register net devices
 625          */
 626         for (i = 0; i < NR_PORTS; i++) {
 627                 struct net_device *dev;
 628                 struct baycom_state *bc;
 629                 char ifname[IFNAMSIZ];
 630
 631                 sprintf(ifname, "bcsf%d", i);
 632
 633                 if (!mode[i])
 634                         set_hw = 0;
 635                 if (!set_hw)
 636                         iobase[i] = irq[i] = 0;
 637
 638                 dev = hdlcdrv_register(&ser12_ops,
 639                                        sizeof(struct baycom_state),
 640                                        ifname, iobase[i], irq[i], 0);
 641                 if (IS_ERR(dev))
 642                         break;
 643
 644                 bc = netdev_priv(dev);
 645                 if (set_hw && baycom_setmode(bc, mode[i]))
 646                         set_hw = 0;
 647                 bc->baud = baud[i];
 648                 found++;
 649                 baycom_device[i] = dev;
 650         }
 651
 652         if (!found)
 653                 return -ENXIO;
 654         return 0;
 655 }
 656
 657 static void __exit cleanup_baycomserfdx(void)
 658 {
 659         int i;
 660
 661         for(i = 0; i < NR_PORTS; i++) {
 662                 struct net_device *dev = baycom_device[i];
 663                 if (dev)
 664                         hdlcdrv_unregister(dev);
 665         }
 666 }
 667
 668 module_init(init_baycomserfdx);
 669 module_exit(cleanup_baycomserfdx);
 670
 671 /* --------------------------------------------------------------------- */
 672
 673 #ifndef MODULE
 674
 675 /*
 676  * format: baycom_ser_fdx=io,irq,mode
 677  * mode: ser#    hardware DCD
 678  *       ser#*   software DCD
 679  *       ser#+   hardware DCD, inverted signal at DCD pin
 680  * '#' denotes the baud rate / 100, eg. ser12* is '1200 baud, soft DCD'
 681  */
 682
 683 static int __init baycom_ser_fdx_setup(char *str)
 684 {
 685         static unsigned nr_dev;
 686         int ints[4];
 687
 688         if (nr_dev >= NR_PORTS)
 689                 return 0;
 690         str = get_options(str, 4, ints);
 691         if (ints[0] < 2)
 692                 return 0;
 693         mode[nr_dev] = str;
 694         iobase[nr_dev] = ints[1];
 695         irq[nr_dev] = ints[2];
 696         if (ints[0] >= 3)
 697                 baud[nr_dev] = ints[3];
 698         nr_dev++;
 699         return 1;
 700 }
 701
 702 __setup("baycom_ser_fdx=", baycom_ser_fdx_setup);
 703
 704 #endif /* MODULE */
 705 /* --------------------------------------------------------------------- */