mos7720.c 56.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
/*
 * mos7720.c
 *   Controls the Moschip 7720 usb to dual port serial convertor
 *
 * Copyright 2006 Moschip Semiconductor Tech. Ltd.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 2 of the License.
 *
 * Developed by:
12 13 14
 * 	Vijaya Kumar <vijaykumar.gn@gmail.com>
 *	Ajay Kumar <naanuajay@yahoo.com>
 *	Gurudeva <ngurudeva@yahoo.com>
15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
 *
 * Cleaned up from the original by:
 *	Greg Kroah-Hartman <gregkh@suse.de>
 *
 * Originally based on drivers/usb/serial/io_edgeport.c which is:
 *	Copyright (C) 2000 Inside Out Networks, All rights reserved.
 *	Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>
 */
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/serial.h>
#include <linux/serial_reg.h>
#include <linux/usb.h>
#include <linux/usb/serial.h>
A
Alan Cox 已提交
36
#include <linux/uaccess.h>
37
#include <linux/parport.h>
38 39 40 41 42

#define DRIVER_AUTHOR "Aspire Communications pvt Ltd."
#define DRIVER_DESC "Moschip USB Serial Driver"

/* default urb timeout */
43
#define MOS_WDR_TIMEOUT	5000
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

#define MOS_MAX_PORT	0x02
#define MOS_WRITE	0x0E
#define MOS_READ	0x0D

/* Interrupt Rotinue Defines	*/
#define SERIAL_IIR_RLS	0x06
#define SERIAL_IIR_RDA	0x04
#define SERIAL_IIR_CTI	0x0c
#define SERIAL_IIR_THR	0x02
#define SERIAL_IIR_MS	0x00

#define NUM_URBS			16	/* URB Count */
#define URB_TRANSFER_BUFFER_SIZE	32	/* URB Size */

59
/* This structure holds all of the local serial port information */
A
Alan Cox 已提交
60
struct moschip_port {
61 62 63 64 65 66 67 68
	__u8	shadowLCR;		/* last LCR value received */
	__u8	shadowMCR;		/* last MCR value received */
	__u8	shadowMSR;		/* last MSR value received */
	char			open;
	struct usb_serial_port	*port;	/* loop back to the owner */
	struct urb		*write_urb_pool[NUM_URBS];
};

69 70
static struct usb_serial_driver moschip7720_2port_driver;

71 72 73 74
#define USB_VENDOR_ID_MOSCHIP		0x9710
#define MOSCHIP_DEVICE_ID_7720		0x7720
#define MOSCHIP_DEVICE_ID_7715		0x7715

75
static const struct usb_device_id id_table[] = {
A
Alan Cox 已提交
76
	{ USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7720) },
77
	{ USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7715) },
78 79
	{ } /* terminating entry */
};
80
MODULE_DEVICE_TABLE(usb, id_table);
81

82 83 84 85 86 87 88 89 90 91 92
#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT

/* initial values for parport regs */
#define DCR_INIT_VAL       0x0c	/* SLCTIN, nINIT */
#define ECR_INIT_VAL       0x00	/* SPP mode */

struct urbtracker {
	struct mos7715_parport  *mos_parport;
	struct list_head        urblist_entry;
	struct kref             ref_count;
	struct urb              *urb;
93
	struct usb_ctrlrequest	*setup;
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
};

enum mos7715_pp_modes {
	SPP = 0<<5,
	PS2 = 1<<5,      /* moschip calls this 'NIBBLE' mode */
	PPF = 2<<5,	 /* moschip calls this 'CB-FIFO mode */
};

struct mos7715_parport {
	struct parport          *pp;	       /* back to containing struct */
	struct kref             ref_count;     /* to instance of this struct */
	struct list_head        deferred_urbs; /* list deferred async urbs */
	struct list_head        active_urbs;   /* list async urbs in flight */
	spinlock_t              listlock;      /* protects list access */
	bool                    msg_pending;   /* usb sync call pending */
	struct completion       syncmsg_compl; /* usb sync call completed */
	struct tasklet_struct   urb_tasklet;   /* for sending deferred urbs */
	struct usb_serial       *serial;       /* back to containing struct */
	__u8	                shadowECR;     /* parallel port regs... */
	__u8	                shadowDCR;
	atomic_t                shadowDSR;     /* updated in int-in callback */
};

/* lock guards against dereferencing NULL ptr in parport ops callbacks */
static DEFINE_SPINLOCK(release_lock);

120 121 122 123
#endif	/* CONFIG_USB_SERIAL_MOS7715_PARPORT */

static const unsigned int dummy; /* for clarity in register access fns */

124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
enum mos_regs {
	THR,	          /* serial port regs */
	RHR,
	IER,
	FCR,
	ISR,
	LCR,
	MCR,
	LSR,
	MSR,
	SPR,
	DLL,
	DLM,
	DPR,              /* parallel port regs */
	DSR,
	DCR,
	ECR,
	SP1_REG,          /* device control regs */
	SP2_REG,          /* serial port 2 (7720 only) */
	PP_REG,
	SP_CONTROL_REG,
};

/*
 * Return the correct value for the Windex field of the setup packet
 * for a control endpoint message.  See the 7715 datasheet.
 */
static inline __u16 get_reg_index(enum mos_regs reg)
{
	static const __u16 mos7715_index_lookup_table[] = {
		0x00,		/* THR */
		0x00,		/* RHR */
		0x01,		/* IER */
		0x02,		/* FCR */
		0x02,		/* ISR */
		0x03,		/* LCR */
		0x04,		/* MCR */
		0x05,		/* LSR */
		0x06,		/* MSR */
		0x07,		/* SPR */
		0x00,		/* DLL */
		0x01,		/* DLM */
		0x00,		/* DPR */
		0x01,		/* DSR */
		0x02,		/* DCR */
		0x0a,		/* ECR */
		0x01,		/* SP1_REG */
		0x02,		/* SP2_REG (7720 only) */
		0x04,		/* PP_REG (7715 only) */
		0x08,		/* SP_CONTROL_REG */
	};
	return mos7715_index_lookup_table[reg];
}

/*
 * Return the correct value for the upper byte of the Wvalue field of
 * the setup packet for a control endpoint message.
 */
182 183
static inline __u16 get_reg_value(enum mos_regs reg,
				  unsigned int serial_portnum)
184 185 186
{
	if (reg >= SP1_REG)	      /* control reg */
		return 0x0000;
187 188

	else if (reg >= DPR)	      /* parallel port reg (7715 only) */
189
		return 0x0100;
190 191 192

	else			      /* serial port reg */
		return (serial_portnum + 2) << 8;
193 194 195 196
}

/*
 * Write data byte to the specified device register.  The data is embedded in
197 198
 * the value field of the setup packet. serial_portnum is ignored for registers
 * not specific to a particular serial port.
199
 */
200 201
static int write_mos_reg(struct usb_serial *serial, unsigned int serial_portnum,
			 enum mos_regs reg, __u8 data)
202 203 204 205 206 207
{
	struct usb_device *usbdev = serial->dev;
	unsigned int pipe = usb_sndctrlpipe(usbdev, 0);
	__u8 request = (__u8)0x0e;
	__u8 requesttype = (__u8)0x40;
	__u16 index = get_reg_index(reg);
208 209 210
	__u16 value = get_reg_value(reg, serial_portnum) + data;
	int status = usb_control_msg(usbdev, pipe, request, requesttype, value,
				     index, NULL, 0, MOS_WDR_TIMEOUT);
211 212 213 214 215 216 217 218
	if (status < 0)
		dev_err(&usbdev->dev,
			"mos7720: usb_control_msg() failed: %d", status);
	return status;
}

/*
 * Read data byte from the specified device register.  The data returned by the
219 220
 * device is embedded in the value field of the setup packet.  serial_portnum is
 * ignored for registers that are not specific to a particular serial port.
221
 */
222 223
static int read_mos_reg(struct usb_serial *serial, unsigned int serial_portnum,
			enum mos_regs reg, __u8 *data)
