int cx23888_ir_probe(struct cx23885_dev *dev)
{
struct cx23888_ir_state *state;
struct v4l2_subdev *sd;
struct v4l2_subdev_ir_parameters default_params;
int ret;
state = kzalloc(sizeof(struct cx23888_ir_state), GFP_KERNEL);
if (state == NULL)
return -ENOMEM;
spin_lock_init(&state->rx_kfifo_lock);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)
state->rx_kfifo = kfifo_alloc(CX23888_IR_RX_KFIFO_SIZE, GFP_KERNEL,
&state->rx_kfifo_lock);
if (state->rx_kfifo == NULL)
return -ENOMEM;
#else
if (kfifo_alloc(&state->rx_kfifo, CX23888_IR_RX_KFIFO_SIZE, GFP_KERNEL))
return -ENOMEM;
#endif
state->dev = dev;
state->id = V4L2_IDENT_CX23888_IR;
state->rev = 0;
sd = &state->sd;
v4l2_subdev_init(sd, &cx23888_ir_controller_ops);
v4l2_set_subdevdata(sd, state);
/* FIXME - fix the formatting of dev->v4l2_dev.name and use it */
snprintf(sd->name, sizeof(sd->name), "%s/888-ir", dev->name);
sd->grp_id = CX23885_HW_888_IR;
ret = v4l2_device_register_subdev(&dev->v4l2_dev, sd);
if (ret == 0) {
/*
* Ensure no interrupts arrive from '888 specific conditions,
* since we ignore them in this driver to have commonality with
* similar IR controller cores.
*/
cx23888_ir_write4(dev, CX23888_IR_IRQEN_REG, 0);
mutex_init(&state->rx_params_lock);
memcpy(&default_params, &default_rx_params,
sizeof(struct v4l2_subdev_ir_parameters));
v4l2_subdev_call(sd, ir, rx_s_parameters, &default_params);
mutex_init(&state->tx_params_lock);
memcpy(&default_params, &default_tx_params,
sizeof(struct v4l2_subdev_ir_parameters));
v4l2_subdev_call(sd, ir, tx_s_parameters, &default_params);
} else {
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)
kfifo_free(state->rx_kfifo);
#else
kfifo_free(&state->rx_kfifo);
#endif
}
return ret;
}
static int __init example_init(void)
{
#ifdef DYNAMIC
int ret;
ret = kfifo_alloc(&test, FIFO_SIZE, GFP_KERNEL);
if (ret) {
printk(KERN_ERR "error kfifo_alloc\n");
return ret;
}
#else
INIT_KFIFO(test);
#endif
if (testfunc() < 0) {
#ifdef DYNAMIC
kfifo_free(&test);
#endif
return -EIO;
}
if (proc_create(PROC_FIFO, 0, NULL, &fifo_fops) == NULL) {
#ifdef DYNAMIC
kfifo_free(&test);
#endif
return -ENOMEM;
}
return 0;
}
static int uart16550_release (struct inode * node, struct file *file){
struct device_data *devicedata = file->private_data;
kfifo_free(&(devicedata->data_from_user));
kfifo_free(&(devicedata->data_from_device));
kfree(devicedata->task_user_push_data);
kfree(devicedata->task_user_get_data);
kfree(file->private_data);
return 0;
}
void dvb_hdhomerun_control_exit() {
DEBUG_FUNC(1);
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,32)
kfifo_free(&control_fifo_user);
kfifo_free(&control_fifo_kernel);
#endif
misc_deregister(&hdhomerun_control_device);
}
/*
* unreg_dev() - unregisters a device & frees resources
*/
void unreg_dev(int minor, int irq)
{
int base_addr = devs[minor].base_addr;
release_region(base_addr, COM_NR_PORTS);
free_irq(irq, &devs[minor]);
cdev_del(&devs[minor].cdev);
kfifo_free(&devs[minor].read_buffer);
kfifo_free(&devs[minor].write_buffer);
unregister_chrdev_region(MKDEV(major, minor), 1);
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//LaunchAudioHalThread
// Clean up: free KFIFO
//----------------------------------------------------------------
int TerminateAudioHalThread(void)
{
if(sgThreadData.pWorkqueue_AudioControl)
{
flush_workqueue(sgThreadData.pWorkqueue_AudioControl);
destroy_workqueue(sgThreadData.pWorkqueue_AudioControl);
}
kfifo_free(&sgThreadData.m_pkfifo);
kfifo_free(&sgThreadData.m_pkfifo_out);
return 0;
}
void threadrw_release(struct stream_buf_s *stbuf)
{
struct threadrw_write_task *task = stbuf->write_thread;
if (task) {
wake_up_interruptible(&task->wq);
cancel_delayed_work_sync(&task->write_work);
free_task_buffers(task);
kfifo_free(&task->freefifo);
kfifo_free(&task->datafifo);
vfree(task);
}
stbuf->write_thread = NULL;
return;
}
int kfifo_ready(struct kfifo *kfifo)
{
if (kfifo) {
return kfifo_size(kfifo) - kfifo_free(kfifo);
}
return 0;
}
static __init int dccpprobe_init(void)
{
int ret = -ENOMEM;
init_waitqueue_head(&dccpw.wait);
spin_lock_init(&dccpw.lock);
dccpw.fifo = kfifo_alloc(bufsize, GFP_KERNEL, &dccpw.lock);
if (IS_ERR(dccpw.fifo))
return PTR_ERR(dccpw.fifo);
if (!proc_net_fops_create(procname, S_IRUSR, &dccpprobe_fops))
goto err0;
ret = register_jprobe(&dccp_send_probe);
if (ret)
goto err1;
pr_info("DCCP watch registered (port=%d)\n", port);
return 0;
err1:
proc_net_remove(procname);
err0:
kfifo_free(dccpw.fifo);
return ret;
}
int IO_irq_release(struct inode *inode, struct file *filp)
{
free_irq(IO_irq_devices->IO_irq1, NULL);
free_irq(IO_irq_devices->IO_irq2, NULL);
free_irq(IO_irq_devices->IO_irq3, NULL);
free_irq(IO_irq_devices->IO_irq4, NULL);
s3c2410_gpio_cfgpin(S3C2410_GPG11, S3C2410_GPG11_INP);
s3c2410_gpio_cfgpin(S3C2410_GPG3, S3C2410_GPG3_INP);
s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_INP);
s3c2410_gpio_cfgpin(S3C2410_GPF0, S3C2410_GPF0_INP);
IO_irq_devices->IO_status = 0 ;
tasklet_kill(&keytask);
if(!cancel_delayed_work(&irq_work_delay)) flush_workqueue(tekkamanwork);
destroy_workqueue(tekkamanwork);
kfifo_free(tekkamanfifo);
kfree(tekkamantmp);
kfree(tekkamanbuf);
atomic_inc(&IO_irq_available); /* release the device */
wake_up_interruptible_sync(&IO_irq_wait); /* awake other uid's */
printk( "IO_irq: release ! \n");
return 0;
}
/*----------------------------------------------------------------------------*/
BOOLEAN glUnregisterAmpc(IN P_GLUE_INFO_T prGlueInfo)
{
ASSERT(prGlueInfo);
if (prGlueInfo->rBowInfo.fgIsRegistered == FALSE) {
return FALSE;
} else {
prGlueInfo->rBowInfo.fgIsRegistered = FALSE;
/* 1. free netdev if necessary */
#if CFG_BOW_SEPARATE_DATA_PATH
kalUninitBowDevice(prGlueInfo);
#endif
/* 2. removal of character device */
cdev_del(&(prGlueInfo->rBowInfo.cdev));
/* 3. free kfifo */
/* kfifo_free(prGlueInfo->rBowInfo.prKfifo); */
kfifo_free(&(prGlueInfo->rBowInfo.rKfifo));
/* prGlueInfo->rBowInfo.prKfifo = NULL; */
/* prGlueInfo->rBowInfo.rKfifo = NULL; */
/* 4. free device number */
unregister_chrdev_region(prGlueInfo->rBowInfo.u4DeviceNumber, 1);
return TRUE;
}
} /* end of glUnregisterAmpc */
static void nfs_do_close(struct file_priv *priv)
{
if (priv->fifo)
kfifo_free(priv->fifo);
free(priv);
}
static int tmsi_release_dev(struct tmsi_data* dev) {
int i;
if (!dev)
return -ENODEV;
// Unlink current receiving bulk URB
for (i = 0; i < BULK_RECV_URBS; ++i)
free_urb(dev->bulk_recv_urb[i]);
// Unlink current receiving isochronous URB's
for (i = ISOC_RECV_URBS-1; i>=0; --i)
free_urb(dev->isoc_recv_urb[i]);
if (dev->device_open > 0)
dev->device_open = 0;
// Remove buffer
kfifo_reset(dev->packet_buffer);
kfifo_free(dev->packet_buffer);
up(dev->fifo_sem);
kfree(dev->fifo_sem);
kfree(dev->release_sem);
/* decrement the count on our device */
kref_put(&dev->kref, tmsi_delete);
info("Tmsi device realese() success\n");
dev->releasing = 0;
return 0;
}
static void logi_dj_remove(struct hid_device *hdev)
{
struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
struct dj_device *dj_dev;
int i;
dbg_hid("%s\n", __func__);
cancel_work_sync(&djrcv_dev->work);
hdev->ll_driver->close(hdev);
hid_hw_stop(hdev);
/* I suppose that at this point the only context that can access
* the djrecv_data is this thread as the work item is guaranteed to
* have finished and no more raw_event callbacks should arrive after
* the remove callback was triggered so no locks are put around the
* code below */
for (i = 0; i < (DJ_MAX_PAIRED_DEVICES + DJ_DEVICE_INDEX_MIN); i++) {
dj_dev = djrcv_dev->paired_dj_devices[i];
if (dj_dev != NULL) {
hid_destroy_device(dj_dev->hdev);
kfree(dj_dev);
djrcv_dev->paired_dj_devices[i] = NULL;
}
}
kfifo_free(&djrcv_dev->notif_fifo);
kfree(djrcv_dev);
hid_set_drvdata(hdev, NULL);
}
int test(void)
{
struct kfifo fifo;
int ret, tam;
char *buf;
/* Inicializo la cola y compruebo errores */
ret = kfifo_alloc(&fifo, FIFO_SIZE, GFP_KERNEL);
if (ret) {
printk(KERN_ERR "error kfifo_alloc\n");
return ret;
}
/* Introduzco la cadena Hello en la cola */
kfifo_in(&fifo, "Hello", 5);
/* Introduzco la cadena LIN de la cola */
kfifo_in(&fifo, "LIN", 3);
/* Extraigo la cadena Hello de la cola */
tam = kfifo_out(&fifo, buf, 5);
printk(KERN_INFO "%s", buf);
/* Devuelvo la cadena LIN sin extraerla de la cola */
if (kfifo_peek(&test, buf))
printk(KERN_INFO " %s\n", buf);
/* Elimino la cola */
kfifo_free(&test);
return 0;
}
static void __exit example_exit(void)
{
remove_proc_entry(PROC_FIFO, NULL);
#ifdef DYNAMIC
kfifo_free(&test);
#endif
}
int canClose_driver(CAN_HANDLE fd0)
{
((CANPipe*)fd0)->used = 0;
kfifo_free (((CANPipe*)fd0)->pipe);
return 0;
}
static void logi_dj_remove(struct hid_device *hdev)
{
struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
struct dj_device *dj_dev;
int i;
dbg_hid("%s\n", __func__);
cancel_work_sync(&djrcv_dev->work);
hdev->ll_driver->close(hdev);
hid_hw_stop(hdev);
for (i = 0; i < (DJ_MAX_PAIRED_DEVICES + DJ_DEVICE_INDEX_MIN); i++) {
dj_dev = djrcv_dev->paired_dj_devices[i];
if (dj_dev != NULL) {
hid_destroy_device(dj_dev->hdev);
kfree(dj_dev);
djrcv_dev->paired_dj_devices[i] = NULL;
}
}
kfifo_free(&djrcv_dev->notif_fifo);
kfree(djrcv_dev);
hid_set_drvdata(hdev, NULL);
}
static __exit void tcpprobe_exit(void)
{
kfifo_free(tcpw.fifo);
proc_net_remove(procname);
unregister_jprobe(&tcp_send_probe);
}
static int gs_console_setup(struct console *co, char *options)
{
struct gscons_info *info = &gscons_info;
int status;
info->port = NULL;
info->console_req = NULL;
info->req_busy = 0;
spin_lock_init(&info->con_lock);
status = kfifo_alloc(&info->con_buf, GS_CONSOLE_BUF_SIZE, GFP_KERNEL);
if (status) {
pr_err("%s: allocate console buffer failed\n", __func__);
return status;
}
info->console_thread = kthread_create(gs_console_thread,
co, "gs_console");
if (IS_ERR(info->console_thread)) {
pr_err("%s: cannot create console thread\n", __func__);
kfifo_free(&info->con_buf);
return PTR_ERR(info->console_thread);
}
wake_up_process(info->console_thread);
return 0;
}
void ccci_logic_ctlb_deinit(int md_id)
{
ccif_t *ccif;
logic_channel_info_t *ch_info;
int i;
logic_dispatch_ctl_block_t *ctl_b;
ctl_b = logic_dispatch_ctlb[md_id];
if(ctl_b != NULL){
// Step 1, freeze ccci
ctl_b->m_freezed = 1;
// Step 2, de-init ccif
ccif = logic_dispatch_ctlb[md_id]->m_ccif;
ccif->ccif_de_init(ccif);
// Step 3, kill ccci dispatch tasklet
tasklet_kill(&ctl_b->m_dispatch_tasklet);
// Step 4, free kfifo memory
for(i=0; i<CCCI_MAX_CH_NUM; i++)
{
ch_info = &ctl_b->m_logic_ch_table[i];
if(ch_info->m_kfifo_ready){
kfifo_free(&ch_info->m_kfifo);
ch_info->m_kfifo_ready = 0;
}
}
// Step 5, destory wake lock
wake_lock_destroy(&ctl_b->m_wakeup_wake_lock);
// Step 6, free logic_dispatch_ctlb memory
kfree(ctl_b);
logic_dispatch_ctlb[md_id] = NULL;
}
}
int main(void)
{
struct kfifo fck;
struct kfifo *fifo = &fck;
int tmp, array[256];
int out[256];
int i;
tmp = kfifo_alloc(fifo, 256, sizeof(int));
printf("\nkfifo_alloc ret = %d\n", tmp);
kfifo_disp_info(fifo);
for(i = 0; i < ARRAY_SIZE(array); i++)
array[i] = i;
// for(i = 0; i < 100; i++)
tmp = kfifo_in(fifo, array, 100);
printf("\nkfifo_in ret = %d\n", tmp);
kfifo_disp_info(fifo);
tmp = kfifo_out(fifo, out, 10);
printf("\nkfifo_out ret = %d\n", tmp);
kfifo_disp_info(fifo);
for(i = 0; i < 10; i++)
printf("out[%d]= %d\n", i, out[i]);
kfifo_free(fifo);
return 0;
}
static void gs_close(struct tty_struct *tty, struct file *file)
{
struct gs_port *port = tty->driver_data;
struct gserial *gser;
spin_lock_irq(&port->port_lock);
if (port->port.count != 1) {
if (port->port.count == 0)
WARN_ON(1);
else
--port->port.count;
goto exit;
}
pr_debug("gs_close: ttyGS%d (%p,%p) ...\n", port->port_num, tty, file);
/* mark port as closing but in use; we can drop port lock
* and sleep if necessary
*/
port->openclose = true;
port->port.count = 0;
gser = port->port_usb;
if (gser && gser->disconnect)
gser->disconnect(gser);
/* wait for circular write buffer to drain, disconnect, or at
* most GS_CLOSE_TIMEOUT seconds; then discard the rest
*/
if (kfifo_len(&port->port_write_buf) > 0 && gser) {
spin_unlock_irq(&port->port_lock);
wait_event_interruptible_timeout(port->drain_wait,
gs_writes_finished(port),
GS_CLOSE_TIMEOUT * HZ);
spin_lock_irq(&port->port_lock);
gser = port->port_usb;
}
/* Iff we're disconnected, there can be no I/O in flight so it's
* ok to free the circular buffer; else just scrub it. And don't
* let the push tasklet fire again until we're re-opened.
*/
if (gser == NULL)
kfifo_free(&port->port_write_buf);
else
kfifo_reset(&port->port_write_buf);
port->port.tty = NULL;
port->openclose = false;
pr_debug("gs_close: ttyGS%d (%p,%p) done!\n",
port->port_num, tty, file);
wake_up(&port->close_wait);
exit:
spin_unlock_irq(&port->port_lock);
}
void rfbi_exit(void)
{
DSSDBG("rfbi_exit\n");
kfifo_free(rfbi.cmd_fifo);
iounmap(rfbi.base);
}
//-------------------------------------------------exit_fun--------------------------------------------------------
static void __exit pseudo_exit(void)
{
printk("device unloaded\n");
kfifo_free(&my_dev->kfifo);
// kfree(my_dev->buff);
kfree(my_dev);
unregister_chrdev_region(pdevice,1);
}
static void lbs_free_adapter(struct lbs_private *priv)
{
lbs_free_cmd_buffer(priv);
kfifo_free(&priv->event_fifo);
del_timer(&priv->command_timer);
del_timer(&priv->tx_lockup_timer);
del_timer(&priv->auto_deepsleep_timer);
}
static void iio_kfifo_buffer_release(struct iio_buffer *buffer)
{
struct iio_kfifo *kf = iio_to_kfifo(buffer);
mutex_destroy(&kf->user_lock);
kfifo_free(&kf->kf);
kfree(kf);
}
static inline void
dhd_kfifo_free(struct kfifo *fifo)
{
kfifo_free(fifo);
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 31))
/* FC11 releases the fifo memory */
kfree(fifo);
#endif
}
void hidpp_remove(struct hidpp_device *hidpp_dev)
{
dbg_hid("%s\n", __func__);
cancel_work_sync(&hidpp_dev->work);
mutex_destroy(&hidpp_dev->send_mutex);
kfifo_free(&hidpp_dev->delayed_work_fifo);
hidpp_dev->initialized = false;
hidpp_dev->hid_dev = NULL;
}
static void gserial_console_exit(void)
{
struct gscons_info *info = &gscons_info;
unregister_console(&gserial_cons);
if (!IS_ERR_OR_NULL(info->console_thread))
kthread_stop(info->console_thread);
kfifo_free(&info->con_buf);
}
