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