224
{
225
	struct usb_device *usbdev = serial->dev;
226 227 228 229
	unsigned int pipe = usb_rcvctrlpipe(usbdev, 0);
	__u8 request = (__u8)0x0d;
	__u8 requesttype = (__u8)0xc0;
	__u16 index = get_reg_index(reg);
230
	__u16 value = get_reg_value(reg, serial_portnum);
J
Johan Hovold 已提交
231 232 233 234 235 236 237 238 239 240 241 242
	u8 *buf;
	int status;

	buf = kmalloc(1, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	status = usb_control_msg(usbdev, pipe, request, requesttype, value,
				     index, buf, 1, MOS_WDR_TIMEOUT);
	if (status == 1)
		*data = *buf;
	else if (status < 0)
243 244
		dev_err(&usbdev->dev,
			"mos7720: usb_control_msg() failed: %d", status);
J
Johan Hovold 已提交
245 246
	kfree(buf);

247 248 249
	return status;
}

250 251
#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT

252 253 254 255
static inline int mos7715_change_mode(struct mos7715_parport *mos_parport,
				      enum mos7715_pp_modes mode)
{
	mos_parport->shadowECR = mode;
256
	write_mos_reg(mos_parport->serial, dummy, ECR, mos_parport->shadowECR);
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
	return 0;
}

static void destroy_mos_parport(struct kref *kref)
{
	struct mos7715_parport *mos_parport =
		container_of(kref, struct mos7715_parport, ref_count);

	kfree(mos_parport);
}

static void destroy_urbtracker(struct kref *kref)
{
	struct urbtracker *urbtrack =
		container_of(kref, struct urbtracker, ref_count);
	struct mos7715_parport *mos_parport = urbtrack->mos_parport;
273

274
	usb_free_urb(urbtrack->urb);
275
	kfree(urbtrack->setup);
276 277 278 279 280 281 282 283 284 285 286 287 288 289
	kfree(urbtrack);
	kref_put(&mos_parport->ref_count, destroy_mos_parport);
}

/*
 * This runs as a tasklet when sending an urb in a non-blocking parallel
 * port callback had to be deferred because the disconnect mutex could not be
 * obtained at the time.
 */
static void send_deferred_urbs(unsigned long _mos_parport)
{
	int ret_val;
	unsigned long flags;
	struct mos7715_parport *mos_parport = (void *)_mos_parport;
290
	struct urbtracker *urbtrack, *tmp;
291
	struct list_head *cursor, *next;
292
	struct device *dev;
293 294 295 296 297

	/* if release function ran, game over */
	if (unlikely(mos_parport->serial == NULL))
		return;

298 299
	dev = &mos_parport->serial->dev->dev;

300 301
	/* try again to get the mutex */
	if (!mutex_trylock(&mos_parport->serial->disc_mutex)) {
302
		dev_dbg(dev, "%s: rescheduling tasklet\n", __func__);
303 304 305 306 307 308 309 310 311 312 313 314 315 316
		tasklet_schedule(&mos_parport->urb_tasklet);
		return;
	}

	/* if device disconnected, game over */
	if (unlikely(mos_parport->serial->disconnected)) {
		mutex_unlock(&mos_parport->serial->disc_mutex);
		return;
	}

	spin_lock_irqsave(&mos_parport->listlock, flags);
	if (list_empty(&mos_parport->deferred_urbs)) {
		spin_unlock_irqrestore(&mos_parport->listlock, flags);
		mutex_unlock(&mos_parport->serial->disc_mutex);
317
		dev_dbg(dev, "%s: deferred_urbs list empty\n", __func__);
318 319 320 321 322 323
		return;
	}

	/* move contents of deferred_urbs list to active_urbs list and submit */
	list_for_each_safe(cursor, next, &mos_parport->deferred_urbs)
		list_move_tail(cursor, &mos_parport->active_urbs);
324
	list_for_each_entry_safe(urbtrack, tmp, &mos_parport->active_urbs,
325 326
			    urblist_entry) {
		ret_val = usb_submit_urb(urbtrack->urb, GFP_ATOMIC);
327
		dev_dbg(dev, "%s: urb submitted\n", __func__);
328
		if (ret_val) {
329
			dev_err(dev, "usb_submit_urb() failed: %d\n", ret_val);
330 331 332 333 334 335 336 337 338 339 340 341 342
			list_del(&urbtrack->urblist_entry);
			kref_put(&urbtrack->ref_count, destroy_urbtracker);
		}
	}
	spin_unlock_irqrestore(&mos_parport->listlock, flags);
	mutex_unlock(&mos_parport->serial->disc_mutex);
}

/* callback for parallel port control urbs submitted asynchronously */
static void async_complete(struct urb *urb)
{
	struct urbtracker *urbtrack = urb->context;
	int status = urb->status;
343

344
	if (unlikely(status))
345
		dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status);
346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364

	/* remove the urbtracker from the active_urbs list */
	spin_lock(&urbtrack->mos_parport->listlock);
	list_del(&urbtrack->urblist_entry);
	spin_unlock(&urbtrack->mos_parport->listlock);
	kref_put(&urbtrack->ref_count, destroy_urbtracker);
}

static int write_parport_reg_nonblock(struct mos7715_parport *mos_parport,
				      enum mos_regs reg, __u8 data)
{
	struct urbtracker *urbtrack;
	int ret_val;
	unsigned long flags;
	struct usb_serial *serial = mos_parport->serial;
	struct usb_device *usbdev = serial->dev;

	/* create and initialize the control urb and containing urbtracker */
	urbtrack = kmalloc(sizeof(struct urbtracker), GFP_ATOMIC);
365
	if (!urbtrack)
366
		return -ENOMEM;
367

368 369 370
	kref_get(&mos_parport->ref_count);
	urbtrack->mos_parport = mos_parport;
	urbtrack->urb = usb_alloc_urb(0, GFP_ATOMIC);
371
	if (!urbtrack->urb) {
372 373 374
		kfree(urbtrack);
		return -ENOMEM;
	}
375
	urbtrack->setup = kmalloc(sizeof(*urbtrack->setup), GFP_ATOMIC);
376 377 378 379 380 381 382
	if (!urbtrack->setup) {
		usb_free_urb(urbtrack->urb);
		kfree(urbtrack);
		return -ENOMEM;
	}
	urbtrack->setup->bRequestType = (__u8)0x40;
	urbtrack->setup->bRequest = (__u8)0x0e;
383 384
	urbtrack->setup->wValue = cpu_to_le16(get_reg_value(reg, dummy));
	urbtrack->setup->wIndex = cpu_to_le16(get_reg_index(reg));
385
	urbtrack->setup->wLength = 0;
386 387
	usb_fill_control_urb(urbtrack->urb, usbdev,
			     usb_sndctrlpipe(usbdev, 0),
388
			     (unsigned char *)urbtrack->setup,
389 390 391 392 393 394 395 396 397 398 399 400 401 402
			     NULL, 0, async_complete, urbtrack);
	kref_init(&urbtrack->ref_count);
	INIT_LIST_HEAD(&urbtrack->urblist_entry);

	/*
	 * get the disconnect mutex, or add tracker to the deferred_urbs list
	 * and schedule a tasklet to try again later
	 */
	if (!mutex_trylock(&serial->disc_mutex)) {
		spin_lock_irqsave(&mos_parport->listlock, flags);
		list_add_tail(&urbtrack->urblist_entry,
			      &mos_parport->deferred_urbs);
		spin_unlock_irqrestore(&mos_parport->listlock, flags);
		tasklet_schedule(&mos_parport->urb_tasklet);
403
		dev_dbg(&usbdev->dev, "tasklet scheduled");
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455
		return 0;
	}

	/* bail if device disconnected */
	if (serial->disconnected) {
		kref_put(&urbtrack->ref_count, destroy_urbtracker);
		mutex_unlock(&serial->disc_mutex);
		return -ENODEV;
	}

	/* add the tracker to the active_urbs list and submit */
	spin_lock_irqsave(&mos_parport->listlock, flags);
	list_add_tail(&urbtrack->urblist_entry, &mos_parport->active_urbs);
	spin_unlock_irqrestore(&mos_parport->listlock, flags);
	ret_val = usb_submit_urb(urbtrack->urb, GFP_ATOMIC);
	mutex_unlock(&serial->disc_mutex);
	if (ret_val) {
		dev_err(&usbdev->dev,
			"%s: submit_urb() failed: %d", __func__, ret_val);
		spin_lock_irqsave(&mos_parport->listlock, flags);
		list_del(&urbtrack->urblist_entry);
		spin_unlock_irqrestore(&mos_parport->listlock, flags);
		kref_put(&urbtrack->ref_count, destroy_urbtracker);
		return ret_val;
	}
	return 0;
}

/*
 * This is the the common top part of all parallel port callback operations that
 * send synchronous messages to the device.  This implements convoluted locking
 * that avoids two scenarios: (1) a port operation is called after usbserial
 * has called our release function, at which point struct mos7715_parport has
 * been destroyed, and (2) the device has been disconnected, but usbserial has
 * not called the release function yet because someone has a serial port open.
 * The shared release_lock prevents the first, and the mutex and disconnected
 * flag maintained by usbserial covers the second.  We also use the msg_pending
 * flag to ensure that all synchronous usb messgage calls have completed before
 * our release function can return.
 */
static int parport_prologue(struct parport *pp)
{
	struct mos7715_parport *mos_parport;

	spin_lock(&release_lock);
	mos_parport = pp->private_data;
	if (unlikely(mos_parport == NULL)) {
		/* release fn called, port struct destroyed */
		spin_unlock(&release_lock);
		return -1;
	}
	mos_parport->msg_pending = true;   /* synch usb call pending */
456
	reinit_completion(&mos_parport->syncmsg_compl);
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485
	spin_unlock(&release_lock);

	mutex_lock(&mos_parport->serial->disc_mutex);
	if (mos_parport->serial->disconnected) {
		/* device disconnected */
		mutex_unlock(&mos_parport->serial->disc_mutex);
		mos_parport->msg_pending = false;
		complete(&mos_parport->syncmsg_compl);
		return -1;
	}

	return 0;
}

/*
 * This is the the common bottom part of all parallel port functions that send
 * synchronous messages to the device.
 */
static inline void parport_epilogue(struct parport *pp)
{
	struct mos7715_parport *mos_parport = pp->private_data;
	mutex_unlock(&mos_parport->serial->disc_mutex);
	mos_parport->msg_pending = false;
	complete(&mos_parport->syncmsg_compl);
}

static void parport_mos7715_write_data(struct parport *pp, unsigned char d)
{
	struct mos7715_parport *mos_parport = pp->private_data;
486

487 488 489
	if (parport_prologue(pp) < 0)
		return;
	mos7715_change_mode(mos_parport, SPP);
490
	write_mos_reg(mos_parport->serial, dummy, DPR, (__u8)d);
491 492 493 494 495 496 497
	parport_epilogue(pp);
}

static unsigned char parport_mos7715_read_data(struct parport *pp)
{
	struct mos7715_parport *mos_parport = pp->private_data;
	unsigned char d;
498

499 500
	if (parport_prologue(pp) < 0)
		return 0;
501
	read_mos_reg(mos_parport->serial, dummy, DPR, &d);
502 503 504 505 506 507 508 509
	parport_epilogue(pp);
	return d;
}

static void parport_mos7715_write_control(struct parport *pp, unsigned char d)
{
	struct mos7715_parport *mos_parport = pp->private_data;
	__u8 data;
510

511 512 513
	if (parport_prologue(pp) < 0)
		return;
	data = ((__u8)d & 0x0f) | (mos_parport->shadowDCR & 0xf0);
514
	write_mos_reg(mos_parport->serial, dummy, DCR, data);
515 516 517 518 519 520 521 522
	mos_parport->shadowDCR = data;
	parport_epilogue(pp);
}

