drivers/usb/serial/mos7720.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * mos7720.c
   4  *   Controls the Moschip 7720 usb to dual port serial converter
   5  *
   6  * Copyright 2006 Moschip Semiconductor Tech. Ltd.
   7  *
   8  * Developed by:
   9  *      Vijaya Kumar <vijaykumar.gn@gmail.com>
  10  *      Ajay Kumar <naanuajay@yahoo.com>
  11  *      Gurudeva <ngurudeva@yahoo.com>
  12  *
  13  * Cleaned up from the original by:
  14  *      Greg Kroah-Hartman <gregkh@suse.de>
  15  *
  16  * Originally based on drivers/usb/serial/io_edgeport.c which is:
  17  *      Copyright (C) 2000 Inside Out Networks, All rights reserved.
  18  *      Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>
  19  */
  20 #include <linux/kernel.h>
  21 #include <linux/errno.h>
  22 #include <linux/slab.h>
  23 #include <linux/tty.h>
  24 #include <linux/tty_driver.h>
  25 #include <linux/tty_flip.h>
  26 #include <linux/module.h>
  27 #include <linux/spinlock.h>
  28 #include <linux/serial.h>
  29 #include <linux/serial_reg.h>
  30 #include <linux/usb.h>
  31 #include <linux/usb/serial.h>
  32 #include <linux/uaccess.h>
  33 #include <linux/parport.h>
  34
  35 #define DRIVER_AUTHOR "Aspire Communications pvt Ltd."
  36 #define DRIVER_DESC "Moschip USB Serial Driver"
  37
  38 /* default urb timeout */
  39 #define MOS_WDR_TIMEOUT 5000
  40
  41 #define MOS_MAX_PORT    0x02
  42 #define MOS_WRITE       0x0E
  43 #define MOS_READ        0x0D
  44
  45 /* Interrupt Routines Defines   */
  46 #define SERIAL_IIR_RLS  0x06
  47 #define SERIAL_IIR_RDA  0x04
  48 #define SERIAL_IIR_CTI  0x0c
  49 #define SERIAL_IIR_THR  0x02
  50 #define SERIAL_IIR_MS   0x00
  51
  52 #define NUM_URBS                        16      /* URB Count */
  53 #define URB_TRANSFER_BUFFER_SIZE        32      /* URB Size */
  54
  55 /* This structure holds all of the local serial port information */
  56 struct moschip_port {
  57         __u8    shadowLCR;              /* last LCR value received */
  58         __u8    shadowMCR;              /* last MCR value received */
  59         __u8    shadowMSR;              /* last MSR value received */
  60         char                    open;
  61         struct usb_serial_port  *port;  /* loop back to the owner */
  62         struct urb              *write_urb_pool[NUM_URBS];
  63 };
  64
  65 #define USB_VENDOR_ID_MOSCHIP           0x9710
  66 #define MOSCHIP_DEVICE_ID_7720          0x7720
  67 #define MOSCHIP_DEVICE_ID_7715          0x7715
  68
  69 static const struct usb_device_id id_table[] = {
  70         { USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7720) },
  71         { USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7715) },
  72         { } /* terminating entry */
  73 };
  74 MODULE_DEVICE_TABLE(usb, id_table);
  75
  76 #ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
  77
  78 /* initial values for parport regs */
  79 #define DCR_INIT_VAL       0x0c /* SLCTIN, nINIT */
  80 #define ECR_INIT_VAL       0x00 /* SPP mode */
  81
  82 enum mos7715_pp_modes {
  83         SPP = 0<<5,
  84         PS2 = 1<<5,      /* moschip calls this 'NIBBLE' mode */
  85         PPF = 2<<5,      /* moschip calls this 'CB-FIFO mode */
  86 };
  87
  88 struct mos7715_parport {
  89         struct parport          *pp;           /* back to containing struct */
  90         struct kref             ref_count;     /* to instance of this struct */
  91         bool                    msg_pending;   /* usb sync call pending */
  92         struct completion       syncmsg_compl; /* usb sync call completed */
  93         struct work_struct      work;          /* restore deferred writes */
  94         struct usb_serial       *serial;       /* back to containing struct */
  95         __u8                    shadowECR;     /* parallel port regs... */
  96         __u8                    shadowDCR;
  97         atomic_t                shadowDSR;     /* updated in int-in callback */
  98 };
  99
 100 /* lock guards against dereferencing NULL ptr in parport ops callbacks */
 101 static DEFINE_SPINLOCK(release_lock);
 102
 103 #endif  /* CONFIG_USB_SERIAL_MOS7715_PARPORT */
 104
 105 static const unsigned int dummy; /* for clarity in register access fns */
 106
 107 enum mos_regs {
 108         MOS7720_THR,              /* serial port regs */
 109         MOS7720_RHR,
 110         MOS7720_IER,
 111         MOS7720_FCR,
 112         MOS7720_ISR,
 113         MOS7720_LCR,
 114         MOS7720_MCR,
 115         MOS7720_LSR,
 116         MOS7720_MSR,
 117         MOS7720_SPR,
 118         MOS7720_DLL,
 119         MOS7720_DLM,
 120         MOS7720_DPR,              /* parallel port regs */
 121         MOS7720_DSR,
 122         MOS7720_DCR,
 123         MOS7720_ECR,
 124         MOS7720_SP1_REG,          /* device control regs */
 125         MOS7720_SP2_REG,          /* serial port 2 (7720 only) */
 126         MOS7720_PP_REG,
 127         MOS7720_SP_CONTROL_REG,
 128 };
 129
 130 /*
 131  * Return the correct value for the Windex field of the setup packet
 132  * for a control endpoint message.  See the 7715 datasheet.
 133  */
 134 static inline __u16 get_reg_index(enum mos_regs reg)
 135 {
 136         static const __u16 mos7715_index_lookup_table[] = {
 137                 0x00,           /* MOS7720_THR */
 138                 0x00,           /* MOS7720_RHR */
 139                 0x01,           /* MOS7720_IER */
 140                 0x02,           /* MOS7720_FCR */
 141                 0x02,           /* MOS7720_ISR */
 142                 0x03,           /* MOS7720_LCR */
 143                 0x04,           /* MOS7720_MCR */
 144                 0x05,           /* MOS7720_LSR */
 145                 0x06,           /* MOS7720_MSR */
 146                 0x07,           /* MOS7720_SPR */
 147                 0x00,           /* MOS7720_DLL */
 148                 0x01,           /* MOS7720_DLM */
 149                 0x00,           /* MOS7720_DPR */
 150                 0x01,           /* MOS7720_DSR */
 151                 0x02,           /* MOS7720_DCR */
 152                 0x0a,           /* MOS7720_ECR */
 153                 0x01,           /* MOS7720_SP1_REG */
 154                 0x02,           /* MOS7720_SP2_REG (7720 only) */
 155                 0x04,           /* MOS7720_PP_REG (7715 only) */
 156                 0x08,           /* MOS7720_SP_CONTROL_REG */
 157         };
 158         return mos7715_index_lookup_table[reg];
 159 }
 160
 161 /*
 162  * Return the correct value for the upper byte of the Wvalue field of
 163  * the setup packet for a control endpoint message.
 164  */
 165 static inline __u16 get_reg_value(enum mos_regs reg,
 166                                   unsigned int serial_portnum)
 167 {
 168         if (reg >= MOS7720_SP1_REG)     /* control reg */
 169                 return 0x0000;
 170
 171         else if (reg >= MOS7720_DPR)    /* parallel port reg (7715 only) */
 172                 return 0x0100;
 173
 174         else                          /* serial port reg */
 175                 return (serial_portnum + 2) << 8;
 176 }
 177
 178 /*
 179  * Write data byte to the specified device register.  The data is embedded in
 180  * the value field of the setup packet. serial_portnum is ignored for registers
 181  * not specific to a particular serial port.
 182  */
 183 static int write_mos_reg(struct usb_serial *serial, unsigned int serial_portnum,
 184                          enum mos_regs reg, __u8 data)
 185 {
 186         struct usb_device *usbdev = serial->dev;
 187         unsigned int pipe = usb_sndctrlpipe(usbdev, 0);
 188         __u8 request = (__u8)0x0e;
 189         __u8 requesttype = (__u8)0x40;
 190         __u16 index = get_reg_index(reg);
 191         __u16 value = get_reg_value(reg, serial_portnum) + data;
 192         int status = usb_control_msg(usbdev, pipe, request, requesttype, value,
 193                                      index, NULL, 0, MOS_WDR_TIMEOUT);
 194         if (status < 0)
 195                 dev_err(&usbdev->dev,
 196                         "mos7720: usb_control_msg() failed: %d\n", status);
 197         return status;
 198 }
 199
 200 /*
 201  * Read data byte from the specified device register.  The data returned by the
 202  * device is embedded in the value field of the setup packet.  serial_portnum is
 203  * ignored for registers that are not specific to a particular serial port.
 204  */
 205 static int read_mos_reg(struct usb_serial *serial, unsigned int serial_portnum,
 206                         enum mos_regs reg, __u8 *data)
 207 {
 208         struct usb_device *usbdev = serial->dev;
 209         unsigned int pipe = usb_rcvctrlpipe(usbdev, 0);
 210         __u8 request = (__u8)0x0d;
 211         __u8 requesttype = (__u8)0xc0;
 212         __u16 index = get_reg_index(reg);
 213         __u16 value = get_reg_value(reg, serial_portnum);
 214         u8 *buf;
 215         int status;
 216
 217         buf = kmalloc(1, GFP_KERNEL);
 218         if (!buf) {
 219                 *data = 0;
 220                 return -ENOMEM;
 221         }
 222
 223         status = usb_control_msg(usbdev, pipe, request, requesttype, value,
 224                                      index, buf, 1, MOS_WDR_TIMEOUT);
 225         if (status == 1) {
 226                 *data = *buf;
 227         } else {
 228                 dev_err(&usbdev->dev,
 229                         "mos7720: usb_control_msg() failed: %d\n", status);
 230                 if (status >= 0)
 231                         status = -EIO;
 232                 *data = 0;
 233         }
 234
 235         kfree(buf);
 236
 237         return status;
 238 }
 239
 240 #ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
 241
 242 static inline int mos7715_change_mode(struct mos7715_parport *mos_parport,
 243                                       enum mos7715_pp_modes mode)
 244 {
 245         mos_parport->shadowECR = mode;
 246         write_mos_reg(mos_parport->serial, dummy, MOS7720_ECR,
 247                       mos_parport->shadowECR);
 248         return 0;
 249 }
 250
 251 static void destroy_mos_parport(struct kref *kref)
 252 {
 253         struct mos7715_parport *mos_parport =
 254                 container_of(kref, struct mos7715_parport, ref_count);
 255
 256         kfree(mos_parport);
 257 }
 258
 259 /*
 260  * This is the common top part of all parallel port callback operations that
 261  * send synchronous messages to the device.  This implements convoluted locking
 262  * that avoids two scenarios: (1) a port operation is called after usbserial
 263  * has called our release function, at which point struct mos7715_parport has
 264  * been destroyed, and (2) the device has been disconnected, but usbserial has
 265  * not called the release function yet because someone has a serial port open.
 266  * The shared release_lock prevents the first, and the mutex and disconnected
 267  * flag maintained by usbserial covers the second.  We also use the msg_pending
 268  * flag to ensure that all synchronous usb message calls have completed before
 269  * our release function can return.
 270  */
 271 static int parport_prologue(struct parport *pp)
 272 {
 273         struct mos7715_parport *mos_parport;
 274
 275         spin_lock(&release_lock);
 276         mos_parport = pp->private_data;
 277         if (unlikely(mos_parport == NULL)) {
 278                 /* release fn called, port struct destroyed */
 279                 spin_unlock(&release_lock);
 280                 return -1;
 281         }
 282         mos_parport->msg_pending = true;   /* synch usb call pending */
 283         reinit_completion(&mos_parport->syncmsg_compl);
 284         spin_unlock(&release_lock);
 285
 286         /* ensure writes from restore are submitted before new requests */
 287         if (work_pending(&mos_parport->work))
 288                 flush_work(&mos_parport->work);
 289
 290         mutex_lock(&mos_parport->serial->disc_mutex);
 291         if (mos_parport->serial->disconnected) {
 292                 /* device disconnected */
 293                 mutex_unlock(&mos_parport->serial->disc_mutex);
 294                 mos_parport->msg_pending = false;
 295                 complete(&mos_parport->syncmsg_compl);
 296                 return -1;
 297         }
 298
 299         return 0;
 300 }
 301
 302 /*
 303  * This is the common bottom part of all parallel port functions that send
 304  * synchronous messages to the device.
 305  */
 306 static inline void parport_epilogue(struct parport *pp)
 307 {
 308         struct mos7715_parport *mos_parport = pp->private_data;
 309         mutex_unlock(&mos_parport->serial->disc_mutex);
 310         mos_parport->msg_pending = false;
 311         complete(&mos_parport->syncmsg_compl);
 312 }
 313
 314 static void deferred_restore_writes(struct work_struct *work)
 315 {
 316         struct mos7715_parport *mos_parport;
 317
 318         mos_parport = container_of(work, struct mos7715_parport, work);
 319
 320         mutex_lock(&mos_parport->serial->disc_mutex);
 321
 322         /* if device disconnected, game over */
 323         if (mos_parport->serial->disconnected)
 324                 goto done;
 325
 326         write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR,
 327                       mos_parport->shadowDCR);
 328         write_mos_reg(mos_parport->serial, dummy, MOS7720_ECR,
 329                       mos_parport->shadowECR);
 330 done:
 331         mutex_unlock(&mos_parport->serial->disc_mutex);
 332 }
 333
 334 static void parport_mos7715_write_data(struct parport *pp, unsigned char d)
 335 {
 336         struct mos7715_parport *mos_parport = pp->private_data;
 337
 338         if (parport_prologue(pp) < 0)
 339                 return;
 340         mos7715_change_mode(mos_parport, SPP);
 341         write_mos_reg(mos_parport->serial, dummy, MOS7720_DPR, (__u8)d);
 342         parport_epilogue(pp);
 343 }
 344
 345 static unsigned char parport_mos7715_read_data(struct parport *pp)
 346 {
 347         struct mos7715_parport *mos_parport = pp->private_data;
 348         unsigned char d;
 349
 350         if (parport_prologue(pp) < 0)
 351                 return 0;
 352         read_mos_reg(mos_parport->serial, dummy, MOS7720_DPR, &d);
 353         parport_epilogue(pp);
 354         return d;
 355 }
 356
 357 static void parport_mos7715_write_control(struct parport *pp, unsigned char d)
 358 {
 359         struct mos7715_parport *mos_parport = pp->private_data;
 360         __u8 data;
 361
 362         if (parport_prologue(pp) < 0)
 363                 return;
 364         data = ((__u8)d & 0x0f) | (mos_parport->shadowDCR & 0xf0);
 365         write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR, data);
 366         mos_parport->shadowDCR = data;
 367         parport_epilogue(pp);
 368 }
 369
 370 static unsigned char parport_mos7715_read_control(struct parport *pp)
 371 {
 372         struct mos7715_parport *mos_parport;
 373         __u8 dcr;
 374
 375         spin_lock(&release_lock);
 376         mos_parport = pp->private_data;
 377         if (unlikely(mos_parport == NULL)) {
 378                 spin_unlock(&release_lock);
 379                 return 0;
 380         }
 381         dcr = mos_parport->shadowDCR & 0x0f;
 382         spin_unlock(&release_lock);
 383         return dcr;
 384 }
 385
 386 static unsigned char parport_mos7715_frob_control(struct parport *pp,
 387                                                   unsigned char mask,
 388                                                   unsigned char val)
 389 {
 390         struct mos7715_parport *mos_parport = pp->private_data;
 391         __u8 dcr;
 392
 393         mask &= 0x0f;
 394         val &= 0x0f;
 395         if (parport_prologue(pp) < 0)
 396                 return 0;
 397         mos_parport->shadowDCR = (mos_parport->shadowDCR & (~mask)) ^ val;
 398         write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR,
 399                       mos_parport->shadowDCR);
 400         dcr = mos_parport->shadowDCR & 0x0f;
 401         parport_epilogue(pp);
 402         return dcr;
 403 }
 404
 405 static unsigned char parport_mos7715_read_status(struct parport *pp)
 406 {
 407         unsigned char status;
 408         struct mos7715_parport *mos_parport;
 409
 410         spin_lock(&release_lock);
 411         mos_parport = pp->private_data;
 412         if (unlikely(mos_parport == NULL)) {    /* release called */
 413                 spin_unlock(&release_lock);
 414                 return 0;
 415         }
 416         status = atomic_read(&mos_parport->shadowDSR) & 0xf8;
 417         spin_unlock(&release_lock);
 418         return status;
 419 }
 420
 421 static void parport_mos7715_enable_irq(struct parport *pp)
 422 {
 423 }
 424
 425 static void parport_mos7715_disable_irq(struct parport *pp)
 426 {
 427 }
 428
 429 static void parport_mos7715_data_forward(struct parport *pp)
 430 {
 431         struct mos7715_parport *mos_parport = pp->private_data;
 432
 433         if (parport_prologue(pp) < 0)
 434                 return;
 435         mos7715_change_mode(mos_parport, PS2);
 436         mos_parport->shadowDCR &=  ~0x20;
 437         write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR,
 438                       mos_parport->shadowDCR);
 439         parport_epilogue(pp);
 440 }
 441
 442 static void parport_mos7715_data_reverse(struct parport *pp)
 443 {
 444         struct mos7715_parport *mos_parport = pp->private_data;
 445
 446         if (parport_prologue(pp) < 0)
 447                 return;
 448         mos7715_change_mode(mos_parport, PS2);
 449         mos_parport->shadowDCR |= 0x20;
 450         write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR,
 451                       mos_parport->shadowDCR);
 452         parport_epilogue(pp);
 453 }
 454
 455 static void parport_mos7715_init_state(struct pardevice *dev,
 456                                        struct parport_state *s)
 457 {
 458         s->u.pc.ctr = DCR_INIT_VAL;
 459         s->u.pc.ecr = ECR_INIT_VAL;
 460 }
 461
 462 /* N.B. Parport core code requires that this function not block */
 463 static void parport_mos7715_save_state(struct parport *pp,
 464                                        struct parport_state *s)
 465 {
 466         struct mos7715_parport *mos_parport;
 467
 468         spin_lock(&release_lock);
 469         mos_parport = pp->private_data;
 470         if (unlikely(mos_parport == NULL)) {    /* release called */
 471                 spin_unlock(&release_lock);
 472                 return;
 473         }
 474         s->u.pc.ctr = mos_parport->shadowDCR;
 475         s->u.pc.ecr = mos_parport->shadowECR;
 476         spin_unlock(&release_lock);
 477 }
 478
 479 /* N.B. Parport core code requires that this function not block */
 480 static void parport_mos7715_restore_state(struct parport *pp,
 481                                           struct parport_state *s)
 482 {
 483         struct mos7715_parport *mos_parport;
 484
 485         spin_lock(&release_lock);
 486         mos_parport = pp->private_data;
 487         if (unlikely(mos_parport == NULL)) {    /* release called */
 488                 spin_unlock(&release_lock);
 489                 return;
 490         }
 491         mos_parport->shadowDCR = s->u.pc.ctr;
 492         mos_parport->shadowECR = s->u.pc.ecr;
 493
 494         schedule_work(&mos_parport->work);
 495         spin_unlock(&release_lock);
 496 }
 497
 498 static size_t parport_mos7715_write_compat(struct parport *pp,
 499                                            const void *buffer,
 500                                            size_t len, int flags)
 501 {
 502         int retval;
 503         struct mos7715_parport *mos_parport = pp->private_data;
 504         int actual_len;
 505
 506         if (parport_prologue(pp) < 0)
 507                 return 0;
 508         mos7715_change_mode(mos_parport, PPF);
 509         retval = usb_bulk_msg(mos_parport->serial->dev,
 510                               usb_sndbulkpipe(mos_parport->serial->dev, 2),
 511                               (void *)buffer, len, &actual_len,
 512                               MOS_WDR_TIMEOUT);
 513         parport_epilogue(pp);
 514         if (retval) {
 515                 dev_err(&mos_parport->serial->dev->dev,
 516                         "mos7720: usb_bulk_msg() failed: %d\n", retval);
 517                 return 0;
 518         }
 519         return actual_len;
 520 }
 521
 522 static struct parport_operations parport_mos7715_ops = {
 523         .owner =                THIS_MODULE,
 524         .write_data =           parport_mos7715_write_data,
 525         .read_data =            parport_mos7715_read_data,
 526
 527         .write_control =        parport_mos7715_write_control,
 528         .read_control =         parport_mos7715_read_control,
 529         .frob_control =         parport_mos7715_frob_control,
 530
 531         .read_status =          parport_mos7715_read_status,
 532
 533         .enable_irq =           parport_mos7715_enable_irq,
 534         .disable_irq =          parport_mos7715_disable_irq,
 535
 536         .data_forward =         parport_mos7715_data_forward,
 537         .data_reverse =         parport_mos7715_data_reverse,
 538
 539         .init_state =           parport_mos7715_init_state,
 540         .save_state =           parport_mos7715_save_state,
 541         .restore_state =        parport_mos7715_restore_state,
 542
 543         .compat_write_data =    parport_mos7715_write_compat,
 544
 545         .nibble_read_data =     parport_ieee1284_read_nibble,
 546         .byte_read_data =       parport_ieee1284_read_byte,
 547 };
 548
 549 /*
 550  * Allocate and initialize parallel port control struct, initialize
 551  * the parallel port hardware device, and register with the parport subsystem.
 552  */
 553 static int mos7715_parport_init(struct usb_serial *serial)
 554 {
 555         struct mos7715_parport *mos_parport;
 556
 557         /* allocate and initialize parallel port control struct */
 558         mos_parport = kzalloc(sizeof(struct mos7715_parport), GFP_KERNEL);
 559         if (!mos_parport)
 560                 return -ENOMEM;
 561
 562         mos_parport->msg_pending = false;
 563         kref_init(&mos_parport->ref_count);
 564         usb_set_serial_data(serial, mos_parport); /* hijack private pointer */
 565         mos_parport->serial = serial;
 566         INIT_WORK(&mos_parport->work, deferred_restore_writes);
 567         init_completion(&mos_parport->syncmsg_compl);
 568
 569         /* cycle parallel port reset bit */
 570         write_mos_reg(mos_parport->serial, dummy, MOS7720_PP_REG, (__u8)0x80);
 571         write_mos_reg(mos_parport->serial, dummy, MOS7720_PP_REG, (__u8)0x00);
 572
 573         /* initialize device registers */
 574         mos_parport->shadowDCR = DCR_INIT_VAL;
 575         write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR,
 576                       mos_parport->shadowDCR);
 577         mos_parport->shadowECR = ECR_INIT_VAL;
 578         write_mos_reg(mos_parport->serial, dummy, MOS7720_ECR,
 579                       mos_parport->shadowECR);
 580
 581         /* register with parport core */
 582         mos_parport->pp = parport_register_port(0, PARPORT_IRQ_NONE,
 583                                                 PARPORT_DMA_NONE,
 584                                                 &parport_mos7715_ops);
 585         if (mos_parport->pp == NULL) {
 586                 dev_err(&serial->interface->dev,
 587                         "Could not register parport\n");
 588                 kref_put(&mos_parport->ref_count, destroy_mos_parport);
 589                 return -EIO;
 590         }
 591         mos_parport->pp->private_data = mos_parport;
 592         mos_parport->pp->modes = PARPORT_MODE_COMPAT | PARPORT_MODE_PCSPP;
 593         mos_parport->pp->dev = &serial->interface->dev;
 594         parport_announce_port(mos_parport->pp);
 595
 596         return 0;
 597 }
 598 #endif  /* CONFIG_USB_SERIAL_MOS7715_PARPORT */
 599
 600 /*
 601  * mos7720_interrupt_callback
 602  *      this is the callback function for when we have received data on the
 603  *      interrupt endpoint.
 604  */
 605 static void mos7720_interrupt_callback(struct urb *urb)
 606 {
 607         int result;
 608         int length;
 609         int status = urb->status;
 610         struct device *dev = &urb->dev->dev;
 611         __u8 *data;
 612         __u8 sp1;
 613         __u8 sp2;
 614
 615         switch (status) {
 616         case 0:
 617                 /* success */
 618                 break;
 619         case -ECONNRESET:
 620         case -ENOENT:
 621         case -ESHUTDOWN:
 622                 /* this urb is terminated, clean up */
 623                 dev_dbg(dev, "%s - urb shutting down with status: %d\n", __func__, status);
 624                 return;
 625         default:
 626                 dev_dbg(dev, "%s - nonzero urb status received: %d\n", __func__, status);
 627                 goto exit;
 628         }
 629
 630         length = urb->actual_length;
 631         data = urb->transfer_buffer;
 632
 633         /* Moschip get 4 bytes
 634          * Byte 1 IIR Port 1 (port.number is 0)
 635          * Byte 2 IIR Port 2 (port.number is 1)
 636          * Byte 3 --------------
 637          * Byte 4 FIFO status for both */
 638
 639         /* the above description is inverted
 640          *      oneukum 2007-03-14 */
 641
 642         if (unlikely(length != 4)) {
 643                 dev_dbg(dev, "Wrong data !!!\n");
 644                 return;
 645         }
 646
 647         sp1 = data[3];
 648         sp2 = data[2];
 649
 650         if ((sp1 | sp2) & 0x01) {
 651                 /* No Interrupt Pending in both the ports */
 652                 dev_dbg(dev, "No Interrupt !!!\n");
 653         } else {
 654                 switch (sp1 & 0x0f) {
 655                 case SERIAL_IIR_RLS:
 656                         dev_dbg(dev, "Serial Port 1: Receiver status error or address bit detected in 9-bit mode\n");
 657                         break;
 658                 case SERIAL_IIR_CTI:
 659                         dev_dbg(dev, "Serial Port 1: Receiver time out\n");
 660                         break;
 661                 case SERIAL_IIR_MS:
 662                         /* dev_dbg(dev, "Serial Port 1: Modem status change\n"); */
 663                         break;
 664                 }
 665
 666                 switch (sp2 & 0x0f) {
 667                 case SERIAL_IIR_RLS:
 668                         dev_dbg(dev, "Serial Port 2: Receiver status error or address bit detected in 9-bit mode\n");
 669                         break;
 670                 case SERIAL_IIR_CTI:
 671                         dev_dbg(dev, "Serial Port 2: Receiver time out\n");
 672                         break;
 673                 case SERIAL_IIR_MS:
 674                         /* dev_dbg(dev, "Serial Port 2: Modem status change\n"); */
 675                         break;
 676                 }
 677         }
 678
 679 exit:
 680         result = usb_submit_urb(urb, GFP_ATOMIC);
 681         if (result)
 682                 dev_err(dev, "%s - Error %d submitting control urb\n", __func__, result);
 683 }
 684
 685 /*
 686  * mos7715_interrupt_callback
 687  *      this is the 7715's callback function for when we have received data on
 688  *      the interrupt endpoint.
 689  */
 690 static void mos7715_interrupt_callback(struct urb *urb)
 691 {
 692         int result;
 693         int length;
 694         int status = urb->status;
 695         struct device *dev = &urb->dev->dev;
 696         __u8 *data;
 697         __u8 iir;
 698
 699         switch (status) {
 700         case 0:
 701                 /* success */
 702                 break;
 703         case -ECONNRESET:
 704         case -ENOENT:
 705         case -ESHUTDOWN:
 706         case -ENODEV:
 707                 /* this urb is terminated, clean up */
 708                 dev_dbg(dev, "%s - urb shutting down with status: %d\n", __func__, status);
 709                 return;
 710         default:
 711                 dev_dbg(dev, "%s - nonzero urb status received: %d\n", __func__, status);
 712                 goto exit;
 713         }
 714
 715         length = urb->actual_length;
 716         data = urb->transfer_buffer;
 717
 718         /* Structure of data from 7715 device:
 719          * Byte 1: IIR serial Port
 720          * Byte 2: unused
 721          * Byte 2: DSR parallel port
 722          * Byte 4: FIFO status for both */
 723
 724         if (unlikely(length != 4)) {
 725                 dev_dbg(dev, "Wrong data !!!\n");
 726                 return;
 727         }
 728
 729         iir = data[0];
 730         if (!(iir & 0x01)) {    /* serial port interrupt pending */
 731                 switch (iir & 0x0f) {
 732                 case SERIAL_IIR_RLS:
 733                         dev_dbg(dev, "Serial Port: Receiver status error or address bit detected in 9-bit mode\n");
 734                         break;
 735                 case SERIAL_IIR_CTI:
 736                         dev_dbg(dev, "Serial Port: Receiver time out\n");
 737                         break;
 738                 case SERIAL_IIR_MS:
 739                         /* dev_dbg(dev, "Serial Port: Modem status change\n"); */
 740                         break;
 741                 }
 742         }
 743
 744 #ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
 745         {       /* update local copy of DSR reg */
 746                 struct usb_serial_port *port = urb->context;
 747                 struct mos7715_parport *mos_parport = port->serial->private;
 748                 if (unlikely(mos_parport == NULL))
 749                         return;
 750                 atomic_set(&mos_parport->shadowDSR, data[2]);
 751         }
 752 #endif
 753
 754 exit:
 755         result = usb_submit_urb(urb, GFP_ATOMIC);
 756         if (result)
 757                 dev_err(dev, "%s - Error %d submitting control urb\n", __func__, result);
 758 }
 759
 760 /*
 761  * mos7720_bulk_in_callback
 762  *      this is the callback function for when we have received data on the
 763  *      bulk in endpoint.
 764  */
 765 static void mos7720_bulk_in_callback(struct urb *urb)
 766 {
 767         int retval;
 768         unsigned char *data ;
 769         struct usb_serial_port *port;
 770         int status = urb->status;
 771
 772         if (status) {
 773                 dev_dbg(&urb->dev->dev, "nonzero read bulk status received: %d\n", status);
 774                 return;
 775         }
 776
 777         port = urb->context;
 778
 779         dev_dbg(&port->dev, "Entering...%s\n", __func__);
 780
 781         data = urb->transfer_buffer;
 782
 783         if (urb->actual_length) {
 784                 tty_insert_flip_string(&port->port, data, urb->actual_length);
 785                 tty_flip_buffer_push(&port->port);
 786         }
 787
 788         if (port->read_urb->status != -EINPROGRESS) {
 789                 retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
 790                 if (retval)
 791                         dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, retval = %d\n", retval);
 792         }
 793 }
 794
 795 /*
 796  * mos7720_bulk_out_data_callback
 797  *      this is the callback function for when we have finished sending serial
 798  *      data on the bulk out endpoint.
 799  */
 800 static void mos7720_bulk_out_data_callback(struct urb *urb)
 801 {
 802         struct moschip_port *mos7720_port;
 803         int status = urb->status;
 804
 805         if (status) {
 806                 dev_dbg(&urb->dev->dev, "nonzero write bulk status received:%d\n", status);
 807                 return;
 808         }
 809
 810         mos7720_port = urb->context;
 811         if (!mos7720_port) {
 812                 dev_dbg(&urb->dev->dev, "NULL mos7720_port pointer\n");
 813                 return ;
 814         }
 815
 816         if (mos7720_port->open)
 817                 tty_port_tty_wakeup(&mos7720_port->port->port);
 818 }
 819
 820 static int mos77xx_calc_num_ports(struct usb_serial *serial,
 821                                         struct usb_serial_endpoints *epds)
 822 {
 823         u16 product = le16_to_cpu(serial->dev->descriptor.idProduct);
 824
 825         if (product == MOSCHIP_DEVICE_ID_7715) {
 826                 /*
 827                  * The 7715 uses the first bulk in/out endpoint pair for the
 828                  * parallel port, and the second for the serial port. We swap
 829                  * the endpoint descriptors here so that the first and
 830                  * only registered port structure uses the serial-port
 831                  * endpoints.
 832                  */
 833                 swap(epds->bulk_in[0], epds->bulk_in[1]);
 834                 swap(epds->bulk_out[0], epds->bulk_out[1]);
 835
 836                 return 1;
 837         }
 838
 839         return 2;
 840 }
 841
 842 static int mos7720_open(struct tty_struct *tty, struct usb_serial_port *port)
 843 {
 844         struct usb_serial *serial;
 845         struct urb *urb;
 846         struct moschip_port *mos7720_port;
 847         int response;
 848         int port_number;
 849         __u8 data;
 850         int allocated_urbs = 0;
 851         int j;
 852
 853         serial = port->serial;
 854
 855         mos7720_port = usb_get_serial_port_data(port);
 856         if (mos7720_port == NULL)
 857                 return -ENODEV;
 858
 859         usb_clear_halt(serial->dev, port->write_urb->pipe);
 860         usb_clear_halt(serial->dev, port->read_urb->pipe);
 861
 862         /* Initialising the write urb pool */
 863         for (j = 0; j < NUM_URBS; ++j) {
 864                 urb = usb_alloc_urb(0, GFP_KERNEL);
 865                 mos7720_port->write_urb_pool[j] = urb;
 866                 if (!urb)
 867                         continue;
 868
 869                 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
 870                                                GFP_KERNEL);
 871                 if (!urb->transfer_buffer) {
 872                         usb_free_urb(mos7720_port->write_urb_pool[j]);
 873                         mos7720_port->write_urb_pool[j] = NULL;
 874                         continue;
 875                 }
 876                 allocated_urbs++;
 877         }
 878
 879         if (!allocated_urbs)
 880                 return -ENOMEM;
 881
 882          /* Initialize MCS7720 -- Write Init values to corresponding Registers
 883           *
 884           * Register Index
 885           * 0 : MOS7720_THR/MOS7720_RHR
 886           * 1 : MOS7720_IER
 887           * 2 : MOS7720_FCR
 888           * 3 : MOS7720_LCR
 889           * 4 : MOS7720_MCR
 890           * 5 : MOS7720_LSR
 891           * 6 : MOS7720_MSR
 892           * 7 : MOS7720_SPR
 893           *
 894           * 0x08 : SP1/2 Control Reg
 895           */
 896         port_number = port->port_number;
 897         read_mos_reg(serial, port_number, MOS7720_LSR, &data);
 898
 899         dev_dbg(&port->dev, "SS::%p LSR:%x\n", mos7720_port, data);
 900
 901         write_mos_reg(serial, dummy, MOS7720_SP1_REG, 0x02);
 902         write_mos_reg(serial, dummy, MOS7720_SP2_REG, 0x02);
 903
 904         write_mos_reg(serial, port_number, MOS7720_IER, 0x00);
 905         write_mos_reg(serial, port_number, MOS7720_FCR, 0x00);
 906
 907         write_mos_reg(serial, port_number, MOS7720_FCR, 0xcf);
 908         mos7720_port->shadowLCR = 0x03;
 909         write_mos_reg(serial, port_number, MOS7720_LCR,
 910                       mos7720_port->shadowLCR);
 911         mos7720_port->shadowMCR = 0x0b;
 912         write_mos_reg(serial, port_number, MOS7720_MCR,
 913                       mos7720_port->shadowMCR);
 914
 915         write_mos_reg(serial, port_number, MOS7720_SP_CONTROL_REG, 0x00);
 916         read_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG, &data);
 917         data = data | (port->port_number + 1);
 918         write_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG, data);
 919         mos7720_port->shadowLCR = 0x83;
 920         write_mos_reg(serial, port_number, MOS7720_LCR,
 921                       mos7720_port->shadowLCR);
 922         write_mos_reg(serial, port_number, MOS7720_THR, 0x0c);
 923         write_mos_reg(serial, port_number, MOS7720_IER, 0x00);
 924         mos7720_port->shadowLCR = 0x03;
 925         write_mos_reg(serial, port_number, MOS7720_LCR,
 926                       mos7720_port->shadowLCR);
 927         write_mos_reg(serial, port_number, MOS7720_IER, 0x0c);
 928
 929         response = usb_submit_urb(port->read_urb, GFP_KERNEL);
 930         if (response)
 931                 dev_err(&port->dev, "%s - Error %d submitting read urb\n",
 932                                                         __func__, response);
 933
 934         /* initialize our port settings */
 935         mos7720_port->shadowMCR = UART_MCR_OUT2; /* Must set to enable ints! */
 936
 937         /* send a open port command */
 938         mos7720_port->open = 1;
 939
 940         return 0;
 941 }
 942
 943 /*
 944  * mos7720_chars_in_buffer
 945  *      this function is called by the tty driver when it wants to know how many
 946  *      bytes of data we currently have outstanding in the port (data that has
 947  *      been written, but hasn't made it out the port yet)
 948  */
 949 static unsigned int mos7720_chars_in_buffer(struct tty_struct *tty)
 950 {
 951         struct usb_serial_port *port = tty->driver_data;
 952         struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
 953         int i;
 954         unsigned int chars = 0;
 955
 956         for (i = 0; i < NUM_URBS; ++i) {
 957                 if (mos7720_port->write_urb_pool[i] &&
 958                     mos7720_port->write_urb_pool[i]->status == -EINPROGRESS)
 959                         chars += URB_TRANSFER_BUFFER_SIZE;
 960         }
 961         dev_dbg(&port->dev, "%s - returns %u\n", __func__, chars);
 962         return chars;
 963 }
 964
 965 static void mos7720_close(struct usb_serial_port *port)
 966 {
 967         struct usb_serial *serial;
 968         struct moschip_port *mos7720_port;
 969         int j;
 970
 971         serial = port->serial;
 972
 973         mos7720_port = usb_get_serial_port_data(port);
 974         if (mos7720_port == NULL)
 975                 return;
 976
 977         for (j = 0; j < NUM_URBS; ++j)
 978                 usb_kill_urb(mos7720_port->write_urb_pool[j]);
 979
 980         /* Freeing Write URBs */
 981         for (j = 0; j < NUM_URBS; ++j) {
 982                 if (mos7720_port->write_urb_pool[j]) {
 983                         kfree(mos7720_port->write_urb_pool[j]->transfer_buffer);
 984                         usb_free_urb(mos7720_port->write_urb_pool[j]);
 985                 }
 986         }
 987
 988         /* While closing port, shutdown all bulk read, write  *
 989          * and interrupt read if they exists, otherwise nop   */
 990         usb_kill_urb(port->write_urb);
 991         usb_kill_urb(port->read_urb);
 992
 993         write_mos_reg(serial, port->port_number, MOS7720_MCR, 0x00);
 994         write_mos_reg(serial, port->port_number, MOS7720_IER, 0x00);
 995
 996         mos7720_port->open = 0;
 997 }
 998
 999 static void mos7720_break(struct tty_struct *tty, int break_state)
