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 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(); }
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; }
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; }
/* * 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 int nmi5625_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; struct device *dev; func_enter(); if (!already_init) { memset(&nd, 0, sizeof(struct nmi_5625_dev)); /** initialize mutex **/ mutex_init(&nd.mu); /** register our driver **/ if ((ret = alloc_chrdev_region (&nd.devn, 0, 1, "nmi")) < 0) { dPrint(N_ERR, "nmi: failed unable to get major...%d\n", ret); goto _fail_; } dPrint(N_INFO, "nmi:dynamic major(%d),minor(%d)\n", MAJOR(nd.devn), MINOR(nd.devn)); cdev_init(&nd.cdv, &nmi5625_fops); nd.cdv.owner = THIS_MODULE; ret = cdev_add(&nd.cdv, nd.devn, 1); if (ret) { dPrint(N_ERR, "nmi: failed to add device...%d\n", ret); goto _fail_; } nd.tv_class = class_create(THIS_MODULE, "atv"); if (IS_ERR(nd.tv_class)) { dPrint(N_ERR, "nmi: failed to create the atv class\n"); } dev = device_create(nd.tv_class, NULL, nd.devn, NULL, "nmi"); if (IS_ERR(dev)) { dPrint(N_ERR, "nmi: failed to create device\n"); } device_create_file(dev, &dev_attr_ant); /*User interface end */ static const struct file_operations nmi_proc_fops = { .write = nmi_status_write_proc, .read = nmi_status_read_proc, }; //kangting nmi_status_proc = proc_create(NMI60X_STATUS, 0666, NULL, &nmi_proc_fops); if (nmi_status_proc) { //nmi_status_proc->read_proc = nmi_status_read_proc; //nmi_status_proc->write_proc = nmi_status_write_proc; } else { dPrint(N_ERR,"add create_proc_entry %s fail \n",NMI60X_STATUS); } //ting.kang already_init = 1; }
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() */
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; }
static int xspi_release(struct inode *inode, struct file *filp) { struct xspi_instance *dev = filp->private_data; func_enter(); if (down_interruptible(&dev->sem)) return -EINTR; if (--dev->use_count == 0) { /* This was the last closer: stop the device and free the IRQ */ if (wait_event_interruptible(dev->waitq, XSpi_Stop(&dev->Spi) != XST_DEVICE_BUSY) != 0) { /* Abort transfer by brute force */ XSpi_Abort(&dev->Spi); } disable_irq(dev->irq); free_irq(dev->irq, &dev->Spi); } up(&dev->sem); return 0; }
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 (); }
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 xspi_open(struct inode *inode, struct file *filp) { int retval = 0; struct xspi_instance *dev; func_enter(); dev = container_of(inode->i_cdev, struct xspi_instance, cdev); filp->private_data = dev; /* for other methods */ if (dev == NULL) return -ENODEV; if (down_interruptible(&dev->sem)) return -EINTR; while (dev->use_count++ == 0) { /* * This was the first opener; we need to get the IRQ, * and to setup the device as master. */ retval = request_irq(dev->irq, xspi_isr, 0, XSPI_NAME, &dev->Spi); if (retval != 0) { printk(KERN_ERR XSPI_NAME "%d: Could not allocate interrupt %d.\n", dev->device_id, dev->irq); break; } if (XSpi_SetOptions(&dev->Spi, XSPI_DEFAULT_OPTIONS) != XST_SUCCESS) { printk(KERN_ERR XSPI_NAME "%d: Could not set device options.\n", dev->device_id); free_irq(dev->irq, &dev->Spi); retval = -EIO; break; } if (XSpi_Start(&dev->Spi) != XST_SUCCESS) { printk(KERN_ERR XSPI_NAME "%d: Could not start the device.\n", dev->device_id); free_irq(dev->irq, &dev->Spi); retval = -EIO; break; } break; } if (retval != 0) --dev->use_count; up(&dev->sem); return retval; }
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; }
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 (); }
/* 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 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(); }
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; }
/* * 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(); }
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 (); }
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; }
static int nmi5625_remove(struct i2c_client *client) { int ret = 0; func_enter(); nd.i2c_client_atv = NULL; func_exit(); return ret; }
/* * 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(); }
/* * ------------------------------------------------------------------------- * unifi_reset_state * * Ensure that a MAC address has been set. * Send the MLME-RESET signal. * This must be called at least once before starting to do any * network activities (e.g. scan, join etc). * * Arguments: * priv Pointer to device private context struct * macaddr Pointer to chip MAC address. * If this is FF:FF:FF:FF:FF:FF it will be replaced * with the MAC address from the chip. * set_default_mib 1 if the f/w must reset the MIB to the default values * 0 otherwise * * Returns: * 0 on success, an error code otherwise. * ------------------------------------------------------------------------- */ int unifi_reset_state(unifi_priv_t *priv, unsigned char *macaddr, unsigned char set_default_mib) { int r = 0; func_enter(); #ifdef CSR_SUPPORT_WEXT /* The reset clears any 802.11 association. */ priv->wext_conf.flag_associated = 0; #endif func_exit(); return r; } /* unifi_reset_state() */
/* * --------------------------------------------------------------------------- * unifi_fw_read_stop * * Called when the HIP driver has finished using the loader or * the firmware file. * The firmware buffer may be released now. * * Arguments: * ospriv Pointer to driver context. * dlpriv The pointer returned by unifi_fw_read_start() * * --------------------------------------------------------------------------- */ void unifi_fw_read_stop(void *ospriv, void *dlpriv) { unifi_priv_t *priv = (unifi_priv_t*)ospriv; struct dlpriv *dl_struct = (struct dlpriv *)dlpriv; func_enter(); if (dl_struct != NULL) { if (dl_struct->dl_data != NULL) { unifi_trace(priv, UDBG2, "Release f/w buffer %p, %d bytes\n", dl_struct->dl_data, dl_struct->dl_len); } uf_release_firmware(priv, dl_struct); } func_exit(); } /* unifi_fw_read_stop() */
/* * --------------------------------------------------------------------------- * 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; }