static unsigned char parport_mos7715_read_control(struct parport *pp)
{
	struct mos7715_parport *mos_parport = pp->private_data;
	__u8 dcr;
523

524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
	spin_lock(&release_lock);
	mos_parport = pp->private_data;
	if (unlikely(mos_parport == NULL)) {
		spin_unlock(&release_lock);
		return 0;
	}
	dcr = mos_parport->shadowDCR & 0x0f;
	spin_unlock(&release_lock);
	return dcr;
}

static unsigned char parport_mos7715_frob_control(struct parport *pp,
						  unsigned char mask,
						  unsigned char val)
{
	struct mos7715_parport *mos_parport = pp->private_data;
	__u8 dcr;
541

542 543 544 545 546
	mask &= 0x0f;
	val &= 0x0f;
	if (parport_prologue(pp) < 0)
		return 0;
	mos_parport->shadowDCR = (mos_parport->shadowDCR & (~mask)) ^ val;
547
	write_mos_reg(mos_parport->serial, dummy, DCR, mos_parport->shadowDCR);
548 549 550 551 552 553 554 555 556
	dcr = mos_parport->shadowDCR & 0x0f;
	parport_epilogue(pp);
	return dcr;
}

static unsigned char parport_mos7715_read_status(struct parport *pp)
{
	unsigned char status;
	struct mos7715_parport *mos_parport = pp->private_data;
557

558 559 560 561 562 563 564 565 566 567 568 569 570 571
	spin_lock(&release_lock);
	mos_parport = pp->private_data;
	if (unlikely(mos_parport == NULL)) {	/* release called */
		spin_unlock(&release_lock);
		return 0;
	}
	status = atomic_read(&mos_parport->shadowDSR) & 0xf8;
	spin_unlock(&release_lock);
	return status;
}

static void parport_mos7715_enable_irq(struct parport *pp)
{
}
572

573 574 575 576 577 578 579
static void parport_mos7715_disable_irq(struct parport *pp)
{
}

static void parport_mos7715_data_forward(struct parport *pp)
{
	struct mos7715_parport *mos_parport = pp->private_data;
580

581 582 583 584
	if (parport_prologue(pp) < 0)
		return;
	mos7715_change_mode(mos_parport, PS2);
	mos_parport->shadowDCR &=  ~0x20;
585
	write_mos_reg(mos_parport->serial, dummy, DCR, mos_parport->shadowDCR);
586 587 588 589 590 591
	parport_epilogue(pp);
}

static void parport_mos7715_data_reverse(struct parport *pp)
{
	struct mos7715_parport *mos_parport = pp->private_data;
592

593 594 595 596
	if (parport_prologue(pp) < 0)
		return;
	mos7715_change_mode(mos_parport, PS2);
	mos_parport->shadowDCR |= 0x20;
597
	write_mos_reg(mos_parport->serial, dummy, DCR, mos_parport->shadowDCR);
598 599 600 601 602 603 604 605 606 607 608 609 610 611 612
	parport_epilogue(pp);
}

static void parport_mos7715_init_state(struct pardevice *dev,
				       struct parport_state *s)
{
	s->u.pc.ctr = DCR_INIT_VAL;
	s->u.pc.ecr = ECR_INIT_VAL;
}

/* N.B. Parport core code requires that this function not block */
static void parport_mos7715_save_state(struct parport *pp,
				       struct parport_state *s)
{
	struct mos7715_parport *mos_parport;
613

614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629
	spin_lock(&release_lock);
	mos_parport = pp->private_data;
	if (unlikely(mos_parport == NULL)) {	/* release called */
		spin_unlock(&release_lock);
		return;
	}
	s->u.pc.ctr = mos_parport->shadowDCR;
	s->u.pc.ecr = mos_parport->shadowECR;
	spin_unlock(&release_lock);
}

/* N.B. Parport core code requires that this function not block */
static void parport_mos7715_restore_state(struct parport *pp,
					  struct parport_state *s)
{
	struct mos7715_parport *mos_parport;
630

631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648
	spin_lock(&release_lock);
	mos_parport = pp->private_data;
	if (unlikely(mos_parport == NULL)) {	/* release called */
		spin_unlock(&release_lock);
		return;
	}
	write_parport_reg_nonblock(mos_parport, DCR, mos_parport->shadowDCR);
	write_parport_reg_nonblock(mos_parport, ECR, mos_parport->shadowECR);
	spin_unlock(&release_lock);
}

static size_t parport_mos7715_write_compat(struct parport *pp,
					   const void *buffer,
					   size_t len, int flags)
{
	int retval;
	struct mos7715_parport *mos_parport = pp->private_data;
	int actual_len;
649

650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
	if (parport_prologue(pp) < 0)
		return 0;
	mos7715_change_mode(mos_parport, PPF);
	retval = usb_bulk_msg(mos_parport->serial->dev,
			      usb_sndbulkpipe(mos_parport->serial->dev, 2),
			      (void *)buffer, len, &actual_len,
			      MOS_WDR_TIMEOUT);
	parport_epilogue(pp);
	if (retval) {
		dev_err(&mos_parport->serial->dev->dev,
			"mos7720: usb_bulk_msg() failed: %d", retval);
		return 0;
	}
	return actual_len;
}

static struct parport_operations parport_mos7715_ops = {
	.owner =		THIS_MODULE,
	.write_data =		parport_mos7715_write_data,
	.read_data =		parport_mos7715_read_data,

	.write_control =	parport_mos7715_write_control,
	.read_control =		parport_mos7715_read_control,
	.frob_control =		parport_mos7715_frob_control,

	.read_status =		parport_mos7715_read_status,

	.enable_irq =		parport_mos7715_enable_irq,
	.disable_irq =		parport_mos7715_disable_irq,

	.data_forward =		parport_mos7715_data_forward,
	.data_reverse =		parport_mos7715_data_reverse,

	.init_state =		parport_mos7715_init_state,
	.save_state =		parport_mos7715_save_state,
	.restore_state =	parport_mos7715_restore_state,

	.compat_write_data =	parport_mos7715_write_compat,

	.nibble_read_data =	parport_ieee1284_read_nibble,
	.byte_read_data =	parport_ieee1284_read_byte,
};

/*
 * Allocate and initialize parallel port control struct, initialize
 * the parallel port hardware device, and register with the parport subsystem.
 */
static int mos7715_parport_init(struct usb_serial *serial)
{
	struct mos7715_parport *mos_parport;

	/* allocate and initialize parallel port control struct */
	mos_parport = kzalloc(sizeof(struct mos7715_parport), GFP_KERNEL);
703
	if (!mos_parport)
704
		return -ENOMEM;
705

706 707 708 709 710 711 712 713 714 715 716 717
	mos_parport->msg_pending = false;
	kref_init(&mos_parport->ref_count);
	spin_lock_init(&mos_parport->listlock);
	INIT_LIST_HEAD(&mos_parport->active_urbs);
	INIT_LIST_HEAD(&mos_parport->deferred_urbs);
	usb_set_serial_data(serial, mos_parport); /* hijack private pointer */
	mos_parport->serial = serial;
	tasklet_init(&mos_parport->urb_tasklet, send_deferred_urbs,
		     (unsigned long) mos_parport);
	init_completion(&mos_parport->syncmsg_compl);

	/* cycle parallel port reset bit */
718 719
	write_mos_reg(mos_parport->serial, dummy, PP_REG, (__u8)0x80);
	write_mos_reg(mos_parport->serial, dummy, PP_REG, (__u8)0x00);
720 721 722

	/* initialize device registers */
	mos_parport->shadowDCR = DCR_INIT_VAL;
723
	write_mos_reg(mos_parport->serial, dummy, DCR, mos_parport->shadowDCR);
724
	mos_parport->shadowECR = ECR_INIT_VAL;
725
	write_mos_reg(mos_parport->serial, dummy, ECR, mos_parport->shadowECR);
726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744

	/* register with parport core */
	mos_parport->pp = parport_register_port(0, PARPORT_IRQ_NONE,
						PARPORT_DMA_NONE,
						&parport_mos7715_ops);
	if (mos_parport->pp == NULL) {
		dev_err(&serial->interface->dev,
			"Could not register parport\n");
		kref_put(&mos_parport->ref_count, destroy_mos_parport);
		return -EIO;
	}
	mos_parport->pp->private_data = mos_parport;
	mos_parport->pp->modes = PARPORT_MODE_COMPAT | PARPORT_MODE_PCSPP;
	mos_parport->pp->dev = &serial->interface->dev;
	parport_announce_port(mos_parport->pp);

	return 0;
}
#endif	/* CONFIG_USB_SERIAL_MOS7715_PARPORT */
745 746 747 748 749 750 751 752 753 754

/*
 * mos7720_interrupt_callback
 *	this is the callback function for when we have received data on the
 *	interrupt endpoint.
 */
