static int gs_chars_in_buffer(struct tty_struct *tty)
{
    struct gs_port	*port = tty->driver_data;
    unsigned long	flags;
    int		chars = 0;

    if (!port)
        return 0;
    spin_lock_irqsave(&port->port_lock, flags);
    chars = gs_buf_data_avail(&port->port_write_buf);
    spin_unlock_irqrestore(&port->port_lock, flags);

    pr_vdebug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
              port->port_num, tty, chars);

    return chars;
}

static int gs_put_char(struct tty_struct *tty, unsigned char ch)
{
    struct gs_port	*port = tty->driver_data;
    unsigned long	flags;
    int		status;

    if (!port)
        return 0;
    pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %pf\n",
              port->port_num, tty, ch, __builtin_return_address(0));

    spin_lock_irqsave(&port->port_lock, flags);
    status = gs_buf_put(&port->port_write_buf, &ch, 1);
    spin_unlock_irqrestore(&port->port_lock, flags);

    return status;
}

static int gs_write_room(struct tty_struct *tty)
{
	struct gs_port	*port = tty->driver_data;
	unsigned long	flags;
	int		room = 0;
	if(port == NULL)
		return room;
	spin_lock_irqsave(&port->port_lock, flags);
	if (port->port_usb)
		room = gs_buf_space_avail(&port->port_write_buf);
	spin_unlock_irqrestore(&port->port_lock, flags);

	pr_vdebug("gs_write_room: (%d,%p) room=%d\n",
		port->port_num, tty, room);

	return room;
}

static void gs_flush_chars(struct tty_struct *tty)
{
	struct gs_port	*port = tty->driver_data;
	unsigned long	flags;

#ifdef CONFIG_USB_G_LGE_ANDROID
	if (!port)
		return;
#endif

	pr_vdebug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);

	spin_lock_irqsave(&port->port_lock, flags);
	if (port->port_usb)
		gs_start_tx(port);
	spin_unlock_irqrestore(&port->port_lock, flags);
}

static int gs_break_ctl(struct tty_struct *tty, int duration)
{
	struct gs_port	*port = tty->driver_data;
	int		status = 0;
	struct gserial	*gser;

	pr_vdebug("gs_break_ctl: ttyGS%d, send break (%d) \n",
			port->port_num, duration);

	spin_lock_irq(&port->port_lock);
	gser = port->port_usb;
	if (gser && gser->send_break)
		status = gser->send_break(gser, duration);
	spin_unlock_irq(&port->port_lock);

	return status;
}

/**
 * Gets a character from the usb endpoint under the
 * interrupt context
 *
 * Returns 0 or a negative error number
 */
static int __gs_poll_get_char(struct gs_port *port, char *ch) {
	struct gserial *gs = port->port_usb;
	struct usb_ep *ept = gs->out;
	struct usb_request *usb_req;
	int rv;

	int read_ch = -EINVAL;

	BUG_ON(!ept);

	for (;;) {
		read_ch = gs_poll_pop_buffer();
		if (read_ch >= 0) {
			break; /* got a character, done */
		}

		/**
		 * There is nothing in buffer, start the USB endpoint to
		 * receive something
		 */

		/* Replace complete function to intercept usb read */
		usb_req = gs_alloc_req(ept, ept->maxpacket, GFP_ATOMIC);
		if (!usb_req) {
			pr_err("%s: OOM for read req\n", __func__);
			return -ENOMEM;
		}

		/* Queue request */
		usb_req->length = ept->maxpacket;
		usb_req->complete = gs_poll_read_complete;
		if ((rv = usb_ep_queue(ept, usb_req, GFP_ATOMIC))) {
			pr_err("%s: usb_ep_queue err %d\n", __func__, rv);
			return rv;
		}

		/* Read and free request */
		pr_vdebug("%s: polling for read\n", __func__);
		while ( usb_loop_poll_hw(ept, 1 /*rx*/) );
		gs_free_req(ept, usb_req);
	}

	*ch = read_ch;
	return 0;
}

static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count)
{
	struct gs_port	*port = tty->driver_data;
	unsigned long	flags;

	pr_vdebug("gs_write: ttyGS%d (%p) writing %d bytes\n",
			port->port_num, tty, count);

	spin_lock_irqsave(&port->port_lock, flags);
	if (count)
		count = kfifo_in(&port->port_write_buf, buf, count);
	/* treat count == 0 as flush_chars() */
	if (port->port_usb)
		gs_start_tx(port);
	spin_unlock_irqrestore(&port->port_lock, flags);

	return count;
}