1000 {
1001         struct usb_serial_port *port = tty->driver_data;
1002         unsigned char data;
1003         struct usb_serial *serial;
1004         struct moschip_port *mos7720_port;
1005
1006         serial = port->serial;
1007
1008         mos7720_port = usb_get_serial_port_data(port);
1009         if (mos7720_port == NULL)
1010                 return;
1011
1012         if (break_state == -1)
1013                 data = mos7720_port->shadowLCR | UART_LCR_SBC;
1014         else
1015                 data = mos7720_port->shadowLCR & ~UART_LCR_SBC;
1016
1017         mos7720_port->shadowLCR  = data;
1018         write_mos_reg(serial, port->port_number, MOS7720_LCR,
1019                       mos7720_port->shadowLCR);
1020 }
1021
1022 /*
1023  * mos7720_write_room
1024  *      this function is called by the tty driver when it wants to know how many
1025  *      bytes of data we can accept for a specific port.
1026  */
1027 static unsigned int mos7720_write_room(struct tty_struct *tty)
1028 {
1029         struct usb_serial_port *port = tty->driver_data;
1030         struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
1031         unsigned int room = 0;
1032         int i;
1033
1034         /* FIXME: Locking */
1035         for (i = 0; i < NUM_URBS; ++i) {
1036                 if (mos7720_port->write_urb_pool[i] &&
1037                     mos7720_port->write_urb_pool[i]->status != -EINPROGRESS)
1038                         room += URB_TRANSFER_BUFFER_SIZE;
1039         }
1040
1041         dev_dbg(&port->dev, "%s - returns %u\n", __func__, room);
1042         return room;
1043 }
1044
1045 static int mos7720_write(struct tty_struct *tty, struct usb_serial_port *port,
1046                                  const unsigned char *data, int count)
1047 {
1048         int status;
1049         int i;
1050         int bytes_sent = 0;
1051         int transfer_size;
1052
1053         struct moschip_port *mos7720_port;
1054         struct usb_serial *serial;
1055         struct urb    *urb;
1056         const unsigned char *current_position = data;
1057
1058         serial = port->serial;
1059
1060         mos7720_port = usb_get_serial_port_data(port);
1061         if (mos7720_port == NULL)
1062                 return -ENODEV;
1063
1064         /* try to find a free urb in the list */
1065         urb = NULL;
1066
1067         for (i = 0; i < NUM_URBS; ++i) {
1068                 if (mos7720_port->write_urb_pool[i] &&
1069                     mos7720_port->write_urb_pool[i]->status != -EINPROGRESS) {
1070                         urb = mos7720_port->write_urb_pool[i];
1071                         dev_dbg(&port->dev, "URB:%d\n", i);
1072                         break;
1073                 }
1074         }
1075
1076         if (urb == NULL) {
1077                 dev_dbg(&port->dev, "%s - no more free urbs\n", __func__);
1078                 goto exit;
1079         }
1080
1081         if (urb->transfer_buffer == NULL) {
1082                 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
1083                                                GFP_ATOMIC);
1084                 if (!urb->transfer_buffer) {
1085                         bytes_sent = -ENOMEM;
1086                         goto exit;
1087                 }
1088         }
1089         transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE);
1090
1091         memcpy(urb->transfer_buffer, current_position, transfer_size);
1092         usb_serial_debug_data(&port->dev, __func__, transfer_size,
1093                               urb->transfer_buffer);
1094
1095         /* fill urb with data and submit  */
1096         usb_fill_bulk_urb(urb, serial->dev,
1097                           usb_sndbulkpipe(serial->dev,
1098                                         port->bulk_out_endpointAddress),
1099                           urb->transfer_buffer, transfer_size,
1100                           mos7720_bulk_out_data_callback, mos7720_port);
1101
1102         /* send it down the pipe */
1103         status = usb_submit_urb(urb, GFP_ATOMIC);
1104         if (status) {
1105                 dev_err_console(port, "%s - usb_submit_urb(write bulk) failed "
1106                         "with status = %d\n", __func__, status);
1107                 bytes_sent = status;
1108                 goto exit;
1109         }
1110         bytes_sent = transfer_size;
1111
1112 exit:
1113         return bytes_sent;
1114 }
1115
1116 static void mos7720_throttle(struct tty_struct *tty)
1117 {
1118         struct usb_serial_port *port = tty->driver_data;
1119         struct moschip_port *mos7720_port;
1120         int status;
1121
1122         mos7720_port = usb_get_serial_port_data(port);
1123
1124         if (mos7720_port == NULL)
1125                 return;
1126
1127         if (!mos7720_port->open) {
1128                 dev_dbg(&port->dev, "%s - port not opened\n", __func__);
1129                 return;
1130         }
1131
1132         /* if we are implementing XON/XOFF, send the stop character */
1133         if (I_IXOFF(tty)) {
1134                 unsigned char stop_char = STOP_CHAR(tty);
1135                 status = mos7720_write(tty, port, &stop_char, 1);
1136                 if (status <= 0)
1137                         return;
1138         }
1139
1140         /* if we are implementing RTS/CTS, toggle that line */
1141         if (C_CRTSCTS(tty)) {
1142                 mos7720_port->shadowMCR &= ~UART_MCR_RTS;
1143                 write_mos_reg(port->serial, port->port_number, MOS7720_MCR,
1144                               mos7720_port->shadowMCR);
1145         }
1146 }
1147
1148 static void mos7720_unthrottle(struct tty_struct *tty)
1149 {
1150         struct usb_serial_port *port = tty->driver_data;
1151         struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
1152         int status;
1153
1154         if (mos7720_port == NULL)
1155                 return;
1156
1157         if (!mos7720_port->open) {
1158                 dev_dbg(&port->dev, "%s - port not opened\n", __func__);
1159                 return;
1160         }
1161
1162         /* if we are implementing XON/XOFF, send the start character */
1163         if (I_IXOFF(tty)) {
1164                 unsigned char start_char = START_CHAR(tty);
1165                 status = mos7720_write(tty, port, &start_char, 1);
1166                 if (status <= 0)
1167                         return;
1168         }
1169
1170         /* if we are implementing RTS/CTS, toggle that line */
1171         if (C_CRTSCTS(tty)) {
1172                 mos7720_port->shadowMCR |= UART_MCR_RTS;
1173                 write_mos_reg(port->serial, port->port_number, MOS7720_MCR,
1174                               mos7720_port->shadowMCR);
1175         }
1176 }
1177
1178 /* FIXME: this function does not work */
1179 static int set_higher_rates(struct moschip_port *mos7720_port,
1180                             unsigned int baud)
1181 {
1182         struct usb_serial_port *port;
1183         struct usb_serial *serial;
1184         int port_number;
1185         enum mos_regs sp_reg;
1186         if (mos7720_port == NULL)
1187                 return -EINVAL;
1188
1189         port = mos7720_port->port;
1190         serial = port->serial;
1191
1192          /***********************************************
1193          *      Init Sequence for higher rates
1194          ***********************************************/
1195         dev_dbg(&port->dev, "Sending Setting Commands ..........\n");
1196         port_number = port->port_number;
1197
1198         write_mos_reg(serial, port_number, MOS7720_IER, 0x00);
1199         write_mos_reg(serial, port_number, MOS7720_FCR, 0x00);
1200         write_mos_reg(serial, port_number, MOS7720_FCR, 0xcf);
1201         mos7720_port->shadowMCR = 0x0b;
1202         write_mos_reg(serial, port_number, MOS7720_MCR,
1203                       mos7720_port->shadowMCR);
1204         write_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG, 0x00);
1205
1206         /***********************************************
1207          *              Set for higher rates           *
1208          ***********************************************/
1209         /* writing baud rate verbatum into uart clock field clearly not right */
1210         if (port_number == 0)
1211                 sp_reg = MOS7720_SP1_REG;
1212         else
1213                 sp_reg = MOS7720_SP2_REG;
1214         write_mos_reg(serial, dummy, sp_reg, baud * 0x10);
1215         write_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG, 0x03);
1216         mos7720_port->shadowMCR = 0x2b;
1217         write_mos_reg(serial, port_number, MOS7720_MCR,
1218                       mos7720_port->shadowMCR);
1219
1220         /***********************************************
1221          *              Set DLL/DLM
1222          ***********************************************/
1223         mos7720_port->shadowLCR = mos7720_port->shadowLCR | UART_LCR_DLAB;
1224         write_mos_reg(serial, port_number, MOS7720_LCR,
1225                       mos7720_port->shadowLCR);
1226         write_mos_reg(serial, port_number, MOS7720_DLL, 0x01);
1227         write_mos_reg(serial, port_number, MOS7720_DLM, 0x00);
1228         mos7720_port->shadowLCR = mos7720_port->shadowLCR & ~UART_LCR_DLAB;
1229         write_mos_reg(serial, port_number, MOS7720_LCR,
1230                       mos7720_port->shadowLCR);
1231
1232         return 0;
1233 }
1234
1235 /* baud rate information */
1236 struct divisor_table_entry {
1237         __u32  baudrate;
1238         __u16  divisor;
1239 };
1240
1241 /* Define table of divisors for moschip 7720 hardware      *
1242  * These assume a 3.6864MHz crystal, the standard /16, and *
1243  * MCR.7 = 0.                                              */
1244 static const struct divisor_table_entry divisor_table[] = {
1245         {   50,         2304},
1246         {   110,        1047},  /* 2094.545455 => 230450   => .0217 % over */
1247         {   134,        857},   /* 1713.011152 => 230398.5 => .00065% under */
1248         {   150,        768},
1249         {   300,        384},
1250         {   600,        192},
1251         {   1200,       96},
1252         {   1800,       64},
1253         {   2400,       48},
1254         {   4800,       24},
1255         {   7200,       16},
1256         {   9600,       12},
1257         {   19200,      6},
1258         {   38400,      3},
1259         {   57600,      2},
1260         {   115200,     1},
1261 };
1262
1263 /*****************************************************************************
1264  * calc_baud_rate_divisor
1265  *      this function calculates the proper baud rate divisor for the specified
1266  *      baud rate.
1267  *****************************************************************************/
1268 static int calc_baud_rate_divisor(struct usb_serial_port *port, int baudrate, int *divisor)
1269 {
1270         int i;
1271         __u16 custom;
1272         __u16 round1;
1273         __u16 round;
1274
1275
1276         dev_dbg(&port->dev, "%s - %d\n", __func__, baudrate);
1277
1278         for (i = 0; i < ARRAY_SIZE(divisor_table); i++) {
1279                 if (divisor_table[i].baudrate == baudrate) {
1280                         *divisor = divisor_table[i].divisor;
1281                         return 0;
1282                 }
1283         }
1284
1285         /* After trying for all the standard baud rates    *
1286          * Try calculating the divisor for this baud rate  */
1287         if (baudrate > 75 &&  baudrate < 230400) {
1288                 /* get the divisor */
1289                 custom = (__u16)(230400L  / baudrate);
1290
1291                 /* Check for round off */
1292                 round1 = (__u16)(2304000L / baudrate);
1293                 round = (__u16)(round1 - (custom * 10));
1294                 if (round > 4)
1295                         custom++;
1296                 *divisor = custom;
1297
1298                 dev_dbg(&port->dev, "Baud %d = %d\n", baudrate, custom);
1299                 return 0;
1300         }
1301
1302         dev_dbg(&port->dev, "Baud calculation Failed...\n");
1303         return -EINVAL;
1304 }
1305
1306 /*
1307  * send_cmd_write_baud_rate
1308  *      this function sends the proper command to change the baud rate of the
1309  *      specified port.
1310  */
1311 static int send_cmd_write_baud_rate(struct moschip_port *mos7720_port,
1312                                     int baudrate)
1313 {
1314         struct usb_serial_port *port;
1315         struct usb_serial *serial;
1316         int divisor;
1317         int status;
1318         unsigned char number;
1319
1320         if (mos7720_port == NULL)
1321                 return -1;
1322
1323         port = mos7720_port->port;
1324         serial = port->serial;
1325
1326         number = port->port_number;
1327         dev_dbg(&port->dev, "%s - baud = %d\n", __func__, baudrate);
1328
1329         /* Calculate the Divisor */
1330         status = calc_baud_rate_divisor(port, baudrate, &divisor);
1331         if (status) {
1332                 dev_err(&port->dev, "%s - bad baud rate\n", __func__);
1333                 return status;
1334         }
1335
1336         /* Enable access to divisor latch */
1337         mos7720_port->shadowLCR = mos7720_port->shadowLCR | UART_LCR_DLAB;
1338         write_mos_reg(serial, number, MOS7720_LCR, mos7720_port->shadowLCR);
1339
1340         /* Write the divisor */
1341         write_mos_reg(serial, number, MOS7720_DLL, (__u8)(divisor & 0xff));
1342         write_mos_reg(serial, number, MOS7720_DLM,
1343                       (__u8)((divisor & 0xff00) >> 8));
1344
1345         /* Disable access to divisor latch */
1346         mos7720_port->shadowLCR = mos7720_port->shadowLCR & ~UART_LCR_DLAB;
1347         write_mos_reg(serial, number, MOS7720_LCR, mos7720_port->shadowLCR);
1348
1349         return status;
1350 }
1351
1352 /*
1353  * change_port_settings
1354  *      This routine is called to set the UART on the device to match
1355  *      the specified new settings.
1356  */
1357 static void change_port_settings(struct tty_struct *tty,
1358                                  struct moschip_port *mos7720_port,
1359                                  const struct ktermios *old_termios)
1360 {
1361         struct usb_serial_port *port;
1362         struct usb_serial *serial;
1363         int baud;
1364         unsigned cflag;
1365         __u8 lData;
1366         __u8 lParity;
1367         __u8 lStop;
1368         int status;
1369         int port_number;
1370
1371         if (mos7720_port == NULL)
1372                 return ;
1373
1374         port = mos7720_port->port;
1375         serial = port->serial;
1376         port_number = port->port_number;
1377
1378         if (!mos7720_port->open) {
1379                 dev_dbg(&port->dev, "%s - port not opened\n", __func__);
1380                 return;
1381         }
1382
1383         lStop = 0x00;   /* 1 stop bit */
1384         lParity = 0x00; /* No parity */
1385
1386         cflag = tty->termios.c_cflag;
1387
1388         lData = UART_LCR_WLEN(tty_get_char_size(cflag));
1389
1390         /* Change the Parity bit */
1391         if (cflag & PARENB) {
1392                 if (cflag & PARODD) {
1393                         lParity = UART_LCR_PARITY;
1394                         dev_dbg(&port->dev, "%s - parity = odd\n", __func__);
1395                 } else {
1396                         lParity = (UART_LCR_EPAR | UART_LCR_PARITY);
1397                         dev_dbg(&port->dev, "%s - parity = even\n", __func__);
1398                 }
1399
1400         } else {
1401                 dev_dbg(&port->dev, "%s - parity = none\n", __func__);
1402         }
1403
1404         if (cflag & CMSPAR)
1405                 lParity = lParity | 0x20;
1406
1407         /* Change the Stop bit */
1408         if (cflag & CSTOPB) {
1409                 lStop = UART_LCR_STOP;
1410                 dev_dbg(&port->dev, "%s - stop bits = 2\n", __func__);
1411         } else {
1412                 lStop = 0x00;
1413                 dev_dbg(&port->dev, "%s - stop bits = 1\n", __func__);
1414         }
1415
1416 #define LCR_BITS_MASK           0x03    /* Mask for bits/char field */
1417 #define LCR_STOP_MASK           0x04    /* Mask for stop bits field */
1418 #define LCR_PAR_MASK            0x38    /* Mask for parity field */
1419
1420         /* Update the LCR with the correct value */
1421         mos7720_port->shadowLCR &=
1422                 ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
1423         mos7720_port->shadowLCR |= (lData | lParity | lStop);
1424
1425
1426         /* Disable Interrupts */
1427         write_mos_reg(serial, port_number, MOS7720_IER, 0x00);
1428         write_mos_reg(serial, port_number, MOS7720_FCR, 0x00);
1429         write_mos_reg(serial, port_number, MOS7720_FCR, 0xcf);
1430
1431         /* Send the updated LCR value to the mos7720 */
1432         write_mos_reg(serial, port_number, MOS7720_LCR,
1433                       mos7720_port->shadowLCR);
1434         mos7720_port->shadowMCR = 0x0b;
1435         write_mos_reg(serial, port_number, MOS7720_MCR,
1436                       mos7720_port->shadowMCR);
1437
1438         /* set up the MCR register and send it to the mos7720 */
1439         mos7720_port->shadowMCR = UART_MCR_OUT2;
1440         if (cflag & CBAUD)
1441                 mos7720_port->shadowMCR |= (UART_MCR_DTR | UART_MCR_RTS);
1442
1443         if (cflag & CRTSCTS) {
1444                 mos7720_port->shadowMCR |= (UART_MCR_XONANY);
1445                 /* To set hardware flow control to the specified *
1446                  * serial port, in SP1/2_CONTROL_REG             */
1447                 if (port_number)
1448                         write_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG,
1449                                       0x01);
1450                 else
1451                         write_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG,
1452                                       0x02);
1453
1454         } else
1455                 mos7720_port->shadowMCR &= ~(UART_MCR_XONANY);
1456
1457         write_mos_reg(serial, port_number, MOS7720_MCR,
1458                       mos7720_port->shadowMCR);
1459
1460         /* Determine divisor based on baud rate */
1461         baud = tty_get_baud_rate(tty);
1462         if (!baud) {
1463                 /* pick a default, any default... */
1464                 dev_dbg(&port->dev, "Picked default baud...\n");
1465                 baud = 9600;
1466         }
1467
1468         if (baud >= 230400) {
1469                 set_higher_rates(mos7720_port, baud);
1470                 /* Enable Interrupts */
1471                 write_mos_reg(serial, port_number, MOS7720_IER, 0x0c);
1472                 return;
1473         }
1474
1475         dev_dbg(&port->dev, "%s - baud rate = %d\n", __func__, baud);
1476         status = send_cmd_write_baud_rate(mos7720_port, baud);
1477         /* FIXME: needs to write actual resulting baud back not just
1478            blindly do so */
1479         if (cflag & CBAUD)
1480                 tty_encode_baud_rate(tty, baud, baud);
1481         /* Enable Interrupts */
1482         write_mos_reg(serial, port_number, MOS7720_IER, 0x0c);
1483
1484         if (port->read_urb->status != -EINPROGRESS) {
1485                 status = usb_submit_urb(port->read_urb, GFP_KERNEL);
1486                 if (status)
1487                         dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n", status);
1488         }
1489 }
1490
1491 /*
1492  * mos7720_set_termios
1493  *      this function is called by the tty driver when it wants to change the
1494  *      termios structure.
1495  */
1496 static void mos7720_set_termios(struct tty_struct *tty,
1497                                 struct usb_serial_port *port,
1498                                 const struct ktermios *old_termios)
1499 {
1500         int status;
1501         struct moschip_port *mos7720_port;
1502
1503         mos7720_port = usb_get_serial_port_data(port);
1504
1505         if (mos7720_port == NULL)
1506                 return;
1507
1508         if (!mos7720_port->open) {
1509                 dev_dbg(&port->dev, "%s - port not opened\n", __func__);
1510                 return;
1511         }
1512
1513         /* change the port settings to the new ones specified */
1514         change_port_settings(tty, mos7720_port, old_termios);
1515
1516         if (port->read_urb->status != -EINPROGRESS) {
1517                 status = usb_submit_urb(port->read_urb, GFP_KERNEL);
1518                 if (status)
1519                         dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n", status);
1520         }
1521 }
1522
1523 /*
1524  * get_lsr_info - get line status register info
1525  *
1526  * Purpose: Let user call ioctl() to get info when the UART physically
1527  *          is emptied.  On bus types like RS485, the transmitter must
1528  *          release the bus after transmitting. This must be done when
1529  *          the transmit shift register is empty, not be done when the
1530  *          transmit holding register is empty.  This functionality
1531  *          allows an RS485 driver to be written in user space.
1532  */
1533 static int get_lsr_info(struct tty_struct *tty,
1534                 struct moschip_port *mos7720_port, unsigned int __user *value)
1535 {
1536         struct usb_serial_port *port = tty->driver_data;
1537         unsigned int result = 0;
1538         unsigned char data = 0;
1539         int port_number = port->port_number;
1540         int count;
1541
1542         count = mos7720_chars_in_buffer(tty);
1543         if (count == 0) {
1544                 read_mos_reg(port->serial, port_number, MOS7720_LSR, &data);
1545                 if ((data & (UART_LSR_TEMT | UART_LSR_THRE))
1546                                         == (UART_LSR_TEMT | UART_LSR_THRE)) {
1547                         dev_dbg(&port->dev, "%s -- Empty\n", __func__);
1548                         result = TIOCSER_TEMT;
1549                 }
1550         }
1551         if (copy_to_user(value, &result, sizeof(int)))
1552                 return -EFAULT;
1553         return 0;
1554 }
1555
1556 static int mos7720_tiocmget(struct tty_struct *tty)
1557 {
1558         struct usb_serial_port *port = tty->driver_data;
1559         struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
1560         unsigned int result = 0;
1561         unsigned int mcr ;
1562         unsigned int msr ;
1563
1564         mcr = mos7720_port->shadowMCR;
1565         msr = mos7720_port->shadowMSR;
1566
1567         result = ((mcr & UART_MCR_DTR)  ? TIOCM_DTR : 0)   /* 0x002 */
1568           | ((mcr & UART_MCR_RTS)   ? TIOCM_RTS : 0)   /* 0x004 */
1569           | ((msr & UART_MSR_CTS)   ? TIOCM_CTS : 0)   /* 0x020 */
1570           | ((msr & UART_MSR_DCD)   ? TIOCM_CAR : 0)   /* 0x040 */
1571           | ((msr & UART_MSR_RI)    ? TIOCM_RI :  0)   /* 0x080 */
1572           | ((msr & UART_MSR_DSR)   ? TIOCM_DSR : 0);  /* 0x100 */
1573
1574         return result;
1575 }
1576
1577 static int mos7720_tiocmset(struct tty_struct *tty,
1578                             unsigned int set, unsigned int clear)
1579 {
1580         struct usb_serial_port *port = tty->driver_data;
1581         struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
1582         unsigned int mcr ;
1583
1584         mcr = mos7720_port->shadowMCR;
1585
1586         if (set & TIOCM_RTS)
1587                 mcr |= UART_MCR_RTS;
1588         if (set & TIOCM_DTR)
1589                 mcr |= UART_MCR_DTR;
1590         if (set & TIOCM_LOOP)
1591                 mcr |= UART_MCR_LOOP;
1592
1593         if (clear & TIOCM_RTS)
1594                 mcr &= ~UART_MCR_RTS;
1595         if (clear & TIOCM_DTR)
1596                 mcr &= ~UART_MCR_DTR;
1597         if (clear & TIOCM_LOOP)
1598                 mcr &= ~UART_MCR_LOOP;
1599
1600         mos7720_port->shadowMCR = mcr;
1601         write_mos_reg(port->serial, port->port_number, MOS7720_MCR,
1602                       mos7720_port->shadowMCR);
1603
1604         return 0;
1605 }
1606
1607 static int mos7720_ioctl(struct tty_struct *tty,
1608                          unsigned int cmd, unsigned long arg)
1609 {
1610         struct usb_serial_port *port = tty->driver_data;
1611         struct moschip_port *mos7720_port;
1612
1613         mos7720_port = usb_get_serial_port_data(port);
1614         if (mos7720_port == NULL)
1615                 return -ENODEV;
1616
1617         switch (cmd) {
1618         case TIOCSERGETLSR:
1619                 dev_dbg(&port->dev, "%s TIOCSERGETLSR\n", __func__);
1620                 return get_lsr_info(tty, mos7720_port,
1621                                         (unsigned int __user *)arg);
1622         }
1623
1624         return -ENOIOCTLCMD;
1625 }
1626
1627 static int mos7720_startup(struct usb_serial *serial)
1628 {
1629         struct usb_device *dev;
1630         char data;
1631         u16 product;
1632         int ret_val;
1633
1634         product = le16_to_cpu(serial->dev->descriptor.idProduct);
1635         dev = serial->dev;
1636
1637         if (product == MOSCHIP_DEVICE_ID_7715) {
1638                 struct urb *urb = serial->port[0]->interrupt_in_urb;
1639
1640                 urb->complete = mos7715_interrupt_callback;
1641
1642 #ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
1643                 ret_val = mos7715_parport_init(serial);
1644                 if (ret_val < 0)
1645                         return ret_val;
1646 #endif
1647         }
1648         /* start the interrupt urb */
1649         ret_val = usb_submit_urb(serial->port[0]->interrupt_in_urb, GFP_KERNEL);
1650         if (ret_val) {
1651                 dev_err(&dev->dev, "failed to submit interrupt urb: %d\n",
1652                         ret_val);
1653         }
1654
1655         /* LSR For Port 1 */
1656         read_mos_reg(serial, 0, MOS7720_LSR, &data);
1657         dev_dbg(&dev->dev, "LSR:%x\n", data);
1658
1659         return 0;
1660 }
1661
1662 static void mos7720_release(struct usb_serial *serial)
1663 {
1664         usb_kill_urb(serial->port[0]->interrupt_in_urb);
1665
1666 #ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
1667         /* close the parallel port */
1668
1669         if (le16_to_cpu(serial->dev->descriptor.idProduct)
1670             == MOSCHIP_DEVICE_ID_7715) {
1671                 struct mos7715_parport *mos_parport =
1672                         usb_get_serial_data(serial);
1673
1674                 /* prevent NULL ptr dereference in port callbacks */
1675                 spin_lock(&release_lock);
1676                 mos_parport->pp->private_data = NULL;
1677                 spin_unlock(&release_lock);
1678
1679                 /* wait for synchronous usb calls to return */
1680                 if (mos_parport->msg_pending)
1681                         wait_for_completion_timeout(&mos_parport->syncmsg_compl,
1682                                             msecs_to_jiffies(MOS_WDR_TIMEOUT));
1683                 /*
1684                  * If delayed work is currently scheduled, wait for it to
1685                  * complete. This also implies barriers that ensure the
1686                  * below serial clearing is not hoisted above the ->work.
1687                  */
1688                 cancel_work_sync(&mos_parport->work);
1689
1690                 parport_remove_port(mos_parport->pp);
1691                 usb_set_serial_data(serial, NULL);
1692                 mos_parport->serial = NULL;
1693
1694                 parport_del_port(mos_parport->pp);
1695
1696                 kref_put(&mos_parport->ref_count, destroy_mos_parport);
1697         }
1698 #endif
1699 }
1700
1701 static int mos7720_port_probe(struct usb_serial_port *port)
1702 {
1703         struct moschip_port *mos7720_port;
1704
1705         mos7720_port = kzalloc(sizeof(*mos7720_port), GFP_KERNEL);
1706         if (!mos7720_port)
1707                 return -ENOMEM;
1708
1709         mos7720_port->port = port;
1710
1711         usb_set_serial_port_data(port, mos7720_port);
1712
1713         return 0;
1714 }
1715
1716 static void mos7720_port_remove(struct usb_serial_port *port)
1717 {
1718         struct moschip_port *mos7720_port;
1719
1720         mos7720_port = usb_get_serial_port_data(port);
1721         kfree(mos7720_port);
1722 }
1723
1724 static struct usb_serial_driver moschip7720_2port_driver = {
1725         .driver = {
1726                 .owner =        THIS_MODULE,
1727                 .name =         "moschip7720",
1728         },
1729         .description            = "Moschip 2 port adapter",
1730         .id_table               = id_table,
1731         .num_bulk_in            = 2,
1732         .num_bulk_out           = 2,
1733         .num_interrupt_in       = 1,
1734         .calc_num_ports         = mos77xx_calc_num_ports,
1735         .open                   = mos7720_open,
1736         .close                  = mos7720_close,
1737         .throttle               = mos7720_throttle,
1738         .unthrottle             = mos7720_unthrottle,
1739         .attach                 = mos7720_startup,
1740         .release                = mos7720_release,
1741         .port_probe             = mos7720_port_probe,
1742         .port_remove            = mos7720_port_remove,
1743         .ioctl                  = mos7720_ioctl,
1744         .tiocmget               = mos7720_tiocmget,
1745         .tiocmset               = mos7720_tiocmset,
1746         .set_termios            = mos7720_set_termios,
1747         .write                  = mos7720_write,
1748         .write_room             = mos7720_write_room,
1749         .chars_in_buffer        = mos7720_chars_in_buffer,
1750         .break_ctl              = mos7720_break,
1751         .read_bulk_callback     = mos7720_bulk_in_callback,
1752         .read_int_callback      = mos7720_interrupt_callback,
1753 };
1754
1755 static struct usb_serial_driver * const serial_drivers[] = {
1756         &moschip7720_2port_driver, NULL
1757 };
1758
1759 module_usb_serial_driver(serial_drivers, id_table);
1760
1761 MODULE_AUTHOR(DRIVER_AUTHOR);
1762 MODULE_DESCRIPTION(DRIVER_DESC);
1763 MODULE_LICENSE("GPL v2");