static void mos7720_interrupt_callback(struct urb *urb)
{
	int result;
	int length;
755
	int status = urb->status;
756
	struct device *dev = &urb->dev->dev;
O
Oliver Neukum 已提交
757
	__u8 *data;
758 759 760
	__u8 sp1;
	__u8 sp2;

761
	switch (status) {
762 763 764 765 766 767 768
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
769
		dev_dbg(dev, "%s - urb shutting down with status: %d\n", __func__, status);
770 771
		return;
	default:
772
		dev_dbg(dev, "%s - nonzero urb status received: %d\n", __func__, status);
773 774 775 776 777 778 779 780 781 782 783
		goto exit;
	}

	length = urb->actual_length;
	data = urb->transfer_buffer;

	/* Moschip get 4 bytes
	 * Byte 1 IIR Port 1 (port.number is 0)
	 * Byte 2 IIR Port 2 (port.number is 1)
	 * Byte 3 --------------
	 * Byte 4 FIFO status for both */
O
Oliver Neukum 已提交
784 785 786 787 788

	/* the above description is inverted
	 * 	oneukum 2007-03-14 */

	if (unlikely(length != 4)) {
789
		dev_dbg(dev, "Wrong data !!!\n");
790 791 792
		return;
	}

O
Oliver Neukum 已提交
793 794
	sp1 = data[3];
	sp2 = data[2];
795

O
Oliver Neukum 已提交
796
	if ((sp1 | sp2) & 0x01) {
797
		/* No Interrupt Pending in both the ports */
798
		dev_dbg(dev, "No Interrupt !!!\n");
799 800 801
	} else {
		switch (sp1 & 0x0f) {
		case SERIAL_IIR_RLS:
802
			dev_dbg(dev, "Serial Port 1: Receiver status error or address bit detected in 9-bit mode\n");
803 804
			break;
		case SERIAL_IIR_CTI:
805
			dev_dbg(dev, "Serial Port 1: Receiver time out\n");
806 807
			break;
		case SERIAL_IIR_MS:
808
			/* dev_dbg(dev, "Serial Port 1: Modem status change\n"); */
809 810 811 812 813
			break;
		}

		switch (sp2 & 0x0f) {
		case SERIAL_IIR_RLS:
814
			dev_dbg(dev, "Serial Port 2: Receiver status error or address bit detected in 9-bit mode\n");
815 816
			break;
		case SERIAL_IIR_CTI:
817
			dev_dbg(dev, "Serial Port 2: Receiver time out\n");
818 819
			break;
		case SERIAL_IIR_MS:
820
			/* dev_dbg(dev, "Serial Port 2: Modem status change\n"); */
821 822 823 824 825 826 827
			break;
		}
	}

exit:
	result = usb_submit_urb(urb, GFP_ATOMIC);
	if (result)
828
		dev_err(dev, "%s - Error %d submitting control urb\n", __func__, result);
829 830
}

831 832 833 834 835 836 837 838 839 840
/*
 * mos7715_interrupt_callback
 *	this is the 7715's callback function for when we have received data on
 *	the interrupt endpoint.
 */
static void mos7715_interrupt_callback(struct urb *urb)
{
	int result;
	int length;
	int status = urb->status;
841
	struct device *dev = &urb->dev->dev;
842 843 844 845 846 847 848 849 850 851
	__u8 *data;
	__u8 iir;

	switch (status) {
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
852
	case -ENODEV:
853
		/* this urb is terminated, clean up */
854
		dev_dbg(dev, "%s - urb shutting down with status: %d\n", __func__, status);
855 856
		return;
	default:
857
		dev_dbg(dev, "%s - nonzero urb status received: %d\n", __func__, status);
858 859 860 861 862 863 864 865 866 867 868 869 870
		goto exit;
	}

	length = urb->actual_length;
	data = urb->transfer_buffer;

	/* Structure of data from 7715 device:
	 * Byte 1: IIR serial Port
	 * Byte 2: unused
	 * Byte 2: DSR parallel port
	 * Byte 4: FIFO status for both */

	if (unlikely(length != 4)) {
871
		dev_dbg(dev, "Wrong data !!!\n");
872 873 874 875 876 877 878
		return;
	}

	iir = data[0];
	if (!(iir & 0x01)) {	/* serial port interrupt pending */
		switch (iir & 0x0f) {
		case SERIAL_IIR_RLS:
879
			dev_dbg(dev, "Serial Port: Receiver status error or address bit detected in 9-bit mode\n\n");
880 881
			break;
		case SERIAL_IIR_CTI:
882
			dev_dbg(dev, "Serial Port: Receiver time out\n");
883 884
			break;
		case SERIAL_IIR_MS:
885
			/* dev_dbg(dev, "Serial Port: Modem status change\n"); */
886 887 888 889
			break;
		}
	}

890 891 892 893 894 895 896 897 898 899
#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
	{       /* update local copy of DSR reg */
		struct usb_serial_port *port = urb->context;
		struct mos7715_parport *mos_parport = port->serial->private;
		if (unlikely(mos_parport == NULL))
			return;
		atomic_set(&mos_parport->shadowDSR, data[2]);
	}
#endif

900 901 902
exit:
	result = usb_submit_urb(urb, GFP_ATOMIC);
	if (result)
903
		dev_err(dev, "%s - Error %d submitting control urb\n", __func__, result);
904 905
}

906 907 908 909 910 911 912
/*
 * mos7720_bulk_in_callback
 *	this is the callback function for when we have received data on the
 *	bulk in endpoint.
 */
static void mos7720_bulk_in_callback(struct urb *urb)
{
913
	int retval;
914 915
	unsigned char *data ;
	struct usb_serial_port *port;
916
	int status = urb->status;
917

918
	if (status) {
919
		dev_dbg(&urb->dev->dev, "nonzero read bulk status received: %d\n", status);
920 921 922
		return;
	}

923
	port = urb->context;
924

925
	dev_dbg(&port->dev, "Entering...%s\n", __func__);
926 927 928

	data = urb->transfer_buffer;

J
Jiri Slaby 已提交
929
	if (urb->actual_length) {
J
Jiri Slaby 已提交
930
		tty_insert_flip_string(&port->port, data, urb->actual_length);
J
Jiri Slaby 已提交
931
		tty_flip_buffer_push(&port->port);
932 933 934
	}

	if (port->read_urb->status != -EINPROGRESS) {
935 936
		retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
		if (retval)
937
			dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, retval = %d\n", retval);
938 939 940 941 942 943 944 945 946 947 948
	}
}

/*
 * mos7720_bulk_out_data_callback
 *	this is the callback function for when we have finished sending serial
 *	data on the bulk out endpoint.
 */
static void mos7720_bulk_out_data_callback(struct urb *urb)
{
	struct moschip_port *mos7720_port;
949
	int status = urb->status;
950

951
	if (status) {
952
		dev_dbg(&urb->dev->dev, "nonzero write bulk status received:%d\n", status);
953 954 955 956 957
		return;
	}

	mos7720_port = urb->context;
	if (!mos7720_port) {
958
		dev_dbg(&urb->dev->dev, "NULL mos7720_port pointer\n");
959 960 961
		return ;
	}

J
Jiri Slaby 已提交
962 963
	if (mos7720_port->open)
		tty_port_tty_wakeup(&mos7720_port->port->port);
964 965
}

966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993
/*
 * mos77xx_probe
 *	this function installs the appropriate read interrupt endpoint callback
 *	depending on whether the device is a 7720 or 7715, thus avoiding costly
 *	run-time checks in the high-frequency callback routine itself.
 */
static int mos77xx_probe(struct usb_serial *serial,
			 const struct usb_device_id *id)
{
	if (id->idProduct == MOSCHIP_DEVICE_ID_7715)
		moschip7720_2port_driver.read_int_callback =
			mos7715_interrupt_callback;
	else
		moschip7720_2port_driver.read_int_callback =
			mos7720_interrupt_callback;

	return 0;
}

static int mos77xx_calc_num_ports(struct usb_serial *serial)
{
	u16 product = le16_to_cpu(serial->dev->descriptor.idProduct);
	if (product == MOSCHIP_DEVICE_ID_7715)
		return 1;

	return 2;
}

994
static int mos7720_open(struct tty_struct *tty, struct usb_serial_port *port)
995 996 997 998 999 1000
{
	struct usb_serial *serial;
	struct urb *urb;
	struct moschip_port *mos7720_port;
	int response;
	int port_number;
1001
	__u8 data;
O
Oliver Neukum 已提交
1002
	int allocated_urbs = 0;
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
	int j;

	serial = port->serial;

	mos7720_port = usb_get_serial_port_data(port);
	if (mos7720_port == NULL)
		return -ENODEV;

	usb_clear_halt(serial->dev, port->write_urb->pipe);
	usb_clear_halt(serial->dev, port->read_urb->pipe);

	/* Initialising the write urb pool */
	for (j = 0; j < NUM_URBS; ++j) {
A
Alan Cox 已提交
1016
		urb = usb_alloc_urb(0, GFP_KERNEL);
1017
		mos7720_port->write_urb_pool[j] = urb;
1018
		if (!urb)
1019 1020 1021 1022 1023
			continue;

		urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
					       GFP_KERNEL);
		if (!urb->transfer_buffer) {
O
Oliver Neukum 已提交
1024 1025
			usb_free_urb(mos7720_port->write_urb_pool[j]);
			mos7720_port->write_urb_pool[j] = NULL;
1026 1027
			continue;
		}
O
Oliver Neukum 已提交
1028
		allocated_urbs++;
1029 1030
	}

O
Oliver Neukum 已提交
1031 1032 1033
	if (!allocated_urbs)
		return -ENOMEM;

1034 1035 1036
	 /* Initialize MCS7720 -- Write Init values to corresponding Registers
	  *
	  * Register Index
1037
	  * 0 : THR/RHR
1038 1039 1040 1041
	  * 1 : IER
	  * 2 : FCR
	  * 3 : LCR
	  * 4 : MCR
1042 1043 1044
	  * 5 : LSR
	  * 6 : MSR
	  * 7 : SPR
1045 1046 1047
	  *
	  * 0x08 : SP1/2 Control Reg
	  */
1048
	port_number = port->port_number;
1049 1050
	read_mos_reg(serial, port_number, LSR, &data);

1051
	dev_dbg(&port->dev, "SS::%p LSR:%x\n", mos7720_port, data);
1052

1053 1054
	write_mos_reg(serial, dummy, SP1_REG, 0x02);
	write_mos_reg(serial, dummy, SP2_REG, 0x02);
1055

1056 1057
	write_mos_reg(serial, port_number, IER, 0x00);
	write_mos_reg(serial, port_number, FCR, 0x00);
1058

1059 1060 1061 1062 1063
	write_mos_reg(serial, port_number, FCR, 0xcf);
	mos7720_port->shadowLCR = 0x03;
	write_mos_reg(serial, port_number, LCR, mos7720_port->shadowLCR);
	mos7720_port->shadowMCR = 0x0b;
	write_mos_reg(serial, port_number, MCR, mos7720_port->shadowMCR);