/* undo side effects of setting TTY_THROTTLED */
static void gs_unthrottle(struct tty_struct *tty)
{
	struct gs_port		*port = tty->driver_data;
	unsigned long		flags;

	if(port == NULL)
		return;
	spin_lock_irqsave(&port->port_lock, flags);
	if (port->port_usb) {
		/* Kickstart read queue processing.  We don't do xon/xoff,
		 * rts/cts, or other handshaking with the host, but if the
		 * read queue backs up enough we'll be NAKing OUT packets.
		 */
		tasklet_schedule(&port->push);
		pr_vdebug(PREFIX "%d: unthrottle\n", port->port_num);
	}
	spin_unlock_irqrestore(&port->port_lock, flags);
}

/**
 * gs_poll_read_complete
 */
static void gs_poll_read_complete(struct usb_ep *ep,
		struct usb_request *req) {
	switch (req->status) {
	case 0:
		/* get data */
		console_buf_len = req->actual;
		console_buf_read = 0;
		memcpy(console_buf, req->buf, req->actual);
		console_buf[req->actual] = '\0';
		pr_vdebug("[%s] len = %d\n", console_buf, console_buf_len);
		break;

	default:
		pr_err("%s: unexpected status error, status=%d\n",
				__func__, req->status);
		break;
	}
}

static int gs_write_room(struct tty_struct *tty)
{
	struct gs_port	*port = tty->driver_data;
	unsigned long	flags;
	/* if usb not connect, return room available;
	   to avoid thread in sleep */
	int		room = WRITE_BUF_SIZE - 1;

	spin_lock_irqsave(&port->port_lock, flags);
	if (port->port_usb)
		room = gs_buf_space_avail(&port->port_write_buf);
	spin_unlock_irqrestore(&port->port_lock, flags);

	pr_vdebug("gs_write_room: (%d,%p) room=%d\n",
		port->port_num, tty, room);

	return room;
}

/**
 * gserial_disconnect - notify TTY I/O glue that USB link is inactive
 * @gser: the function, on which gserial_connect() was called
 * Context: any (usually from irq)
 *
 * This is called to deactivate endpoints and let the TTY layer know
 * that the connection went inactive ... not unlike "hangup".
 *
 * On return, the state is as if gserial_connect() had never been called;
 * there is no active USB I/O on these endpoints.
 */
void gserial_disconnect(struct gserial *gser)
{
	struct gs_port	*port = gser->ioport;
	unsigned long	flags;
	pr_vdebug("%s\n", __func__);

	if (!port)
		return;

	/* tell the TTY glue not to do I/O here any more */
	spin_lock_irqsave(&port->port_lock, flags);

	/* REVISIT as above: how best to track this? */
	port->port_line_coding = gser->port_line_coding;

	port->port_usb = NULL;
	gser->ioport = NULL;
#if 0
	if (port->open_count > 0 || port->openclose) {
		wake_up_interruptible(&port->drain_wait);
		if (port->port_tty)
			tty_hangup(port->port_tty);
	}
#endif
	spin_unlock_irqrestore(&port->port_lock, flags);

	/* disable endpoints, aborting down any active I/O */
	usb_ep_fifo_flush(gser->out);
	usb_ep_fifo_flush(gser->in);
	usb_ep_disable(gser->out);
	gser->out->driver_data = NULL;

	usb_ep_disable(gser->in);
	gser->in->driver_data = NULL;

	/* finally, free any unused/unusable I/O buffers */
	spin_lock_irqsave(&port->port_lock, flags);
	if (port->open_count == 0 && !port->openclose)
		gs_buf_free(&port->port_write_buf);
	gs_free_requests(gser->out, &port->read_pool);
	gs_free_requests(gser->out, &port->read_queue);
	gs_free_requests(gser->in, &port->write_pool);
	spin_unlock_irqrestore(&port->port_lock, flags);
}

