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;
}