1064

1065 1066
	write_mos_reg(serial, port_number, SP_CONTROL_REG, 0x00);
	read_mos_reg(serial, dummy, SP_CONTROL_REG, &data);
1067
	data = data | (port->port_number + 1);
1068 1069 1070 1071 1072 1073 1074 1075
	write_mos_reg(serial, dummy, SP_CONTROL_REG, data);
	mos7720_port->shadowLCR = 0x83;
	write_mos_reg(serial, port_number, LCR, mos7720_port->shadowLCR);
	write_mos_reg(serial, port_number, THR, 0x0c);
	write_mos_reg(serial, port_number, IER, 0x00);
	mos7720_port->shadowLCR = 0x03;
	write_mos_reg(serial, port_number, LCR, mos7720_port->shadowLCR);
	write_mos_reg(serial, port_number, IER, 0x0c);
1076 1077 1078

	response = usb_submit_urb(port->read_urb, GFP_KERNEL);
	if (response)
A
Alan Cox 已提交
1079 1080
		dev_err(&port->dev, "%s - Error %d submitting read urb\n",
							__func__, response);
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099

	/* initialize our port settings */
	mos7720_port->shadowMCR = UART_MCR_OUT2; /* Must set to enable ints! */

	/* send a open port command */
	mos7720_port->open = 1;

	return 0;
}

/*
 * mos7720_chars_in_buffer
 *	this function is called by the tty driver when it wants to know how many
 *	bytes of data we currently have outstanding in the port (data that has
 *	been written, but hasn't made it out the port yet)
 *	If successful, we return the number of bytes left to be written in the
 *	system,
 *	Otherwise we return a negative error number.
 */
A
Alan Cox 已提交
1100
static int mos7720_chars_in_buffer(struct tty_struct *tty)
1101
{
A
Alan Cox 已提交
1102
	struct usb_serial_port *port = tty->driver_data;
1103 1104 1105 1106 1107
	int i;
	int chars = 0;
	struct moschip_port *mos7720_port;

	mos7720_port = usb_get_serial_port_data(port);
1108
	if (mos7720_port == NULL)
A
Alan Cox 已提交
1109
		return 0;
1110 1111

	for (i = 0; i < NUM_URBS; ++i) {
A
Alan Cox 已提交
1112 1113
		if (mos7720_port->write_urb_pool[i] &&
		    mos7720_port->write_urb_pool[i]->status == -EINPROGRESS)
1114 1115
			chars += URB_TRANSFER_BUFFER_SIZE;
	}
1116
	dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);
1117 1118 1119
	return chars;
}

1120
static void mos7720_close(struct usb_serial_port *port)
1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
{
	struct usb_serial *serial;
	struct moschip_port *mos7720_port;
	int j;

	serial = port->serial;

	mos7720_port = usb_get_serial_port_data(port);
	if (mos7720_port == NULL)
		return;

	for (j = 0; j < NUM_URBS; ++j)
		usb_kill_urb(mos7720_port->write_urb_pool[j]);

	/* Freeing Write URBs */
	for (j = 0; j < NUM_URBS; ++j) {
		if (mos7720_port->write_urb_pool[j]) {
			kfree(mos7720_port->write_urb_pool[j]->transfer_buffer);
			usb_free_urb(mos7720_port->write_urb_pool[j]);
		}
	}

	/* While closing port, shutdown all bulk read, write  *
1144 1145 1146 1147
	 * and interrupt read if they exists, otherwise nop   */
	usb_kill_urb(port->write_urb);
	usb_kill_urb(port->read_urb);

1148 1149
	write_mos_reg(serial, port->port_number, MCR, 0x00);
	write_mos_reg(serial, port->port_number, IER, 0x00);
1150

1151 1152 1153
	mos7720_port->open = 0;
}

A
Alan Cox 已提交
1154
static void mos7720_break(struct tty_struct *tty, int break_state)
1155
{
A
Alan Cox 已提交
1156
	struct usb_serial_port *port = tty->driver_data;
A
Alan Cox 已提交
1157
	unsigned char data;
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172
	struct usb_serial *serial;
	struct moschip_port *mos7720_port;

	serial = port->serial;

	mos7720_port = usb_get_serial_port_data(port);
	if (mos7720_port == NULL)
		return;

	if (break_state == -1)
		data = mos7720_port->shadowLCR | UART_LCR_SBC;
	else
		data = mos7720_port->shadowLCR & ~UART_LCR_SBC;

	mos7720_port->shadowLCR  = data;
1173
	write_mos_reg(serial, port->port_number, LCR, mos7720_port->shadowLCR);
1174 1175 1176 1177 1178 1179 1180 1181 1182
}

/*
 * mos7720_write_room
 *	this function is called by the tty driver when it wants to know how many
 *	bytes of data we can accept for a specific port.
 *	If successful, we return the amount of room that we have for this port
 *	Otherwise we return a negative error number.
 */
A
Alan Cox 已提交
1183
static int mos7720_write_room(struct tty_struct *tty)
1184
{
A
Alan Cox 已提交
1185
	struct usb_serial_port *port = tty->driver_data;
1186 1187 1188 1189 1190
	struct moschip_port *mos7720_port;
	int room = 0;
	int i;

	mos7720_port = usb_get_serial_port_data(port);
1191
	if (mos7720_port == NULL)
1192 1193
		return -ENODEV;

1194
	/* FIXME: Locking */
1195
	for (i = 0; i < NUM_URBS; ++i) {
A
Alan Cox 已提交
1196 1197
		if (mos7720_port->write_urb_pool[i] &&
		    mos7720_port->write_urb_pool[i]->status != -EINPROGRESS)
1198 1199 1200
			room += URB_TRANSFER_BUFFER_SIZE;
	}

1201
	dev_dbg(&port->dev, "%s - returns %d\n", __func__, room);
1202 1203 1204
	return room;
}

A
Alan Cox 已提交
1205 1206
static int mos7720_write(struct tty_struct *tty, struct usb_serial_port *port,
				 const unsigned char *data, int count)
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
{
	int status;
	int i;
	int bytes_sent = 0;
	int transfer_size;

	struct moschip_port *mos7720_port;
	struct usb_serial *serial;
	struct urb    *urb;
	const unsigned char *current_position = data;

	serial = port->serial;

	mos7720_port = usb_get_serial_port_data(port);
1221
	if (mos7720_port == NULL)
1222 1223 1224 1225 1226 1227
		return -ENODEV;

	/* try to find a free urb in the list */
	urb = NULL;

	for (i = 0; i < NUM_URBS; ++i) {
A
Alan Cox 已提交
1228 1229
		if (mos7720_port->write_urb_pool[i] &&
		    mos7720_port->write_urb_pool[i]->status != -EINPROGRESS) {
1230
			urb = mos7720_port->write_urb_pool[i];
1231
			dev_dbg(&port->dev, "URB:%d\n", i);
1232 1233 1234 1235 1236
			break;
		}
	}

	if (urb == NULL) {
1237
		dev_dbg(&port->dev, "%s - no more free urbs\n", __func__);
1238 1239 1240 1241 1242 1243
		goto exit;
	}

	if (urb->transfer_buffer == NULL) {
		urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
					       GFP_KERNEL);
1244
		if (!urb->transfer_buffer)
1245 1246
			goto exit;
	}
A
Alan Cox 已提交
1247
	transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE);
1248 1249

	memcpy(urb->transfer_buffer, current_position, transfer_size);
1250
	usb_serial_debug_data(&port->dev, __func__, transfer_size,
1251 1252 1253 1254 1255
			      urb->transfer_buffer);

	/* fill urb with data and submit  */
	usb_fill_bulk_urb(urb, serial->dev,
			  usb_sndbulkpipe(serial->dev,
A
Alan Cox 已提交
1256
					port->bulk_out_endpointAddress),
1257 1258 1259 1260
			  urb->transfer_buffer, transfer_size,
			  mos7720_bulk_out_data_callback, mos7720_port);

	/* send it down the pipe */
A
Alan Cox 已提交
1261
	status = usb_submit_urb(urb, GFP_ATOMIC);
1262
	if (status) {
1263
		dev_err_console(port, "%s - usb_submit_urb(write bulk) failed "
1264
			"with status = %d\n", __func__, status);
1265 1266 1267 1268 1269 1270 1271 1272 1273
		bytes_sent = status;
		goto exit;
	}
	bytes_sent = transfer_size;

exit:
	return bytes_sent;
}

A
Alan Cox 已提交
1274
static void mos7720_throttle(struct tty_struct *tty)
1275
{
A
Alan Cox 已提交
1276
	struct usb_serial_port *port = tty->driver_data;
1277 1278 1279 1280 1281 1282 1283 1284 1285
	struct moschip_port *mos7720_port;
	int status;

	mos7720_port = usb_get_serial_port_data(port);

	if (mos7720_port == NULL)
		return;

	if (!mos7720_port->open) {
1286
		dev_dbg(&port->dev, "%s - port not opened\n", __func__);
1287 1288 1289 1290 1291 1292
		return;
	}

	/* if we are implementing XON/XOFF, send the stop character */
	if (I_IXOFF(tty)) {
		unsigned char stop_char = STOP_CHAR(tty);
A
Alan Cox 已提交
1293
		status = mos7720_write(tty, port, &stop_char, 1);
1294 1295 1296 1297 1298
		if (status <= 0)
			return;
	}

	/* if we are implementing RTS/CTS, toggle that line */
1299
	if (tty->termios.c_cflag & CRTSCTS) {
1300
		mos7720_port->shadowMCR &= ~UART_MCR_RTS;
1301 1302
		write_mos_reg(port->serial, port->port_number, MCR,
			      mos7720_port->shadowMCR);
1303 1304 1305 1306 1307
		if (status != 0)
			return;
	}
}

