static CsrResult signal_buffer_init(unifi_priv_t * priv, int size)
{
int i;
func_enter();
priv->rxSignalBuffer.writePointer =
priv->rxSignalBuffer.readPointer = 0;
priv->rxSignalBuffer.size = size;
/* Allocating Memory for Signal primitive pointer */
for(i=0; i<size; i++)
{
priv->rxSignalBuffer.rx_buff[i].sig_len=0;
priv->rxSignalBuffer.rx_buff[i].bufptr = CsrMemAlloc(UNIFI_PACKED_SIGBUF_SIZE);
if (priv->rxSignalBuffer.rx_buff[i].bufptr == NULL)
{
int j;
unifi_error(priv,"signal_buffer_init:Failed to Allocate shared memory for T-H signals \n");
for(j=0;j<i;j++)
{
priv->rxSignalBuffer.rx_buff[j].sig_len=0;
CsrMemFree(priv->rxSignalBuffer.rx_buff[j].bufptr);
priv->rxSignalBuffer.rx_buff[j].bufptr = NULL;
}
func_exit();
return -1;
}
}
func_exit();
return 0;
}
int
uf_sme_init(unifi_priv_t *priv)
{
func_enter();
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)
sema_init(&priv->mlme_blocking_mutex, 1);
#else
init_MUTEX(&priv->mlme_blocking_mutex);
#endif
#ifdef CSR_SUPPORT_WEXT
{
int r = uf_init_wext_interface(priv);
if (r != 0) {
func_exit();
return r;
}
}
#endif
func_exit();
return 0;
} /* uf_sme_init() */
/* Must be called with interrupts enabled */
int gs_init_port(struct gs_port *port)
{
unsigned long flags;
unsigned long page;
func_enter ();
if (!tmp_buf) {
page = get_zeroed_page(GFP_KERNEL);
spin_lock_irqsave (&port->driver_lock, flags); /* Don't expect this to make a difference. */
if (tmp_buf)
free_page(page);
else
tmp_buf = (unsigned char *) page;
spin_unlock_irqrestore (&port->driver_lock, flags);
if (!tmp_buf) {
func_exit ();
return -ENOMEM;
}
}
if (port->flags & ASYNC_INITIALIZED) {
func_exit ();
return 0;
}
if (!port->xmit_buf) {
/* We may sleep in get_zeroed_page() */
unsigned long tmp;
tmp = get_zeroed_page(GFP_KERNEL);
spin_lock_irqsave (&port->driver_lock, flags);
if (port->xmit_buf)
free_page (tmp);
else
port->xmit_buf = (unsigned char *) tmp;
spin_unlock_irqrestore(&port->driver_lock, flags);
if (!port->xmit_buf) {
func_exit ();
return -ENOMEM;
}
}
spin_lock_irqsave (&port->driver_lock, flags);
if (port->tty)
clear_bit(TTY_IO_ERROR, &port->tty->flags);
init_MUTEX(&port->port_write_sem);
port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
spin_unlock_irqrestore(&port->driver_lock, flags);
gs_set_termios(port->tty, NULL);
spin_lock_irqsave (&port->driver_lock, flags);
port->flags |= ASYNC_INITIALIZED;
port->flags &= ~GS_TX_INTEN;
spin_unlock_irqrestore(&port->driver_lock, flags);
func_exit ();
return 0;
}
int gs_put_char(struct tty_struct * tty, unsigned char ch)
{
struct gs_port *port;
func_enter ();
if (!tty) return 0;
port = tty->driver_data;
if (!port) return 0;
if (! (port->flags & ASYNC_INITIALIZED)) return 0;
/* Take a lock on the serial tranmit buffer! */
mutex_lock(& port->port_write_mutex);
if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
/* Sorry, buffer is full, drop character. Update statistics???? -- REW */
mutex_unlock(&port->port_write_mutex);
return 0;
}
port->xmit_buf[port->xmit_head++] = ch;
port->xmit_head &= SERIAL_XMIT_SIZE - 1;
port->xmit_cnt++; /* Characters in buffer */
mutex_unlock(&port->port_write_mutex);
func_exit ();
return 1;
}
void gs_shutdown_port (struct gs_port *port)
{
unsigned long flags;
func_enter();
if (!port) return;
if (!(port->flags & ASYNC_INITIALIZED))
return;
save_flags (flags);
cli ();
if (port->xmit_buf) {
free_page((unsigned long) port->xmit_buf);
port->xmit_buf = 0;
}
if (port->tty)
set_bit(TTY_IO_ERROR, &port->tty->flags);
port->rd->shutdown_port (port);
port->flags &= ~ASYNC_INITIALIZED;
restore_flags (flags);
func_exit();
}
void gs_put_char(struct tty_struct * tty, unsigned char ch)
{
struct gs_port *port;
DECL
func_enter ();
if (!tty) return;
port = tty->driver_data;
if (!port) return;
if (! (port->flags & ASYNC_INITIALIZED)) return;
/* Take a lock on the serial tranmit buffer! */
LOCKIT;
if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
/* Sorry, buffer is full, drop character. Update statistics???? -- REW */
RELEASEIT;
return;
}
port->xmit_buf[port->xmit_head++] = ch;
port->xmit_head &= SERIAL_XMIT_SIZE - 1;
port->xmit_cnt++; /* Characters in buffer */
RELEASEIT;
func_exit ();
}
/*
* Open the serial port
*/
static int rs_open(struct tty_struct * tty, struct file * filp)
{
int retval;
func_enter();
if(!rs_initialized) {
return -EIO;
}
if(MINOR(tty->device) - tty->driver.minor_start) {
return -ENODEV;
}
rs_dprintk(TX3912_UART_DEBUG_OPEN, "Serial opening...\n");
tty->driver_data = rs_port;
rs_port->gs.tty = tty;
rs_port->gs.count++;
/*
* Start up serial port
*/
retval = gs_init_port(&rs_port->gs);
rs_dprintk(TX3912_UART_DEBUG_OPEN, "Finished gs_init...\n");
if(retval) {
rs_port->gs.count--;
return retval;
}
rs_port->gs.flags |= GS_ACTIVE;
if(rs_port->gs.count == 1) {
MOD_INC_USE_COUNT;
}
rs_enable_rx_interrupts(rs_port);
rs_enable_tx_interrupts(rs_port);
retval = gs_block_til_ready(&rs_port->gs, filp);
if(retval) {
MOD_DEC_USE_COUNT;
rs_port->gs.count--;
return retval;
}
if((rs_port->gs.count == 1) &&
(rs_port->gs.flags & ASYNC_SPLIT_TERMIOS)) {
if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
*tty->termios = rs_port->gs.normal_termios;
else
*tty->termios = rs_port->gs.callout_termios;
rs_set_real_termios(rs_port);
}
rs_port->gs.session = current->session;
rs_port->gs.pgrp = current->pgrp;
func_exit();
return 0;
}
static void gs_shutdown_port (struct gs_port *port)
{
unsigned long flags;
func_enter();
if (!port) return;
if (!(port->flags & ASYNC_INITIALIZED))
return;
spin_lock_irqsave(&port->driver_lock, flags);
if (port->xmit_buf) {
free_page((unsigned long) port->xmit_buf);
port->xmit_buf = NULL;
}
if (port->tty)
set_bit(TTY_IO_ERROR, &port->tty->flags);
port->rd->shutdown_port (port);
port->flags &= ~ASYNC_INITIALIZED;
spin_unlock_irqrestore(&port->driver_lock, flags);
func_exit();
}
void executa_comando(struct command_t *cmd) //execução do comando
{
const char *cmdname = cmd->argv[0];
glob_t *globbuf = (glob_t *) malloc(sizeof(glob_t));
globbuf = expande_glob(cmd);
if(strcmp(cmdname,"cd") == 0) func_cd(cmd->argc,cmd->argv); //comandos internos - sem uso do fork()
else if(strcmp(cmdname,"pwd") == 0) func_pwd();
if(strcmp(cmdname,"exit") == 0) func_exit();
else{ //uso do fork aqui
//pid_t cpid = fork();
int wait_pid;
int status;
int lastchild;
if (cpid < 0) {
perror("fork");
exit(127);
}
else if (cpid > 0) { /* pai */
lastchild = cpid;
wait_pid = wait(&status);
}
else { /* filho */
if(globbuf == NULL) execvp(cmdname, cmd->argv);
else execvp(cmdname, globbuf->gl_pathv);
perror("exec");
exit(127);
}
if(wait_pid < 0) perror("wait");
}
}
static int nmi5625_release(struct inode * inode, struct file * file)
{
int ret = 0;
struct nmi_5625_dev *d = file->private_data;
func_enter();
dPrint(N_INFO, "LHJ nmi: nmi5625_release %d \n",already_init);
//kdCISModulePowerOn(DUAL_CAMERA_SUB_SENSOR,SENSOR_DRVNAME_DB8V63L_YUV,false,"atv");
/*
if(TRUE != hwPowerDown(CAMERA_POWER_VCAM_A,"mode_name")) {
// PK_DBG("[CAMERA SENSOR] Fail to OFF analog power\n");
//return -EIO;
return ret;
}
*/
//Disable I2D Data pin
#ifdef NMI_USE_MTK_I2C_DMA
if(gpDMABuf_va){
dma_free_coherent(NULL, 4096, gpDMABuf_va, gpDMABuf_pa);
gpDMABuf_va = NULL;
gpDMABuf_pa = NULL;
}
#endif
#ifndef NMI_HW_I2C
nmi_i2c_deinit();
#endif
func_exit();
return ret;
}
void gs_close(struct tty_struct * tty, struct file * filp)
{
unsigned long flags;
struct gs_port *port;
func_enter ();
port = tty->driver_data;
if (!port) return;
if (!port->port.tty) {
/* This seems to happen when this is called from vhangup. */
gs_dprintk (GS_DEBUG_CLOSE, "gs: Odd: port->port.tty is NULL\n");
port->port.tty = tty;
}
spin_lock_irqsave(&port->port.lock, flags);
if (tty_hung_up_p(filp)) {
spin_unlock_irqrestore(&port->port.lock, flags);
if (port->rd->hungup)
port->rd->hungup (port);
func_exit ();
return;
}
if ((tty->count == 1) && (port->port.count != 1)) {
;
" tty->count is 1, port count is %d\n", port, port->port.count);
port->port.count = 1;
}
static int rs_init_drivers(void)
{
int error;
func_enter();
memset(&rs_driver, 0, sizeof(rs_driver));
rs_driver.magic = TTY_DRIVER_MAGIC;
rs_driver.driver_name = "serial";
rs_driver.name = "ttyS";
rs_driver.major = TTY_MAJOR;
rs_driver.minor_start = 64;
rs_driver.num = TX3912_UART_NPORTS;
rs_driver.type = TTY_DRIVER_TYPE_SERIAL;
rs_driver.subtype = SERIAL_TYPE_NORMAL;
rs_driver.init_termios = tty_std_termios;
rs_driver.init_termios.c_cflag =
B115200 | CS8 | CREAD | HUPCL | CLOCAL;
rs_driver.refcount = &rs_refcount;
rs_driver.table = rs_table;
rs_driver.termios = rs_termios;
rs_driver.termios_locked = rs_termios_locked;
rs_driver.open = rs_open;
rs_driver.close = gs_close;
rs_driver.write = gs_write;
rs_driver.put_char = gs_put_char;
rs_driver.flush_chars = gs_flush_chars;
rs_driver.write_room = gs_write_room;
rs_driver.chars_in_buffer = gs_chars_in_buffer;
rs_driver.flush_buffer = gs_flush_buffer;
rs_driver.ioctl = rs_ioctl;
rs_driver.throttle = rs_throttle;
rs_driver.unthrottle = rs_unthrottle;
rs_driver.set_termios = gs_set_termios;
rs_driver.stop = gs_stop;
rs_driver.start = gs_start;
rs_driver.hangup = gs_hangup;
rs_callout_driver = rs_driver;
rs_callout_driver.name = "cua";
rs_callout_driver.major = TTYAUX_MAJOR;
rs_callout_driver.subtype = SERIAL_TYPE_CALLOUT;
if ((error = tty_register_driver(&rs_driver))) {
printk(KERN_ERR "Couldn't register serial driver, error = %d\n",
error);
return 1;
}
if ((error = tty_register_driver(&rs_callout_driver))) {
tty_unregister_driver(&rs_driver);
printk(KERN_ERR "Couldn't register callout driver, error = %d\n",
error);
return 1;
}
func_exit();
return 0;
}
/*
* ---------------------------------------------------------------------------
* unifi_fw_open_buffer
*
* Returns a handle for a buffer dynamically allocated by the driver,
* e.g. into which a firmware file may have been converted from another format
* which is the case with some production test images.
*
* The handle may then be used by unifi_fw_read() to access the contents of
* the buffer.
*
* Arguments:
* ospriv Pointer to driver context.
* fwbuf Buffer containing firmware image
* len Length of buffer in bytes
*
* Returns
* Handle for buffer, or NULL on error
* ---------------------------------------------------------------------------
*/
void *
unifi_fw_open_buffer(void *ospriv, void *fwbuf, CsrUint32 len)
{
unifi_priv_t *priv = (unifi_priv_t*)ospriv;
func_enter();
if (fwbuf == NULL) {
func_exit();
return NULL;
}
priv->fw_conv.dl_data = fwbuf;
priv->fw_conv.dl_len = len;
priv->fw_conv.fw_desc = NULL; /* No OS f/w resource is associated */
func_exit();
return &priv->fw_conv;
}
int gs_chars_in_buffer(struct tty_struct *tty)
{
struct gs_port *port = tty->driver_data;
func_enter ();
func_exit ();
return port->xmit_cnt;
}
static void rs_close (void *ptr)
{
func_enter ();
/* Anything to do here? */
MOD_DEC_USE_COUNT;
func_exit ();
}
int
sme_queue_message(unifi_priv_t *priv, u8 *buffer, int length)
{
ul_client_t *pcli;
udi_log_t *logptr;
udi_msg_t *msgptr;
u8 *p;
func_enter();
/* Just a sanity check */
if ((buffer == NULL) || (length <= 0)) {
return -EINVAL;
}
pcli = priv->sme_cli;
if (pcli == NULL) {
CsrPfree(buffer);
return -EINVAL;
}
/* Allocate log structure plus actual signal. */
logptr = (udi_log_t *)kmalloc(sizeof(udi_log_t) + length, GFP_KERNEL);
if (logptr == NULL) {
unifi_error(priv, "Failed to allocate %d bytes for an SME message\n",
sizeof(udi_log_t) + length);
CsrPfree(buffer);
return -ENOMEM;
}
/* Fill in udi_log struct */
INIT_LIST_HEAD(&logptr->q);
msgptr = &logptr->msg;
msgptr->length = sizeof(udi_msg_t) + length;
msgptr->signal_length = length;
/* Copy signal and bulk data to the log */
p = (u8 *)(msgptr + 1);
memcpy(p, buffer, length);
/* Add to tail of log queue */
down(&pcli->udi_sem);
list_add_tail(&logptr->q, &pcli->udi_log);
up(&pcli->udi_sem);
/* Wake any waiting user process */
wake_up_interruptible(&pcli->udi_wq);
/* It is our responsibility to free the buffer allocated in build_packed_*() */
CsrPfree(buffer);
func_exit();
return 0;
} /* sme_queue_message() */
static void rs_shutdown_port (void * ptr)
{
struct rs_port *port = ptr;
func_enter();
port->gs.flags &= ~GS_ACTIVE;
func_exit();
}
/*
* ---------------------------------------------------------------------------
* unifi_fw_read_start
*
* Returns a structure to be passed in unifi_fw_read().
* This structure is an OS specific description of the f/w file.
* In the linux implementation it is a buffer with the f/w and its' length.
* The HIP driver calls this functions to request for the loader or
* the firmware file.
* The structure pointer can be freed when unifi_fw_read_stop() is called.
*
* Arguments:
* ospriv Pointer to driver context.
* is_fw Flag to indicate whether it is the f/w or the loader
* info Versions information. Can be used to determine
* the appropriate f/w file to load.
*
* Returns:
* O on success, non-zero otherwise.
*
* ---------------------------------------------------------------------------
*/
void*
unifi_fw_read_start(void *ospriv, CsrInt8 is_fw, const card_info_t *info)
{
unifi_priv_t *priv = (unifi_priv_t*)ospriv;
CSR_UNUSED(info);
func_enter();
#ifdef ANDROID_BUILD
/* Copy content of info to the priv struct to make it available in the reguest_firmware_files() function */
priv->card_info = *info;
printk("Unifi: Firmware build %d\n", (int) info->fw_build);
#endif
if (is_fw == UNIFI_FW_LOADER) {
/* F/w may have been released after a previous successful download */
if (priv->fw_loader.dl_data == NULL) {
unifi_trace(priv, UDBG2, "Attempt reload of loader f/w\n");
uf_request_firmware_files(priv, UNIFI_FW_LOADER);
}
/* Set up callback struct for readfunc() */
if (priv->fw_loader.dl_data != NULL) {
func_exit();
return &priv->fw_loader;
}
} else if (is_fw == UNIFI_FW_STA) {
/* F/w may have been released after a previous successful download. */
if (priv->fw_sta.dl_data == NULL) {
unifi_trace(priv, UDBG2, "Attempt reload of sta f/w\n");
uf_request_firmware_files(priv, UNIFI_FW_STA);
}
/* Set up callback struct for readfunc() */
if (priv->fw_sta.dl_data != NULL) {
func_exit();
return &priv->fw_sta;
}
} else {
unifi_error(priv, "downloading firmware... unknown request: %d\n", is_fw);
}
func_exit();
return NULL;
} /* unifi_fw_read_start() */
static int rs_set_real_termios (void *ptr)
{
struct rs_port *port = ptr;
int t;
switch (port->gs.baud) {
/* Save some typing work... */
#define e(x) case x:t= TX3912_UART_CTRL2_B ## x ; break
e(300);e(600);e(1200);e(2400);e(4800);e(9600);
e(19200);e(38400);e(57600);e(76800);e(115200);e(230400);
case 0 :t = -1;
break;
default:
/* Can I return "invalid"? */
t = TX3912_UART_CTRL2_B9600;
printk (KERN_INFO "rs: unsupported baud rate: %d.\n", port->gs.baud);
break;
}
#undef e
if (t >= 0) {
/* Jim: Set Hardware Baud rate - there is some good
code in drivers/char/serial.c */
/* Program hardware for parity, data bits, stop bits (note: these are hardcoded to 8N1 */
UartA_Ctrl1 &= 0xf000000f;
UartA_Ctrl1 &= ~(UART_DIS_TXD | SER_SEVEN_BIT | SER_EVEN_PARITY | SER_TWO_STOP);
#define CFLAG port->gs.tty->termios->c_cflag
if (C_PARENB(port->gs.tty)) {
if (!C_PARODD(port->gs.tty))
UartA_Ctrl1 |= SER_EVEN_PARITY;
else
UartA_Ctrl1 |= SER_ODD_PARITY;
}
if ((CFLAG & CSIZE)==CS6)
printk(KERN_ERR "6 bits not supported\n");
if ((CFLAG & CSIZE)==CS5)
printk(KERN_ERR "5 bits not supported\n");
if ((CFLAG & CSIZE)==CS7)
UartA_Ctrl1 |= SER_SEVEN_BIT;
if (C_CSTOPB(port->gs.tty))
UartA_Ctrl1 |= SER_TWO_STOP;
outl(t, port->base + TX3912_UART_CTRL2);
outl(0, port->base + TX3912_UART_DMA_CTRL1);
outl(0, port->base + TX3912_UART_DMA_CTRL2);
UartA_Ctrl1 |= TX3912_UART_CTRL1_UARTON;
/* wait until UARTA is stable */
while (~UartA_Ctrl1 & TX3912_UART_CTRL1_UARTON);
}
func_exit ();
return 0;
}
static int rs_init_portstructs(void)
{
struct rs_port *port;
int i;
/* Debugging */
func_enter();
rs_ports = ckmalloc(TX3912_UART_NPORTS * sizeof (struct rs_port));
if (!rs_ports)
return -ENOMEM;
rs_termios = ckmalloc(TX3912_UART_NPORTS * sizeof (struct termios *));
if (!rs_termios) {
kfree (rs_ports);
return -ENOMEM;
}
rs_termios_locked = ckmalloc(TX3912_UART_NPORTS * sizeof (struct termios *));
if (!rs_termios_locked) {
kfree (rs_ports);
kfree (rs_termios);
return -ENOMEM;
}
/* Adjust the values in the "driver" */
rs_driver.termios = rs_termios;
rs_driver.termios_locked = rs_termios_locked;
port = rs_ports;
for (i=0; i < TX3912_UART_NPORTS;i++) {
rs_dprintk (TX3912_UART_DEBUG_INIT, "initing port %d\n", i);
port->gs.callout_termios = tty_std_termios;
port->gs.normal_termios = tty_std_termios;
port->gs.magic = SERIAL_MAGIC;
port->gs.close_delay = HZ/2;
port->gs.closing_wait = 30 * HZ;
port->gs.rd = &rs_real_driver;
#ifdef NEW_WRITE_LOCKING
port->gs.port_write_sem = MUTEX;
#endif
#ifdef DECLARE_WAITQUEUE
init_waitqueue_head(&port->gs.open_wait);
init_waitqueue_head(&port->gs.close_wait);
#endif
port->base = (i == 0) ? TX3912_UARTA_BASE : TX3912_UARTB_BASE;
port->intshift = (i == 0) ? UARTA_SHIFT : UARTB_SHIFT;
rs_dprintk (TX3912_UART_DEBUG_INIT, "base 0x%08lx intshift %d\n",
port->base, port->intshift);
port++;
}
func_exit();
return 0;
}
/* Must be called with interrupts enabled */
int gs_init_port(struct gs_port *port)
{
unsigned long flags;
func_enter ();
if (port->port.flags & ASYNC_INITIALIZED) {
func_exit ();
return 0;
}
if (!port->xmit_buf) {
/* We may sleep in get_zeroed_page() */
unsigned long tmp;
tmp = get_zeroed_page(GFP_KERNEL);
spin_lock_irqsave (&port->driver_lock, flags);
if (port->xmit_buf)
free_page (tmp);
else
port->xmit_buf = (unsigned char *) tmp;
spin_unlock_irqrestore(&port->driver_lock, flags);
if (!port->xmit_buf) {
func_exit ();
return -ENOMEM;
}
}
spin_lock_irqsave (&port->driver_lock, flags);
if (port->port.tty)
clear_bit(TTY_IO_ERROR, &port->port.tty->flags);
mutex_init(&port->port_write_mutex);
port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
spin_unlock_irqrestore(&port->driver_lock, flags);
gs_set_termios(port->port.tty, NULL);
spin_lock_irqsave (&port->driver_lock, flags);
port->port.flags |= ASYNC_INITIALIZED;
port->port.flags &= ~GS_TX_INTEN;
spin_unlock_irqrestore(&port->driver_lock, flags);
func_exit ();
return 0;
}
/*
* Send xchar
*/
static void rs_send_xchar(struct tty_struct * tty, char ch)
{
func_enter();
rs_port->x_char = ch;
if (ch) {
rs_enable_tx_interrupts(tty);
}
func_exit();
}
static int nmi5625_remove(struct i2c_client *client)
{
int ret = 0;
func_enter();
nd.i2c_client_atv = NULL;
func_exit();
return ret;
}
void gs_flush_chars(struct tty_struct * tty)
{
struct gs_port *port;
func_enter ();
port = tty->driver_data;
if (!port) return;
if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
!port->xmit_buf) {
func_exit ();
return;
}
/* Beats me -- REW */
port->port.flags |= GS_TX_INTEN;
port->rd->enable_tx_interrupts (port);
func_exit ();
}
int gs_write_room(struct tty_struct * tty)
{
struct gs_port *port = tty->driver_data;
int ret;
func_enter ();
ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
if (ret < 0)
ret = 0;
func_exit ();
return ret;
}
void gs_got_break(struct gs_port *port)
{
func_enter ();
tty_insert_flip_char(port->tty, 0, TTY_BREAK);
tty_schedule_flip(port->tty);
if (port->flags & ASYNC_SAK) {
do_SAK (port->tty);
}
func_exit ();
}
/*
* This function is used to send a high-priority XON/XOFF character to
* the device
*/
static void rs_send_xchar(struct tty_struct * tty, char ch)
{
struct rs_port *port = (struct rs_port *)tty->driver_data;
func_enter ();
port->x_char = ch;
if (ch) {
/* Make sure transmit interrupts are on */
rs_enable_tx_interrupts(tty);
}
func_exit();
}
static int gs_real_chars_in_buffer(struct tty_struct *tty)
{
struct gs_port *port;
func_enter ();
port = tty->driver_data;
if (!port->rd) return 0;
if (!port->rd->chars_in_buffer) return 0;
func_exit ();
return port->xmit_cnt + port->rd->chars_in_buffer (port);
}
static __exit void nmi5625_clean(void)
{
func_enter();
i2c_del_driver(&nmi5625_i2c_driver);
if (already_init) {
device_destroy(nd.tv_class, nd.devn);
cdev_del(&nd.cdv);
unregister_chrdev_region(nd.devn, 1);
already_init = 0;
}
func_exit();
}
/*
* Throttle characters as directed by upper tty layer
*/
static void rs_throttle(struct tty_struct * tty)
{
#ifdef TX3912_UART_DEBUG_THROTTLE
char buf[64];
printk("throttle %s: %d....\n", tty_name(tty, buf),
tty->ldisc.chars_in_buffer(tty));
#endif
func_enter();
if (I_IXOFF(tty))
rs_send_xchar(tty, STOP_CHAR(tty));
func_exit();
}