static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
{
	struct gs_port	*port = ep->driver_data;
	unsigned long flags;
	pr_vdebug("%s: %d bytes\n", __func__, req->actual);

	spin_lock_irqsave(&port->port_lock, flags);
	list_add(&req->list, &port->write_pool);

	switch (req->status) {
	default:
		/* presumably a transient fault */
		pr_warning("%s: unexpected %s status %d\n",
				__func__, ep->name, req->status);
		/* FALL THROUGH */
	case 0:
		/* normal completion */
		if (port->port_usb)
			gs_start_tx(port);
		break;

	case -ESHUTDOWN:
		/* disconnect */
		printk("%s: ESHUTDOWN\n", __func__);
		break;
	case -ENODEV:
		spin_lock(&port->port_lock);
		printk("%s: ENODEV\n", __func__);
		list_add_tail(&req->list, &port->read_pool);
		/* Implemented handling in future if needed */
		spin_unlock(&port->port_lock);
		break;

		spin_lock(&port->port_lock);
		list_add_tail(&req->list, &port->read_pool);
		printk(KERN_ERR
		"gs_read_complete: unexpected status error, status=%d\n",
			req->status);
		spin_unlock(&port->port_lock);
		/* goto requeue; */
		break;
	}
}

static void gs_flush_chars(struct tty_struct *tty)
{
	struct gs_port	*port = tty->driver_data;
	unsigned long	flags;

	//ALPS00423739
	if(!port)
	{
		printk("ERROR!!! port is closed!! %s, line %d: port = %p\n", __func__, __LINE__, port);
		/*abort immediately after disconnect */
		return;
	}
	//ALPS00423739

	pr_vdebug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);

	spin_lock_irqsave(&port->port_lock, flags);
	if (port->port_usb)
		gs_start_tx(port);
	spin_unlock_irqrestore(&port->port_lock, flags);
}

/**
 * gserial_cleanup - remove TTY-over-USB driver and devices
 * Context: may sleep
 *
 * This is called to free all resources allocated by @gserial_setup().
 * Accordingly, it may need to wait until some open /dev/ files have
 * closed.
 *
 * The caller must have issued @gserial_disconnect() for any ports
 * that had previously been connected, so that there is never any
 * I/O pending when it's called.
 */
void gserial_cleanup(void)
{
	unsigned	i;
	struct gs_port	*port;

    /* don't need to free console tty - port0 */
	if (gs_console_tty_driver)
	    tty_unregister_device(gs_console_tty_driver, 0);

	if (!gs_tty_driver)
		return;

	/* start sysfs and /dev/ttyGS* node removal */
	for (i = 1; i < n_ports; i++)
		tty_unregister_device(gs_tty_driver, i-1);

	for (i = 1; i < n_ports; i++) {
		/* prevent new opens */
		mutex_lock(&ports[i].lock);
		port = ports[i].port;
		ports[i].port = NULL;
		mutex_unlock(&ports[i].lock);

		tasklet_kill(&port->push);

		/* wait for old opens to finish */
		wait_event(port->close_wait, gs_closed(port));

		WARN_ON(port->port_usb != NULL);

		kfree(port);
	}
	n_ports = 0;

	tty_unregister_driver(gs_tty_driver);
	put_tty_driver(gs_tty_driver);
	gs_tty_driver = NULL;

	pr_vdebug("%s: cleaned up ttyGS* support\n", __func__);
}

static int at_write(struct tty_struct *tty, const unsigned char *buf, int count)
{
    struct gdata_port *port = tty->driver_data;
    int avail;
    struct sk_buff *skb;
    int status;

    pr_vdebug("at_write: ttyGS%d (%p) writing %d bytes\n",
            port->port_num, tty, count);

    avail = test_bit(CH_OPENED, &port->bridge_sts);
    /* if no space, we'll have to setup a notification later to wake up the
     * tty framework when space becomes avaliable
     */
    if (!avail) {
        pr_debug("at_write: avail(0)\n");
        return 0;
    }

#ifdef VERBOSE_DEBUG
    print_hex_dump(KERN_DEBUG, "fromatd:", DUMP_PREFIX_OFFSET, 16, 1, buf, count, 1);
#endif

    skb = alloc_skb(count, GFP_ATOMIC);
    if (!skb) {
        pr_debug("at_write: ENOMEM\n");
        return -ENOMEM;
    }
    memcpy(skb->data, buf, count);
    skb->len = count;
    status = ghsic_data_receive(port, skb, count);
    if (status) {
        pr_debug("at_write: status(%d)\n", status);
        return status;
    }

    pr_debug("at_write: return(%d)\n", count);
    return count;
}