A
Alan Cox 已提交
1308
static void mos7720_unthrottle(struct tty_struct *tty)
1309
{
A
Alan Cox 已提交
1310
	struct usb_serial_port *port = tty->driver_data;
1311
	struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
A
Alan Cox 已提交
1312
	int status;
1313 1314 1315 1316 1317

	if (mos7720_port == NULL)
		return;

	if (!mos7720_port->open) {
1318
		dev_dbg(&port->dev, "%s - port not opened\n", __func__);
1319 1320 1321 1322 1323 1324
		return;
	}

	/* if we are implementing XON/XOFF, send the start character */
	if (I_IXOFF(tty)) {
		unsigned char start_char = START_CHAR(tty);
A
Alan Cox 已提交
1325
		status = mos7720_write(tty, port, &start_char, 1);
1326 1327 1328 1329 1330
		if (status <= 0)
			return;
	}

	/* if we are implementing RTS/CTS, toggle that line */
1331
	if (tty->termios.c_cflag & CRTSCTS) {
1332
		mos7720_port->shadowMCR |= UART_MCR_RTS;
1333 1334
		write_mos_reg(port->serial, port->port_number, MCR,
			      mos7720_port->shadowMCR);
1335 1336 1337 1338 1339
		if (status != 0)
			return;
	}
}

1340
/* FIXME: this function does not work */
1341 1342 1343 1344 1345 1346
static int set_higher_rates(struct moschip_port *mos7720_port,
			    unsigned int baud)
{
	struct usb_serial_port *port;
	struct usb_serial *serial;
	int port_number;
1347
	enum mos_regs sp_reg;
1348 1349 1350 1351 1352 1353
	if (mos7720_port == NULL)
		return -EINVAL;

	port = mos7720_port->port;
	serial = port->serial;

A
Alan Cox 已提交
1354 1355 1356
	 /***********************************************
	 *      Init Sequence for higher rates
	 ***********************************************/
1357
	dev_dbg(&port->dev, "Sending Setting Commands ..........\n");
1358
	port_number = port->port_number;
1359

1360 1361 1362 1363 1364 1365
	write_mos_reg(serial, port_number, IER, 0x00);
	write_mos_reg(serial, port_number, FCR, 0x00);
	write_mos_reg(serial, port_number, FCR, 0xcf);
	mos7720_port->shadowMCR = 0x0b;
	write_mos_reg(serial, port_number, MCR, mos7720_port->shadowMCR);
	write_mos_reg(serial, dummy, SP_CONTROL_REG, 0x00);
1366

A
Alan Cox 已提交
1367 1368 1369
	/***********************************************
	 *              Set for higher rates           *
	 ***********************************************/
1370
	/* writing baud rate verbatum into uart clock field clearly not right */
1371 1372 1373 1374 1375 1376 1377 1378
	if (port_number == 0)
		sp_reg = SP1_REG;
	else
		sp_reg = SP2_REG;
	write_mos_reg(serial, dummy, sp_reg, baud * 0x10);
	write_mos_reg(serial, dummy, SP_CONTROL_REG, 0x03);
	mos7720_port->shadowMCR = 0x2b;
	write_mos_reg(serial, port_number, MCR, mos7720_port->shadowMCR);
1379

A
Alan Cox 已提交
1380 1381 1382
	/***********************************************
	 *              Set DLL/DLM
	 ***********************************************/
1383 1384 1385 1386 1387 1388
	mos7720_port->shadowLCR = mos7720_port->shadowLCR | UART_LCR_DLAB;
	write_mos_reg(serial, port_number, LCR, mos7720_port->shadowLCR);
	write_mos_reg(serial, port_number, DLL, 0x01);
	write_mos_reg(serial, port_number, DLM, 0x00);
	mos7720_port->shadowLCR = mos7720_port->shadowLCR & ~UART_LCR_DLAB;
	write_mos_reg(serial, port_number, LCR, mos7720_port->shadowLCR);
1389 1390 1391 1392 1393

	return 0;
}

/* baud rate information */
A
Alan Cox 已提交
1394
struct divisor_table_entry {
1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425
	__u32  baudrate;
	__u16  divisor;
};

/* Define table of divisors for moschip 7720 hardware	   *
 * These assume a 3.6864MHz crystal, the standard /16, and *
 * MCR.7 = 0.						   */
static struct divisor_table_entry divisor_table[] = {
	{   50,		2304},
	{   110,	1047},	/* 2094.545455 => 230450   => .0217 % over */
	{   134,	857},	/* 1713.011152 => 230398.5 => .00065% under */
	{   150,	768},
	{   300,	384},
	{   600,	192},
	{   1200,	96},
	{   1800,	64},
	{   2400,	48},
	{   4800,	24},
	{   7200,	16},
	{   9600,	12},
	{   19200,	6},
	{   38400,	3},
	{   57600,	2},
	{   115200,	1},
};

/*****************************************************************************
 * calc_baud_rate_divisor
 *	this function calculates the proper baud rate divisor for the specified
 *	baud rate.
 *****************************************************************************/
1426
static int calc_baud_rate_divisor(struct usb_serial_port *port, int baudrate, int *divisor)
1427 1428 1429 1430 1431 1432 1433
{
	int i;
	__u16 custom;
	__u16 round1;
	__u16 round;


1434
	dev_dbg(&port->dev, "%s - %d\n", __func__, baudrate);
1435 1436 1437 1438 1439 1440 1441 1442

	for (i = 0; i < ARRAY_SIZE(divisor_table); i++) {
		if (divisor_table[i].baudrate == baudrate) {
			*divisor = divisor_table[i].divisor;
			return 0;
		}
	}

A
Alan Cox 已提交
1443 1444
	/* After trying for all the standard baud rates    *
	 * Try calculating the divisor for this baud rate  */
1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455
	if (baudrate > 75 &&  baudrate < 230400) {
		/* get the divisor */
		custom = (__u16)(230400L  / baudrate);

		/* Check for round off */
		round1 = (__u16)(2304000L / baudrate);
		round = (__u16)(round1 - (custom * 10));
		if (round > 4)
			custom++;
		*divisor = custom;

1456
		dev_dbg(&port->dev, "Baud %d = %d\n", baudrate, custom);
1457 1458 1459
		return 0;
	}

1460
	dev_dbg(&port->dev, "Baud calculation Failed...\n");
1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483
	return -EINVAL;
}

/*
 * send_cmd_write_baud_rate
 *	this function sends the proper command to change the baud rate of the
 *	specified port.
 */
static int send_cmd_write_baud_rate(struct moschip_port *mos7720_port,
				    int baudrate)
{
	struct usb_serial_port *port;
	struct usb_serial *serial;
	int divisor;
	int status;
	unsigned char number;

	if (mos7720_port == NULL)
		return -1;

	port = mos7720_port->port;
	serial = port->serial;

1484
	number = port->port_number;
1485
	dev_dbg(&port->dev, "%s - baud = %d\n", __func__, baudrate);
1486

A
Alan Cox 已提交
1487
	/* Calculate the Divisor */
1488
	status = calc_baud_rate_divisor(port, baudrate, &divisor);
1489
	if (status) {
1490
		dev_err(&port->dev, "%s - bad baud rate\n", __func__);
1491 1492 1493
		return status;
	}

A
Alan Cox 已提交
1494
	/* Enable access to divisor latch */
1495 1496
	mos7720_port->shadowLCR = mos7720_port->shadowLCR | UART_LCR_DLAB;
	write_mos_reg(serial, number, LCR, mos7720_port->shadowLCR);
1497 1498

	/* Write the divisor */
1499 1500
	write_mos_reg(serial, number, DLL, (__u8)(divisor & 0xff));
	write_mos_reg(serial, number, DLM, (__u8)((divisor & 0xff00) >> 8));
1501

A
Alan Cox 已提交
1502
	/* Disable access to divisor latch */
1503 1504
	mos7720_port->shadowLCR = mos7720_port->shadowLCR & ~UART_LCR_DLAB;
	write_mos_reg(serial, number, LCR, mos7720_port->shadowLCR);
1505 1506 1507 1508 1509 1510 1511 1512 1513

	return status;
}

/*
 * change_port_settings
 *	This routine is called to set the UART on the device to match
 *      the specified new settings.
 */
A
Alan Cox 已提交
1514 1515
static void change_port_settings(struct tty_struct *tty,
				 struct moschip_port *mos7720_port,
A
Alan Cox 已提交
1516
				 struct ktermios *old_termios)
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534
{
	struct usb_serial_port *port;
	struct usb_serial *serial;
	int baud;
	unsigned cflag;
	unsigned iflag;
	__u8 mask = 0xff;
	__u8 lData;
	__u8 lParity;
	__u8 lStop;
	int status;
	int port_number;

	if (mos7720_port == NULL)
		return ;

	port = mos7720_port->port;
	serial = port->serial;
1535
	port_number = port->port_number;
1536 1537

	if (!mos7720_port->open) {
1538
		dev_dbg(&port->dev, "%s - port not opened\n", __func__);
1539 1540 1541 1542 1543 1544 1545
		return;
	}

	lData = UART_LCR_WLEN8;
	lStop = 0x00;	/* 1 stop bit */
	lParity = 0x00;	/* No parity */

1546 1547
	cflag = tty->termios.c_cflag;
	iflag = tty->termios.c_iflag;
1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574

	/* Change the number of bits */
	switch (cflag & CSIZE) {
	case CS5:
		lData = UART_LCR_WLEN5;
		mask = 0x1f;
		break;

	case CS6:
		lData = UART_LCR_WLEN6;
		mask = 0x3f;
		break;

	case CS7:
		lData = UART_LCR_WLEN7;
		mask = 0x7f;
		break;
	default:
	case CS8:
		lData = UART_LCR_WLEN8;
		break;
	}

	/* Change the Parity bit */
	if (cflag & PARENB) {
		if (cflag & PARODD) {
			lParity = UART_LCR_PARITY;
1575
			dev_dbg(&port->dev, "%s - parity = odd\n", __func__);
1576 1577
		} else {
			lParity = (UART_LCR_EPAR | UART_LCR_PARITY);
1578
			dev_dbg(&port->dev, "%s - parity = even\n", __func__);
1579 1580 1581
		}

	} else {
1582
		dev_dbg(&port->dev, "%s - parity = none\n", __func__);
1583 1584 1585 1586 1587 1588 1589 1590
	}

	if (cflag & CMSPAR)
		lParity = lParity | 0x20;

	/* Change the Stop bit */
	if (cflag & CSTOPB) {
		lStop = UART_LCR_STOP;
1591
		dev_dbg(&port->dev, "%s - stop bits = 2\n", __func__);
1592 1593
	} else {
		lStop = 0x00;
1594
		dev_dbg(&port->dev, "%s - stop bits = 1\n", __func__);
1595 1596 1597 1598 1599 1600 1601
	}

#define LCR_BITS_MASK		0x03	/* Mask for bits/char field */
#define LCR_STOP_MASK		0x04	/* Mask for stop bits field */
#define LCR_PAR_MASK		0x38	/* Mask for parity field */

	/* Update the LCR with the correct value */
A
Alan Cox 已提交
1602
	mos7720_port->shadowLCR &=
1603
		~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
1604 1605 1606 1607
	mos7720_port->shadowLCR |= (lData | lParity | lStop);


	/* Disable Interrupts */
1608 1609 1610
	write_mos_reg(serial, port_number, IER, 0x00);
	write_mos_reg(serial, port_number, FCR, 0x00);
	write_mos_reg(serial, port_number, FCR, 0xcf);
1611 1612

	/* Send the updated LCR value to the mos7720 */
1613 1614 1615
	write_mos_reg(serial, port_number, LCR, mos7720_port->shadowLCR);
	mos7720_port->shadowMCR = 0x0b;
	write_mos_reg(serial, port_number, MCR, mos7720_port->shadowMCR);
1616 1617 1618 1619 1620 1621 1622 1623

	/* set up the MCR register and send it to the mos7720 */
	mos7720_port->shadowMCR = UART_MCR_OUT2;
	if (cflag & CBAUD)
		mos7720_port->shadowMCR |= (UART_MCR_DTR | UART_MCR_RTS);

	if (cflag & CRTSCTS) {
		mos7720_port->shadowMCR |= (UART_MCR_XONANY);
A
Alan Cox 已提交
1624 1625
		/* To set hardware flow control to the specified *
		 * serial port, in SP1/2_CONTROL_REG             */
1626
		if (port_number)
1627 1628 1629 1630 1631
			write_mos_reg(serial, dummy, SP_CONTROL_REG, 0x01);
		else
			write_mos_reg(serial, dummy, SP_CONTROL_REG, 0x02);

	} else
1632 1633
		mos7720_port->shadowMCR &= ~(UART_MCR_XONANY);

1634
	write_mos_reg(serial, port_number, MCR, mos7720_port->shadowMCR);
1635 1636 1637 1638 1639

	/* Determine divisor based on baud rate */
	baud = tty_get_baud_rate(tty);
	if (!baud) {
		/* pick a default, any default... */
1640
		dev_dbg(&port->dev, "Picked default baud...\n");
1641 1642 1643 1644 1645 1646
		baud = 9600;
	}

	if (baud >= 230400) {
		set_higher_rates(mos7720_port, baud);
		/* Enable Interrupts */
1647
		write_mos_reg(serial, port_number, IER, 0x0c);
1648 1649 1650
		return;
	}

1651
	dev_dbg(&port->dev, "%s - baud rate = %d\n", __func__, baud);
1652
	status = send_cmd_write_baud_rate(mos7720_port, baud);
A
Alan Cox 已提交
1653 1654 1655 1656
	/* FIXME: needs to write actual resulting baud back not just
	   blindly do so */
	if (cflag & CBAUD)
		tty_encode_baud_rate(tty, baud, baud);
1657
	/* Enable Interrupts */
1658
	write_mos_reg(serial, port_number, IER, 0x0c);
1659 1660 1661 1662

	if (port->read_urb->status != -EINPROGRESS) {
		status = usb_submit_urb(port->read_urb, GFP_ATOMIC);
		if (status)
1663
			dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n", status);
1664 1665 1666 1667 1668 1669 1670 1671
	}
}

/*
 * mos7720_set_termios
 *	this function is called by the tty driver when it wants to change the
 *	termios structure.
 */
A
Alan Cox 已提交
1672 1673
static void mos7720_set_termios(struct tty_struct *tty,
		struct usb_serial_port *port, struct ktermios *old_termios)
1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687
{
	int status;
	unsigned int cflag;
	struct usb_serial *serial;
	struct moschip_port *mos7720_port;

	serial = port->serial;

	mos7720_port = usb_get_serial_port_data(port);

	if (mos7720_port == NULL)
		return;

	if (!mos7720_port->open) {
1688
		dev_dbg(&port->dev, "%s - port not opened\n", __func__);
1689 1690 1691
		return;
	}

1692
	dev_dbg(&port->dev, "setting termios - ASPIRE\n");
1693

1694
	cflag = tty->termios.c_cflag;
1695

1696
	dev_dbg(&port->dev, "%s - cflag %08x iflag %08x\n", __func__,
1697
		tty->termios.c_cflag, RELEVANT_IFLAG(tty->termios.c_iflag));
1698

1699 1700
	dev_dbg(&port->dev, "%s - old cflag %08x old iflag %08x\n", __func__,
		old_termios->c_cflag, RELEVANT_IFLAG(old_termios->c_iflag));
1701 1702

	/* change the port settings to the new ones specified */
A
Alan Cox 已提交
1703
	change_port_settings(tty, mos7720_port, old_termios);
1704

A
Alan Cox 已提交
1705
	if (port->read_urb->status != -EINPROGRESS) {
1706 1707
		status = usb_submit_urb(port->read_urb, GFP_ATOMIC);
		if (status)
1708
			dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n", status);
1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721
	}
}

/*
 * get_lsr_info - get line status register info
 *
 * Purpose: Let user call ioctl() to get info when the UART physically
 * 	    is emptied.  On bus types like RS485, the transmitter must
 * 	    release the bus after transmitting. This must be done when
 * 	    the transmit shift register is empty, not be done when the
 * 	    transmit holding register is empty.  This functionality
 * 	    allows an RS485 driver to be written in user space.
 */
A
Alan Cox 已提交
1722 1723
static int get_lsr_info(struct tty_struct *tty,
		struct moschip_port *mos7720_port, unsigned int __user *value)
1724
{
1725
	struct usb_serial_port *port = tty->driver_data;
1726
	unsigned int result = 0;
1727
	unsigned char data = 0;
1728
	int port_number = port->port_number;
1729
	int count;
1730

A
Alan Cox 已提交
1731
	count = mos7720_chars_in_buffer(tty);
1732
	if (count == 0) {
1733
		read_mos_reg(port->serial, port_number, LSR, &data);
1734 1735
		if ((data & (UART_LSR_TEMT | UART_LSR_THRE))
					== (UART_LSR_TEMT | UART_LSR_THRE)) {
1736
			dev_dbg(&port->dev, "%s -- Empty\n", __func__);
1737 1738
			result = TIOCSER_TEMT;
		}
1739 1740 1741 1742 1743 1744
	}
	if (copy_to_user(value, &result, sizeof(int)))
		return -EFAULT;
	return 0;
}

1745
static int mos7720_tiocmget(struct tty_struct *tty)
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765
{
	struct usb_serial_port *port = tty->driver_data;
	struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
	unsigned int result = 0;
	unsigned int mcr ;
	unsigned int msr ;

	mcr = mos7720_port->shadowMCR;
	msr = mos7720_port->shadowMSR;

	result = ((mcr & UART_MCR_DTR)  ? TIOCM_DTR : 0)   /* 0x002 */
	  | ((mcr & UART_MCR_RTS)   ? TIOCM_RTS : 0)   /* 0x004 */
	  | ((msr & UART_MSR_CTS)   ? TIOCM_CTS : 0)   /* 0x020 */
	  | ((msr & UART_MSR_DCD)   ? TIOCM_CAR : 0)   /* 0x040 */
	  | ((msr & UART_MSR_RI)    ? TIOCM_RI :  0)   /* 0x080 */
	  | ((msr & UART_MSR_DSR)   ? TIOCM_DSR : 0);  /* 0x100 */

	return result;
}

1766
static int mos7720_tiocmset(struct tty_struct *tty,
1767
			    unsigned int set, unsigned int clear)
1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789
{
	struct usb_serial_port *port = tty->driver_data;
	struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
	unsigned int mcr ;

	mcr = mos7720_port->shadowMCR;

	if (set & TIOCM_RTS)
		mcr |= UART_MCR_RTS;
	if (set & TIOCM_DTR)
		mcr |= UART_MCR_DTR;
	if (set & TIOCM_LOOP)
		mcr |= UART_MCR_LOOP;

	if (clear & TIOCM_RTS)
		mcr &= ~UART_MCR_RTS;
	if (clear & TIOCM_DTR)
		mcr &= ~UART_MCR_DTR;
	if (clear & TIOCM_LOOP)
		mcr &= ~UART_MCR_LOOP;

	mos7720_port->shadowMCR = mcr;
1790 1791
	write_mos_reg(port->serial, port->port_number, MCR,
		      mos7720_port->shadowMCR);
1792 1793 1794 1795

	return 0;
}