static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count)
{
	struct gs_port	*port = tty->driver_data;
	unsigned long	flags;
	int		status;

	pr_vdebug("gs_write: ttyGS%d (%p) writing %d bytes\n",
			port->port_num, tty, count);

	spin_lock_irqsave(&port->port_lock, flags);
	if (unlikely(!port->open_count)) {
	    spin_unlock_irqrestore(&port->port_lock, flags);
        return -EINVAL;
    }
	if (unlikely(!port->port_usb || port->is_suspend)) {
	    port->stat_write_not_conn++;
	    spin_unlock_irqrestore(&port->port_lock, flags);
        return -ESHUTDOWN;
    }
	/*
	 * we don't have enough room for some data
	 * may be the host don't start read, so drop the data.
	 * otherwise the printed thread may pending forever.
	 */
	if (!port->line_state_on && list_empty(&port->write_pool)) {
	    port->stat_write_no_mem++;
	    spin_unlock_irqrestore(&port->port_lock, flags);
	    return -ENOMEM;
	}
	if (count)
		count = gs_buf_put(&port->port_write_buf, buf, count);
	/* treat count == 0 as flush_chars() */
	if (port->port_usb)
		status = gs_start_tx(port);/* [false alarm]:fortify disable */
	spin_unlock_irqrestore(&port->port_lock, flags);

	return count;
}

/* undo side effects of setting TTY_THROTTLED */
static void gs_unthrottle(struct tty_struct *tty)
{
	struct gs_port		*port = tty->driver_data;
	unsigned long		flags;

	/*
	 * tty's driver data is set to NULL during port close.  Nothing
	 * to do here.
	 */
	if (!port)
		return;

	spin_lock_irqsave(&port->port_lock, flags);
	if (port->port_usb) {
		/* Kickstart read queue processing.  We don't do xon/xoff,
		 * rts/cts, or other handshaking with the host, but if the
		 * read queue backs up enough we'll be NAKing OUT packets.
		 */
		queue_work(gserial_wq, &port->push);
		pr_vdebug(PREFIX "%d: unthrottle\n", port->port_num);
	}
	spin_unlock_irqrestore(&port->port_lock, flags);
}

static void gs_complete_out(struct usb_ep *ep, struct usb_request *req)
{
	struct gscons_info *info = &gscons_info;

	switch (req->status) {
	default:
		pr_warn("%s: unexpected %s status %d\n",
			__func__, ep->name, req->status);
		/* fall through */
	case 0:
		/* normal completion */
		spin_lock(&info->con_lock);
		info->req_busy = 0;
		spin_unlock(&info->con_lock);

		wake_up_process(info->console_thread);
		break;
	case -ESHUTDOWN:
		/* disconnect */
		pr_vdebug("%s: %s shutdown\n", __func__, ep->name);
		break;
	}
}

static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count)
{
	struct gs_port	*port = tty->driver_data;
	unsigned long	flags;
	int		status;

#ifdef CONFIG_USB_G_LGE_ANDROID
	if (!port)
		return 0;
#endif

	pr_vdebug("gs_write: ttyGS%d (%p) writing %d bytes\n",
			port->port_num, tty, count);

	spin_lock_irqsave(&port->port_lock, flags);
	if (count)
		count = gs_buf_put(&port->port_write_buf, buf, count);
	/* treat count == 0 as flush_chars() */
	if (port->port_usb)
		status = gs_start_tx(port);
	spin_unlock_irqrestore(&port->port_lock, flags);

	return count;
}

static int gs_chars_in_buffer(struct tty_struct *tty)
{
	struct gs_port	*port = tty->driver_data;
	unsigned long	flags;
	int		chars = 0;

	//ALPS00423739
	if(!port)
	{
		printk("ERROR!!! port is closed!! %s, line %d: port = %p\n", __func__, __LINE__, port);
		/*abort immediately after disconnect */
		return -EINVAL;
	}
	//ALPS00423739

	spin_lock_irqsave(&port->port_lock, flags);
	chars = gs_buf_data_avail(&port->port_write_buf);
	spin_unlock_irqrestore(&port->port_lock, flags);

	pr_vdebug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
		port->port_num, tty, chars);

	return chars;
}