1796 1797 1798
static int set_modem_info(struct moschip_port *mos7720_port, unsigned int cmd,
			  unsigned int __user *value)
{
1799
	unsigned int mcr;
1800 1801 1802 1803 1804 1805 1806
	unsigned int arg;

	struct usb_serial_port *port;

	if (mos7720_port == NULL)
		return -1;

A
Alan Cox 已提交
1807
	port = (struct usb_serial_port *)mos7720_port->port;
1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834
	mcr = mos7720_port->shadowMCR;

	if (copy_from_user(&arg, value, sizeof(int)))
		return -EFAULT;

	switch (cmd) {
	case TIOCMBIS:
		if (arg & TIOCM_RTS)
			mcr |= UART_MCR_RTS;
		if (arg & TIOCM_DTR)
			mcr |= UART_MCR_RTS;
		if (arg & TIOCM_LOOP)
			mcr |= UART_MCR_LOOP;
		break;

	case TIOCMBIC:
		if (arg & TIOCM_RTS)
			mcr &= ~UART_MCR_RTS;
		if (arg & TIOCM_DTR)
			mcr &= ~UART_MCR_RTS;
		if (arg & TIOCM_LOOP)
			mcr &= ~UART_MCR_LOOP;
		break;

	}

	mos7720_port->shadowMCR = mcr;
1835 1836
	write_mos_reg(port->serial, port->port_number, MCR,
		      mos7720_port->shadowMCR);
1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851

	return 0;
}

static int get_serial_info(struct moschip_port *mos7720_port,
			   struct serial_struct __user *retinfo)
{
	struct serial_struct tmp;

	if (!retinfo)
		return -EFAULT;

	memset(&tmp, 0, sizeof(tmp));

	tmp.type		= PORT_16550A;
1852
	tmp.line		= mos7720_port->port->minor;
1853
	tmp.port		= mos7720_port->port->port_number;
1854 1855
	tmp.irq			= 0;
	tmp.flags		= ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
A
Alan Cox 已提交
1856
	tmp.xmit_fifo_size	= NUM_URBS * URB_TRANSFER_BUFFER_SIZE;
1857 1858 1859 1860 1861 1862 1863 1864 1865
	tmp.baud_base		= 9600;
	tmp.close_delay		= 5*HZ;
	tmp.closing_wait	= 30*HZ;

	if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
		return -EFAULT;
	return 0;
}

1866
static int mos7720_ioctl(struct tty_struct *tty,
1867 1868
			 unsigned int cmd, unsigned long arg)
{
A
Alan Cox 已提交
1869
	struct usb_serial_port *port = tty->driver_data;
1870 1871 1872 1873 1874 1875 1876 1877
	struct moschip_port *mos7720_port;

	mos7720_port = usb_get_serial_port_data(port);
	if (mos7720_port == NULL)
		return -ENODEV;

	switch (cmd) {
	case TIOCSERGETLSR:
1878
		dev_dbg(&port->dev, "%s TIOCSERGETLSR\n", __func__);
A
Alan Cox 已提交
1879 1880
		return get_lsr_info(tty, mos7720_port,
					(unsigned int __user *)arg);
1881

A
Alan Cox 已提交
1882
	/* FIXME: These should be using the mode methods */
1883 1884
	case TIOCMBIS:
	case TIOCMBIC:
1885
		dev_dbg(&port->dev, "%s TIOCMSET/TIOCMBIC/TIOCMSET\n", __func__);
1886 1887 1888 1889
		return set_modem_info(mos7720_port, cmd,
				      (unsigned int __user *)arg);

	case TIOCGSERIAL:
1890
		dev_dbg(&port->dev, "%s TIOCGSERIAL\n", __func__);
1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901
		return get_serial_info(mos7720_port,
				       (struct serial_struct __user *)arg);
	}

	return -ENOIOCTLCMD;
}

static int mos7720_startup(struct usb_serial *serial)
{
	struct usb_device *dev;
	char data;
1902
	u16 product;
1903
	int ret_val;
1904

1905
	product = le16_to_cpu(serial->dev->descriptor.idProduct);
1906 1907
	dev = serial->dev;

1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930
	/*
	 * The 7715 uses the first bulk in/out endpoint pair for the parallel
	 * port, and the second for the serial port.  Because the usbserial core
	 * assumes both pairs are serial ports, we must engage in a bit of
	 * subterfuge and swap the pointers for ports 0 and 1 in order to make
	 * port 0 point to the serial port.  However, both moschip devices use a
	 * single interrupt-in endpoint for both ports (as mentioned a little
	 * further down), and this endpoint was assigned to port 0.  So after
	 * the swap, we must copy the interrupt endpoint elements from port 1
	 * (as newly assigned) to port 0, and null out port 1 pointers.
	 */
	if (product == MOSCHIP_DEVICE_ID_7715) {
		struct usb_serial_port *tmp = serial->port[0];
		serial->port[0] = serial->port[1];
		serial->port[1] = tmp;
		serial->port[0]->interrupt_in_urb = tmp->interrupt_in_urb;
		serial->port[0]->interrupt_in_buffer = tmp->interrupt_in_buffer;
		serial->port[0]->interrupt_in_endpointAddress =
			tmp->interrupt_in_endpointAddress;
		serial->port[1]->interrupt_in_urb = NULL;
		serial->port[1]->interrupt_in_buffer = NULL;
	}

1931 1932
	/* setting configuration feature to one */
	usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1933
			(__u8)0x03, 0x00, 0x01, 0x00, NULL, 0x00, 5000);
1934

1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948
	/* start the interrupt urb */
	ret_val = usb_submit_urb(serial->port[0]->interrupt_in_urb, GFP_KERNEL);
	if (ret_val)
		dev_err(&dev->dev,
			"%s - Error %d submitting control urb\n",
			__func__, ret_val);

#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
	if (product == MOSCHIP_DEVICE_ID_7715) {
		ret_val = mos7715_parport_init(serial);
		if (ret_val < 0)
			return ret_val;
	}
#endif
A
Alan Cox 已提交
1949
	/* LSR For Port 1 */
1950
	read_mos_reg(serial, 0, LSR, &data);
1951
	dev_dbg(&dev->dev, "LSR:%x\n", data);
1952 1953 1954 1955

	return 0;
}

1956
static void mos7720_release(struct usb_serial *serial)
1957
{
1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975
#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
	/* close the parallel port */

	if (le16_to_cpu(serial->dev->descriptor.idProduct)
	    == MOSCHIP_DEVICE_ID_7715) {
		struct urbtracker *urbtrack;
		unsigned long flags;
		struct mos7715_parport *mos_parport =
			usb_get_serial_data(serial);

		/* prevent NULL ptr dereference in port callbacks */
		spin_lock(&release_lock);
		mos_parport->pp->private_data = NULL;
		spin_unlock(&release_lock);

		/* wait for synchronous usb calls to return */
		if (mos_parport->msg_pending)
			wait_for_completion_timeout(&mos_parport->syncmsg_compl,
1976
					    msecs_to_jiffies(MOS_WDR_TIMEOUT));
1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995

		parport_remove_port(mos_parport->pp);
		usb_set_serial_data(serial, NULL);
		mos_parport->serial = NULL;

		/* if tasklet currently scheduled, wait for it to complete */
		tasklet_kill(&mos_parport->urb_tasklet);

		/* unlink any urbs sent by the tasklet  */
		spin_lock_irqsave(&mos_parport->listlock, flags);
		list_for_each_entry(urbtrack,
				    &mos_parport->active_urbs,
				    urblist_entry)
			usb_unlink_urb(urbtrack->urb);
		spin_unlock_irqrestore(&mos_parport->listlock, flags);

		kref_put(&mos_parport->ref_count, destroy_mos_parport);
	}
#endif
1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025
}

static int mos7720_port_probe(struct usb_serial_port *port)
{
	struct moschip_port *mos7720_port;

	mos7720_port = kzalloc(sizeof(*mos7720_port), GFP_KERNEL);
	if (!mos7720_port)
		return -ENOMEM;

	/* Initialize all port interrupt end point to port 0 int endpoint.
	 * Our device has only one interrupt endpoint common to all ports.
	 */
	port->interrupt_in_endpointAddress =
		port->serial->port[0]->interrupt_in_endpointAddress;
	mos7720_port->port = port;

	usb_set_serial_port_data(port, mos7720_port);

	return 0;
}

static int mos7720_port_remove(struct usb_serial_port *port)
{
	struct moschip_port *mos7720_port;

	mos7720_port = usb_get_serial_port_data(port);
	kfree(mos7720_port);

	return 0;
2026 2027 2028 2029 2030 2031 2032 2033
}

static struct usb_serial_driver moschip7720_2port_driver = {
	.driver = {
		.owner =	THIS_MODULE,
		.name =		"moschip7720",
	},
	.description		= "Moschip 2 port adapter",
2034
	.id_table		= id_table,
2035
	.calc_num_ports		= mos77xx_calc_num_ports,
2036 2037 2038 2039
	.open			= mos7720_open,
	.close			= mos7720_close,
	.throttle		= mos7720_throttle,
	.unthrottle		= mos7720_unthrottle,
2040
	.probe			= mos77xx_probe,
2041
	.attach			= mos7720_startup,
2042
	.release		= mos7720_release,
2043 2044
	.port_probe		= mos7720_port_probe,
	.port_remove		= mos7720_port_remove,
2045
	.ioctl			= mos7720_ioctl,
2046 2047
	.tiocmget		= mos7720_tiocmget,
	.tiocmset		= mos7720_tiocmset,
2048 2049 2050 2051 2052 2053
	.set_termios		= mos7720_set_termios,
	.write			= mos7720_write,
	.write_room		= mos7720_write_room,
	.chars_in_buffer	= mos7720_chars_in_buffer,
	.break_ctl		= mos7720_break,
	.read_bulk_callback	= mos7720_bulk_in_callback,
2054
	.read_int_callback	= NULL  /* dynamically assigned in probe() */
2055 2056
};

2057 2058 2059 2060
static struct usb_serial_driver * const serial_drivers[] = {
	&moschip7720_2port_driver, NULL
};

2061
module_usb_serial_driver(serial_drivers, id_table);
2062

A
Alan Cox 已提交
2063 2064
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
2065
MODULE_LICENSE("GPL");